listen 0.4.7 → 0.5.0

data/lib/listen/adapters/darwin.rb

@@ -4,6 +4,10 @@ module Listen
     # Adapter implementation for Mac OS X `FSEvents`.
     #
     class Darwin < Adapter
+      extend DependencyManager
+
+      # Declare the adapter's dependencies
+      dependency 'rb-fsevent', '~> 0.9.1'
 
       LAST_SEPARATOR_REGEX = /\/$/
 
@@ -25,13 +29,14 @@ module Listen
         end
 
         @worker_thread = Thread.new { @worker.run }
-        @poll_thread   = Thread.new { poll_changed_dirs }
 
         # The FSEvent worker needs sometime to startup. Turnstiles can't
         # be used to wait for it as it runs in a loop.
         # TODO: Find a better way to block until the worker starts.
-        sleep @latency
-        @poll_thread.join if blocking
+        sleep 0.1
+
+        @poll_thread = Thread.new { poll_changed_dirs } if @report_changes
+        @worker_thread.join if blocking
       end
 
       # Stops the adapter.
@@ -43,8 +48,8 @@ module Listen
         end
 
         @worker.stop
-        Thread.kill(@worker_thread) if @worker_thread
-        @poll_thread.join
+        @worker_thread.join if @worker_thread
+        @poll_thread.join if @poll_thread
       end
 
       # Checks if the adapter is usable on the current OS.
@@ -53,11 +58,7 @@ module Listen
       #
       def self.usable?
         return false unless RbConfig::CONFIG['target_os'] =~ /darwin(1.+)?$/i
-
-        require 'rb-fsevent'
-        true
-      rescue LoadError
-        false
+        super
       end
 
       private

data/lib/listen/adapters/linux.rb

@@ -4,6 +4,10 @@ module Listen
     # Listener implementation for Linux `inotify`.
     #
     class Linux < Adapter
+      extend DependencyManager
+
+      # Declare the adapter's dependencies
+      dependency 'rb-inotify', '~> 0.8.8'
 
       # Watched inotify events
       #
@@ -41,8 +45,9 @@ module Listen
         end
 
         @worker_thread = Thread.new { @worker.run }
-        @poll_thread   = Thread.new { poll_changed_dirs }
-        @poll_thread.join if blocking
+        @poll_thread   = Thread.new { poll_changed_dirs } if @report_changes
+
+        @worker_thread.join if blocking
       end
 
       # Stops the adapter.
@@ -55,20 +60,16 @@ module Listen
 
         @worker.stop
         Thread.kill(@worker_thread) if @worker_thread
-        @poll_thread.join
+        @poll_thread.join if @poll_thread
       end
 
-      # Check if the adapter is usable on the current OS.
+      # Checks if the adapter is usable on the current OS.
       #
       # @return [Boolean] whether usable or not
       #
       def self.usable?
         return false unless RbConfig::CONFIG['target_os'] =~ /linux/i
-
-        require 'rb-inotify'
-        true
-      rescue LoadError
-        false
+        super
       end
 
     private
@@ -79,29 +80,31 @@ module Listen
       # @return [INotify::Notifier] initialized worker
       #
       def init_worker
-        worker = INotify::Notifier.new
-        @directories.each do |directory|
-          worker.watch(directory, *EVENTS.map(&:to_sym)) do |event|
-            if @paused || (
-              # Event on root directory
-              event.name == ""
-            ) || (
-              # INotify reports changes to files inside directories as events
-              # on the directories themselves too.
-              #
-              # @see http://linux.die.net/man/7/inotify
-              event.flags.include?(:isdir) and event.flags & [:close, :modify] != []
-            )
-              # Skip all of these!
-              next
-            end
-
-            @mutex.synchronize do
-              @changed_dirs << File.dirname(event.absolute_name)
-            end
+        callback = lambda do |event|
+          if @paused || (
+            # Event on root directory
+            event.name == ""
+          ) || (
+            # INotify reports changes to files inside directories as events
+            # on the directories themselves too.
+            #
+            # @see http://linux.die.net/man/7/inotify
+            event.flags.include?(:isdir) and event.flags & [:close, :modify] != []
+          )
+            # Skip all of these!
+            next
+          end
+
+          @mutex.synchronize do
+            @changed_dirs << File.dirname(event.absolute_name)
+          end
+        end
+
+        INotify::Notifier.new.tap do |worker|
+          @directories.each do |directory|
+            worker.watch(directory, *EVENTS.map(&:to_sym), &callback)
           end
         end
