sass-listen 3.0.7

data/lib/listen/adapter/polling.rb

@@ -0,0 +1,37 @@
+module 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(:dir, dir, '.', recursive: true)
+      end
+    end
+  end
+end

data/lib/listen/adapter/windows.rb

@@ -0,0 +1,99 @@
+module 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/listen/backend.rb

@@ -0,0 +1,41 @@
+require 'listen/adapter'
+require 'listen/adapter/base'
+require 'listen/adapter/config'
+
+# This class just aggregates configuration object to avoid Listener specs
+# from exploding with huge test setup blocks
+module 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 min_delay_between_events
+      @min_delay_between_events
+    end
+
+    private
+
+    attr_reader :adapter
+  end
+end

data/lib/listen/change.rb

@@ -0,0 +1,78 @@
+require 'listen/file'
+require 'listen/directory'
+
+module 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)
+        Listen::Logger.debug {  "(silenced): #{rel_path.inspect}" }
+        return
+      end
+
+      path = watched_dir + rel_path
+
+      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 == :dir
+          # NOTE: POSSIBLE RECURSION
+          # TODO: fix - use a queue instead
+          Directory.scan(self, rel_path, options)
+        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")
+      Listen::Logger.error(msg)
+      raise
+    end
+
+    private
+
+    attr_reader :config
+  end
+end

data/lib/listen/cli.rb

@@ -0,0 +1,65 @@
+require 'thor'
+require 'listen'
+require 'logger'
+
+module 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
+      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 = Listen.to(
+        directory,
+        relative: relative,
+        &callback)
+
+      listener.start
+
+      sleep 0.5 while listener.processing?
+    end
+  end
+end

data/lib/listen/directory.rb

@@ -0,0 +1,76 @@
+require 'set'
+
+module 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
+      dir = Pathname.new(record.root)
+      previous = record.dir_entries(rel_path)
+
+      record.add_dir(rel_path)
+
+      # TODO: use children(with_directory: false)
+      path = dir + rel_path
+      current = Set.new(path.children)
+
+      Listen::Logger.debug do
+        format('%s: %s(%s): %s -> %s',
+               (options[:silence] ? 'Recording' : 'Scanning'),
+               rel_path, options.inspect, previous.inspect, current.inspect)
+      end
+
+      begin
+        current.each do |full_path|
+          type = ::File.lstat(full_path.to_s).directory? ? :dir : :file
+          item_rel_path = full_path.relative_path_from(dir).to_s
+          _change(snapshot, type, item_rel_path, options)
+        end
+      rescue Errno::ENOENT
+        # The directory changed meanwhile, so rescan it
+        current = Set.new(path.children)
+        retry
+      end
+
+      # TODO: this is not tested properly
+      previous = previous.reject { |entry, _| current.include? path + entry }
+
+      _async_changes(snapshot, Pathname.new(rel_path), previous, options)
+
+    rescue Errno::ENOENT, Errno::EHOSTDOWN
+      record.unset_path(rel_path)
+      _async_changes(snapshot, Pathname.new(rel_path), previous, options)
+
+    rescue Errno::ENOTDIR
+      # TODO: path not tested
+      record.unset_path(rel_path)
+      _async_changes(snapshot, path, previous, options)
+      _change(snapshot, :file, rel_path, options)
+    rescue
+      Listen::Logger.warn do
+        format('scan DIED: %s:%s', $ERROR_INFO, $ERROR_POSITION * "\n")
+      end
+      raise
+    end
+
+    def self._async_changes(snapshot, path, previous, options)
+      fail "Not a Pathname: #{path.inspect}" unless path.respond_to?(:children)
+      previous.each do |entry, data|
+        # TODO: this is a hack with insufficient testing
+        type = data.key?(:mtime) ? :file : :dir
+        rel_path_s = (path + entry).to_s
+        _change(snapshot, type, rel_path_s, options)
+      end
+    end
+
+    def self._change(snapshot, type, path, options)
+      return snapshot.invalidate(type, path, options) if type == :dir
+
+      # Minor param cleanup for tests
+      # TODO: use a dedicated Event class
+      opts = options.dup
+      opts.delete(:recursive)
+      snapshot.invalidate(type, path, opts)
+    end
+  end
+end

data/lib/listen/event/config.rb

@@ -0,0 +1,59 @@
+module Listen
+  module Event
+    class Config
+      def initialize(
+        listener,
+        event_queue,
+        queue_optimizer,
+        wait_for_delay,
+        &block)
+
+        @listener = listener
+        @event_queue = event_queue
+        @queue_optimizer = queue_optimizer
+        @min_delay_between_events = wait_for_delay
+        @block = block
+      end
+
+      def sleep(*args)
+        Kernel.sleep(*args)
+      end
+
+      def call(*args)
+        @block.call(*args) if @block
+      end
+
+      def timestamp
+        Time.now.to_f
+      end
+
+      def event_queue
+        @event_queue
+      end
+
+      def callable?
+        @block
+      end
+
+      def optimize_changes(changes)
+        @queue_optimizer.smoosh_changes(changes)
+      end
+
+      def min_delay_between_events
+        @min_delay_between_events
+      end
+
+      def stopped?
+        listener.state == :stopped
+      end
+
+      def paused?
+        listener.state == :paused
+      end
+
+      private
+
+      attr_reader :listener
+    end
+  end
+end