listen 1.3.1 → 2.0.0.beta.1

data/lib/listen/listener.rb

@@ -1,27 +1,17 @@
-require 'pathname'
+require 'listen/adapter'
+require 'listen/change'
+require 'listen/record'
 
 module Listen
   class Listener
-    attr_reader :directories, :directories_records, :block, :adapter, :adapter_options, :use_relative_paths
-
-    BLOCKING_PARAMETER_DEPRECATION_MESSAGE = <<-EOS.gsub(/^\s*/, '')
-      The blocking parameter of Listen::Listener#start is deprecated.\n
-      Please use Listen::Adapter#start for a non-blocking listener and Listen::Listener#start! for a blocking one.
-    EOS
+    attr_accessor :options, :directories, :paused, :changes, :block
 
     RELATIVE_PATHS_WITH_MULTIPLE_DIRECTORIES_WARNING_MESSAGE = "The relative_paths option doesn't work when listening to multiple diretories."
 
     # Initializes the directories listener.
     #
     # @param [String] directory the directories to listen to
-    # @param [Hash] options the listen options
-    # @option options [Regexp] ignore a pattern for ignoring paths
-    # @option options [Regexp] filter a pattern for filtering paths
-    # @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
-    # @option options [Class] force_adapter force the use of this adapter class, skipping usual adapter selection
+    # @param [Hash] options the listen options (see Listen::Listener::Options)
     #
     # @yield [modified, added, removed] the changed files
     # @yieldparam [Array<String>] modified the list of modified files
@@ -29,295 +19,114 @@ module Listen
     # @yieldparam [Array<String>] removed the list of removed files
     #
     def initialize(*args, &block)
-      options     = args.last.is_a?(Hash) ? args.pop : {}
-      directories = args.flatten
-      initialize_directories_and_directories_records(directories)
-      initialize_relative_paths_usage(options)
-      @block = block
-
-      ignore(*options.delete(:ignore))
-      filter(*options.delete(:filter))
-
-      @adapter_options = options
+      @options     = _init_options(args.last.is_a?(Hash) ? args.pop : {})
+      @directories = args.flatten.map { |path| Pathname.new(path) }
+      @changes     = []
+      @block       = block
+      _init_debug
     end
 
     # Starts the listener by initializing the adapter and building
     # the directory record concurrently, then it starts the adapter to watch
     # for changes. The current thread is not blocked after starting.
     #
-    # @see Listen::Listener#start!
-    #
-    def start(deprecated_blocking = nil)
-      Kernel.warn "[Listen warning]:\n#{BLOCKING_PARAMETER_DEPRECATION_MESSAGE}" unless deprecated_blocking.nil?
-      setup
-      adapter.start
-    end
-
-    # Starts the listener by initializing the adapter and building
-    # the directory record concurrently, then it starts the adapter to watch
-    # for changes. The current thread is blocked after starting.
-    #
-    # @see Listen::Listener#start
-    #
-    # @since 1.0.0
-    #
-    def start!
-      setup
-      adapter.start!
+    def start
+      _signals_trap
+      _init_actors
+      unpause
+      adapter.async.start
+      @thread = Thread.new { _wait_for_changes }
     end
 
-    # Stops the listener.
-    #
     def stop
-      adapter && adapter.stop
+      Celluloid::Actor.kill(adapter)
+      Celluloid::Actor[:listen_change_pool].terminate
+      record && record.terminate
+      @thread && @thread.kill
     end
 
-    # Pauses the listener.
-    #
-    # @return [Listen::Listener] the listener
-    #
     def pause
-      adapter.pause
-      self
+      @paused = true
     end
 
-    # Unpauses the listener.
-    #
-    # @return [Listen::Listener] the listener
-    #
     def unpause
-      build_directories_records
-      adapter.unpause
-      self
+      _build_record_if_needed
+      @paused = false
     end
 
-    # Returns whether the listener is paused or not.
-    #
-    # @return [Boolean] adapter paused status
-    #
     def paused?
-      !!adapter && adapter.paused?
+      @paused == true
     end
 
-    # Adds ignoring patterns to the listener.
-    #
-    # @param (see Listen::DirectoryRecord#ignore)
-    #
-    # @return [Listen::Listener] the listener
-    #
-    # @see Listen::DirectoryRecord#ignore
-    #
-    def ignore(*regexps)
-      directories_records.each { |r| r.ignore(*regexps) }
-      self
+    def listen?
+      @paused == false
     end
 
