driskell-listen 3.0.6.10

data/lib/driskell-listen/adapter/polling.rb

@@ -0,0 +1,37 @@
+module Driskell::Listen
+  module Adapter
+    # Polling Adapter that works cross-platform and
+    # has no dependencies. This is the adapter that
+    # uses the most CPU processing power and has higher
+    # file IO than the other implementations.
+    #
+    class Polling < Base
+      OS_REGEXP = // # match every OS
+
+      DEFAULTS = { latency: 1.0, wait_for_delay: 0.05 }
+
+      private
+
+      def _configure(_, &callback)
+        @polling_callbacks ||= []
+        @polling_callbacks << callback
+      end
+
+      def _run
+        loop do
+          start = Time.now.to_f
+          @polling_callbacks.each do |callback|
+            callback.call(nil)
+            nap_time = options.latency - (Time.now.to_f - start)
+            # TODO: warn if nap_time is negative (polling too slow)
+            sleep(nap_time) if nap_time > 0
+          end
+        end
+      end
+
+      def _process_event(dir, _)
+        _queue_change(:tree, dir, '.')
+      end
+    end
+  end
+end

data/lib/driskell-listen/adapter/simulated_darwin.rb

@@ -0,0 +1,65 @@
+module Driskell::Listen
+  module Adapter
+    class SimulatedDarwin < Linux
+      def self.usable?
+        os = RbConfig::CONFIG['target_os']
+        return false unless const_get('OS_REGEXP') =~ os
+        /1|true/ =~ ENV['LISTEN_GEM_SIMULATE_FSEVENT']
+      end
+
+      class FakeEvent
+        attr_reader :dir
+
+        def initialize(watched_dir, event)
+          # NOTE: avoid using event.absolute_name since new API
+          # will need to have a custom recursion implemented
+          # to properly match events to configured directories
+          @real_path = full_path(event).relative_path_from(watched_dir)
+          @dir = "#{Pathname(watched_dir) + dir_for_event(event, @real_path)}/"
+        end
+
+        def real_path
+          @real_path.to_s
+        end
+
+        private
+
+        def dir?(event)
+          event.flags.include?(:isdir)
+        end
+
+        def moved?(event)
+          (event.flags & [:moved_to, :moved_from])
+        end
+
+        def dir_for_event(event, rel_path)
+          (moved?(event) || dir?(event)) ?  rel_path.dirname : rel_path
+        end
+
+        def full_path(event)
+          Pathname.new(event.watcher.path) + event.name
+        end
+      end
+
+      private
+
+      def _process_event(watched_dir, event)
+        ev = FakeEvent.new(watched_dir, event)
+
+        _log(
+          :debug,
+          "fake_fsevent: #{ev.dir}(#{ev.real_path}=#{event.flags.inspect})")
+
+        _darwin.send(:_process_event, watched_dir, [ev.dir])
+      end
+
+      def _darwin
+        @darwin ||= Class.new(Darwin) do
+          def _configure(*_args)
+            # Skip FSEvent setup
+          end
+        end.new(mq: @mq)
+      end
+    end
+  end
+end

data/lib/driskell-listen/adapter/windows.rb

@@ -0,0 +1,99 @@
+module Driskell::Listen
+  module Adapter
+    # Adapter implementation for Windows `wdm`.
+    #
+    class Windows < Base
+      OS_REGEXP = /mswin|mingw|cygwin/i
+
+      BUNDLER_DECLARE_GEM = <<-EOS.gsub(/^ {6}/, '')
+        Please add the following to your Gemfile to avoid polling for changes:
+          gem 'wdm', '>= 0.1.0' if Gem.win_platform?
+      EOS
+
+      def self.usable?
+        return false unless super
+        require 'wdm'
+        true
+      rescue LoadError
+        _log :debug, format('wdm - load failed: %s:%s', $ERROR_INFO,
+                            $ERROR_POSITION * "\n")
+
+        Kernel.warn BUNDLER_DECLARE_GEM
+        false
+      end
+
+      private
+
+      def _configure(dir, &callback)
+        require 'wdm'
+        _log :debug, 'wdm - starting...'
+        @worker ||= WDM::Monitor.new
+        @worker.watch_recursively(dir.to_s, :files) do |change|
+          callback.call([:file, change])
+        end
+
+        @worker.watch_recursively(dir.to_s, :directories) do |change|
+          callback.call([:dir, change])
+        end
+
+        events = [:attributes, :last_write]
+        @worker.watch_recursively(dir.to_s, *events) do |change|
+          callback.call([:attr, change])
+        end
+      end
+
+      def _run
+        @worker.run!
+      end
+
+      def _process_event(dir, event)
+        _log :debug, "wdm - callback: #{event.inspect}"
+
+        type, change = event
+
+        full_path = Pathname(change.path)
+
+        rel_path = full_path.relative_path_from(dir).to_s
+
+        options = { change: _change(change.type) }
+
+        case type
+        when :file
+          _queue_change(:file, dir, rel_path, options)
+        when :attr
+          unless full_path.directory?
+            _queue_change(:file, dir, rel_path, options)
+          end
+        when :dir
+          if change.type == :removed
+            # TODO: check if watched dir?
+            _queue_change(:dir, dir, Pathname(rel_path).dirname.to_s, {})
+          elsif change.type == :added
+            _queue_change(:dir, dir, rel_path, {})
+          else
+            # do nothing - changed directory means either:
+            #   - removed subdirs (handled above)
+            #   - added subdirs (handled above)
+            #   - removed files (handled by _file_callback)
+            #   - added files (handled by _file_callback)
+            # so what's left?
+          end
+        end
+      rescue
+        details = event.inspect
+        _log :error, format('wdm - callback (%): %s:%s', details, $ERROR_INFO,
+                            $ERROR_POSITION * "\n")
+        raise
+      end
+
+      def _change(type)
+        { modified: [:modified, :attrib], # TODO: is attrib really passed?
+          added:    [:added, :renamed_new_file],
+          removed:  [:removed, :renamed_old_file] }.each do |change, types|
+          return change if types.include?(type)
+        end
+        nil
+      end
+    end
+  end
+end

