listen 2.7.5 → 2.7.6

data/lib/listen/listener.rb

@@ -3,12 +3,20 @@ require 'listen/adapter'
 require 'listen/change'
 require 'listen/record'
 require 'listen/silencer'
+require 'listen/queue_optimizer'
 require 'English'
 
 module Listen
   class Listener
-    attr_accessor :options, :directories, :paused, :changes, :block, :stopping
-    attr_accessor :registry, :supervisor
+    include Celluloid::FSM
+    include QueueOptimizer
+
+    attr_accessor :block
+
+    # TODO: deprecate
+    attr_reader :options, :directories
+    attr_reader :registry, :supervisor
+    attr_reader :host, :port
 
     # Initializes the directories listener.
     #
@@ -21,94 +29,138 @@ module Listen
     # @yieldparam [Array<String>] removed the list of removed files
     #
     def initialize(*args, &block)
-      @options     = _init_options(args.last.is_a?(Hash) ? args.pop : {})
+      @options = _init_options(args.last.is_a?(Hash) ? args.pop : {})
+
+      # Setup logging first
+      Celluloid.logger.level = _debug_level
+      _log :info, "Celluloid loglevel set to: #{Celluloid.logger.level}"
+
+      @tcp_mode = nil
+      if [:recipient, :broadcaster].include? args[1]
+        target = args.shift
+        @tcp_mode = args.shift
+        _init_tcp_options(target)
+      end
+
       @directories = args.flatten.map { |path| Pathname.new(path).realpath }
-      @changes     = []
-      @block       = block
-      @registry    = Celluloid::Registry.new
-      _init_debug
+      @queue = Queue.new
+      @block = block
+      @registry = Celluloid::Registry.new
+
+      transition :stopped
     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.
-    #
+    default_state :initializing
+
+    state :initializing, to: :stopped
+    state :paused, to: [:processing, :stopped]
+
+    state :stopped, to: [:processing] do
+      _stop_wait_thread
+      if @supervisor
+        @supervisor.terminate
+        @supervisor = nil
+      end
+    end
+
+    state :processing, to: [:paused, :stopped] do
+      if wait_thread # means - was paused
+        _wakeup_wait_thread
+      else
+        @last_queue_event_time = nil
+        _start_wait_thread
+        _init_actors
+
+        # Note: make sure building is finished before starting adapter (for
+        # consistent results both in specs and normal usage)
+        sync(:record).build
+
+        _start_adapter
+      end
+    end
+
+    # Starts processing events and starts adapters
+    # or resumes invoking callbacks if paused
     def start
-      _init_actors
-      unpause
-      @stopping = false
-      registry[:adapter].async.start
-      Thread.new { _wait_for_changes }
+      transition :processing
     end
 
-    # Terminates all Listen actors and kill the adapter.
-    #
+    # TODO: depreciate
+    alias_method :unpause, :start
+
+    # Stops processing and terminates all actors
     def stop
-      @stopping = true
-      supervisor.terminate
+      transition :stopped
     end
 
-    # Pauses listening callback (adapter still running)
-    #
+    # Stops invoking callbacks (messages pile up)
     def pause
-      @paused = true
+      transition :paused
     end
 
-    # Unpauses listening callback
-    #
-    def unpause
-      registry[:record].build
-      @paused = false
+    # processing means callbacks are called
+    def processing?
+      state == :processing
     end
 
-    # Returns true if Listener is paused
-    #
-    # @return [Boolean]
-    #
     def paused?
-      @paused == true
+      state == :paused
     end
 
-    # Returns true if Listener is neither paused nor stopped
-    #
-    # @return [Boolean]
-    #
-    def listen?
-      @paused == false && @stopping == false
+    # TODO: deprecate
+    alias_method :listen?, :processing?
+
+    # TODO: deprecate
+    def paused=(value)
+      transition value ? :paused : :processing
     end
 
-    # Adds ignore patterns to the existing one
-    #
-    # @see DEFAULT_IGNORED_DIRECTORIES and DEFAULT_IGNORED_EXTENSIONS in
-    #   Listen::Silencer)
+    # TODO: deprecate
+    alias_method :paused, :paused?
+
+    # Add files and dirs to ignore on top of defaults
     #
-    # @param [Regexp, Array<Regexp>] new ignoring patterns.
+    # (@see Listen::Silencer for default ignored files and dirs)
     #
     def ignore(regexps)
-      @options[:ignore] = [options[:ignore], regexps]
-      registry[:silencer] = Silencer.new(self)
+      _reconfigure_silencer(ignore: [options[:ignore], regexps])
     end
 
