listen 0.3.3 → 0.4.0

data/lib/listen/listener.rb

@@ -1,26 +1,18 @@
-require 'find'
-require 'digest/sha1'
-
-require 'listen/adapter'
-require 'listen/adapters/darwin'
-require 'listen/adapters/linux'
-require 'listen/adapters/polling'
-require 'listen/adapters/windows'
-
 module Listen
   class Listener
-    attr_accessor :directory, :ignored_paths, :file_filters, :sha1_checksums, :paths, :adapter, :paused
+    attr_reader :directory, :directory_record, :adapter
 
-    # Default paths that gets ignored by the listener
-    DEFAULT_IGNORED_PATHS = %w[.bundle .git .DS_Store log tmp vendor]
+    # The default value for using relative paths in the callback.
+    DEFAULT_TO_RELATIVE_PATHS = false
 
-    # Initialize the file listener.
+    # Initializes the directory listener.
     #
-    # @param [String, Pathname] directory the directory to watch
+    # @param [String] directory the directory to listen to
     # @param [Hash] options the listen options
     # @option options [String] ignore a list of paths to ignore
     # @option options [Regexp] filter a list of regexps file filters
     # @option options [Float] latency the delay between checking for changes in seconds
+    # @option options [Boolean] relative_paths whether or not to use relative-paths in the callback
     # @option options [Boolean] force_polling whether to force the polling adapter or not
     # @option options [String, Boolean] polling_fallback_message to change polling fallback message or remove it
     #
@@ -29,81 +21,84 @@ module Listen
     # @yieldparam [Array<String>] added the list of added files
     # @yieldparam [Array<String>] removed the list of removed files
     #
-    # @return [Listen::Listener] the file listener
-    #
     def initialize(directory, options = {}, &block)
-      @directory      = directory
-      @ignored_paths  = DEFAULT_IGNORED_PATHS
-      @file_filters   = []
-      @sha1_checksums = {}
-      @block          = block
-      @ignored_paths += Array(options.delete(:ignore)) if options[:ignore]
-      @file_filters  += Array(options.delete(:filter)) if options[:filter]
+      @block              = block
+      @directory          = directory
+      @directory_record   = DirectoryRecord.new(directory)
+      @use_relative_paths = DEFAULT_TO_RELATIVE_PATHS
+
+      @use_relative_paths = options.delete(:relative_paths) if options[:relative_paths]
+      @directory_record.ignore(*options.delete(:ignore))    if options[:ignore]
+      @directory_record.filter(*options.delete(:filter))    if options[:filter]
 
       @adapter_options = options
     end
 
-    # Initialize the adapter and the @paths concurrently and start the adapter.
+    # Starts the listener by initializing the adapter and building
+    # the directory record concurrently, then it starts the adapter to watch
+    # for changes.
     #
-    def start
-      Thread.new { @adapter = initialize_adapter }
-      init_paths
-      sleep 0.01 while @adapter.nil?
-      @adapter.start
+    # @param [Boolean] blocking whether or not to block the current thread after starting
+    #
+    def start(blocking = true)
+      t = Thread.new { @adapter = initialize_adapter }
+      @directory_record.build
+      t.join
+      @adapter.start(blocking)
     end
 
-    # Stop the adapter.
+    # Stops the listener.
     #
     def stop
       @adapter.stop
     end
 
-    # Pause the adapter
+    # Pauses the listener.
+    #
+    # @return [Listen::Listener] the listener
     #
     def pause
       @adapter.paused = true
+      self
     end
 
-    # Re-initialize @paths and unpause the adapter
+    # Unpauses the listener.
+    #
+    # @return [Listen::Listener] the listener
     #
     def unpause
-      init_paths
+      @directory_record.build
       @adapter.paused = false
+      self
     end
 
-    # Is adapter paused
+    # Returns whether the listener is paused or not.
     #
     # @return [Boolean] adapter paused status
     #
     def paused?
-      !@adapter.nil? && @adapter.paused == true
+      !!@adapter && @adapter.paused == true
     end
 
-    # Add ignored path to the listener.
-    #
-    # @example Ignore some paths
-    #   ignore ".git", ".svn"
+    # Adds ignored paths to the listener.
     #