data/lib/driskell-listen/backend.rb

@@ -0,0 +1,45 @@
+require 'driskell-listen/adapter'
+require 'driskell-listen/adapter/base'
+require 'driskell-listen/adapter/config'
+
+# This class just aggregates configuration object to avoid Listener specs
+# from exploding with huge test setup blocks
+module Driskell::Listen
+  class Backend
+    def initialize(directories, queue, silencer, config)
+      adapter_select_opts = config.adapter_select_options
+
+      adapter_class = Adapter.select(adapter_select_opts)
+
+      # Use default from adapter if possible
+      @min_delay_between_events = config.min_delay_between_events
+      @min_delay_between_events ||= adapter_class::DEFAULTS[:wait_for_delay]
+      @min_delay_between_events ||= 0.1
+
+      adapter_opts = config.adapter_instance_options(adapter_class)
+
+      aconfig = Adapter::Config.new(directories, queue, silencer, adapter_opts)
+      @adapter = adapter_class.new(aconfig)
+    end
+
+    def start
+      adapter.start
+    end
+
+    def stop
+      adapter.stop
+    end
+
+    def preempt_change(dir, rel_path, data)
+      adapter.preempt_change dir, rel_path, data
+    end
+
+    def min_delay_between_events
+      @min_delay_between_events
+    end
+
+    private
+
+    attr_reader :adapter
+  end
+end

data/lib/driskell-listen/change.rb

@@ -0,0 +1,80 @@
+require 'driskell-listen/file'
+require 'driskell-listen/directory'
+
+module Driskell::Listen
+  # TODO: rename to Snapshot
+  class Change
+    # TODO: test this class for coverage
+    class Config
+      def initialize(queue, silencer)
+        @queue = queue
+        @silencer = silencer
+      end
+
+      def silenced?(path, type)
+        @silencer.silenced?(Pathname(path), type)
+      end
+
+      def queue(*args)
+        @queue << args
+      end
+    end
+
+    attr_reader :record
+
+    def initialize(config, record)
+      @config = config
+      @record = record
+    end
+
+    # Invalidate some part of the snapshot/record (dir, file, subtree, etc.)
+    def invalidate(type, rel_path, options)
+      watched_dir = Pathname.new(record.root)
+
+      change = options[:change]
+      cookie = options[:cookie]
+
+      if !cookie && config.silenced?(rel_path, type)
+        Driskell::Listen::Logger.debug {  "(silenced): #{rel_path.inspect}" }
+        return
+      end
+
+      path = watched_dir + rel_path
+
+      Driskell::Listen::Logger.debug do
+        log_details = options[:silence] && 'recording' || change || 'unknown'
+        "#{log_details}: #{type}:#{path} (#{options.inspect})"
+      end
+
+      if change
+        options = cookie ? { cookie: cookie } : {}
+        config.queue(type, change, watched_dir, rel_path, options)
+      else
+        if type == :tree
+          # Invalid the entire directory tree
+          Directory.scan(self, rel_path, **options, recurse: true)
+        elsif type == :dir
+          # Invalid directory contents, but do not recurse
+          Directory.scan(self, rel_path, **options, recurse: false)
+        else
+          change = File.change(record, rel_path)
+          return if !change || options[:silence]
+          config.queue(:file, change, watched_dir, rel_path)
+        end
+      end
+    rescue RuntimeError => ex
+      msg = format(
+        '%s#%s crashed %s:%s',
+        self.class,
+        __method__,
+        exinspect,
+        ex.backtrace * "\n")
+      Driskell::Listen::Logger.error(msg)
+      raise
+    end
+
+    private
+
+    attr_reader :config
+  end
+end

