guard 0.2.2 → 0.3.0

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Thibaud Guillaume-Gentil
+Copyright (c) 2011 Thibaud Guillaume-Gentil
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.rdoc

@@ -1,6 +1,6 @@
 = Guard
 
-Guard is a command line tool to easly handle events on files modifications.
+Guard is a command line tool that easily handle events on files modifications.
 
 == Features
 
@@ -27,73 +27,90 @@ Generate an empty Guardfile with:
 
     guard init
 
-Add guard(s) you need (see available guards below)
+Add the guards you need (see available guards below)
 
 === On Mac OS X
 
-Install rb-fsevent for {FSEvent}[http://en.wikipedia.org/wiki/FSEvents] support
+Install rb-fsevent for {FSEvent}[http://en.wikipedia.org/wiki/FSEvents] support:
 
     gem install rb-fsevent
 
-Install growl for Growl notification support
+Install growl for Growl notification support:
 
     gem install growl
 
-And add it to you Gemfile
+And add it to you Gemfile:
 
     gem 'growl'
 
 === On Linux
 
-Install rb-inotify for {inotify}[http://en.wikipedia.org/wiki/Inotify] support
+Install rb-inotify for {inotify}[http://en.wikipedia.org/wiki/Inotify] support:
 
     gem install rb-inotify
 
-Install libnotify for libonity notification support
+Install libnotify for libonity notification support:
 
     gem install libnotify
 
-And add it to you Gemfile
+And add it to you Gemfile:
 
     gem 'libnotify'
 
 == Usage
 
-Just launch Guard inside your ruby/rails project with:
+Just launch Guard inside your Ruby / Rails project with:
 
     guard
 
+or if you use Bundler, to run the Guard executable specific to your bundle:
+
+    bundle exec guard
+
+== Command line options
+
 Shell can be cleared after each change with:
 
-    guard -c
+    guard --clear
+    guard -c # shortcut
+
+The guards to start can be specified by group (see Guardfile DSL below) specifying the `--group` (or `-g`) option:
+
+    guard --group group_name another_group_name
+    guard -g group_name another_group_name # shortcut
 
 Options list is available with:
 
     guard help [TASK]
 
+== Signal handlers
+
 Signal handlers are used to interact with Guard:
 
-- Ctrl-C - Quit Guard (call stop guard(s) method before)
-- Ctrl-\ - Call run_all guard(s) method
-- Ctrl-Z - Call reload guard(s) method
+- Ctrl-C - Quit Guard (call each guard's run_all method, in the same order they are declared in the Guarfile)
+- Ctrl-\ - Call each guard's run_all method, in the same order they are declared in the Guarfile
+- Ctrl-Z - Call each guard's reload method, in the same order they are declared in the Guarfile
 
 == Available Guards
 
-- {guard-rspec}[http://github.com/guard/guard-rspec]
-- {guard-test}[http://github.com/guard/guard-test]
-- {guard-minitest}[http://github.com/guard/guard-minitest]
-- {guard-livereload}[http://github.com/guard/guard-livereload]
-- {guard-sass}[http://github.com/guard/guard-sass]
-- {guard-compass}[http://github.com/guard/guard-compass]
-- {guard-shell}[http://github.com/guard/guard-shell]
-- {guard-bundler}[http://github.com/guard/guard-bundler]
-- {guard-passenger}[http://github.com/guard/guard-passenger]
-
-guard ideas:
-
-- guard-spork
-- guard-cucumber
-- others ideas?
+- {guard-bundler}[https://github.com/guard/guard-bundler] by {Yann Lugrin}[https://github.com/yannlugrin]
+- {guard-coffeescript}[https://github.com/guard/guard-coffeescript] by {Michael Kessler}[https://github.com/netzpirat]
+- {guard-compass}[https://github.com/guard/guard-compass] by {Olivier Amblet}[https://github.com/oliamb]
+- {guard-cucumber}[https://github.com/guard/guard-cucumber] by {Michael Kessler}[https://github.com/netzpirat]
+- {guard-ego}[https://github.com/guard/guard-ego] by {Fabio Kuhn}[https://github.com/mordaroso]
+- {guard-jammit}[https://github.com/guard/guard-jammit] by {Pelle Braendgaard}[https://github.com/pelle]
+- {guard-less}[https://github.com/guard/guard-less] by {Brendan Erwin}[https://github.com/brendanjerwin]
+- {guard-livereload}[https://github.com/guard/guard-livereload] by {Thibaud Guillaume-Gentil}[https://github.com/thibaudgg]
+- {guard-minitest}[https://github.com/guard/guard-minitest] by {Yann Lugrin}[https://github.com/yannlugrin]
+- {guard-nanoc}[https://github.com/guard/guard-nanoc] by {Yann Lugrin}[https://github.com/yannlugrin]
+- {guard-passenger}[https://github.com/guard/guard-passenger] by {Fabio Kuhn}[https://github.com/mordaroso]
+- {guard-rspec}[https://github.com/guard/guard-rspec] by {Thibaud Guillaume-Gentil}[https://github.com/thibaudgg]
+- {guard-sass}[https://github.com/guard/guard-sass] by {Joshua Hawxwell}[https://github.com/hawx]
+- {guard-shell}[https://github.com/guard/guard-shell] by {Joshua Hawxwell}[https://github.com/hawx]
+- {guard-soca}[https://github.com/guard/guard-soca] by {Luke Amdor}[https://github.com/rubbish]
+- {guard-spork}[https://github.com/guard/guard-spork] by {Thibaud Guillaume-Gentil}[https://github.com/thibaudgg]
+- {guard-stendhal}[https://github.com/guard/guard-stendhal] by {Josep Mª Bach}[https://github.com/txus]
+- {guard-test}[https://github.com/guard/guard-test] by {Rémy Coutable}[https://github.com/rymai]
 
 === Add a guard to your Guardfile
 
@@ -107,6 +124,46 @@ Add guard definition to your Guardfile by running this command:
 
 You are good to go!
 
+== Guardfile DSL
+
+The Guardfile DSL consists of just three simple main methods: `guard`, `watch` & `group`.
+
+Required:
+- The `guard` method allows you to add a guard with an optional options hash.
+- The `watch` method allows you to define which files are supervised per this guard. A optional block can be added to overwrite path sent to run_on_change guard method or launch simple command.
+
+Optional:
+- The `group` method allows you to group several guards. Groups to run can be specified with the Guard DSL option `--group` (or `-g`). This comes in handy especially when you have a huge Guardfile and want to focus your development.
+
+Example:
+
+    group 'backend' do
+      guard 'bundler' do
+        watch('Gemfile')
+      end
+
+      guard 'rspec' do
+        # Regexp watch patterns are matched with Regexp#match
+        watch(%r{^spec/(.+)_spec\.rb})
+        watch(%r{^lib/(.+)\.rb})         { |m| "spec/lib/#{m[1]}_spec.rb" }
+        watch(%r{^spec/models/.+\.rb})   { ["spec/models", "spec/acceptance"] }
+        watch(%r{^spec/.+\.rb})          { `say hello` }
+
+        # String watch patterns are matched with simple '=='
+        watch('spec/spec_helper.rb') { "spec" }
+      end
+    end
+
+    group 'frontend' do
+      guard 'coffeescript', :output => 'public/javascripts/compiled' do
+        watch(%r{app/coffeescripts/.+\.coffee})
+      end
+
+      guard 'livereload' do
+        watch(%r{app/.+\.(erb|haml)})
+      end
+    end
+
 == Create a guard
 
 Create a new guard is very easy, just create a new gem with this basic structure:
@@ -122,72 +179,63 @@ lib/guard/guard-name.rb inherit from guard/guard and should overwrite at least o
 
     require 'guard'
     require 'guard/guard'
-    
+
     module Guard
       class GuardName < Guard
-        
+
+        def initialize(watchers = [], options = {})
+          super
+          # init stuff here, thx!
+        end
+
         # ================
         # = Guard method =
         # ================
-        
+
+        # If one of those methods raise an exception, the Guard instance
+        # will be removed from the active guard.
+
         # Call once when guard starts
+        # Please override initialize method to init stuff
         def start
           true
         end
-        
-        # Call with Ctrl-C signal (when Guard quit).
-        # This method must return a true value 
-        # if everything went well or guard will not stop.
+
+        # Call with Ctrl-C signal (when Guard quit)
         def stop
           true
         end
-        
+
         # Call with Ctrl-Z signal
+        # This method should be mainly used for "reload" (really!) actions like reloading passenger/spork/bundler/...
         def reload
           true
         end
-        
+
         # Call with Ctrl-/ signal
+        # This method should be principally used for long action like running all specs/tests/...
         def run_all
           true
         end
-        
+
         # Call on file(s) modifications
         def run_on_change(paths)
           true
         end
-        
+
       end
     end
 
 Looks at available guards code for more concrete example.
 
-== Guardfile DSL
-
-Guardfile DSL consists of just two simple methods: guard & watch. Example:
-
-    guard 'rspec', :version => 2 do
-      watch('^spec/(.*)_spec.rb')
-      watch('^lib/(.*)\.rb')        { |m| "spec/lib/#{m[1]}_spec.rb" }
-      watch('^spec/spec_helper.rb') { "spec" }
-      watch('^spec/spec_helper.rb') { `say hello` }
-    end
-    
-- "guard" method allow to add a guard with an optional options hash
-- "watch" method allow to define which files are supervised per this guard. A optional block can be added to overwrite path sending to run_on_change guard method or launch simple command.
-
-== TODO
-
-- Add more specs, help are welcome because I'm not sure about how to test stuff like this :-)
-
 == Development
 
-- Source hosted at {GitHub}[http://github.com/guard/guard]
-- Report issues/Questions/Feature requests on {GitHub Issues}[http://github.com/guard/guard/issues]
+- Source hosted at {GitHub}[https://github.com/guard/guard]
+- Report issues/Questions/Feature requests on {GitHub Issues}[https://github.com/guard/guard/issues]
 
 Pull requests are very welcome! Make sure your patches are well tested. Please create a topic branch for every separate change
 you make.
 
 == Authors
 
-{Thibaud Guillaume-Gentil}[http://github.com/thibaudgg]
+{Thibaud Guillaume-Gentil}[https://github.com/thibaudgg]

data/lib/guard.rb

@@ -1,74 +1,101 @@
 require 'bundler'
 
 module Guard
-  
+
   autoload :UI,         'guard/ui'
   autoload :Dsl,        'guard/dsl'
   autoload :Interactor, 'guard/interactor'
   autoload :Listener,   'guard/listener'
   autoload :Watcher,    'guard/watcher'
   autoload :Notifier,   'guard/notifier'
-  
+
   class << self
     attr_accessor :options, :guards, :listener
-    
-    def start(options = {})
+
+    # initialize this singleton
+    def setup(options = {})
       @options  = options
-      @listener = Listener.init
+      @listener = Listener.select_and_init
       @guards   = []
-      
-      Dsl.evaluate_guardfile
+      self
+    end
+
+    def start(options = {})
+      setup(options)
+
+      Interactor.init_signal_traps
+      Dsl.evaluate_guardfile(options)
+
       if guards.empty?
-        UI.error "No guards found in Guardfile, please add it at least one."
+        UI.error "No guards found in Guardfile, please add at least one."
       else
-        Interactor.init_signal_traps
-        
         listener.on_change do |files|
-          run do
-            guards.each do |guard|
-              paths = Watcher.match_files(guard, files)
-              guard.run_on_change(paths) unless paths.empty?
-            end
+          if Watcher.match_files?(guards, files)
+            run { run_on_change_for_all_guards(files) }
           end
         end
-        
+
         UI.info "Guard is now watching at '#{Dir.pwd}'"
-        guards.each { |g| g.start }
+        guards.each { |guard| supervised_task(guard, :start) }
         listener.start
       end
     end
-    
+
+    def run_on_change_for_all_guards(files)
+      guards.each do |guard|
+        paths = Watcher.match_files(guard, files)
+        supervised_task(guard, :run_on_change, paths) unless paths.empty?
+      end
+      # Reparse the whole directory to catch new files modified during the guards run
+      new_modified_files = listener.modified_files([Dir.pwd + '/'], :all => true)
+      listener.update_last_event
+      unless new_modified_files.empty?
+        run_on_change_for_all_guards(new_modified_files)
+      end
+    end
+
+    # Let a guard execute its task but
+    # fire it if his work leads to a system failure
+    def supervised_task(guard, task_to_supervise, *args)
+      guard.send(task_to_supervise, *args)
+    rescue Exception
+      UI.error("#{guard.class.name} guard failed to achieve its <#{task_to_supervise.to_s}> command: #{$!}")
+      ::Guard.guards.delete guard
+      UI.info("Guard #{guard.class.name} has just been fired")
+      return $!
+    end
+
+    def run
+      listener.stop
+      UI.clear if options[:clear]
+      begin
+        yield
+      rescue Interrupt
+      end
+      listener.start
+    end
+
     def add_guard(name, watchers = [], options = {})
       guard_class = get_guard_class(name)
       @guards << guard_class.new(watchers, options)
     end
-    
+
     def get_guard_class(name)
       require "guard/#{name.downcase}"
       klasses = []
       ObjectSpace.each_object(Class) do |klass|
-        klasses << klass if klass.to_s.downcase.match "^guard::#{name.downcase}"
+        klasses << klass if klass.to_s.downcase.match(/^guard::#{name.downcase}/)
       end
       klasses.first
     rescue LoadError
-      UI.error "Could not find gem 'guard-#{name}' in the current Gemfile."
+      UI.error "Could not find gem 'guard-#{name}', please add it in your Gemfile."
     end
-    
+
     def locate_guard(name)
       `gem open guard-#{name} --latest --command echo`.chomp
     rescue
       UI.error "Could not find 'guard-#{name}' gem path."
     end
-    
-    def run
-      listener.stop
-      UI.clear if options[:clear]
-      begin
-        yield
-      rescue Interrupt
-      end
-      listener.start
-    end
-    
+
   end
 end

data/lib/guard/cli.rb

@@ -5,20 +5,22 @@ module Guard
   class CLI < Thor
     default_task :start
     
-    desc "start", "Starts guard"
     method_option :clear, :type => :boolean, :default => false, :aliases => '-c', :banner => "Auto clear shell before each change/run_all/reload"
     method_option :debug, :type => :boolean, :default => false, :aliases => '-d', :banner => "Print debug messages"
+    method_option :group, :type => :array,   :default => [],    :aliases => '-g', :banner => "Run only the passed groups"
+    
+    desc "start", "Starts Guard"
     def start
       ::Guard.start(options)
     end
     
-    desc "version", "Prints the guard's version information"
+    desc "version", "Prints Guard's version information"
     def version
       ::Guard::UI.info "Guard version #{Guard::VERSION}"
     end
     map %w(-v --version) => :version
     
-    desc "init [GUARD]", "Generates a Guardfile into the current working directory, or add it given guard"
+    desc "init [GUARD]", "Generates a Guardfile into the current working directory, or insert the given GUARD"
     def init(guard_name = nil)
       if !File.exist?("Guardfile")
         puts "Writing new Guardfile to #{Dir.pwd}/Guardfile"

data/lib/guard/dsl.rb

@@ -1,28 +1,45 @@
 module Guard
   class Dsl
-    
-    def self.evaluate_guardfile
-      guardfile = "#{Dir.pwd}/Guardfile"
-      dsl = new
-      dsl.instance_eval(File.read(guardfile.to_s), guardfile.to_s, 1)
-    rescue
-      UI.error "Guardfile not found or invalid"
-      exit 1
+
+    class << self
+      def evaluate_guardfile(options = {})
+        @@options = options
+        
+        if File.exists?(guardfile_path)
+          begin
+            new.instance_eval(File.read(guardfile_path), guardfile_path, 1)
+          rescue
+            UI.error "Invalid Guardfile, original error is:\n#{$!}"
+            exit 1
+          end
+        else
+          UI.error "No Guardfile in current folder, please create one."
+          exit 1
+        end
+      end
+
+      def guardfile_include?(guard_name)
+        File.read(guardfile_path).match(/^guard\s*\(?\s*['":]#{guard_name}['"]?/)
+      end
+      
+      def guardfile_path
+        File.join(Dir.pwd, 'Guardfile')
+      end
     end
-    
-    def self.guardfile_included?(guard_name)
-      File.read('Guardfile').include?("guard '#{guard_name}'")
+
+    def group(name, &guard_definition)
+      guard_definition.call if guard_definition && (@@options[:group].empty? || @@options[:group].include?(name))
     end
-    
-    def guard(name, options = {}, &definition)
+
+    def guard(name, options = {}, &watch_definition)
       @watchers = []
-      definition.call if definition
+      watch_definition.call if watch_definition
       ::Guard.add_guard(name, @watchers, options)
     end
-    
+
     def watch(pattern, &action)
       @watchers << ::Guard::Watcher.new(pattern, action)
     end
-    
+
   end
 end

data/lib/guard/guard.rb

@@ -1,51 +1,55 @@
 module Guard
   class Guard
     attr_accessor :watchers, :options
-    
+
     def initialize(watchers = [], options = {})
       @watchers, @options = watchers, options
     end
-    
+
     # Guardfile template needed inside guard gem
     def self.init(name)
-      if ::Guard::Dsl.guardfile_included?(name)
+      if ::Guard::Dsl.guardfile_include?(name)
         ::Guard::UI.info "Guardfile already include #{name} guard"
       else
         content = File.read('Guardfile')
         guard   = File.read("#{::Guard.locate_guard(name)}/lib/guard/#{name}/templates/Guardfile")
         File.open('Guardfile', 'wb') do |f|
-          f.puts content
-          f.puts ""
-          f.puts guard
+          f.puts(content)
+          f.puts("")
+          f.puts(guard)
         end
         ::Guard::UI.info "#{name} guard added to Guardfile, feel free to edit it"
       end
     end
-    
+
     # ================
     # = Guard method =
     # ================
-    
+
+    # Call once when guard starts
+    # Please override initialize method to init stuff
     def start
       true
     end
-    
-    # Retrieve a true value if the instance successfuly stopped
+
+    # Call once when guard quit
     def stop
       true
     end
-    
+
+    # Should be mainly used for "reload" (really!) actions like reloading passenger/spork/bundler/...
     def reload
       true
     end
-    
+
+    # Should be principally used for long action like running all specs/tests/...
     def run_all
       true
     end
-    
+
     def run_on_change(paths)
       true
     end
-    
+
   end
 end

data/lib/guard/interactor.rb

@@ -5,25 +5,22 @@ module Guard
       # Run all (Ctrl-\)
       Signal.trap('QUIT') do
         ::Guard.run do
-          ::Guard.guards.each { |g| g.run_all }
+          ::Guard.guards.each { |guard| ::Guard.supervised_task(guard, :run_all) }
         end
       end
       
       # Stop (Ctrl-C)
       Signal.trap('INT') do
+        UI.info "Bye bye...", :reset => true
         ::Guard.listener.stop
-        if ::Guard.guards.all? { |g| g.stop }
-          UI.info "Bye bye...", :reset => true
-          abort("\n")
-        else
-          ::Guard.listener.start
-        end
+        ::Guard.guards.each { |guard| ::Guard.supervised_task(guard, :stop) }
+        abort("\n")
       end
       
       # Reload (Ctrl-Z)
       Signal.trap('TSTP') do
         ::Guard.run do
-          ::Guard.guards.each { |g| g.reload }
+          ::Guard.guards.each { |guard| ::Guard.supervised_task(guard, :reload) }
         end
       end
     end

data/lib/guard/listener.rb

@@ -1,15 +1,15 @@
 require 'rbconfig'
 
 module Guard
-  
+
   autoload :Darwin,  'guard/listeners/darwin'
   autoload :Linux,   'guard/listeners/linux'
   autoload :Polling, 'guard/listeners/polling'
-  
+
   class Listener
     attr_reader :last_event
-    
-    def self.init
+
+    def self.select_and_init
       if mac? && Darwin.usable?
         Darwin.new
       elsif linux? && Linux.usable?
@@ -19,40 +19,107 @@ module Guard
         Polling.new
       end
     end
-    
+
     def initialize
       update_last_event
     end
-    
-  private
-    
+
+    def update_last_event
+      @last_event = Time.now
+    end
+
     def modified_files(dirs, options = {})
       files = potentially_modified_files(dirs, options).select { |path| File.file?(path) && recent_file?(path) }
       files.map! { |file| file.gsub("#{Dir.pwd}/", '') }
     end
-    
+
+  private
+
     def potentially_modified_files(dirs, options = {})
       match = options[:all] ? "**/*" : "*"
       Dir.glob(dirs.map { |dir| "#{dir}#{match}" })
     end
-    
+
     def recent_file?(file)
       File.mtime(file) >= last_event
     rescue
       false
     end
-    
-    def update_last_event
-      @last_event = Time.now
-    end
-    
+
+
     def self.mac?
       Config::CONFIG['target_os'] =~ /darwin/i
     end
-    
+
     def self.linux?
       Config::CONFIG['target_os'] =~ /linux/i
     end
-    
+
   end
-end
+end
+
+# require 'rbconfig'
+#
+# module Guard
+#
+#   autoload :Darwin,  'guard/listeners/darwin'
+#   autoload :Linux,   'guard/listeners/linux'
+#   autoload :Polling, 'guard/listeners/polling'
+#
+#   class Listener
+#     attr_accessor :last_event, :changed_files
+#
+#     def self.select_and_init
+#       if mac? && Darwin.usable?
+#         Darwin.new
+#       elsif linux? && Linux.usable?
+#         Linux.new
+#       else
+#         UI.info "Using polling (Please help us to support your system better than that.)"
+#         Polling.new
+#       end
+#     end
+#
+#     def initialize
+#       @changed_files = []
+#       update_last_event
+#     end
+#
+#     def get_and_clear_changed_files
+#       files = changed_files.dup
+#       changed_files.clear
+#       files.uniq
+#     end
+#
+#   private
+#
+#     def find_changed_files(dirs, options = {})
+#       files = potentially_changed_files(dirs, options).select { |path| File.file?(path) && changed_file?(path) }
+#       files.map! { |file| file.gsub("#{Dir.pwd}/", '') }
+#     end
+#
+#     def potentially_changed_files(dirs, options = {})
+#       match = options[:all] ? "**/*" : "*"
+#       Dir.glob(dirs.map { |dir| "#{dir}#{match}" })
+#     end
+#
+#     def changed_file?(file)
+#       File.mtime(file) >= last_event
+#     rescue
+#       false
+#     end
+#
+#     def update_last_event
+#       @last_event = Time.now
+#     end
+#
+#     def self.mac?
+#       Config::CONFIG['target_os'] =~ /darwin/i
+#     end
+#
+#     def self.linux?
+#       Config::CONFIG['target_os'] =~ /linux/i
+#     end
+#
+#   end
+# end

data/lib/guard/listeners/darwin.rb

@@ -1,12 +1,12 @@
 module Guard
   class Darwin < Listener
     attr_reader :fsevent
-    
+
     def initialize
       super
       @fsevent = FSEvent.new
     end
-    
+
     def on_change(&callback)
       @fsevent.watch Dir.pwd do |modified_dirs|
         files = modified_files(modified_dirs)
@@ -14,19 +14,19 @@ module Guard
         callback.call(files)
       end
     end
-    
+
     def start
       @fsevent.run
     end
-    
+
     def stop
       @fsevent.stop
     end
-    
+
     def self.usable?
       require 'rb-fsevent'
-      if !defined?(FSEvent::VERSION) || Gem::Version.new(FSEvent::VERSION) < Gem::Version.new('0.3.5')
-        UI.info "Please update rb-fsevent (>= 0.3.5)"
+      if !defined?(FSEvent::VERSION) || Gem::Version.new(FSEvent::VERSION) < Gem::Version.new('0.3.9')
+        UI.info "Please update rb-fsevent (>= 0.3.9)"
         false
       else
         true
@@ -35,6 +35,6 @@ module Guard
       UI.info "Please install rb-fsevent gem for Mac OSX FSEvents support"
       false
     end
-    
+
   end
-end
+end

data/lib/guard/listeners/linux.rb

@@ -70,4 +70,4 @@ module Guard
     end
 
   end
-end
+end

data/lib/guard/listeners/polling.rb

@@ -1,27 +1,27 @@
 module Guard
   class Polling < Listener
     attr_reader :callback, :latency
-    
+
     def initialize
       super
       @latency = 1.5
     end
-    
+
     def on_change(&callback)
       @callback = callback
     end
-    
+
     def start
       @stop = false
       watch_change
     end
-    
+
     def stop
       @stop = true
     end
-    
+
   private
-    
+
     def watch_change
       while !@stop
         start = Time.now.to_f
@@ -32,6 +32,6 @@ module Guard
         sleep(nap_time) if nap_time > 0
       end
     end
-    
+
   end
-end
+end

data/lib/guard/templates/Guardfile

@@ -1,2 +1,2 @@
 # A sample Guardfile
-# More info at http://github.com/guard/guard#readme
+# More info at https://github.com/guard/guard#readme

data/lib/guard/ui.rb

@@ -9,12 +9,16 @@ module Guard
         end
       end
       
-      def error(message)
-        puts "ERROR: #{message}"
+      def error(message, options = {})
+        unless ENV["GUARD_ENV"] == "test"
+          reset_line if options[:reset]
+          puts "ERROR: #{message}"
+        end
       end
       
-      def debug(message)
+      def debug(message, options = {})
         unless ENV["GUARD_ENV"] == "test"
+          reset_line if options[:reset]
           puts "DEBUG: #{message}" if ::Guard.options && ::Guard.options[:debug]
         end
       end

data/lib/guard/version.rb

@@ -1,3 +1,3 @@
 module Guard
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

data/lib/guard/watcher.rb

@@ -4,29 +4,57 @@ module Guard
     
     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 "You have strings in your Guardfile's watch patterns that seem to represent regexps.\nGuard matchs String with == and Regexp with Regexp#match.\nYou should either use plain String (without Regexp special characters) or real Regexp.\n"
+          @@warning_printed = true
+        end
+        UI.info "\"#{@pattern}\" has been converted to #{Regexp.new(@pattern).inspect}\n"
+        @pattern = Regexp.new(@pattern)
+      end
     end
     
     def self.match_files(guard, files)
       guard.watchers.inject([]) do |paths, watcher|
         files.each do |file|
-          if matches = file.match(watcher.pattern)
+          if matches = watcher.match_file?(file)
             if watcher.action
-              begin 
-                if watcher.action.arity == 1
-                  result = watcher.action.call(matches)
-                else
-                  result = watcher.action.call
-                end
-              rescue
-                UI.info "Problem with watch action"
-              end
-              paths << result if result.is_a?(String) && result != ''
+              result = watcher.call_action(matches)
+              paths << Array(result) if result.respond_to?(:empty?) && !result.empty?
             else
               paths << matches[0]
             end
           end
         end
-        paths
+        paths.flatten.map { |p| p.to_s }
+      end
+    end
+    
+    def self.match_files?(guards, files)
+      guards.any? do |guard|
+        guard.watchers.any? do |watcher|
+          files.any? { |file| watcher.match_file?(file) }
+        end
+      end
+    end
+    
+    def match_file?(file)
+      if @pattern.is_a?(Regexp)
+        file.match(@pattern)
+      else
+        file == @pattern ? [file] : nil
+      end
+    end
+    
+    def call_action(matches)
+      begin
+        @action.arity > 0 ? @action.call(matches) : @action.call
+      rescue
+        UI.error "Problem with watch action!"
       end
     end
     

metadata

@@ -5,9 +5,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 2
-  version: 0.2.2
+  - 3
+  - 0
+  version: 0.3.0
 platform: ruby
 authors: 
 - Thibaud Guillaume-Gentil
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-26 00:00:00 +02:00
+date: 2011-01-19 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,12 +26,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 17
+        hash: 25
         segments: 
         - 1
         - 0
-        - 3
-        version: 1.0.3
+        - 7
+        version: 1.0.7
   type: :development
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -42,12 +42,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 13
+        hash: 31
         segments: 
         - 2
+        - 4
         - 0
-        - 1
-        version: 2.0.1
+        version: 2.4.0
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -58,12 +58,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 19
+        hash: 9
         segments: 
         - 0
         - 1
-        - 4
-        version: 0.1.4
+        - 9
+        version: 0.1.9
   type: :development
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
@@ -74,12 +74,12 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 33
+        hash: 43
         segments: 
         - 0
         - 14
-        - 3
-        version: 0.14.3
+        - 6
+        version: 0.14.6
   type: :runtime
   version_requirements: *id004
 - !ruby/object:Gem::Dependency