-    # @param [Array<String>] paths a list of paths to ignore
+    # @param (see Listen::DirectoryRecord#ignore)
     #
-    # @return [Listen::Listener] the listener itself
+    # @return [Listen::Listener] the listener
     #
     def ignore(*paths)
-      @ignored_paths.push(*paths)
+      @directory_record.ignore(*paths)
       self
     end
 
-    # Add file filters to the listener.
+    # Adds file filters to the listener.
     #
-    # @example Filter some files
-    #   ignore /\.txt$/, /.*\.zip/
+    # @param (see Listen::DirectoryRecord#filter)
     #
-    # @param [Array<Regexp>] regexps a list of regexps file filters
-    #
-    # @return [Listen::Listener] the listener itself
+    # @return [Listen::Listener] the listener
     #
     def filter(*regexps)
-      @file_filters.push(*regexps)
+      @directory_record.filter(*regexps)
       self
     end
 
@@ -115,7 +110,7 @@ module Listen
     #
     # @param [Float] seconds the amount of delay, in seconds
     #
-    # @return [Listen::Listener] the listener itself
+    # @return [Listen::Listener] the listener
     #
     def latency(seconds)
       @adapter_options[:latency] = seconds
@@ -128,9 +123,9 @@ module Listen
     # @example Forcing the use of the polling adapter
     #   force_polling true
     #
-    # @param [Boolean] value wheather to force the polling adapter or not
+    # @param [Boolean] value whether to force the polling adapter or not
     #
-    # @return [Listen::Listener] the listener itself
+    # @return [Listen::Listener] the listener
     #
     def force_polling(value)
       @adapter_options[:force_polling] = value
@@ -144,212 +139,48 @@ module Listen
     #
     # @param [String, Boolean] value to change polling fallback message or remove it
     #
-    # @return [Listen::Listener] the listener itself
+    # @return [Listen::Listener] the listener
     #
     def polling_fallback_message(value)
       @adapter_options[:polling_fallback_message] = value
       self
     end
 
-    # Set change callback block to the listener.
+    # Sets the callback that gets called on changes.
     #
     # @example Assign a callback to be called on changes
     #   callback = lambda { |modified, added, removed| ... }
     #   change &callback
     #
-    # @param [Block] block a block callback called on changes
+    # @param [Proc] block the callback proc
     #
-    # @return [Listen::Listener] the listener itself
+    # @return [Listen::Listener] the listener
     #
     def change(&block) # modified, added, removed
       @block = block
       self
     end
 
-    # Call @block callback when there is a diff in the passed directory.
+    # Runs the callback passing it the changes if there are any.
     #
-    # @param [Array] directories the list of directories to diff
+    # @param (see Listen::DirectoryRecord#fetch_changes)
     #
-    def on_change(directories, diff_options = {})
-      changes = diff(directories, diff_options)
+    def on_change(directories, options = {})
+      changes = @directory_record.fetch_changes(directories, options.merge(
+        :relative_paths => @use_relative_paths
+      ))
       unless changes.values.all? { |paths| paths.empty? }
         @block.call(changes[:modified],changes[:added],changes[:removed])
       end
     end
 
-    # Initialize the @paths double levels Hash with all existing paths and set diffed_at.
-    #
-    def init_paths
-      @paths = Hash.new { |h,k| h[k] = {} }
-      all_existing_paths { |path| insert_path(path) }
-      @diffed_at = Time.now.to_i
-    end
-
-    # Detect changes diff in a directory.
-    #
-    # @param [Array] directories the list of directories to diff
-    # @param [Hash] options
-    # @option options [Boolean] recursive scan all sub-direcoties recursively (true when polling)
-    # @return [Hash<Array>] the file changes
-    #
-    def diff(directories, options = {})
-      @changes    = { :modified => [], :added => [], :removed => [] }
-      directories = directories.sort_by { |el| el.length }.reverse # diff sub-dir first
-      directories.each do |directory|
-        detect_modifications_and_removals(directory, options)
-        detect_additions(directory, options)
-      end
-      @diffed_at = Time.now.to_i
-      @changes
-    end
-
-  private
+    private
 
