listen 2.7.6 → 2.7.7

data/lib/listen/queue_optimizer.rb

@@ -5,18 +5,26 @@ module Listen
     def _smoosh_changes(changes)
       # TODO: adapter could be nil at this point (shutdown)
       if _adapter_class.local_fs?
-        cookies = changes.group_by do |_, _, _, options|
+        cookies = changes.group_by do |_, _, _, _, options|
           (options || {})[:cookie]
         end
         _squash_changes(_reinterpret_related_changes(cookies))
       else
         smooshed = { modified: [], added: [], removed: [] }
-        changes.each { |_, change, path, _| smooshed[change] << path.to_s }
+        changes.each do |_, change, dir, rel_path, _|
+          smooshed[change] << (dir + rel_path).to_s
+        end
         smooshed.tap { |s| s.each { |_, v| v.uniq! } }
       end
     end
 
+    # groups changes into the expected structure expected by
+    # clients
     def _squash_changes(changes)
+      # We combine here for backward compatibility
+      # Newer clients should receive dir and path separately
+      changes = changes.map { |change, dir, path| [change, dir + path] }
+
       actions = changes.group_by(&:last).map do |path, action_list|
         [_logical_action_for(path, action_list.map(&:first)), path.to_s]
       end
@@ -63,15 +71,16 @@ module Listen
     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]]
+        data = _detect_possible_editor_save(changes)
+        if data
+          to_dir, to_file = data
+          [[:modified, to_dir, to_file]]
         else
-          not_silenced = changes.reject do |type, _, path, _|
-            _silenced?(path, type)
+          not_silenced = changes.reject do |type, _, _, path, _|
+            _silenced?(Pathname(path), type)
           end
-          not_silenced.map do |_, change, path, _|
-            [table.fetch(change, change), path]
+          not_silenced.map do |_, change, dir, path, _|
+            [table.fetch(change, change), dir, path]
           end
         end
       end.flatten(1)
@@ -81,14 +90,14 @@ module Listen
       return unless changes.size == 2
 
       from_type = from_change = from = nil
-      to_type = to_change = to = nil
+      to_type = to_change = to_dir = to = nil
 
       changes.each do |data|
         case data[1]
         when :moved_from
-          from_type, from_change, from, _ = data
+          from_type, from_change, _, from, _ = data
         when :moved_to
-          to_type, to_change, to, _ = data
+          to_type, to_change, to_dir, to, _ = data
         else
           return nil
         end
@@ -98,7 +107,8 @@ module Listen
 
       # Expect an ignored moved_from and non-ignored moved_to
       # to qualify as an "editor modify"
-      _silenced?(from, from_type) && !_silenced?(to, to_type) ? to : nil
+      return unless _silenced?(Pathname(from), from_type)
+      _silenced?(Pathname(to), to_type) ? nil : [to_dir, to]
     end
   end
 end

data/lib/listen/record.rb

@@ -2,52 +2,129 @@ module Listen
   class Record
     include Celluloid
 
+    # TODO: one Record object per watched directory?
+
     # TODO: deprecate
     attr_accessor :paths, :listener
 
     def initialize(listener)
       @listener = listener
-      @paths    = _init_paths
+      @paths    = _auto_hash
+    end
+
+    def add_dir(dir, rel_path)
+      return if [nil, '', '.'].include? rel_path
+      @paths[dir.to_s][rel_path] ||= {}
     end
 
-    def set_path(type, path, data = {})
-      new_data = file_data(path).merge(data).merge(type: type)
-      @paths[::File.dirname(path)][::File.basename(path)] = new_data
+    def update_file(dir, rel_path, data)
+      dirname, basename = Pathname(rel_path).split.map(&:to_s)
+      _fast_update_file(dir, dirname, basename, data)
     end
 
-    def unset_path(path)
-      @paths[::File.dirname(path)].delete(::File.basename(path))
+    def unset_path(dir, rel_path)
+      dirname, basename = Pathname(rel_path).split.map(&:to_s)
+
+      @paths[dir.to_s][dirname] ||= {}
+      _fast_unset_path(dir, dirname, basename)
     end
 