-    # Replaces ignoring patterns in the listener.
-    #
-    # @param (see Listen::DirectoryRecord#ignore!)
-    #
-    # @return [Listen::Listener] the listener
-    #
-    # @see Listen::DirectoryRecord#ignore!
-    #
-    def ignore!(*regexps)
-      directories_records.each { |r| r.ignore!(*regexps) }
-      self
-    end
-
-    # Adds filtering patterns to the listener.
-    #
-    # @param (see Listen::DirectoryRecord#filter)
-    #
-    # @return [Listen::Listener] the listener
-    #
-    # @see Listen::DirectoryRecord#filter
-    #
-    def filter(*regexps)
-      directories_records.each { |r| r.filter(*regexps) }
-      self
+    def adapter
+      Celluloid::Actor[:listen_adapter]
     end
 
-    # Replaces filtering patterns in the listener.
-    #
-    # @param (see Listen::DirectoryRecord#filter!)
-    #
-    # @return [Listen::Listener] the listener
-    #
-    # @see Listen::DirectoryRecord#filter!
-    #
-    def filter!(*regexps)
-      directories_records.each { |r| r.filter!(*regexps) }
-      self
+    def record
+      Celluloid::Actor[:listen_record]
     end
 
-    # Sets the latency for the adapter. This is a helper method
-    # to simplify changing the latency directly from the listener.
-    #
-    # @example Wait 0.5 seconds each time before checking changes
-    #   latency 0.5
-    #
-    # @param [Float] seconds the amount of delay, in seconds
-    #
-    # @return [Listen::Listener] the listener
-    #
-    def latency(seconds)
-      @adapter_options[:latency] = seconds
-      self
-    end
+    private
 
-    # Sets whether the use of the polling adapter
-    # should be forced or not.
-    #
-    # @example Forcing the use of the polling adapter
-    #   force_polling true
-    #
-    # @param [Boolean] value whether to force the polling adapter or not
-    #
-    # @return [Listen::Listener] the listener
-    #
-    def force_polling(value)
-      @adapter_options[:force_polling] = value
-      self
+    def _init_options(options = {})
+      { debug: false,
+        latency: nil,
+        force_polling: false,
+        polling_fallback_message: nil }.merge(options)
     end
 
-    # Sets whether to force the use of a particular adapter, rather than
-    # going through usual adapter selection process on start.
-    #
-    # @example Force use of Linux polling
-    #   force_adapter Listen::Adapters::Linux
-    #
-    # @param [Class] adapter class to use for file system event notification.
-    #
-    # @return [Listen::Listener] the listener
-    #
-    def force_adapter(adapter_class)
-      @adapter_options[:force_adapter] = adapter_class
-      self
+    def _init_debug
+      if options[:debug]
+        Celluloid.logger.level = Logger::INFO
+      else
+        Celluloid.logger = nil
+      end
     end
 
-    # Sets whether the paths in the callback should be
-    # relative or absolute.
-    #
-    # @example Enabling relative paths in the callback
-    #   relative_paths true
-    #
-    # @param [Boolean] value whether to enable relative paths in the callback or not
-    #
-    # @return [Listen::Listener] the listener
-    #
-    def relative_paths(value)
-      @use_relative_paths = value
-      self
+    def _init_actors
+      cores = Celluloid.cores || 2
+      Celluloid::Actor[:listen_change_pool] = Change.pool(size: cores, args: self)
+      Celluloid::Actor[:listen_adapter]     = Adapter.new(self)
+      Celluloid::Actor[:listen_record]      = Record.new(self)
     end
 
-    # Defines a custom polling fallback message or disable it.
-    #
-    # @example Disabling the polling fallback message
-    #   polling_fallback_message false
-    #
-    # @param [String, Boolean] value to change polling fallback message or remove it
-    #
-    # @return [Listen::Listener] the listener
-    #
-    def polling_fallback_message(value)
-      @adapter_options[:polling_fallback_message] = value
-      self
+    def _signals_trap
+      if Signal.list.keys.include?('INT')
+        Signal.trap('INT') { exit }
+      end
     end
 
-    # 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 [Proc] block the callback proc
-    #
-    # @return [Listen::Listener] the listener
-    #
-    def change(&block) # modified, added, removed
-      @block = block
-      self
+    def _build_record_if_needed
+      record && record.build
     end
 
-    # Runs the callback passing it the changes if there are any.
-    #
-    # @param (see Listen::DirectoryRecord#fetch_changes)
-    #
-    # @see Listen::DirectoryRecord#fetch_changes
-    #
-    def on_change(directories, options = {})
-      changes = fetch_records_changes(directories, options)
-      unless changes.values.all? { |paths| paths.empty? }
-        block.call(changes[:modified], changes[:added], changes[:removed])
+    def _wait_for_changes
+      loop do
+        changes = _pop_changes
+        unless changes.values.all?(&:empty?)
+          block.call(
+            changes[:modified].uniq,
+            changes[:added].uniq,
+            changes[:removed].uniq)
+        end
+        sleep 0.1
       end
     rescue => ex
       Kernel.warn "[Listen warning]: Change block raise an execption: #{$!}"
       Kernel.warn "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
     end
 