-    # Overwrites ignore patterns
-    #
-    # @see DEFAULT_IGNORED_DIRECTORIES and DEFAULT_IGNORED_EXTENSIONS in
-    #   Listen::Silencer)
-    #
-    # @param [Regexp, Array<Regexp>] new ignoring patterns.
-    #
+    # Replace default ignore patterns with provided regexp
     def ignore!(regexps)
-      @options.delete(:ignore)
-      @options[:ignore!] = regexps
-      registry[:silencer] = Silencer.new(self)
+      _reconfigure_silencer(ignore: [], ignore!: regexps)
     end
 
-    # Sets only patterns, to listen only to specific regexps
-    #
-    # @param [Regexp, Array<Regexp>] new ignoring patterns.
-    #
+    # Listen only to files and dirs matching regexp
     def only(regexps)
-      @options[:only] = regexps
-      registry[:silencer] = Silencer.new(self)
+      _reconfigure_silencer(only: regexps)
+    end
+
+    def async(type)
+      proxy = sync(type)
+      proxy ? proxy.async : nil
+    end
+
+    def sync(type)
+      @registry[type]
+    end
+
+    def queue(type, change, path, options = {})
+      fail "Invalid type: #{type.inspect}" unless [:dir, :file].include? type
+      fail "Invalid change: #{change.inspect}" unless change.is_a?(Symbol)
+      @queue << [type, change, path, options]
+
+      @last_queue_event_time = Time.now.to_f
+      _wakeup_wait_thread unless state == :paused
+
+      return unless @tcp_mode == :broadcaster
+
+      message = TCP::Message.new(type, change, path, options)
+      registry[:broadcaster].async.broadcast(message.payload)
+    end
+
+    def silencer
+      @registry[:silencer]
     end
 
     private
@@ -121,16 +173,19 @@ module Listen
         polling_fallback_message: nil }.merge(options)
     end
 
-    def _init_debug
-      if options[:debug] || ENV['LISTEN_GEM_DEBUGGING'] =~ /true|1/i
-        if RbConfig::CONFIG['host_os'] =~ /bsd|dragonfly/
-          Celluloid.logger.level = Logger::INFO
-        else
-          # BSDs silently fail ;;(
-          Celluloid.logger.level = Logger::DEBUG
-        end
+    def _debug_level
+      # TODO: remove? (since there are BSD warnings anyway)
+      bsd = RbConfig::CONFIG['host_os'] =~ /bsd|dragonfly/
+      return Logger::DEBUG if bsd
+
+      debugging = ENV['LISTEN_GEM_DEBUGGING'] || options[:debug]
+      case debugging.to_s
+      when /2/
+        Logger::DEBUG
+      when /true|yes|1/i
+        Logger::INFO
       else
-        Celluloid.logger.level = Logger::FATAL
+        Logger::ERROR
       end
     end
 
@@ -140,119 +195,123 @@ module Listen
       supervisor.add(Record, as: :record, args: self)
       supervisor.pool(Change, as: :change_pool, args: self)
 
-      adapter_class = Adapter.select(options)
-      supervisor.add(adapter_class, as: :adapter, args: self)
+      if @tcp_mode == :broadcaster
+        require 'listen/tcp/broadcaster'
+        supervisor.add(TCP::Broadcaster, as: :broadcaster, args: [@host, @port])
+
+        # TODO: should be auto started, because if it crashes
+        # a new instance is spawned by supervisor, but it's 'start' isn't
+        # called
+        registry[:broadcaster].start
+      end
+
+      supervisor.add(_adapter_class, as: :adapter, args: self)
     end
 
     def _wait_for_changes
+      latency = options[:wait_for_delay]
+
       loop do
-        break if @stopping
-
-        changes = []
-        begin
-          sleep options[:wait_for_delay] # wait for changes to accumulate
-          new_changes = _pop_changes
-          changes += new_changes
-        end until new_changes.empty?
-        unless changes.empty?
-          hash = _smoosh_changes(changes)
-          block.call(hash[:modified], hash[:added], hash[:removed])
+        break if state == :stopped
+
+        if state == :paused || @queue.empty?
+          sleep
+          break if state == :stopped
         end
+
+        # Assure there's at least latency between callbacks to allow
+        # for accumulating changes
+        now = Time.now.to_f
+        diff = latency + (@last_queue_event_time || now) - now
+        if diff > 0
+          sleep diff
+          next
+        end
+
+        _process_changes unless state == :paused
       end
-    rescue => ex
+    rescue RuntimeError
       Kernel.warn "[Listen warning]: Change block raised an exception: #{$!}"
-      Kernel.warn "Backtrace:\n\t#{ex.backtrace.join("\n\t")}"
+      Kernel.warn "Backtrace:\n\t#{$@.join("\n\t")}"
     end
 
-    def _pop_changes
-      popped = []
-      popped << @changes.shift until @changes.empty?
-      popped
+    def _silenced?(path, type)
+      sync(:silencer).silenced?(path, type)
     end
 