-    def file_data(path)
-      @paths[::File.dirname(path)][::File.basename(path)] || {}
+    def file_data(dir, rel_path)
+      root = @paths[dir.to_s]
+      dirname, basename = Pathname(rel_path).split.map(&:to_s)
+      if [nil, '', '.'].include? dirname
+        root[basename] ||= {}
+        root[basename].dup
+      else
+        root[dirname] ||= {}
+        root[dirname][basename] ||= {}
+        root[dirname][basename].dup
+      end
     end
 
-    def dir_entries(path)
-      @paths[path.to_s].dup
+    def dir_entries(dir, rel_path)
+      tree = if [nil, '', '.'].include? rel_path.to_s
+               @paths[dir.to_s]
+             else
+               @paths[dir.to_s][rel_path.to_s] ||= _auto_hash
+               @paths[dir.to_s][rel_path.to_s]
+             end
+
+      result = {}
+      tree.each do |key, values|
+        # only get data for file entries
+        result[key] = values.key?(:mtime) ? values : {}
+      end
+      result
     end
 
     def build
-      @last_build_at = Time.now
-      @paths = _init_paths
-      listener.directories.each do |path|
-        options = { recursive: true, silence: true, build: true }
-        listener.sync(:change_pool).change(:dir, path, options)
+      start = Time.now.to_f
+      @paths = _auto_hash
+
+      # TODO: refactor this out (1 Record = 1 watched dir)
+      listener.directories.each do |directory|
+        _fast_build(directory.to_s)
       end
-      sleep 0.01 until @last_build_at + 0.1 < Time.now
+
+      Celluloid.logger.info "Record.build took #{Time.now.to_f - start} seconds"
     rescue
       Celluloid.logger.warn "build crashed: #{$!.inspect}"
       raise
     end
 
-    def still_building!
-      @last_build_at = Time.now
-    end
-
     private
 
-    def _init_paths
+    def _auto_hash
       Hash.new { |h, k| h[k] = Hash.new }
     end
+
+    def _fast_update_file(dir, dirname, basename, data)
+      root = @paths[dir.to_s]
+      if [nil, '', '.'].include? dirname
+        root[basename] = (root[basename] || {}).merge(data)
+      else
+        root[dirname] ||= {}
+        root[dirname][basename] = (root[dirname][basename] || {}).merge(data)
+      end
+    end
+
+    def _fast_unset_path(dir, dirname, basename)
+      root = @paths[dir.to_s]
+      # this may need to be reworked to properly remove
+      # entries from a tree, without adding non-existing dirs to the record
+      return unless root.key?(dirname)
+      root[dirname].delete(basename)
+    end
+
+    def _fast_build(root)
+      @paths[root] = _auto_hash
+      left = Queue.new
+      left << '.'
+
+      while !left.empty?
+        dirname = left.pop
+        add_dir(root, dirname)
+
+        path = ::File.join(root, dirname)
+        current = Dir.entries(path.to_s) - %w(. ..)
+
+        current.each do |entry|
+          full_path = ::File.join(path, entry)
+
+          if Dir.exist?(full_path)
+            left << (dirname == '.' ? entry : ::File.join(dirname, entry))
+          else
+            begin
+              lstat = ::File.lstat(full_path)
+              data = { mtime: lstat.mtime.to_f, mode: lstat.mode }
+              _fast_update_file(root, dirname, entry, data)
+            rescue SystemCallError
+              _fast_unset_path(root, dirname, entry)
+            end
+          end
+        end
+      end
+    end
   end
 end

data/lib/listen/silencer.rb

@@ -1,7 +1,5 @@
 module Listen
   class Silencer
-    include Celluloid
-
     # The default list of directories that get ignored.
     DEFAULT_IGNORED_DIRECTORIES = %r{^(?:
       \.git
@@ -40,63 +38,46 @@ module Listen
       | ~
     )$}x
 