-    private
-
-    # Initializes the directories to watch as well as the directories records.
-    #
-    # @see Listen::DirectoryRecord
-    #
-    def initialize_directories_and_directories_records(directories)
-      @directories = directories.map { |d| Pathname.new(d).realpath.to_s }
-      @directories_records = directories.map { |d| DirectoryRecord.new(d) }
-    end
-
-    # Initializes whether or not using relative paths.
-    #
-    def initialize_relative_paths_usage(options)
-      if directories.size > 1 && options[:relative_paths]
-        Kernel.warn "[Listen warning]: #{RELATIVE_PATHS_WITH_MULTIPLE_DIRECTORIES_WARNING_MESSAGE}"
+    def _pop_changes
+      changes = { modified: [], added: [], removed: [] }
+      until @changes.empty?
+        change = @changes.pop
+        change.each { |k, v| changes[k] << v.to_s }
       end
-      @use_relative_paths = directories.one? && options.delete(:relative_paths) { false }
-    end
-
-    # Build the directory record concurrently and initialize the adapter.
-    #
-    def setup
-      t = Thread.new { build_directories_records }
-      @adapter = initialize_adapter
-      t.join
-    end
-
-    # Initializes an adapter passing it the callback and adapters' options.
-    #
-    def initialize_adapter
-      callback = lambda { |changed_directories, options| self.on_change(changed_directories, options) }
-      Adapter.select_and_initialize(directories, adapter_options, &callback)
+      changes
     end
-
-    # Build the watched directories' records.
-    #
-    def build_directories_records
-      directories_records.each { |r| r.build }
-    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 => use_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

data/lib/listen/record.rb

@@ -0,0 +1,41 @@
+module Listen
+  class Record
+    include Celluloid
+
+    attr_accessor :paths, :listener
+
+    def initialize(listener)
+      @listener = listener
+      @paths    = _init_paths
+    end
+
+    def set_path(path, data)
+      @paths[::File.dirname(path)][::File.basename(path)] = file_data(path).merge(data)
+    end
+
+    def unset_path(path)
+      @paths[::File.dirname(path)].delete(::File.basename(path))
+    end
+
+    def file_data(path)
+      @paths[::File.dirname(path)][::File.basename(path)] || {}
+    end
+
+    def dir_entries(path)
+      @paths[path.to_s]
+    end
+
+    def build
+      @paths = _init_paths
+      listener.directories.each do |path|
+        Actor[:listen_change_pool].change(path, type: 'Dir', recursive: true, silence: true)
+      end
+    end
+
+    private
+
+    def _init_paths
+      Hash.new { |h, k| h[k] = Hash.new }
+    end
+  end
+end

data/lib/listen/silencer.rb

@@ -0,0 +1,44 @@
+module Listen
+  class Silencer
+    # The default list of directories that get ignored.
+    DEFAULT_IGNORED_DIRECTORIES = %w[.rbx .bundle .git .svn .hg bundle log tmp vendor]
+
+    # The default list of files that get ignored.
+    DEFAULT_IGNORED_EXTENSIONS  = %w[.DS_Store]
+
+    attr_accessor :options, :patterns
+
+    def initialize(options = {})
+      @options = options
+      _init_patterns
+    end
+
+    def silenced?(path)
+      patterns.any? { |pattern| pattern =~ path.to_s }
+    end
+
+    private
+
+    def _init_patterns
+      @patterns = []
+      @patterns << _default_patterns unless options[:ignore!]
+      @patterns << options[:ignore] << options[:ignore!]
+      @patterns.compact
+      @patterns.flatten!
+    end
+
+    def _default_patterns
+      [_default_ignored_directories_patterns, _default_ignored_extensions_patterns]
+    end
+
+    def _default_ignored_directories_patterns
+      ignored_directories = DEFAULT_IGNORED_DIRECTORIES.map { |d| Regexp.escape(d) }
+      %r{(?:#{ignored_directories.join('|')})}
+    end
+
+    def _default_ignored_extensions_patterns
+      ignored_extensions = DEFAULT_IGNORED_EXTENSIONS.map { |e| Regexp.escape(e) }
+      %r{(?:#{ignored_extensions.join('|')})$}
+    end
+  end
+end