-        worker
       end
 
     end

data/lib/listen/adapters/polling.rb

@@ -10,6 +10,7 @@ module Listen
     # file IO that the other implementations.
     #
     class Polling < Adapter
+      extend DependencyManager
 
       # Initialize the Adapter. See {Listen::Adapter#initialize} for more info.
       #

data/lib/listen/adapters/windows.rb

@@ -3,9 +3,13 @@ require 'set'
 module Listen
   module Adapters
 
-    # Adapter implementation for Windows `fchange`.
+    # Adapter implementation for Windows `wdm`.
     #
     class Windows < Adapter
+      extend DependencyManager
+
+      # Declare the adapter's dependencies
+      dependency 'wdm', '~> 0.0.3'
 
       # Initializes the Adapter. See {Listen::Adapter#initialize} for more info.
       #
@@ -24,9 +28,15 @@ module Listen
           super
         end
 
-        @worker_thread = Thread.new { @worker.run }
-        @poll_thread   = Thread.new { poll_changed_dirs(true) }
-        @poll_thread.join if blocking
+        @worker_thread = Thread.new { @worker.run! }
+
+        # Wait for the worker to start. This is needed to avoid a deadlock
+        # when stopping immediately after starting.
+        sleep 0.1
+
+        @poll_thread = Thread.new { poll_changed_dirs } if @report_changes
+
+        @worker_thread.join if blocking
       end
 
       # Stops the adapter.
@@ -38,8 +48,8 @@ module Listen
         end
 
         @worker.stop
-        Thread.kill(@worker_thread) if @worker_thread
-        @poll_thread.join
+        @worker_thread.join if @worker_thread
+        @poll_thread.join if @poll_thread
       end
 
       # Checks if the adapter is usable on the current OS.
@@ -48,31 +58,27 @@ module Listen
       #
       def self.usable?
         return false unless RbConfig::CONFIG['target_os'] =~ /mswin|mingw/i
-
-        require 'rb-fchange'
-        true
-      rescue LoadError
-        false
+        super
       end
 
     private
 
-      # Initializes a FChange worker and adds a watcher for
+      # Initializes a WDM monitor and adds a watcher for
       # each directory passed to the adapter.
       #
-      # @return [FChange::Notifier] initialized worker
+      # @return [WDM::Monitor] initialized worker
       #
       def init_worker
-        FChange::Notifier.new.tap do |worker|
-          @directories.each do |directory|
-            worker.watch(directory, :all_events, :recursive) do |event|
-              next if @paused
-              @mutex.synchronize do
-                @changed_dirs << File.expand_path(event.watcher.path)
-              end
-            end
+        callback = Proc.new do |change|
+          next if @paused
+          @mutex.synchronize do
+            @changed_dirs << File.dirname(change.path)
           end
         end
+
+        WDM::Monitor.new.tap do |worker|
+          @directories.each { |d| worker.watch_recursively(d, &callback) }
+        end
       end
 
     end

data/lib/listen/dependency_manager.rb