-    def _smoosh_changes(changes)
-      if registry[:adapter].class.local_fs?
-        cookies = changes.group_by { |x| x[:cookie] }
-        _squash_changes(_reinterpret_related_changes(cookies))
-      else
-        smooshed = { modified: [], added: [], removed: [] }
-        changes.map(&:first).each { |type, path| smooshed[type] << path.to_s }
-        smooshed.tap { |s| s.each { |_, v| v.uniq! } }
-      end
+    def _start_adapter
+      # Don't run async, because configuration has to finish first
+      sync(:adapter).start
     end
 
-    def _squash_changes(changes)
-      actions = changes.group_by(&:last).map do |path, action_list|
-        [_logical_action_for(path, action_list.map(&:first)), path.to_s]
-      end
-      Celluloid.logger.info "listen: raw changes: #{actions.inspect}"
+    def _log(type, message)
+      Celluloid.logger.send(type, message)
+    end
 
-      { modified: [], added: [], removed: [] }.tap do |squashed|
-        actions.each do |type, path|
-          squashed[type] << path unless type.nil?
-        end
-        Celluloid.logger.info "listen: final changes: #{squashed.inspect}"
-      end
+    def _adapter_class
+      @adapter_class ||= Adapter.select(options)
     end
 
-    def _logical_action_for(path, actions)
-      actions << :added if actions.delete(:moved_to)
-      actions << :removed if actions.delete(:moved_from)
+    # for easier testing without sleep loop
+    def _process_changes
+      return if @queue.empty?
+
+      @last_queue_event_time = nil
+
+      changes = []
+      while !@queue.empty?
+        changes << @queue.pop
+      end
+
+      return if block.nil?
+
+      hash = _smoosh_changes(changes)
+      result = [hash[:modified], hash[:added], hash[:removed]]
 
-      modified = actions.detect { |x| x == :modified }
-      _calculate_add_remove_difference(actions, path, modified)
+      # TODO: condition not tested, but too complex to test ATM
+      block.call(*result) unless result.all?(&:empty?)
     end
 
-    def _calculate_add_remove_difference(actions, path, default_if_exists)
-      added = actions.count { |x| x == :added }
-      removed = actions.count { |x| x == :removed }
-      diff = added - removed
+    attr_reader :wait_thread
 
-      if path.exist?
-        if diff > 0
-          :added
-        elsif diff.zero? && added > 0
-          :modified
-        else
-          default_if_exists
-        end
+    def _init_tcp_options(target)
+      # Handle TCP options here
+      require 'listen/tcp'
+      fail ArgumentError, 'missing host/port for TCP' unless target
+
+      if @tcp_mode == :recipient
+        @host = 'localhost'
+        @options[:force_tcp] = true
+      end
+
+      if target.is_a? Fixnum
+        @port = target
       else
-        diff < 0 ? :removed : nil
+        @host, port = target.split(':')
+        @port = port.to_i
       end
     end
 
-    # remove extraneous rb-inotify events, keeping them only if it's a possible
-    # editor rename() call (e.g. Kate and Sublime)
-    def _reinterpret_related_changes(cookies)
-      table = { moved_to: :added, moved_from: :removed }
-      cookies.map do |_, changes|
-        file = _detect_possible_editor_save(changes)
-        if file
-          [[:modified, file]]
-        else
-          not_silenced = changes.map(&:first).reject do |_, path|
-            _silenced?(path)
-          end
-          not_silenced.map { |type, path| [table.fetch(type, type), path] }
-        end
-      end.flatten(1)
+    def _reconfigure_silencer(extra_options)
+      @options.merge!(extra_options)
+      registry[:silencer] = Silencer.new(self)
     end
 
-    def _detect_possible_editor_save(changes)
-      return unless changes.size == 2
-
-      from, to = changes.sort { |x, y| x.keys.first <=> y.keys.first }
-      from, to = from[:moved_from], to[:moved_to]
-      return unless from && to
+    def _start_wait_thread
+      @wait_thread = Thread.new { _wait_for_changes }
+    end
 
-      # Expect an ignored moved_from and non-ignored moved_to
-      # to qualify as an "editor modify"
-      _silenced?(from) && !_silenced?(to) ? to : nil
+    def _wakeup_wait_thread
+      wait_thread.wakeup if wait_thread && wait_thread.alive?
     end
 
-    def _silenced?(path)
-      type = path.directory? ? 'Dir' : 'File'
-      registry[:silencer].silenced?(path, type)
+    def _stop_wait_thread
+      return unless wait_thread
+      if wait_thread.alive?
+        wait_thread.wakeup
+        wait_thread.join
+      end
+      @wait_thread = nil
     end
   end
 end