sass-listen 3.0.7

data/lib/listen/event/loop.rb

@@ -0,0 +1,117 @@
+require 'thread'
+
+require 'timeout'
+require 'listen/event/processor'
+
+module Listen
+  module Event
+    class Loop
+      class Error < RuntimeError
+        class NotStarted < Error
+        end
+      end
+
+      def initialize(config)
+        @config = config
+        @wait_thread = nil
+        @state = :paused
+        @reasons = ::Queue.new
+      end
+
+      def wakeup_on_event
+        return if stopped?
+        return unless processing?
+        return unless wait_thread.alive?
+        _wakeup(:event)
+      end
+
+      def paused?
+        wait_thread && state == :paused
+      end
+
+      def processing?
+        return false if stopped?
+        return false if paused?
+        state == :processing
+      end
+
+      def setup
+        # TODO: use a Fiber instead?
+        q = ::Queue.new
+        @wait_thread = Internals::ThreadPool.add do
+          _wait_for_changes(q, config)
+        end
+
+        Listen::Logger.debug('Waiting for processing to start...')
+        Timeout.timeout(5) { q.pop }
+      end
+
+      def resume
+        fail Error::NotStarted if stopped?
+        return unless wait_thread
+        _wakeup(:resume)
+      end
+
+      def pause
+        # TODO: works?
+        # fail NotImplementedError
+      end
+
+      def teardown
+        return unless wait_thread
+        if wait_thread.alive?
+          _wakeup(:teardown)
+          wait_thread.join
+        end
+        @wait_thread = nil
+      end
+
+      def stopped?
+        !wait_thread
+      end
+
+      private
+
+      attr_reader :config
+      attr_reader :wait_thread
+
+      attr_accessor :state
+
+      def _wait_for_changes(ready_queue, config)
+        processor = Event::Processor.new(config, @reasons)
+
+        _wait_until_resumed(ready_queue)
+        processor.loop_for(config.min_delay_between_events)
+      rescue StandardError => ex
+        _nice_error(ex)
+      end
+
+      def _sleep(*args)
+        Kernel.sleep(*args)
+      end
+
+      def _wait_until_resumed(ready_queue)
+        self.state = :paused
+        ready_queue << :ready
+        sleep
+        self.state = :processing
+      end
+
+      def _nice_error(ex)
+        indent = "\n -- "
+        msg = format(
+          'exception while processing events: %s Backtrace:%s%s',
+          ex,
+          indent,
+          ex.backtrace * indent
+        )
+        Listen::Logger.error(msg)
+      end
+
+      def _wakeup(reason)
+        @reasons << reason
+        wait_thread.wakeup
+      end
+    end
+  end
+end

data/lib/listen/event/processor.rb

@@ -0,0 +1,122 @@
+module Listen
+  module Event
+    class Processor
+      def initialize(config, reasons)
+        @config = config
+        @reasons = reasons
+        _reset_no_unprocessed_events
+      end
+
+      # TODO: implement this properly instead of checking the state at arbitrary
+      # points in time
+      def loop_for(latency)
+        @latency = latency
+
+        loop do
+          _wait_until_events
+          _wait_until_events_calm_down
+          _wait_until_no_longer_paused
+          _process_changes
+        end
+      rescue Stopped
+        Listen::Logger.debug('Processing stopped')
+      end
+
+      private
+
+      class Stopped < RuntimeError
+      end
+
+      def _wait_until_events_calm_down
+        loop do
+          now = _timestamp
+
+          # Assure there's at least latency between callbacks to allow
+          # for accumulating changes
+          diff = _deadline - now
+          break if diff <= 0
+
+          # give events a bit of time to accumulate so they can be
+          # compressed/optimized
+          _sleep(:waiting_until_latency, diff)
+        end
+      end
+
+      def _wait_until_no_longer_paused
+        # TODO: may not be a good idea?
+        _sleep(:waiting_for_unpause) while config.paused?
+      end
+
+      def _check_stopped
+        return unless config.stopped?
+
+        _flush_wakeup_reasons
+        raise Stopped
+      end
+
+      def _sleep(_local_reason, *args)
+        _check_stopped
+        sleep_duration = config.sleep(*args)
+        _check_stopped
+
+        _flush_wakeup_reasons do |reason|
+          next unless reason == :event
+          _remember_time_of_first_unprocessed_event unless config.paused?
+        end
+
+        sleep_duration
+      end
+
+      def _remember_time_of_first_unprocessed_event
+        @first_unprocessed_event_time ||= _timestamp
+      end
+
+      def _reset_no_unprocessed_events
+        @first_unprocessed_event_time = nil
+      end
+
+      def _deadline
+        @first_unprocessed_event_time + @latency
+      end
+
+      def _wait_until_events
+        # TODO: long sleep may not be a good idea?
+        _sleep(:waiting_for_events) while config.event_queue.empty?
+        @first_unprocessed_event_time ||= _timestamp
+      end
+
+      def _flush_wakeup_reasons
+        reasons = @reasons
+        until reasons.empty?
+          reason = reasons.pop
+          yield reason if block_given?
+        end
+      end
+
+      def _timestamp
+        config.timestamp
+      end
+
+      # for easier testing without sleep loop
+      def _process_changes
+        _reset_no_unprocessed_events
+
+        changes = []
+        changes << config.event_queue.pop until config.event_queue.empty?
+
+        callable = config.callable?
+        return unless callable
+
+        hash = config.optimize_changes(changes)
+        result = [hash[:modified], hash[:added], hash[:removed]]
+        return if result.all?(&:empty?)
+
+        block_start = _timestamp
+        config.call(*result)
+        Listen::Logger.debug "Callback took #{_timestamp - block_start} sec"
+      end
+
+      attr_reader :config
+    end
+  end
+end