@@ -0,0 +1,126 @@
+require 'set'
+
+module Listen
+
+  # The dependency-manager offers a simple DSL which allows
+  # classes to declare their gem dependencies and load them when
+  # needed.
+  # It raises a user-friendly exception when the dependencies
+  # can't be loaded which has the install command in the message.
+  #
+  module DependencyManager
+
+    GEM_LOAD_MESSAGE = <<-EOS.gsub(/^ {6}/, '')
+      Missing dependency '%s' (version '%s')!
+    EOS
+
+    GEM_INSTALL_COMMAND = <<-EOS.gsub(/^ {6}/, '')
+      Please run the following to satisfy the dependency:
+        gem install --version '%s' %s
+    EOS
+
+    BUNDLER_DECLARE_GEM = <<-EOS.gsub(/^ {6}/, '')
+      Please add the following to your Gemfile to satisfy the dependency:
+        gem '%s', '%s'
+    EOS
+
+    Dependency = Struct.new(:name, :version)
+
+    # The error raised when a dependency can't be loaded.
+    class Error < StandardError; end
+
+    # A list of all loaded dependencies in the dependency manager.
+    @_loaded_dependencies = Set.new
+
+    # class methods
+    class << self
+
+      # Initializes the extended class.
+      #
+      # @param [Class] the class for which some dependencies must be managed
+      #
+      def extended(base)
+        base.class_eval do
+          @_dependencies = Set.new
+        end
+      end
+
+      # Adds a loaded dependency to a list so that it doesn't have
+      # to be loaded again by another classes.
+      #
+      # @param [Dependency] dependency
+      #
+      def add_loaded(dependency)
+        @_loaded_dependencies << dependency
+      end
+
+      # Returns whether the dependency is alread loaded or not.
+      #
+      # @param [Dependency] dependency
+      # @return [Boolean]
+      #
+      def already_loaded?(dependency)
+        @_loaded_dependencies.include?(dependency)
+      end
+
+      # Clears the list of loaded dependencies.
+      #
+      def clear_loaded
+        @_loaded_dependencies.clear
+      end
+    end
+
+    # Registers a new dependency.
+    #
+    # @param [String] name the name of the gem
+    # @param [String] version the version of the gem
+    #
+    def dependency(name, version)
+      @_dependencies << Dependency.new(name, version)
+    end
+
+    # Loads the registered dependencies.
+    #
+    # @raise DependencyManager::Error if the dependency can't be loaded.
+    #
+    def load_depenencies
+      @_dependencies.each do |dependency|
+        begin
+          next if DependencyManager.already_loaded?(dependency)
+          gem(dependency.name, dependency.version)
+          require(dependency.name)
+          DependencyManager.add_loaded(dependency)
+          @_dependencies.delete(dependency)
+        rescue Gem::LoadError
+          args = [dependency.name, dependency.version]
+          command = if running_under_bundler?
+            BUNDLER_DECLARE_GEM % args
+          else
+            GEM_INSTALL_COMMAND % args.reverse
+          end
+          message = GEM_LOAD_MESSAGE % args
+
+          raise Error.new(message + command)
+        end
+      end
+    end
+
+    # Returns whether all the dependencies has been loaded or not.
+    #
+    # @return [Boolean]
+    #
+    def dependencies_loaded?
+      @_dependencies.empty?
+    end
+
+    private
+
+    # Returns whether we are running under bundler or not
+    #
+    # @return [Boolean]
+    #
+    def running_under_bundler?
+      !!(File.exists?('Gemfile') && ENV['BUNDLE_GEMFILE'])
+    end
+  end
+end

data/lib/listen/directory_record.rb