-    attr_accessor :listener, :only_patterns, :ignore_patterns
+    attr_accessor :only_patterns, :ignore_patterns
+
+    def initialize
+      configure({})
+    end
 
-    def initialize(listener)
-      @listener = listener
-      _init_only_patterns
-      _init_ignore_patterns
+    def configure(options)
+      @only_patterns = options[:only] ? Array(options[:only]) : nil
+      @ignore_patterns = _init_ignores(options[:ignore], options[:ignore!])
     end
 
-    def silenced?(path, type)
-      silenced = false
+    # Note: relative_path is temporarily expected to be a relative Pathname to
+    # make refactoring easier (ideally, it would take a string)
 
-      relative_path = _relative_path(path)
+    # TODO: switch type and path places - and verify
+    def silenced?(relative_path, type)
+      path = relative_path.to_s
 
       if only_patterns && type == :file
-        silenced = !only_patterns.any? { |pattern| relative_path =~ pattern }
+        return true unless only_patterns.any? { |pattern| path =~ pattern }
       end
 
-      silenced || ignore_patterns.any? { |pattern| relative_path =~ pattern }
+      ignore_patterns.any? { |pattern| path =~ pattern }
     end
 
     private
 
-    def _init_only_patterns
-      return unless listener.options[:only]
-
-      @only_patterns = Array(listener.options[:only])
-    end
-
-    def _init_ignore_patterns
-      options = listener.options
+    attr_reader :options
 
+    def _init_ignores(ignores, overrides)
       patterns = []
-      unless options[:ignore!]
+      unless overrides
         patterns << DEFAULT_IGNORED_DIRECTORIES
         patterns << DEFAULT_IGNORED_EXTENSIONS
       end
 
-      patterns << options[:ignore]
-      patterns << options[:ignore!]
-
-      patterns.compact!
-      patterns.flatten!
+      patterns << ignores
+      patterns << overrides
 
-      @ignore_patterns = patterns
-    end
-
-    def _relative_path(path)
-      relative_paths = listener.directories.map do |dir|
-        begin
-          path.relative_path_from(dir).to_s
-        rescue ArgumentError
-          # Windows raises errors across drives, e.g. when 'C:/' and 'E:/dir'
-          # So, here's a Dirty hack to fool the detect() below..
-          '../'
-        end
-      end
-      relative_paths.detect { |rel_path| !rel_path.start_with?('../') }
+      patterns.compact.flatten
     end
   end
 end

data/lib/listen/version.rb

@@ -1,3 +1,3 @@
 module Listen
-  VERSION = '2.7.6'
+  VERSION = '2.7.7'
 end

data/spec/lib/listen/adapter/base_spec.rb

@@ -1,29 +1,30 @@
 require 'spec_helper'
 
-describe Listen::Adapter::Base do
-  subject { described_class.new(listener) }
+include Listen
 
-  let(:listener) { instance_double(Listen::Listener) }
+describe Adapter::Base do
 
-  before { allow(listener).to receive(:async).with(:change_pool) { worker } }
+  class FakeAdapter < described_class
+    def initialize(*args)
+      super(*args)
+    end
+  end
+
+  subject { FakeAdapter.new(mq: mq, directories: []) }
+
+  let(:mq) { instance_double(Listener) }
 
   describe '#_notify_change' do
+    let(:dir) { Pathname.pwd }
+
     context 'listener is listening or paused' do
-      let(:worker) { instance_double(Listen::Change) }
+      let(:worker) { instance_double(Change) }
 
       it 'calls change on change_pool asynchronously' do
-        expect(worker).to receive(:change).
-          with(:dir, 'path', recursive: true)
-        subject.send(:_notify_change, :dir, 'path', recursive: true)
-      end
-    end
-
-    context 'listener is stopped' do
-      let(:worker) { nil }
+        expect(mq).to receive(:_queue_raw_change).
+          with(:dir, dir, 'path', recursive: true)
 
-      it 'does not fail when no worker is available' do
-        expect(worker).to_not receive(:change)
-        subject.send(:_notify_change, :dir, 'path', recursive: true)
+        subject.send(:_queue_change, :dir, dir, 'path', recursive: true)
       end
     end
   end