data/lib/listen/event/queue.rb

@@ -0,0 +1,56 @@
+require 'thread'
+
+module Listen
+  module Event
+    class Queue
+      class Config
+        def initialize(relative)
+          @relative = relative
+        end
+
+        def relative?
+          @relative
+        end
+      end
+
+      def initialize(config, &block)
+        @event_queue = ::Queue.new
+        @block = block
+        @config = config
+      end
+
+      def <<(args)
+        type, change, dir, path, options = *args
+        fail "Invalid type: #{type.inspect}" unless [:dir, :file].include? type
+        fail "Invalid change: #{change.inspect}" unless change.is_a?(Symbol)
+        fail "Invalid path: #{path.inspect}" unless path.is_a?(String)
+
+        dir = _safe_relative_from_cwd(dir)
+        event_queue.public_send(:<<, [type, change, dir, path, options])
+
+        block.call(args) if block
+      end
+
+      def empty?
+        event_queue.empty?
+      end
+
+      def pop
+        event_queue.pop
+      end
+
+      private
+
+      attr_reader :event_queue
+      attr_reader :block
+      attr_reader :config
+
+      def _safe_relative_from_cwd(dir)
+        return dir unless config.relative?
+        dir.relative_path_from(Pathname.pwd)
+      rescue ArgumentError
+        dir
+      end
+    end
+  end
+end

data/lib/listen/file.rb

@@ -0,0 +1,80 @@
+require 'digest/md5'
+
+module Listen
+  class File
+    def self.change(record, rel_path)
+      path = Pathname.new(record.root) + rel_path
+      lstat = path.lstat
+
+      data = { mtime: lstat.mtime.to_f, mode: lstat.mode }
+
+      record_data = record.file_data(rel_path)
+
+      if record_data.empty?
+        record.update_file(rel_path, data)
+        return :added
+      end
+
+      if data[:mode] != record_data[:mode]
+        record.update_file(rel_path, data)
+        return :modified
+      end
+
+      if data[:mtime] != record_data[:mtime]
+        record.update_file(rel_path, data)
+        return :modified
+      end
+
+      return if /1|true/ =~ ENV['LISTEN_GEM_DISABLE_HASHING']
+      return unless self.inaccurate_mac_time?(lstat)
+
+      # Check if change happened within 1 second (maybe it's even
+      # too much, e.g. 0.3-0.5 could be sufficient).
+      #
+      # With rb-fsevent, there's a (configurable) latency between
+      # when file was changed and when the event was triggered.
+      #
+      # If a file is saved at ???14.998, by the time the event is
+      # actually received by Listen, the time could already be e.g.
+      # ???15.7.
+      #
+      # And since Darwin adapter uses directory scanning, the file
+      # mtime may be the same (e.g. file was changed at ???14.001,
+      # then at ???14.998, but the fstat time would be ???14.0 in
+      # both cases).
+      #
+      # If change happend at ???14.999997, the mtime is 14.0, so for
+      # an mtime=???14.0 we assume it could even be almost ???15.0
+      #
+      # So if Time.now.to_f is ???15.999998 and stat reports mtime
+      # at ???14.0, then event was due to that file'd change when:
+      #
+      # ???15.999997 - ???14.999998 < 1.0s
+      #
+      # So the "2" is "1 + 1" (1s to cover rb-fsevent latency +
+      # 1s maximum difference between real mtime and that recorded
+      # in the file system)
+      #
+      return if data[:mtime].to_i + 2 <= Time.now.to_f
+
+      md5 = Digest::MD5.file(path).digest
+      record.update_file(rel_path, data.merge(md5: md5))
+      :modified if record_data[:md5] && md5 != record_data[:md5]
+    rescue SystemCallError
+      record.unset_path(rel_path)
+      :removed
+    rescue
+      Listen::Logger.debug "lstat failed for: #{rel_path} (#{$ERROR_INFO})"
+      raise
+    end
+
+    def self.inaccurate_mac_time?(stat)
+      # 'mac' means Modified/Accessed/Created
+
+      # Since precision depends on mounted FS (e.g. you can have a FAT partiion
+      # mounted on Linux), check for fields with a remainder to detect this
+
+      [stat.mtime, stat.ctime, stat.atime].map(&:usec).all?(&:zero?)
+    end
+  end
+end