@@ -1,318 +1,318 @@
-require 'set'
-require 'find'
-require 'digest/sha1'
-
-module Listen
-
-  # The directory record stores information about
-  # a directory and keeps track of changes to
-  # the structure of its childs.
-  #
-  class DirectoryRecord
-    attr_reader :directory, :paths, :sha1_checksums
-
-    DEFAULT_IGNORED_DIRECTORIES = %w[.rbx .bundle .git .svn log tmp vendor]
-
-    DEFAULT_IGNORED_EXTENSIONS  = %w[.DS_Store]
-
-    # Defines the used precision based on the type of mtime returned by the
-    # system (whether its in milliseconds or just seconds)
-    #
-    HIGH_PRECISION_SUPPORTED = File.mtime(__FILE__).to_f.to_s[-2..-1] != '.0'
-
-    # Data structure used to save meta data about a path
-    #
-    MetaData = Struct.new(:type, :mtime)
-
-    # Class methods
-    #
-    class << self
-
-      # Creates the ignoring patterns from the default ignored
-      # directories and extensions. It memoizes the generated patterns
-      # to avoid unnecessary computation.
-      #
-      def generate_default_ignoring_patterns
-        @@default_ignoring_patterns ||= Array.new.tap do |default_patterns|
-          # Add directories
-          ignored_directories = DEFAULT_IGNORED_DIRECTORIES.map { |d| Regexp.escape(d) }
-          default_patterns << %r{^(?:#{ignored_directories.join('|')})/}
-
-          # Add extensions
-          ignored_extensions = DEFAULT_IGNORED_EXTENSIONS.map { |e| Regexp.escape(e) }
-          default_patterns << %r{(?:#{ignored_extensions.join('|')})$}
-        end
-      end
-    end
-
-    # Initializes a directory record.
-    #
-    # @option [String] directory the directory to keep track of
-    #
-    def initialize(directory)
-      raise ArgumentError, "The path '#{directory}' is not a directory!" unless File.directory?(directory)
-
-      @directory          = directory
-      @ignoring_patterns  = Set.new
-      @filtering_patterns = Set.new
-      @sha1_checksums     = Hash.new
-
-      @ignoring_patterns.merge(DirectoryRecord.generate_default_ignoring_patterns)
-    end
-
-    # Returns the ignoring patterns in the record
-    #
-    # @return [Array<Regexp>] the ignoring patterns
-    #
-    def ignoring_patterns
-      @ignoring_patterns.to_a
-    end
-
-    # Returns the filtering patterns used in the record to know
-    # which paths should be stored.
-    #
-    # @return [Array<Regexp>] the filtering patterns
-    #
-    def filtering_patterns
-      @filtering_patterns.to_a
-    end
-
-    # Adds ignoring patterns to the record.
-    #
-    # @example Ignore some paths
-    #   ignore %r{^ignored/path/}, /man/
-    #
-    # @param [Regexp] regexp a pattern for ignoring paths
-    #
-    def ignore(*regexps)
-      @ignoring_patterns.merge(regexps)
-    end
-
-    # Adds filtering patterns to the listener.
-    #
-    # @example Filter some files
-    #   ignore /\.txt$/, /.*\.zip/
-    #
-    # @param [Regexp] regexp a pattern for filtering paths
-    #
-    def filter(*regexps)
-      @filtering_patterns.merge(regexps)
-    end
-
-    # Returns whether a path should be ignored or not.
-    #
-    # @param [String] path the path to test.
-    #
-    # @return [Boolean]
-    #
-    def ignored?(path)
-      path = relative_to_base(path)
-      @ignoring_patterns.any? { |pattern| pattern =~ path }
-    end
-
-    # Returns whether a path should be filtered or not.
-    #
-    # @param [String] path the path to test.
-    #
-    # @return [Boolean]
-    #
-    def filtered?(path)
-      # When no filtering patterns are set, ALL files are stored.
-      return true if @filtering_patterns.empty?
-
-      path = relative_to_base(path)
-      @filtering_patterns.any? { |pattern| pattern =~ path }
-    end
-
-    # Finds the paths that should be stored and adds them
-    # to the paths' hash.
-    #
-    def build
-      @paths = Hash.new { |h, k| h[k] = Hash.new }
-      important_paths { |path| insert_path(path) }
-    end
-
-    # Detects changes in the passed directories, updates
-    # the record with the new changes and returns the changes
-    #
-    # @param [Array] directories the list of directories scan for changes
-    # @param [Hash] options
-    # @option options [Boolean] recursive scan all sub-directories recursively
-    # @option options [Boolean] relative_paths whether or not to use relative paths for changes
-    #
-    # @return [Hash<Array>] the changes
-    #
-    def fetch_changes(directories, options = {})
-      @changes    = { :modified => [], :added => [], :removed => [] }
-      directories = directories.sort_by { |el| el.length }.reverse # diff sub-dir first
-
-      directories.each do |directory|
-        next unless directory[@directory] # Path is or inside directory
-        detect_modifications_and_removals(directory, options)
-        detect_additions(directory, options)
-      end
-
-      @changes
-    end
-
-    # Converts an absolute path to a path that's relative to the base directory.
-    #
-    # @param [String] path the path to convert
-    #
-    # @return [String] the relative path
-    #
-    def relative_to_base(path)
-      return nil unless path[@directory]
-      path.sub(%r{^#{Regexp.quote(@directory)}#{File::SEPARATOR}?}, '')
-    end
-
-    private
-
-    # Detects modifications and removals recursively in a directory.
-    #
-    # @note Modifications detection begins by checking the modification time (mtime)
-    #   of files and then by checking content changes (using SHA1-checksum)
-    #   when the mtime of files is not changed.
-    #
-    # @param [String] directory the path to analyze
-    # @param [Hash] options
-    # @option options [Boolean] recursive scan all sub-directories recursively
-    # @option options [Boolean] relative_paths whether or not to use relative paths for changes
-    #
-    def detect_modifications_and_removals(directory, options = {})
-      @paths[directory].each do |basename, meta_data|
-        path = File.join(directory, basename)
-
-        case meta_data.type
-        when 'Dir'
-          if File.directory?(path)
-            detect_modifications_and_removals(path, options) if options[:recursive]
-          else
-            detect_modifications_and_removals(path, { :recursive => true }.merge(options))
-            @paths[directory].delete(basename)
-            @paths.delete("#{directory}/#{basename}")
-          end
-        when 'File'
-          if File.exist?(path)
-            new_mtime = mtime_of(path)
-
-            # First check if we are in the same second (to update checksums)
-            # before checking the time difference
-            if  (meta_data.mtime.to_i == new_mtime.to_i && content_modified?(path)) || meta_data.mtime < new_mtime
-              # Update the meta data of the files
-              meta_data.mtime = new_mtime
-              @paths[directory][basename] = meta_data
-
-              @changes[:modified] << (options[:relative_paths] ? relative_to_base(path) : path)
-            end
-          else
-            @paths[directory].delete(basename)
-            @sha1_checksums.delete(path)
-            @changes[:removed] << (options[:relative_paths] ? relative_to_base(path) : path)
-          end
-        end
-      end
-    end
-
-    # Detects additions in a directory.
-    #
-    # @param [String] directory the path to analyze
-    # @param [Hash] options
-    # @option options [Boolean] recursive scan all sub-directories recursively
-    # @option options [Boolean] relative_paths whether or not to use relative paths for changes
-    #
-    def detect_additions(directory, options = {})
-      # Don't process removed directories
-      return unless File.exist?(directory)
-
-      Find.find(directory) do |path|
-        next if path == @directory
-
-        if File.directory?(path)
-          # Add a trailing slash to directories when checking if a directory is
-          # ignored to optimize finding them as Find.find doesn't.
-          if ignored?(path + File::SEPARATOR) || (directory != path && (!options[:recursive] && existing_path?(path)))
-            Find.prune # Don't look any further into this directory.
-          else
-            insert_path(path)
-          end
-        elsif !ignored?(path) && filtered?(path) && !existing_path?(path)
-          if File.file?(path)
-            @changes[:added] << (options[:relative_paths] ? relative_to_base(path) : path)
-            insert_path(path)
-          end
-        end
-      end
-    end
-
-    # Returns whether or not a file's content has been modified by
-    # comparing the SHA1-checksum to a stored one.
-    #
-    # @param [String] path the file path
-    #
-    def content_modified?(path)
-      sha1_checksum = Digest::SHA1.file(path).to_s
-      return false if @sha1_checksums[path] == sha1_checksum
-      @sha1_checksums.key?(path)
-    rescue Errno::EACCES, Errno::ENOENT
-      false
-    ensure
-      @sha1_checksums[path] = sha1_checksum if sha1_checksum
-    end
-
-    # Traverses the base directory looking for paths that should
-    # be stored; thus paths that are filters or not ignored.
-    #
-    # @yield [path] an important path
-    #
-    def important_paths
-      Find.find(@directory) do |path|
-        next if path == @directory
-
-        if File.directory?(path)
-          # Add a trailing slash to directories when checking if a directory is
-          # ignored to optimize finding them as Find.find doesn't.
-          if ignored?(path + File::SEPARATOR)
-            Find.prune # Don't look any further into this directory.
-          else
-            yield(path)
-          end
-        elsif !ignored?(path) && filtered?(path)
-          yield(path)
-        end
-      end
-    end
-
-    # Inserts a path with its type (Dir or File) in paths hash.
-    #
-    # @param [String] path the path to insert in @paths.
-    #
-    def insert_path(path)
-      meta_data = MetaData.new
-      meta_data.type = File.directory?(path) ? 'Dir' : 'File'
-      meta_data.mtime = mtime_of(path) unless meta_data.type == 'Dir' # mtimes of dirs are not used yet
-      @paths[File.dirname(path)][File.basename(path)] = meta_data
-    rescue Errno::ENOENT
-    end
-
-    # Returns whether or not a path exists in the paths hash.
-    #
-    # @param [String] path the path to check
-    #
-    # @return [Boolean]
-    #
-    def existing_path?(path)
-      @paths[File.dirname(path)][File.basename(path)] != nil
-    end
-
-    # Returns the modification time of a file based on the precision defined by the system
-    #
-    # @param [String] file the file for which the mtime must be returned
-    #
-    # @return [Fixnum, Float] the mtime of the file
-    #
-    def mtime_of(file)
-      File.lstat(file).mtime.send(HIGH_PRECISION_SUPPORTED ? :to_f : :to_i)
-    end
-  end
-end
+require 'set'
+require 'find'
+require 'digest/sha1'
+
+module Listen
+
+  # The directory record stores information about
+  # a directory and keeps track of changes to
+  # the structure of its childs.
+  #
+  class DirectoryRecord
+    attr_reader :directory, :paths, :sha1_checksums
+
+    DEFAULT_IGNORED_DIRECTORIES = %w[.rbx .bundle .git .svn log tmp vendor]
+
+    DEFAULT_IGNORED_EXTENSIONS  = %w[.DS_Store]
+
+    # Defines the used precision based on the type of mtime returned by the
+    # system (whether its in milliseconds or just seconds)
+    #
+    HIGH_PRECISION_SUPPORTED = File.mtime(__FILE__).to_f.to_s[-2..-1] != '.0'
+
+    # Data structure used to save meta data about a path
+    #
+    MetaData = Struct.new(:type, :mtime)
+
+    # Class methods
+    #
+    class << self
+
+      # Creates the ignoring patterns from the default ignored
+      # directories and extensions. It memoizes the generated patterns
+      # to avoid unnecessary computation.
+      #
+      def generate_default_ignoring_patterns
+        @@default_ignoring_patterns ||= Array.new.tap do |default_patterns|
+          # Add directories
+          ignored_directories = DEFAULT_IGNORED_DIRECTORIES.map { |d| Regexp.escape(d) }
+          default_patterns << %r{^(?:#{ignored_directories.join('|')})/}
+
+          # Add extensions
+          ignored_extensions = DEFAULT_IGNORED_EXTENSIONS.map { |e| Regexp.escape(e) }
+          default_patterns << %r{(?:#{ignored_extensions.join('|')})$}
+        end
+      end
+    end
+
+    # Initializes a directory record.
+    #
+    # @option [String] directory the directory to keep track of
+    #
+    def initialize(directory)
+      raise ArgumentError, "The path '#{directory}' is not a directory!" unless File.directory?(directory)
+
+      @directory          = directory
+      @ignoring_patterns  = Set.new
+      @filtering_patterns = Set.new
+      @sha1_checksums     = Hash.new
+
+      @ignoring_patterns.merge(DirectoryRecord.generate_default_ignoring_patterns)
+    end
+
+    # Returns the ignoring patterns in the record
+    #
+    # @return [Array<Regexp>] the ignoring patterns
+    #
+    def ignoring_patterns
+      @ignoring_patterns.to_a
+    end
+
+    # Returns the filtering patterns used in the record to know
+    # which paths should be stored.
+    #
+    # @return [Array<Regexp>] the filtering patterns
+    #
+    def filtering_patterns
+      @filtering_patterns.to_a
+    end
+
+    # Adds ignoring patterns to the record.
+    #
+    # @example Ignore some paths
+    #   ignore %r{^ignored/path/}, /man/
+    #
+    # @param [Regexp] regexp a pattern for ignoring paths
+    #
+    def ignore(*regexps)
+      @ignoring_patterns.merge(regexps)
+    end
+
+    # Adds filtering patterns to the listener.
+    #
+    # @example Filter some files
+    #   ignore /\.txt$/, /.*\.zip/
+    #
+    # @param [Regexp] regexp a pattern for filtering paths
+    #
+    def filter(*regexps)
+      @filtering_patterns.merge(regexps)
+    end
+
+    # Returns whether a path should be ignored or not.
+    #
+    # @param [String] path the path to test.
+    #
+    # @return [Boolean]
+    #
+    def ignored?(path)
+      path = relative_to_base(path)
+      @ignoring_patterns.any? { |pattern| pattern =~ path }
+    end
+
+    # Returns whether a path should be filtered or not.
+    #
+    # @param [String] path the path to test.
+    #
+    # @return [Boolean]
+    #
+    def filtered?(path)
+      # When no filtering patterns are set, ALL files are stored.
+      return true if @filtering_patterns.empty?
+
+      path = relative_to_base(path)
+      @filtering_patterns.any? { |pattern| pattern =~ path }
+    end
+
+    # Finds the paths that should be stored and adds them
+    # to the paths' hash.
+    #
+    def build
+      @paths = Hash.new { |h, k| h[k] = Hash.new }
+      important_paths { |path| insert_path(path) }
+    end
+
+    # Detects changes in the passed directories, updates
+    # the record with the new changes and returns the changes
+    #
+    # @param [Array] directories the list of directories scan for changes
+    # @param [Hash] options
+    # @option options [Boolean] recursive scan all sub-directories recursively
+    # @option options [Boolean] relative_paths whether or not to use relative paths for changes
+    #
+    # @return [Hash<Array>] the changes
+    #
+    def fetch_changes(directories, options = {})
+      @changes    = { :modified => [], :added => [], :removed => [] }
+      directories = directories.sort_by { |el| el.length }.reverse # diff sub-dir first
+
+      directories.each do |directory|
+        next unless directory[@directory] # Path is or inside directory
+        detect_modifications_and_removals(directory, options)
+        detect_additions(directory, options)
+      end
+
+      @changes
+    end
+
+    # Converts an absolute path to a path that's relative to the base directory.
+    #
+    # @param [String] path the path to convert
+    #
+    # @return [String] the relative path
+    #
+    def relative_to_base(path)
+      return nil unless path[@directory]
+      path.sub(%r{^#{Regexp.quote(@directory)}#{File::SEPARATOR}?}, '')
+    end
+
+    private
+
+    # Detects modifications and removals recursively in a directory.
+    #
+    # @note Modifications detection begins by checking the modification time (mtime)
+    #   of files and then by checking content changes (using SHA1-checksum)
+    #   when the mtime of files is not changed.
+    #
+    # @param [String] directory the path to analyze
+    # @param [Hash] options
+    # @option options [Boolean] recursive scan all sub-directories recursively
+    # @option options [Boolean] relative_paths whether or not to use relative paths for changes
+    #
+    def detect_modifications_and_removals(directory, options = {})
+      @paths[directory].each do |basename, meta_data|
+        path = File.join(directory, basename)
+
+        case meta_data.type
+        when 'Dir'
+          if File.directory?(path)
+            detect_modifications_and_removals(path, options) if options[:recursive]
+          else
+            detect_modifications_and_removals(path, { :recursive => true }.merge(options))
+            @paths[directory].delete(basename)
+            @paths.delete("#{directory}/#{basename}")
+          end
+        when 'File'
+          if File.exist?(path)
+            new_mtime = mtime_of(path)
+
+            # First check if we are in the same second (to update checksums)
+            # before checking the time difference
+            if  (meta_data.mtime.to_i == new_mtime.to_i && content_modified?(path)) || meta_data.mtime < new_mtime
+              # Update the meta data of the files
+              meta_data.mtime = new_mtime
+              @paths[directory][basename] = meta_data
+
+              @changes[:modified] << (options[:relative_paths] ? relative_to_base(path) : path)
+            end
+          else
+            @paths[directory].delete(basename)
+            @sha1_checksums.delete(path)
+            @changes[:removed] << (options[:relative_paths] ? relative_to_base(path) : path)
+          end
+        end
+      end
+    end
+
+    # Detects additions in a directory.
+    #
+    # @param [String] directory the path to analyze
+    # @param [Hash] options
+    # @option options [Boolean] recursive scan all sub-directories recursively
+    # @option options [Boolean] relative_paths whether or not to use relative paths for changes
+    #
+    def detect_additions(directory, options = {})
+      # Don't process removed directories
+      return unless File.exist?(directory)
+
+      Find.find(directory) do |path|
+        next if path == @directory
+
+        if File.directory?(path)
+          # Add a trailing slash to directories when checking if a directory is
+          # ignored to optimize finding them as Find.find doesn't.
+          if ignored?(path + File::SEPARATOR) || (directory != path && (!options[:recursive] && existing_path?(path)))
+            Find.prune # Don't look any further into this directory.
+          else
+            insert_path(path)
+          end
+        elsif !ignored?(path) && filtered?(path) && !existing_path?(path)
+          if File.file?(path)
+            @changes[:added] << (options[:relative_paths] ? relative_to_base(path) : path)
+            insert_path(path)
+          end
+        end
+      end
+    end
+
+    # Returns whether or not a file's content has been modified by
+    # comparing the SHA1-checksum to a stored one.
+    #
+    # @param [String] path the file path
+    #
+    def content_modified?(path)
+      sha1_checksum = Digest::SHA1.file(path).to_s
+      return false if @sha1_checksums[path] == sha1_checksum
+      @sha1_checksums.key?(path)
+    rescue Errno::EACCES, Errno::ENOENT
+      false
+    ensure
+      @sha1_checksums[path] = sha1_checksum if sha1_checksum
+    end
+
+    # Traverses the base directory looking for paths that should
+    # be stored; thus paths that are filters or not ignored.
+    #
+    # @yield [path] an important path
+    #
+    def important_paths
+      Find.find(@directory) do |path|
+        next if path == @directory
+
+        if File.directory?(path)
+          # Add a trailing slash to directories when checking if a directory is
+          # ignored to optimize finding them as Find.find doesn't.
+          if ignored?(path + File::SEPARATOR)
+            Find.prune # Don't look any further into this directory.
+          else
+            yield(path)
+          end
+        elsif !ignored?(path) && filtered?(path)
+          yield(path)
+        end
+      end
+    end
+
+    # Inserts a path with its type (Dir or File) in paths hash.
+    #
+    # @param [String] path the path to insert in @paths.
+    #
+    def insert_path(path)
+      meta_data = MetaData.new
+      meta_data.type = File.directory?(path) ? 'Dir' : 'File'
+      meta_data.mtime = mtime_of(path) unless meta_data.type == 'Dir' # mtimes of dirs are not used yet
+      @paths[File.dirname(path)][File.basename(path)] = meta_data
+    rescue Errno::ENOENT
+    end
+
+    # Returns whether or not a path exists in the paths hash.
+    #
+    # @param [String] path the path to check
+    #
+    # @return [Boolean]
+    #
+    def existing_path?(path)
+      @paths[File.dirname(path)][File.basename(path)] != nil
+    end
+
+    # Returns the modification time of a file based on the precision defined by the system
+    #
+    # @param [String] file the file for which the mtime must be returned
+    #
+    # @return [Fixnum, Float] the mtime of the file
+    #
+    def mtime_of(file)
+      File.lstat(file).mtime.send(HIGH_PRECISION_SUPPORTED ? :to_f : :to_i)
+    end
+  end
+end