Class: Guard::Watcher

Inherits:
Object
  • Object
show all
Defined in:
lib/guard/watcher.rb

Overview

The watcher defines a RegExp that will be matched against file system modifications. When a watcher matches a change, an optional action block is executed to enable processing the file system change result.

Instance Attribute Summary (collapse)

Class Method Summary (collapse)

Instance Method Summary (collapse)

Constructor Details

- (Watcher) initialize(pattern, action = nil)

Initialize a file watcher.

Parameters:

  • pattern (String, Regexp) —

    the pattern to be watched by the guard

  • action (Block) (defaults to: nil) —

    the action to execute before passing the result to the Guard



16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/guard/watcher.rb', line 16

def initialize(pattern, action = nil)
  @pattern, @action = pattern, action
  @@warning_printed ||= false

  # deprecation warning
  if @pattern.is_a?(String) && @pattern =~ /(^(\^))|(>?(\\\.)|(\.\*))|(\(.*\))|(\[.*\])|(\$$)/
    unless @@warning_printed
      UI.info "*"*20 + "\nDEPRECATION WARNING!\n" + "*"*20
      UI.info <<-MSG
        You have a string in your Guardfile watch patterns that seem to represent a Regexp.
        Guard matches String with == and Regexp with Regexp#match.
        You should either use plain String (without Regexp special characters) or real Regexp.
      MSG
      @@warning_printed = true
    end

    UI.info "\"#{@pattern}\" has been converted to #{ Regexp.new(@pattern).inspect }\n"
    @pattern = Regexp.new(@pattern)
  end
end

Instance Attribute Details

- (Object) action

Returns the value of attribute action



9
10
11
 
# File 'lib/guard/watcher.rb', line 9

def action
  @action
end

- (Object) pattern

Returns the value of attribute pattern



9
10
11
 
# File 'lib/guard/watcher.rb', line 9

def pattern
  @pattern
end

Class Method Details

+ (Array<Object>) match_files(guard, files)

Finds the files that matches a Guard.

Parameters:

  • guard (Guard::Guard) —

    the guard which watchers are used

  • files (Array<String>) —

    the changed files

Returns:

  • (Array<Object>) —

    the matched watcher response



43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/guard/watcher.rb', line 43

def self.match_files(guard, files)
  guard.watchers.inject([]) do |paths, watcher|
    files.each do |file|
      if matches = watcher.match(file)
        if watcher.action
          result = watcher.call_action(matches)
          if guard.options[:any_return]
            paths << result
          elsif result.respond_to?(:empty?) && !result.empty?
            paths << Array(result)
          end
        else
          paths << matches[0]
        end
      end
    end

    guard.options[:any_return] ? paths : paths.flatten.map { |p| p.to_s }
  end
end

+ (Boolean) match_files?(guards, files)

Test if a file would be matched by any of the Guards watchers.

Parameters:

  • guards (Array<Guard::Guard>) —

    the guards to use the watchers from

  • files (Array<String>) —

    the files to test

Returns:

  • (Boolean) —

    Whether a file matches



70
71
72
73
74
75
76
 
# File 'lib/guard/watcher.rb', line 70

def self.match_files?(guards, files)
  guards.any? do |guard|
    guard.watchers.any? do |watcher|
      files.any? { |file| watcher.match(file) }
    end
  end
end

+ (Boolean) match_guardfile?(files)

Test if any of the files is the Guardfile.

Parameters:

  • the (Array<String>) —

    files to test

Returns:

  • (Boolean) —

    whether one of these files is the Guardfile



110
111
112
 
# File 'lib/guard/watcher.rb', line 110

def self.match_guardfile?(files)
  files.any? { |file| "#{ Dir.pwd }/#{ file }" == Dsl.guardfile_path }
end

Instance Method Details

- (String) call_action(matches)

Executes a watcher action.

Parameters:

  • matches (String, MatchData) —

    the matched path or the match from the Regex

Returns:

  • (String) —

    the final paths



119
120
121
122
123
124
125
 
# File 'lib/guard/watcher.rb', line 119

def call_action(matches)
  begin
    @action.arity > 0 ? @action.call(matches) : @action.call
  rescue Exception => e
    UI.error "Problem with watch action!\n#{ e.message }\n\n#{ e.backtrace.join("\n") }"
  end
end

- (Array<String>) match(file)

Test the watchers pattern against a file.

Parameters:

  • file (String) —

    the file to test

Returns:

  • (Array<String>) —

    an array of matches (or containing a single path if the pattern is a string)



90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/guard/watcher.rb', line 90

def match(file)
  f = file
  deleted = file.start_with?('!')
  f = deleted ? f[1..-1] : f
  if @pattern.is_a?(Regexp)
    if m = f.match(@pattern)
      m = m.to_a
      m[0] = file
      m
    end
  else
    f == @pattern ? [file] : nil
  end
end

- (Boolean) match_file?(file)

Deprecated.

Use .match instead

Returns:

  • (Boolean) 


80
81
82
83
 
# File 'lib/guard/watcher.rb', line 80

def match_file?(file)
  UI.info "Guard::Watcher.match_file? is deprecated, please use Guard::Watcher.match instead."
  match(file)
end