data/lib/driskell-listen/cli.rb

@@ -0,0 +1,65 @@
+require 'thor'
+require 'driskell-listen'
+require 'logger'
+
+module Driskell::Listen
+  class CLI < Thor
+    default_task :start
+
+    desc 'start', 'Starts Listen'
+
+    class_option :verbose,
+                 type:    :boolean,
+                 default: false,
+                 aliases: '-v',
+                 banner:  'Verbose'
+
+    class_option :directory,
+                 type:    :array,
+                 default: '.',
+                 aliases: '-d',
+                 banner:  'The directory to listen to'
+
+    class_option :relative,
+                 type:    :boolean,
+                 default: false,
+                 aliases: '-r',
+                 banner:  'Convert paths relative to current directory'
+
+    def start
+      Driskell::Listen::Forwarder.new(options).start
+    end
+  end
+
+  class Forwarder
+    attr_reader :logger
+    def initialize(options)
+      @options = options
+      @logger = ::Logger.new(STDOUT)
+      @logger.level = ::Logger::INFO
+      @logger.formatter = proc { |_, _, _, msg| "#{msg}\n" }
+    end
+
+    def start
+      logger.info 'Starting listen...'
+      directory = @options[:directory]
+      relative = @options[:relative]
+      callback = proc do |modified, added, removed|
+        if @options[:verbose]
+          logger.info "+ #{added}" unless added.empty?
+          logger.info "- #{removed}" unless removed.empty?
+          logger.info "> #{modified}" unless modified.empty?
+        end
+      end
+
+      listener = Driskell::Listen.to(
+        directory,
+        relative: relative,
+        &callback)
+
+      listener.start
+
+      sleep 0.5 while listener.processing?
+    end
+  end
+end

data/lib/driskell-listen/directory.rb

@@ -0,0 +1,83 @@
+require 'set'
+
+module Driskell::Listen
+  # TODO: refactor (turn it into a normal object, cache the stat, etc)
+  class Directory
+    def self.scan(snapshot, rel_path, options)
+      record = snapshot.record
+
+      previous = record.dir_entries(rel_path)
+
+      dir = Pathname.new(record.root)
+      path = dir + rel_path
+      current = Set.new(path.children)
+
+      Driskell::Listen::Logger.debug do
+        format('%s: %s(%s): %s -> %s',
+               (options[:silence] ? 'Recording' : 'Scanning'),
+               rel_path, options.inspect, previous.inspect, current.inspect)
+      end
+
+      record.update_dir(rel_path)
+
+      current.each do |full_path|
+        # Find old type so we can ensure we invalidate directory contents
+        # if we were previously a file, and vice versa
+        if previous.key?(full_path.basename)
+          old = previous.delete(full_path.basename)
+          old_type = old.key?(:mtime) ? :dir : :file
+        else
+          old_type = nil
+        end
+
+        item_rel_path = full_path.relative_path_from(dir).to_s
+        if detect_type(full_path) == :dir
+          if old_type == :file
+            snapshot.invalidate(:file, item_rel_path, options)
+          end
+
+          # Only invalidate subdirectories if we're recursing or it is new
+          if options[:recurse] || old_type.nil?
+            snapshot.invalidate(:tree, item_rel_path, options)
+          end
+        else
+          if old_type == :dir
+            snapshot.invalidate(:tree, item_rel_path, options)
+          end
+
+          snapshot.invalidate(:file, item_rel_path, options)
+        end
+      end
+
+      process_previous(snapshot, Pathname.new(rel_path), previous, options)
+    rescue Errno::ENOENT, Errno::EHOSTDOWN
+      record.unset_path(rel_path)
+      process_previous(snapshot, Pathname.new(rel_path), previous, options)
+    rescue Errno::ENOTDIR
+      record.unset_path(rel_path)
+      process_previous(snapshot, path, previous, options)
+      snapshot.invalidate(:file, rel_path, options)
+    rescue
+      Driskell::Listen::Logger.warn do
+        format('scan DIED: %s:%s', $ERROR_INFO, $ERROR_POSITION * "\n")
+      end
+      raise
+    end
+
+    def self.process_previous(snapshot, path, previous, options)
+      previous.each do |entry, data|
+        type = data.key?(:mtime) ? :file : :tree
+        rel_path_s = (path + entry).to_s
+        snapshot.invalidate(type, rel_path_s, options)
+      end
+    end
+
+    def self.detect_type(full_path)
+      stat = ::File.lstat(full_path.to_s)
+      stat.directory? ? :dir : :file
+    rescue Errno::ENOENT
+      # report as dir for scanning
+      :dir
+    end
+  end
+end