data/lib/listen/fsm.rb

@@ -0,0 +1,131 @@
+# Code copied from https://github.com/celluloid/celluloid-fsm
+module Listen
+  module FSM
+    DEFAULT_STATE = :default # Default state name unless one is explicitly set
+
+    # Included hook to extend class methods
+    def self.included(klass)
+      klass.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+      # Obtain or set the default state
+      # Passing a state name sets the default state
+      def default_state(new_default = nil)
+        if new_default
+          @default_state = new_default.to_sym
+        else
+          defined?(@default_state) ? @default_state : DEFAULT_STATE
+        end
+      end
+
+      # Obtain the valid states for this FSM
+      def states
+        @states ||= {}
+      end
+
+      # Declare an FSM state and optionally provide a callback block to fire
+      # Options:
+      # * to: a state or array of states this state can transition to
+      def state(*args, &block)
+        if args.last.is_a? Hash
+          # Stringify keys :/
+          options = args.pop.each_with_object({}) { |(k, v), h| h[k.to_s] = v }
+        else
+          options = {}
+        end
+
+        args.each do |name|
+          name = name.to_sym
+          default_state name if options['default']
+          states[name] = State.new(name, options['to'], &block)
+        end
+      end
+    end
+
+    # Be kind and call super if you must redefine initialize
+    def initialize
+      @state = self.class.default_state
+    end
+
+    # Obtain the current state of the FSM
+    attr_reader :state
+
+    def transition(state_name)
+      new_state = validate_and_sanitize_new_state(state_name)
+      return unless new_state
+      transition_with_callbacks!(new_state)
+    end
+
+    # Immediate state transition with no checks, or callbacks. "Dangerous!"
+    def transition!(state_name)
+      @state = state_name
+    end
+
+    protected
+
+    def validate_and_sanitize_new_state(state_name)
+      state_name = state_name.to_sym
+
+      return if current_state_name == state_name
+
+      if current_state && !current_state.valid_transition?(state_name)
+        valid = current_state.transitions.map(&:to_s).join(', ')
+        msg = "#{self.class} can't change state from '#{@state}'"\
+          " to '#{state_name}', only to: #{valid}"
+        fail ArgumentError, msg
+      end
+
+      new_state = states[state_name]
+
+      unless new_state
+        return if state_name == default_state
+        fail ArgumentError, "invalid state for #{self.class}: #{state_name}"
+      end
+
+      new_state
+    end
+
+    def transition_with_callbacks!(state_name)
+      transition! state_name.name
+      state_name.call(self)
+    end
+
+    def states
+      self.class.states
+    end
+
+    def default_state
+      self.class.default_state
+    end
+
+    def current_state
+      states[@state]
+    end
+
+    def current_state_name
+      current_state && current_state.name || ''
+    end
+
+    class State
+      attr_reader :name, :transitions
+
+      def initialize(name, transitions = nil, &block)
+        @name, @block = name, block
+        @transitions = nil
+        @transitions = Array(transitions).map(&:to_sym) if transitions
+      end
+
+      def call(obj)
+        obj.instance_eval(&@block) if @block
+      end
+
+      def valid_transition?(new_state)
+        # All transitions are allowed unless expressly
+        return true unless @transitions
+
+        @transitions.include? new_state.to_sym
+      end
+    end
+  end
+end