guard 0.8.4 → 0.8.5

data/lib/guard/hook.rb

@@ -1,118 +1,118 @@
-module Guard
-
-  # Guard has a hook mechanism that allows you to insert callbacks for individual Guards.
-  # By default, each of the Guard instance methods has a "_begin" and an "_end" hook.
-  # For example, the Guard::Guard#start method has a :start_begin hook that is runs immediately
-  # before Guard::Guard#start, and a :start_end hook that runs immediately after Guard::Guard#start.
-  #
-  # Read more about [hooks and callbacks on the wiki](https://github.com/guard/guard/wiki/Hooks-and-callbacks).
-  #
-  module Hook
-
-    # The Hook module gets included.
-    #
-    # @param [Class] base the class that includes the module
-    #
-    def self.included(base)
-      base.send :include, InstanceMethods
-    end
-
-    # Instance methods that gets included in the base class.
-    #
-    module InstanceMethods
-
-      # When event is a Symbol, {#hook} will generate a hook name
-      # by concatenating the method name from where {#hook} is called
-      # with the given Symbol.
-      #
-      # @example Add a hook with a Symbol
-      #
-      #   def run_all
-      #     hook :foo
-      #   end
-      #
-      # Here, when {Guard::Guard#run_all} is called, {#hook} will notify callbacks
-      # registered for the "run_all_foo" event.
-      #
-      # When event is a String, {#hook} will directly turn the String
-      # into a Symbol.
-      #
-      # @example Add a hook with a String
-      #
-      #   def run_all
-      #     hook "foo_bar"
-      #   end
-      #
-      # When {Guard::Guard#run_all} is called, {#hook} will notify callbacks
-      # registered for the "foo_bar" event.
-      #
-      # @param [Symbol, String] event the name of the Guard event
-      # @param [Array] args the parameters are passed as is to the callbacks registered for the given event.
-      #
-      def hook(event, *args)
-        hook_name = if event.is_a? Symbol
-                      calling_method = caller[0][/`([^']*)'/, 1]
-                      "#{ calling_method }_#{ event }"
-                    else
-                      event
-                    end.to_sym
-
-        UI.debug "Hook :#{ hook_name } executed for #{ self.class }"
-
-        Hook.notify(self.class, hook_name, *args)
-      end
-    end
-
-    class << self
-
-      # Get all callbacks.
-      #
-      def callbacks
-        @callbacks ||= Hash.new { |hash, key| hash[key] = [] }
-      end
-
-      # Add a callback.
-      #
-      # @param [Block] listener the listener to notify
-      # @param [Guard::Guard] guard_class the Guard class to add the callback
-      # @param [Array<Symbol>] events the events to register
-      #
-      def add_callback(listener, guard_class, events)
-        _events = events.is_a?(Array) ? events : [events]
-        _events.each do |event|
-          callbacks[[guard_class, event]] << listener
-        end
-      end
-
-      # Checks if a callback has been registered.
-      #
-      # @param [Block] listener the listener to notify
-      # @param [Guard::Guard] guard_class the Guard class to add the callback
-      # @param [Symbol] event the event to look for
-      #
-      def has_callback?(listener, guard_class, event)
-        callbacks[[guard_class, event]].include?(listener)
-      end
-
-      # Notify a callback.
-      #
-      # @param [Guard::Guard] guard_class the Guard class to add the callback
-      # @param [Symbol] event the event to trigger
-      # @param [Array] args the arguments for the listener
-      #
-      def notify(guard_class, event, *args)
-        callbacks[[guard_class, event]].each do |listener|
-          listener.call(guard_class, event, *args)
-        end
-      end
-
-      # Reset all callbacks.
-      #
-      def reset_callbacks!
-        @callbacks = nil
-      end
-
-    end
-
-  end
-end
+module Guard
+
+  # Guard has a hook mechanism that allows you to insert callbacks for individual Guards.
+  # By default, each of the Guard instance methods has a "_begin" and an "_end" hook.
+  # For example, the Guard::Guard#start method has a :start_begin hook that is runs immediately
+  # before Guard::Guard#start, and a :start_end hook that runs immediately after Guard::Guard#start.
+  #
+  # Read more about [hooks and callbacks on the wiki](https://github.com/guard/guard/wiki/Hooks-and-callbacks).
+  #
+  module Hook
+
+    # The Hook module gets included.
+    #
+    # @param [Class] base the class that includes the module
+    #
+    def self.included(base)
+      base.send :include, InstanceMethods
+    end
+
+    # Instance methods that gets included in the base class.
+    #
+    module InstanceMethods
+
+      # When event is a Symbol, {#hook} will generate a hook name
+      # by concatenating the method name from where {#hook} is called
+      # with the given Symbol.
+      #
+      # @example Add a hook with a Symbol
+      #
+      #   def run_all
+      #     hook :foo
+      #   end
+      #
+      # Here, when {Guard::Guard#run_all} is called, {#hook} will notify callbacks
+      # registered for the "run_all_foo" event.
+      #
+      # When event is a String, {#hook} will directly turn the String
+      # into a Symbol.
+      #
+      # @example Add a hook with a String
+      #
+      #   def run_all
+      #     hook "foo_bar"
+      #   end
+      #
+      # When {Guard::Guard#run_all} is called, {#hook} will notify callbacks
+      # registered for the "foo_bar" event.
+      #
+      # @param [Symbol, String] event the name of the Guard event
+      # @param [Array] args the parameters are passed as is to the callbacks registered for the given event.
+      #
+      def hook(event, *args)
+        hook_name = if event.is_a? Symbol
+                      calling_method = caller[0][/`([^']*)'/, 1]
+                      "#{ calling_method }_#{ event }"
+                    else
+                      event
+                    end.to_sym
+
+        UI.debug "Hook :#{ hook_name } executed for #{ self.class }"
+
+        Hook.notify(self.class, hook_name, *args)
+      end
+    end
+
+    class << self
+
+      # Get all callbacks.
+      #
+      def callbacks
+        @callbacks ||= Hash.new { |hash, key| hash[key] = [] }
+      end
+
+      # Add a callback.
+      #
+      # @param [Block] listener the listener to notify
+      # @param [Guard::Guard] guard_class the Guard class to add the callback
+      # @param [Array<Symbol>] events the events to register
+      #
+      def add_callback(listener, guard_class, events)
+        _events = events.is_a?(Array) ? events : [events]
+        _events.each do |event|
+          callbacks[[guard_class, event]] << listener
+        end
+      end
+
+      # Checks if a callback has been registered.
+      #
+      # @param [Block] listener the listener to notify
+      # @param [Guard::Guard] guard_class the Guard class to add the callback
+      # @param [Symbol] event the event to look for
+      #
+      def has_callback?(listener, guard_class, event)
+        callbacks[[guard_class, event]].include?(listener)
+      end
+
+      # Notify a callback.
+      #
+      # @param [Guard::Guard] guard_class the Guard class to add the callback
+      # @param [Symbol] event the event to trigger
+      # @param [Array] args the arguments for the listener
+      #
+      def notify(guard_class, event, *args)
+        callbacks[[guard_class, event]].each do |listener|
+          listener.call(guard_class, event, *args)
+        end
+      end
+
+      # Reset all callbacks.
+      #
+      def reset_callbacks!
+        @callbacks = nil
+      end
+
+    end
+
+  end
+end

data/lib/guard/interactor.rb

@@ -1,44 +1,110 @@
-module Guard
-
-  # The interactor reads user input and triggers
-  # specific action upon them unless its locked.
-  #
-  # Currently the following actions are implemented:
-  #
-  # - stop, quit, exit, s, q, e => Exit Guard
-  # - reload, r, z => Reload Guard
-  # - pause, p => Pause Guard
-  # - Everything else => Run all
-  #
-  class Interactor
-    # Start the interactor in its own thread.
-    #
-    def start
-      return if ENV["GUARD_ENV"] == 'test'
-
-      if !@thread || @thread.stop?
-        @thread = Thread.new do
-          while entry = $stdin.gets.chomp
-            case entry
-              when 'stop', 'quit', 'exit', 's', 'q', 'e'
-                ::Guard.stop
-              when 'reload', 'r', 'z'
-                ::Guard::Dsl.reevaluate_guardfile
-                ::Guard.reload
-              when 'pause', 'p'
-                ::Guard.pause
-              else
-                ::Guard.run_all
-            end
-          end
-        end
-      end
-    end
-
-    def stop_if_not_current
-      unless Thread.current == @thread
-        @thread.kill
-      end
-    end
-  end
-end
+module Guard
+
+  # The interactor reads user input and triggers
+  # specific action upon them unless its locked.
+  #
+  # Currently the following actions are implemented:
+  #
+  # - stop, quit, exit, s, q, e => Exit Guard
+  # - reload, r, z => Reload Guard
+  # - pause, p => Pause Guard
+  # - Everything else => Run all
+  #
+  # It's also possible to scope `reload` and `run all` actions to only a specified group or a guard.
+  #
+  # @example `backend reload` will only reload backend group
+  # @example `spork reload` will only reload rspec guard
+  # @example `jasmine` will only run all jasmine specs
+  #
+  class Interactor
+
+    STOP_ACTIONS   = %w[stop quit exit s q e]
+    RELOAD_ACTIONS = %w[reload r z]
+    PAUSE_ACTIONS  = %w[pause p]
+
+    # Start the interactor in its own thread.
+    #
+    def start
+      return if ENV["GUARD_ENV"] == 'test'
+
+      if !@thread || @thread.stop?
+        @thread = Thread.new do
+          while entry = $stdin.gets.chomp
+            scopes, action = extract_scopes_and_action(entry)
+            case action
+            when :stop
+              ::Guard.stop
+            when :pause
+              ::Guard.pause
+            when :reload
+              ::Guard::Dsl.reevaluate_guardfile if scopes.empty?
+              ::Guard.reload(scopes)
+            when :run_all
+              ::Guard.run_all(scopes)
+            end
+          end
+        end
+      end
+    end
+
+    # Extract guard or group scope and action from Interactor entry
+    #
+    # @example `spork reload` will only reload rspec
+    # @example `jasmine` will only run all jasmine specs
+    #
+    # @param [String] Interactor entry gets from $stdin
+    # @return [Array] entry group or guard scope hash and action
+    def extract_scopes_and_action(entry)
+      scopes  = {}
+      entries = entry.split(' ')
+      case entries.length
+      when 1
+        unless action = action_from_entry(entries[0])
+          scopes = scopes_from_entry(entries[0])
+        end
+      when 2
+        scopes = scopes_from_entry(entries[0])
+        action = action_from_entry(entries[1])
+      end
+      action ||= :run_all
+      [scopes, action]
+    end
+
+    # Extract guard or group scope from entry if valid
+    #
+    # @param [String] Interactor entry gets from $stdin
+    # @return [Hash] An hash with a guard or a group scope
+    def scopes_from_entry(entry)
+      scopes = {}
+      if guard = ::Guard.guards(entry)
+        scopes[:guard] = guard
+      end
+      if group = ::Guard.groups(entry)
+        scopes[:group] = group
+      end
+      scopes
+    end
+
+    # Extract action from entry if an existing action is present
+    #
+    # @param [String] Interactor entry gets from $stdin
+    # @return [Symbol] A guard action
+    def action_from_entry(entry)
+      if STOP_ACTIONS.include?(entry)
+        :stop
+      elsif RELOAD_ACTIONS.include?(entry)
+        :reload
+      elsif PAUSE_ACTIONS.include?(entry)
+        :pause
+      end
+    end
+
+    # Kill interactor thread if not current
+    #
+    def stop_if_not_current
+      unless Thread.current == @thread
+        @thread.kill
+      end
+    end
+  end
+end

data/lib/guard/listener.rb

@@ -1,350 +1,350 @@
-require 'rbconfig'
-require 'digest/sha1'
-
-module Guard
-
-  autoload :Darwin,  'guard/listeners/darwin'
-  autoload :Linux,   'guard/listeners/linux'
-  autoload :Windows, 'guard/listeners/windows'
-  autoload :Polling, 'guard/listeners/polling'
-
-  # The Listener is the base class for all listener
-  # implementations.
-  #
-  # @abstract
-  #
-  class Listener
-
-    # Default paths that gets ignored by the listener
-    DEFAULT_IGNORE_PATHS = %w[. .. .bundle .git log tmp vendor]
-
-    attr_accessor :changed_files
-    attr_reader :directory, :ignore_paths
-
-    def paused?
-      @paused
-    end
-
-    # Select the appropriate listener implementation for the
-    # current OS and initializes it.
-    #
-    # @param [Array] args the arguments for the listener
-    # @return [Guard::Listener] the chosen listener
-    #
-    def self.select_and_init(*args)
-      if mac? && Darwin.usable?
-        Darwin.new(*args)
-      elsif linux? && Linux.usable?
-        Linux.new(*args)
-      elsif windows? && Windows.usable?
-        Windows.new(*args)
-      else
-        UI.info 'Using polling (Please help us to support your system better than that).'
-        Polling.new(*args)
-      end
-    end
-
-    # Initialize the listener.
-    #
-    # @param [String] directory the root directory to listen to
-    # @option options [Boolean] relativize_paths use only relative paths
-    # @option options [Array<String>] ignore_paths the paths to ignore by the listener
-    #
-    def initialize(directory = Dir.pwd, options = {})
-      @directory                = directory.to_s
-      @sha1_checksums_hash      = {}
-      @file_timestamp_hash      = {}
-      @relativize_paths         = options.fetch(:relativize_paths, true)
-      @changed_files            = []
-      @paused                   = false
-      @ignore_paths             = DEFAULT_IGNORE_PATHS
-      @ignore_paths            |= options[:ignore_paths] if options[:ignore_paths]
-      @watch_all_modifications  = options.fetch(:watch_all_modifications, false)
-
-      update_last_event
-      start_reactor
-    end
-
-    # Start the listener thread.
-    #
-    def start_reactor
-      return if ENV["GUARD_ENV"] == 'test'
-
-      Thread.new do
-        loop do
-          if @changed_files != [] && !@paused
-            changed_files = @changed_files.dup
-            clear_changed_files
-            ::Guard.run_on_change(changed_files)
-          else
-            sleep 0.1
-          end
-        end
-      end
-    end
-
-    # Start watching the root directory.
-    #
-    def start
-      watch(@directory)
-      timestamp_files
-    end
-
-    # Stop listening for events.
-    #
-    def stop
-    end
-
-    # Pause the listener to ignore change events.
-    #
-    def pause
-      @paused = true
-    end
-
-    # Unpause the listener to listen again to change events.
-    #
-    def run
-      @paused = false
-    end
-
-    # Clear the list of changed files.
-    #
-    def clear_changed_files
-      @changed_files.clear
-    end
-
-    # Store a listener callback.
-    #
-    # @param [Block] callback the callback to store
-    #
-    def on_change(&callback)
-      @callback = callback
-    end
-
-    # Updates the timestamp of the last event.
-    #
-    def update_last_event
-      @last_event = Time.now
-    end
-
-    # Get the modified files.
-    #
-    # If the `:watch_all_modifications` option is true, then moved and
-    # deleted files are also reported, but prefixed by an exclamation point.
-    #
-    # @example Deleted or moved file
-    #   !/home/user/dir/file.rb
-    #
-    # @param [Array<String>] dirs the watched directories
-    # @param [Hash] options the listener options
-    # @option options [Symbol] all whether to files in sub directories
-    # @return [Array<String>] paths of files that have been modified
-    #
-    def modified_files(dirs, options = {})
-      last_event = @last_event
-      files = []
-      if @watch_all_modifications
-        deleted_files = @file_timestamp_hash.collect do |path, ts|
-          unless File.exists?(path)
-            @sha1_checksums_hash.delete(path)
-            @file_timestamp_hash.delete(path)
-            "!#{path}"
-          end
-        end
-        files.concat(deleted_files.compact)
-      end
-      update_last_event
-      files.concat(potentially_modified_files(dirs, options).select { |path| file_modified?(path, last_event) })
-
-      relativize_paths(files)
-    end
-
-    # Register a directory to watch.
-    # Must be implemented by the subclasses.
-    #
-    # @param [String] directory the directory to watch
-    #
-    def watch(directory)
-      raise NotImplementedError, "do whatever you want here, given the directory as only argument"
-    end
-
-    # Get all files that are in the watched directory.
-    #
-    # @return [Array<String>] the list of files
-    #
-    def all_files
-      potentially_modified_files([@directory], :all => true)
-    end
-
-    # Scopes all given paths to the current directory.
-    #
-    # @param [Array<String>] paths the paths to change
-    # @return [Array<String>] all paths now relative to the current dir
-    #
-    def relativize_paths(paths)
-      return paths unless relativize_paths?
-      paths.map do |path|
-      path.gsub(%r{^(!)?#{ @directory }/},'\1')
-      end
-    end
-
-    # Use paths relative to the current directory.
-    #
-    # @return [Boolean] whether to use relative or absolute paths
-    #
-    def relativize_paths?
-      !!@relativize_paths
-    end
-
-    # Populate initial timestamp file hash to watch for deleted or moved files.
-    #
-    def timestamp_files
-      all_files.each {|path| set_file_timestamp_hash(path, file_timestamp(path)) } if @watch_all_modifications
-    end
-
-    # Removes the ignored paths from the directory list.
-    #
-    # @param [Array<String>] dirs the directory to listen to
-    # @param [Array<String>] ignore_paths the paths to ignore
-    # @return children of the passed dirs that are not in the ignore_paths list
-    #
-    def exclude_ignored_paths(dirs, ignore_paths = self.ignore_paths)
-      Dir.glob(dirs.map { |d| "#{d.sub(%r{/+$}, '')}/*" }, File::FNM_DOTMATCH).reject do |path|
-        ignore_paths.include?(File.basename(path))
-      end
-    end
-
-    private
-
-    # Gets a list of files that are in the modified directories.
-    #
-    # @param [Array<String>] dirs the list of directories
-    # @param [Hash] options the find file option
-    # @option options [Symbol] all whether to files in sub directories
-    #
-    def potentially_modified_files(dirs, options = {})
-      paths = exclude_ignored_paths(dirs)
-
-      if options[:all]
-        paths.inject([]) do |array, path|
-          if File.file?(path)
-            array << path
-          else
-            array += Dir.glob("#{ path }/**/*", File::FNM_DOTMATCH).select { |p| File.file?(p) }
-          end
-          array
-        end
-      else
-        paths.select { |path| File.file?(path) }
-      end
-    end
-
-    # Test if the file content has changed.
-    #
-    # Depending on the filesystem, mtime/ctime is probably only precise to the second, so round
-    # both values down to the second for the comparison.
-    #
-    # ctime is used only on == comparison to always catches Rails 3.1 Assets pipelined on Mac OSX
-    #
-    # @param [String] path the file path
-    # @param [Time] last_event the time of the last event
-    # @return [Boolean] Whether the file content has changed or not.
-    #
-    def file_modified?(path, last_event)
-      ctime = File.ctime(path).to_i
-      mtime = File.mtime(path).to_i
-      if [mtime, ctime].max == last_event.to_i
-        file_content_modified?(path, sha1_checksum(path))
-      elsif mtime > last_event.to_i
-        set_sha1_checksums_hash(path, sha1_checksum(path))
-        true
-      elsif @watch_all_modifications
-        ts = file_timestamp(path)
-        if ts != @file_timestamp_hash[path]
-          set_file_timestamp_hash(path, ts)
-          true
-        end
-      else
-        false
-      end
-    rescue
-      false
-    end
-
-    # Tests if the file content has been modified by
-    # comparing the SHA1 checksum.
-    #
-    # @param [String] path the file path
-    # @param [String] sha1_checksum the checksum of the file
-    #
-    def file_content_modified?(path, sha1_checksum)
-      if @sha1_checksums_hash[path] != sha1_checksum
-        set_sha1_checksums_hash(path, sha1_checksum)
-        true
-      else
-        false
-      end
-    end
-
-    # Set save a files current timestamp
-    #
-    # @param [String] path the file path
-    # @param [Int] file_timestamp the files modified timestamp
-    #
-    def set_file_timestamp_hash(path, file_timestamp)
-        @file_timestamp_hash[path] = file_timestamp
-    end
-
-    # Set the current checksum of a file.
-    #
-    # @param [String] path the file path
-    # @param [String] sha1_checksum the checksum of the file
-    #
-    def set_sha1_checksums_hash(path, sha1_checksum)
-      @sha1_checksums_hash[path] = sha1_checksum
-    end
-
-    # Gets a files modified timestamp
-    #
-    # @path [String] path the file path
-    # @return [Int] file modified timestamp
-    #
-    def file_timestamp(path)
-      File.mtime(path).to_i
-    end
-
-    # Calculates the SHA1 checksum of a file.
-    #
-    # @param [String] path the path to the file
-    # @return [String] the SHA1 checksum
-    #
-    def sha1_checksum(path)
-      Digest::SHA1.file(path).to_s
-    end
-
-    # Test if the OS is Mac OS X.
-    #
-    # @return [Boolean] Whether the OS is Mac OS X
-    #
-    def self.mac?
-      RbConfig::CONFIG['target_os'] =~ /darwin/i
-    end
-
-    # Test if the OS is Linux.
-    #
-    # @return [Boolean] Whether the OS is Linux
-    #
-    def self.linux?
-      RbConfig::CONFIG['target_os'] =~ /linux/i
-    end
-
-    # Test if the OS is Windows.
-    #
-    # @return [Boolean] Whether the OS is Windows
-    #
-    def self.windows?
-      RbConfig::CONFIG['target_os'] =~ /mswin|mingw/i
-    end
-
-  end
-end
+require 'rbconfig'
+require 'digest/sha1'
+
+module Guard
+
+  autoload :Darwin,  'guard/listeners/darwin'
+  autoload :Linux,   'guard/listeners/linux'
+  autoload :Windows, 'guard/listeners/windows'
+  autoload :Polling, 'guard/listeners/polling'
+
+  # The Listener is the base class for all listener
+  # implementations.
+  #
+  # @abstract
+  #
+  class Listener
+
+    # Default paths that gets ignored by the listener
+    DEFAULT_IGNORE_PATHS = %w[. .. .bundle .git log tmp vendor]
+
+    attr_accessor :changed_files
+    attr_reader :directory, :ignore_paths
+
+    def paused?
+      @paused
+    end
+
+    # Select the appropriate listener implementation for the
+    # current OS and initializes it.
+    #
+    # @param [Array] args the arguments for the listener
+    # @return [Guard::Listener] the chosen listener
+    #
+    def self.select_and_init(*args)
+      if mac? && Darwin.usable?
+        Darwin.new(*args)
+      elsif linux? && Linux.usable?
+        Linux.new(*args)
+      elsif windows? && Windows.usable?
+        Windows.new(*args)
+      else
+        UI.info 'Using polling (Please help us to support your system better than that).'
+        Polling.new(*args)
+      end
+    end
+
+    # Initialize the listener.
+    #
+    # @param [String] directory the root directory to listen to
+    # @option options [Boolean] relativize_paths use only relative paths
+    # @option options [Array<String>] ignore_paths the paths to ignore by the listener
+    #
+    def initialize(directory = Dir.pwd, options = {})
+      @directory                = directory.to_s
+      @sha1_checksums_hash      = {}
+      @file_timestamp_hash      = {}
+      @relativize_paths         = options.fetch(:relativize_paths, true)
+      @changed_files            = []
+      @paused                   = false
+      @ignore_paths             = DEFAULT_IGNORE_PATHS
+      @ignore_paths            |= options[:ignore_paths] if options[:ignore_paths]
+      @watch_all_modifications  = options.fetch(:watch_all_modifications, false)
+
+      update_last_event
+      start_reactor
+    end
+
+    # Start the listener thread.
+    #
+    def start_reactor
+      return if ENV["GUARD_ENV"] == 'test'
+
+      Thread.new do
+        loop do
+          if @changed_files != [] && !@paused
+            changed_files = @changed_files.dup
+            clear_changed_files
+            ::Guard.run_on_change(changed_files)
+          else
+            sleep 0.1
+          end
+        end
+      end
+    end
+
+    # Start watching the root directory.
+    #
+    def start
+      watch(@directory)
+      timestamp_files
+    end
+
+    # Stop listening for events.
+    #
+    def stop
+    end
+
+    # Pause the listener to ignore change events.
+    #
+    def pause
+      @paused = true
+    end
+
+    # Unpause the listener to listen again to change events.
+    #
+    def run
+      @paused = false
+    end
+
+    # Clear the list of changed files.
+    #
+    def clear_changed_files
+      @changed_files.clear
+    end
+
+    # Store a listener callback.
+    #
+    # @param [Block] callback the callback to store
+    #
+    def on_change(&callback)
+      @callback = callback
+    end
+
+    # Updates the timestamp of the last event.
+    #
+    def update_last_event
+      @last_event = Time.now
+    end
+
+    # Get the modified files.
+    #
+    # If the `:watch_all_modifications` option is true, then moved and
+    # deleted files are also reported, but prefixed by an exclamation point.
+    #
+    # @example Deleted or moved file
+    #   !/home/user/dir/file.rb
+    #
+    # @param [Array<String>] dirs the watched directories
+    # @param [Hash] options the listener options
+    # @option options [Symbol] all whether to files in sub directories
+    # @return [Array<String>] paths of files that have been modified
+    #
+    def modified_files(dirs, options = {})
+      last_event = @last_event
+      files = []
+      if @watch_all_modifications
+        deleted_files = @file_timestamp_hash.collect do |path, ts|
+          unless File.exists?(path)
+            @sha1_checksums_hash.delete(path)
+            @file_timestamp_hash.delete(path)
+            "!#{path}"
+          end
+        end
+        files.concat(deleted_files.compact)
+      end
+      update_last_event
+      files.concat(potentially_modified_files(dirs, options).select { |path| file_modified?(path, last_event) })
+
+      relativize_paths(files)
+    end
+
+    # Register a directory to watch.
+    # Must be implemented by the subclasses.
+    #
+    # @param [String] directory the directory to watch
+    #
+    def watch(directory)
+      raise NotImplementedError, "do whatever you want here, given the directory as only argument"
+    end
+
+    # Get all files that are in the watched directory.
+    #
+    # @return [Array<String>] the list of files
+    #
+    def all_files
+      potentially_modified_files([@directory], :all => true)
+    end
+
+    # Scopes all given paths to the current directory.
+    #
+    # @param [Array<String>] paths the paths to change
+    # @return [Array<String>] all paths now relative to the current dir
+    #
+    def relativize_paths(paths)
+      return paths unless relativize_paths?
+      paths.map do |path|
+      path.gsub(%r{^(!)?#{ @directory }/},'\1')
+      end
+    end
+
+    # Use paths relative to the current directory.
+    #
+    # @return [Boolean] whether to use relative or absolute paths
+    #
+    def relativize_paths?
+      !!@relativize_paths
+    end
+
+    # Populate initial timestamp file hash to watch for deleted or moved files.
+    #
+    def timestamp_files
+      all_files.each {|path| set_file_timestamp_hash(path, file_timestamp(path)) } if @watch_all_modifications
+    end
+
+    # Removes the ignored paths from the directory list.
+    #
+    # @param [Array<String>] dirs the directory to listen to
+    # @param [Array<String>] ignore_paths the paths to ignore
+    # @return children of the passed dirs that are not in the ignore_paths list
+    #
+    def exclude_ignored_paths(dirs, ignore_paths = self.ignore_paths)
+      Dir.glob(dirs.map { |d| "#{d.sub(%r{/+$}, '')}/*" }, File::FNM_DOTMATCH).reject do |path|
+        ignore_paths.include?(File.basename(path))
+      end
+    end
+
+    private
+
+    # Gets a list of files that are in the modified directories.
+    #
+    # @param [Array<String>] dirs the list of directories
+    # @param [Hash] options the find file option
+    # @option options [Symbol] all whether to files in sub directories
+    #
+    def potentially_modified_files(dirs, options = {})
+      paths = exclude_ignored_paths(dirs)
+
+      if options[:all]
+        paths.inject([]) do |array, path|
+          if File.file?(path)
+            array << path
+          else
+            array += Dir.glob("#{ path }/**/*", File::FNM_DOTMATCH).select { |p| File.file?(p) }
+          end
+          array
+        end
+      else
+        paths.select { |path| File.file?(path) }
+      end
+    end
+
+    # Test if the file content has changed.
+    #
+    # Depending on the filesystem, mtime/ctime is probably only precise to the second, so round
+    # both values down to the second for the comparison.
+    #
+    # ctime is used only on == comparison to always catches Rails 3.1 Assets pipelined on Mac OSX
+    #
+    # @param [String] path the file path
+    # @param [Time] last_event the time of the last event
+    # @return [Boolean] Whether the file content has changed or not.
+    #
+    def file_modified?(path, last_event)
+      ctime = File.ctime(path).to_i
+      mtime = File.mtime(path).to_i
+      if [mtime, ctime].max == last_event.to_i
+        file_content_modified?(path, sha1_checksum(path))
+      elsif mtime > last_event.to_i
+        set_sha1_checksums_hash(path, sha1_checksum(path))
+        true
+      elsif @watch_all_modifications
+        ts = file_timestamp(path)
+        if ts != @file_timestamp_hash[path]
+          set_file_timestamp_hash(path, ts)
+          true
+        end
+      else
+        false
+      end
+    rescue
+      false
+    end
+
+    # Tests if the file content has been modified by
+    # comparing the SHA1 checksum.
+    #
+    # @param [String] path the file path
+    # @param [String] sha1_checksum the checksum of the file
+    #
+    def file_content_modified?(path, sha1_checksum)
+      if @sha1_checksums_hash[path] != sha1_checksum
+        set_sha1_checksums_hash(path, sha1_checksum)
+        true
+      else
+        false
+      end
+    end
+
+    # Set save a files current timestamp
+    #
+    # @param [String] path the file path
+    # @param [Int] file_timestamp the files modified timestamp
+    #
+    def set_file_timestamp_hash(path, file_timestamp)
+        @file_timestamp_hash[path] = file_timestamp
+    end
+
+    # Set the current checksum of a file.
+    #
+    # @param [String] path the file path
+    # @param [String] sha1_checksum the checksum of the file
+    #
+    def set_sha1_checksums_hash(path, sha1_checksum)
+      @sha1_checksums_hash[path] = sha1_checksum
+    end
+
+    # Gets a files modified timestamp
+    #
+    # @path [String] path the file path
+    # @return [Int] file modified timestamp
+    #
+    def file_timestamp(path)
+      File.mtime(path).to_i
+    end
+
+    # Calculates the SHA1 checksum of a file.
+    #
+    # @param [String] path the path to the file
+    # @return [String] the SHA1 checksum
+    #
+    def sha1_checksum(path)
+      Digest::SHA1.file(path).to_s
+    end
+
+    # Test if the OS is Mac OS X.
+    #
+    # @return [Boolean] Whether the OS is Mac OS X
+    #
+    def self.mac?
+      RbConfig::CONFIG['target_os'] =~ /darwin/i
+    end
+
+    # Test if the OS is Linux.
+    #
+    # @return [Boolean] Whether the OS is Linux
+    #
+    def self.linux?
+      RbConfig::CONFIG['target_os'] =~ /linux/i
+    end
+
+    # Test if the OS is Windows.
+    #
+    # @return [Boolean] Whether the OS is Windows
+    #
+    def self.windows?
+      RbConfig::CONFIG['target_os'] =~ /mswin|mingw/i
+    end
+
+  end
+end