-    # Initialize adapter with the listener callback and the @adapter_options
+    # Initializes an adapter passing it the callback and adapters' options.
     #
     def initialize_adapter
       callback = lambda { |changed_dirs, options| self.on_change(changed_dirs, options) }
       Adapter.select_and_initialize(@directory, @adapter_options, &callback)
     end
-
-    # Research all existing paths (directories & files) filtered and without ignored directories paths.
-    #
-    # @yield [path] the existing path
-    #
-    def all_existing_paths
-      Find.find(@directory) do |path|
-        next if @directory == path
-
-        if File.directory?(path)
-          if ignored_path?(path)
-            Find.prune # Don't look any further into this directory.
-          else
-            yield(path)
-          end
-        elsif !ignored_path?(path) && filtered_file?(path)
-          yield(path)
-        end
-      end
-    end
-
-    # Insert a path with its type (Dir or File) in @paths.
-    #
-    # @param [String] path the path to insert in @paths.
-    #
-    def insert_path(path)
-      @paths[File.dirname(path)][File.basename(path)] = File.directory?(path) ? 'Dir' : 'File'
-    end
-
-    # Find is a path exists in @paths.
-    #
-    # @param [String] path the path to find in @paths.
-    # @return [Boolean]
-    #
-    def existing_path?(path)
-      @paths[File.dirname(path)][File.basename(path)] != nil
-    end
-
-    # Detect modifications and removals recursivly in a directory.
-    # Modifications detection are based on mtime first and on checksum when mtime == last diffed_at
-    #
-    # @param [String] directory the path to analyze
-    # @param [Hash] options
-    # @option options [Boolean] recursive scan all sub-direcoties recursively (when polling)
-    #
-    def detect_modifications_and_removals(directory, options = {})
-      @paths[directory].each do |basename, type|
-        path = File.join(directory, basename)
-
-        case type
-        when 'Dir'
-          if File.directory?(path)
-            detect_modifications_and_removals(path, options) if options[:recursive]
-          else
-            detect_modifications_and_removals(path, :recursive => true)
-            @paths[directory].delete(basename)
-            @paths.delete("#{directory}/#{basename}")
-          end
-        when 'File'
-          if File.exist?(path)
-            new_mtime = File.mtime(path).to_i
-            if @diffed_at < new_mtime || (@diffed_at == new_mtime && content_modified?(path))
-              @changes[:modified] << relative_path(path)
-            end
-          else
-            @paths[directory].delete(basename)
-            @sha1_checksums.delete(path)
-            @changes[:removed] << relative_path(path)
-          end
-        end
-      end
-    end
-
-    # Tests if the file content has been modified by
-    # comparing the SHA1 checksum.
-    #
-    # @param [String] path the file path
-    #
-    def content_modified?(path)
-      sha1_checksum = Digest::SHA1.file(path).to_s
-      if @sha1_checksums[path] != sha1_checksum
-        @sha1_checksums[path] = sha1_checksum
-        true
-      else
-        false
-      end
-    end
-
-    # Detect additions in a directory.
-    #
-    # @param [String] directory the path to analyze
-    # @param [Hash] options
-    # @option options [Boolean] recursive scan all sub-direcoties recursively (when polling)
-    #
-    def detect_additions(directory, options = {})
-      Find.find(directory) do |path|
-        next if @directory == path
-
-        if File.directory?(path)
-          if ignored_path?(path) || (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?(path) && filtered_file?(path) && !existing_path?(path)
-          @changes[:added] << relative_path(path) if File.file?(path)
-          insert_path(path)
-        end
-      end
-    end
-
-    # Convert absolute path to a path relative to the listener directory (by default).
-    #
-    # @param [String] path the path to convert
-    # @param [String] directory the directoy path to relative from
-    # @return [String] the relative converted path
-    #
-    def relative_path(path, directory = @directory)
-      base_dir = directory.sub(/\/$/, '')
-      path.sub(%r(^#{base_dir}/), '')
-    end
-
-    # Test if a path should be ignored or not.
-    #
-    # @param [String] path the path to test.
-    # @return [Boolean]
-    #
-    def ignored_path?(path)
-      @ignored_paths.any? { |ignored_path| path =~ /#{ignored_path}$/ }
-    end
-
-    # Test if a file path should be filtered or not.
-    #
-    # @param [String] path the file path to test.
-    # @return [Boolean]
-    #
-    def filtered_file?(path)
-      @file_filters.empty? || @file_filters.any? { |file_filter| path =~ file_filter }
-    end
-
   end
 end

data/lib/listen/multi_listener.rb

@@ -0,0 +1,121 @@
+module Listen
+  class MultiListener < Listener
+    attr_reader :directories, :directories_records, :adapter
+
+    # Initializes the multiple directories listener.
+    #
+    # @param [String] directories the directories to listen to
+    # @param [Hash] options the listen options
+    # @option options [String] ignore a list of paths to ignore
+    # @option options [Regexp] filter a list of regexps file filters
+    # @option options [Float] latency the delay between checking for changes in seconds
+    # @option options [Boolean] force_polling whether to force the polling adapter or not
+    # @option options [String, Boolean] polling_fallback_message to change polling fallback message or remove it
+    #
+    # @yield [modified, added, removed] the changed files
+    # @yieldparam [Array<String>] modified the list of modified files
+    # @yieldparam [Array<String>] added the list of added files
+    # @yieldparam [Array<String>] removed the list of removed files
+    #
+    def initialize(*args, &block)
+      options     = args.last.is_a?(Hash) ? args.pop : {}
+      directories = args
+
+      @block               = block
+      @directories         = directories
+      @directories_records = directories.map { |d| DirectoryRecord.new(d) }
+
+      ignore(*options.delete(:ignore)) if options[:ignore]
+      filter(*options.delete(:filter)) if options[:filter]
+
+      @adapter_options = options
+    end
+
+    # Starts the listener by initializing the adapter and building
+    # the directory record concurrently, then it starts the adapter to watch
+    # for changes.
+    #
+    # @param [Boolean] blocking whether or not to block the current thread after starting
+    #
+    def start(blocking = true)
+      t = Thread.new { @adapter = initialize_adapter }
+      @directories_records.each { |r| r.build }
+      t.join
+      @adapter.start(blocking)
+    end
+
+    # Unpauses the listener.
+    #
+    # @return [Listen::Listener] the listener
+    #
+    def unpause
+      @directories_records.each { |r| r.build }
+      @adapter.paused = false
+      self
+    end
+
+    # Adds ignored paths to the listener.
+    #
+    # @param (see Listen::DirectoryRecord#ignore)
+    #
+    # @return [Listen::Listener] the listener
+    #
+    def ignore(*paths)
+      @directories_records.each { |r| r.ignore(*paths) }
+      self
+    end
+
+    # Adds file filters to the listener.
+    #
+    # @param (see Listen::DirectoryRecord#filter)
+    #
+    # @return [Listen::Listener] the listener
+    #
+    def filter(*regexps)
+      @directories_records.each { |r| r.filter(*regexps) }
+      self
+    end
+
+    # Runs the callback passing it the changes if there are any.
+    #
+    # @param (see Listen::DirectoryRecord#fetch_changes)
+    #
+    def on_change(directories_to_search, options = {})
+      changes = fetch_records_changes(directories_to_search, options)
+      unless changes.values.all? { |paths| paths.empty? }
+        @block.call(changes[:modified],changes[:added],changes[:removed])
+      end
+    end
+
+    private
+
+    # Initializes an adapter passing it the callback and adapters' options.
+    #
+    def initialize_adapter
+      callback = lambda { |changed_dirs, options| self.on_change(changed_dirs, options) }
+      Adapter.select_and_initialize(@directories, @adapter_options, &callback)
+    end
+
+    # Returns the sum of all the changes to the directories records
+    #
+    # @param (see Listen::DirectoryRecord#fetch_changes)
+    #
+    # @return [Hash] the changes
+    #
+    def fetch_records_changes(directories_to_search, options)
+      @directories_records.inject({}) do |h, r|
+        # directory records skips paths outside their range, so passing the
+        # whole `directories` array is not a problem.
+        record_changes = r.fetch_changes(directories_to_search, options.merge(:relative_paths => DEFAULT_TO_RELATIVE_PATHS))
+
+        if h.empty?
+          h.merge!(record_changes)
+        else
+          h.each { |k, v| h[k] += record_changes[k] }
+        end
+
+        h
+      end
+    end
+  end
+end