data/spec/lib/listen/adapter/darwin_spec.rb

@@ -1,6 +1,10 @@
 require 'spec_helper'
 
-describe Listen::Adapter::Darwin do
+require 'listen/adapter/darwin'
+
+include Listen
+
+describe Adapter::Darwin do
   describe 'class' do
     subject { described_class }
     it { should be_local_fs }
@@ -13,13 +17,16 @@ describe Listen::Adapter::Darwin do
   end
 
   let(:options) { {} }
-  let(:listener) { instance_double(Listen::Listener, options: options) }
+  let(:mq) { instance_double(Listener, options: options) }
 
   describe '#_latency' do
-    subject { described_class.new(listener).send(:_latency) }
+    subject do
+      adapter = described_class.new(options.merge(mq: mq, directories: []))
+      adapter.options.latency
+    end
 
     context 'with no overriding option' do
-      it { should eq described_class.const_get('DEFAULT_LATENCY') }
+      it { should eq 0.1 }
     end
 
     context 'with custom latency overriding' do

data/spec/lib/listen/adapter/linux_spec.rb

@@ -13,26 +13,17 @@ describe Listen::Adapter::Linux do
   end
 
   if linux?
-    let(:listener) { instance_double(Listen::Listener) }
-    let(:adapter) { described_class.new(listener) }
+    let(:directories) { [] }
+    let(:mq) { instance_double(Listen::Listener) }
 
-    describe '#initialize' do
-      before do
-        allow(listener).to receive(:directories) { [] }
-      end
-      it 'requires rb-inotify gem' do
-        adapter.send(:_configure)
-        expect(defined?(INotify)).to be
-      end
-    end
+    subject { described_class.new(mq: mq, directories: directories) }
 
     # workaround: Celluloid ignores SystemExit exception messages
     describe 'inotify limit message' do
-      let!(:adapter) { described_class.new(listener) }
+      let(:directories) { [Pathname.pwd] }
 
       before do
         require 'rb-inotify'
-        allow(listener).to receive(:directories) { ['foo/dir'] }
         fake_worker = double(:fake_worker)
         allow(fake_worker).to receive(:watch).and_raise(Errno::ENOSPC)
 
@@ -46,23 +37,21 @@ describe Listen::Adapter::Linux do
 
         # Expect RuntimeError here, for the sake of unit testing (actual
         # handling depends on Celluloid supervisor setup, which is beyond the
-        # scope of adapter tests)
-        expect { adapter.start }.to raise_error RuntimeError, expected_message
+        # scope of subject tests)
+        expect { subject.start }.to raise_error RuntimeError, expected_message
       end
     end
 
     describe '_callback' do
-      before do
-        allow(listener).to receive(:directories) { [] }
-      end
-
+      let(:directories) { [Pathname.pwd] }
+      before { subject.configure }
       let(:expect_change) do
         lambda do |change|
-          allow_any_instance_of(Listen::Adapter::Base).
-            to receive(:_notify_change).
+          allow(mq).to receive(:_queue_raw_change).
             with(
               :file,
-              Pathname.new('path/foo.txt'),
+              Pathname.pwd,
+              'path/foo.txt',
               change: change,
               cookie: 123)
         end
@@ -70,13 +59,15 @@ describe Listen::Adapter::Linux do
 
       let(:event_callback) do
         lambda do |flags|
-          callback = adapter.send(:_callback)
-          callback.call double(
-            :inotify_event,
-            name: 'foo.txt',
-            watcher: double(:watcher, path: 'path'),
-            flags: flags,
-            cookie: 123)
+          callbacks = subject.instance_variable_get(:'@callbacks')
+          callbacks.values.flatten.each do |callback|
+            callback.call double(
+              :inotify_event,
+              name: 'foo.txt',
+              watcher: double(:watcher, path: (Pathname.pwd + 'path').to_s),
+              flags: flags,
+              cookie: 123)
+          end
         end
       end