listen 1.3.1 → 2.0.0.beta.1

data/lib/listen/adapter/darwin.rb

@@ -0,0 +1,44 @@
+module Listen
+  module Adapter
+
+    # Adapter implementation for Mac OS X `FSEvents`.
+    #
+    class Darwin < Base
+
+      def self.usable?
+        RbConfig::CONFIG['target_os'] =~ /darwin(1.+)?$/i
+      end
+
+      def initialize(listener)
+        require 'rb-fsevent'
+        super
+      end
+
+      def start
+        worker = _init_worker
+        worker.run
+      end
+
+      private
+
+      # Initializes a FSEvent worker and adds a watcher for
+      # each directory listened.
+      #
+      def _init_worker
+        FSEvent.new.tap do |worker|
+          worker.watch(_directories_path, latency: _latency) do |changes|
+            _changes_path(changes).each { |path| _notify_change(path, type: 'Dir') }
+          end
+        end
+      end
+
+      def _changes_path(changes)
+        changes.map do |path|
+          path.sub!(/\/$/, '')
+          Pathname.new(path)
+        end
+      end
+    end
+
+  end
+end

data/lib/listen/adapter/linux.rb

@@ -0,0 +1,92 @@
+module Listen
+  module Adapter
+
+    # Listener implementation for Linux `inotify`.
+    #
+    class Linux < Base
+      # Watched inotify events
+      #
+      # @see http://www.tin.org/bin/man.cgi?section=7&topic=inotify
+      # @see https://github.com/nex3/rb-inotify/blob/master/lib/rb-inotify/notifier.rb#L99-L177
+      #
+      EVENTS = [:recursive, :attrib, :create, :delete, :move, :close_write]
+
+      # The message to show when the limit of inotify watchers is not enough
+      #
+      INOTIFY_LIMIT_MESSAGE = <<-EOS.gsub(/^\s*/, '')
+        Listen error: unable to monitor directories for changes.
+
+        Please head to https://github.com/guard/listen/wiki/Increasing-the-amount-of-inotify-watchers
+        for information on how to solve this issue.
+      EOS
+
+      def self.usable?
+        RbConfig::CONFIG['target_os'] =~ /linux/i
+      end
+
+      def initialize(listener)
+        require 'rb-inotify'
+        super
+      end
+
+      def start
+        worker = _init_worker
+        worker.run
+      rescue Errno::ENOSPC
+        abort(INOTIFY_LIMIT_MESSAGE)
+      end
+
+      private
+
+      # Initializes a INotify worker and adds a watcher for
+      # each directory passed to the adapter.
+      #
+      # @return [INotify::Notifier] initialized worker
+      def _init_worker
+        INotify::Notifier.new.tap do |worker|
+          _directories_path.each { |path| worker.watch(path, *EVENTS, &_worker_callback) }
+        end
+      end
+
+      def _worker_callback
+        lambda do |event|
+          next if _skip_event?(event)
+
+          if _dir_event?(event)
+            _notify_change(_event_path(event), type: 'Dir')
+          else
+            _notify_change(_event_path(event), type: 'file', change: _change(event.flags))
+          end
+        end
+      end
+
+      def _skip_event?(event)
+        # Event on root directory
+        return true if event.name == ""
+        # INotify reports changes to files inside directories as events
+        # on the directories themselves too.
+        #
+        # @see http://linux.die.net/man/7/inotify
+        return true if _dir_event?(event) && (event.flags & [:close, :modify]).any?
+      end
+
+      def _change(event_flags)
+        { modified: [:attrib],
+          added:    [:moved_to, :create],
+          removed:  [:moved_from, :delete] }.each do |change, flags|
+          return change unless (flags & event_flags).empty?
+        end
+        nil
+      end
+
+      def _dir_event?(event)
+        event.flags.include?(:isdir)
+      end
+
+      def _event_path(event)
+        Pathname.new(event.absolute_name)
+      end
+    end
+
+  end
+end

data/lib/listen/adapter/polling.rb

@@ -0,0 +1,49 @@
+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
+      DEFAULT_POLLING_LATENCY = 1.0
+
+      def self.usable?
+        true
+      end
+
+      def start
+        _poll_directories
+      end
+
+      private
+
+      def _latency
+        listener.options[:latency] || DEFAULT_POLLING_LATENCY
+      end
+
+      def _poll_directories
+        _napped_loop do
+          listener.directories.each do |path|
+            _notify_change(path, type: 'Dir', recursive: true)
+          end
+        end
+      end
+
+      def _napped_loop
+        loop do
+          _nap_time { yield }
+        end
+      end
+
+      def _nap_time
+        start = Time.now.to_f
+        yield
+        nap_time = _latency - (Time.now.to_f - start)
+        sleep(nap_time) if nap_time > 0
+      end
+    end
+
+  end
+end

data/lib/listen/adapter/windows.rb

@@ -0,0 +1,63 @@
+module Listen
+  module Adapter
+
+    # Adapter implementation for Windows `wdm`.
+    #
+    class Windows < Base
+
+      # The message to show when wdm gem isn't available
+      #
+      BUNDLER_DECLARE_GEM = <<-EOS.gsub(/^ {6}/, '')
+        Please add the following to your Gemfile to avoid polling for changes:
+          require 'rbconfig'
+          gem 'wdm', '>= 0.1.0' if RbConfig::CONFIG['target_os'] =~ /mswin|mingw|cygwin/i
+      EOS
+
+      def self.usable?
+        if RbConfig::CONFIG['target_os'] =~ /mswin|mingw|cygwin/i
+          require 'wdm'
+          true
+        end
+      rescue Gem::LoadError
+        Kernel.warn BUNDLER_DECLARE_GEM
+      end
+
+      def start
+        worker = _init_worker
+        worker.run!
+      end
+
+      private
+
+      # Initializes a WDM monitor and adds a watcher for
+      # each directory passed to the adapter.
+      #
+      # @return [WDM::Monitor] initialized worker
+      def _init_worker
+        WDM::Monitor.new.tap do |worker|
+          _directories_path.each { |path| worker.watch_recursively(path, &_worker_callback) }
+        end
+      end
+
+      def _worker_callback
+        lambda do |change|
+            _notify_change(_path(change.path), type: 'file', change: _change(change.type))
+        end
+      end
+
+      def _path(path)
+        Pathname.new(path)
+      end
+
+      def _change(type)
+        { modified: [:modified],
+          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/change.rb

@@ -0,0 +1,42 @@
+require 'listen/file'
+require 'listen/directory'
+require 'listen/silencer'
+
+module Listen
+  class Change
+    include Celluloid
+
+    attr_accessor :listener, :silencer
+
+    def initialize(listener)
+      @listener = listener
+      @silencer = Silencer.new(listener.options)
+    end
+
+    def change(path, options)
+      return if silencer.silenced?(path)
+      if change = options[:change]
+        _notify_listener(change, path)
+      else
+        send("_#{options[:type].downcase}_change", path, options)
+      end
+    end
+
+    private
+
+    def _file_change(path, options)
+      change = File.new(path).change
+      if change && listener.listen? && !options[:silence]
+        _notify_listener(change, path)
+      end
+    end
+
+    def _dir_change(path, options)
+      Directory.new(path, options).scan
+    end
+
+    def _notify_listener(change, path)
+      listener.changes << { change => path }
+    end
+  end
+end

data/lib/listen/directory.rb

@@ -0,0 +1,73 @@
+module Listen
+  class Directory
+    attr_accessor :path, :options
+
+    def initialize(path, options = {})
+      @path    = path
+      @options = options
+    end
+
+    def scan
+      _update_record
+      _all_entries.each do |entry_path, data|
+        case data[:type]
+        when 'File' then _async_change(entry_path, options.merge(type: 'File'))
+        when 'Dir'
+          _async_change(entry_path, options.merge(type: 'Dir')) if _recursive_scan?(entry_path)
+        end
+      end
+    end
+
+    private
+
+    def _update_record
+      if ::Dir.exists?(path)
+        _record.async.set_path(path, { type: 'Dir'})
+      else
+        _record.async.unset_path(path)
+      end
+    end
+
+    def _all_entries
+      _record_entries.merge(_entries)
+    end
+
+    def _entries
+      return {} unless ::Dir.exists?(path)
+      entries = ::Dir.entries(path) - %w[. ..]
+      entries = entries.map { |entry| [entry, type: _entry_type(entry)] }
+      Hash[*entries.flatten]
+    end
+
+    def _entry_type(entry_path)
+      entry_path = path.join(entry_path)
+      if entry_path.file?
+        'File'
+      elsif entry_path.directory?
+        'Dir'
+      end
+    end
+
+    def _record_entries
+      future = _record.future.dir_entries(path)
+      future.value
+    end
+
+    def _record
+      Celluloid::Actor[:listen_record]
+    end
+
+    def _change_pool
+      Celluloid::Actor[:listen_change_pool]
+    end
+
+    def _recursive_scan?(path)
+      !::Dir.exists?(path) || options[:recursive]
+    end
+
+    def _async_change(entry_path, options)
+      entry_path = path.join(entry_path)
+      _change_pool.async.change(entry_path, options)
+    end
+  end
+end

data/lib/listen/file.rb

@@ -0,0 +1,108 @@
+module Listen
+  class File
+    attr_accessor :path, :data
+
+    def initialize(path)
+      @path = path
+      @data = { type: 'File' }
+    end
+
+    def change
+      if _existing_path? && _modified?
+        _set_record_data
+        :modified
+      elsif _new_path?
+        _set_record_data
+        :added
+      elsif _removed_path?
+        _unset_record_data
+        :removed
+      end
+    end
+
+    private
+
+    def _new_path?
+      _exist? && !_record_data?
+    end
+
+    def _existing_path?
+      _exist? && _record_data?
+    end
+
+    def _removed_path?
+      !_exist?
+    end
+
+    def _record_data?
+      !_record_data.empty?
+    end
+
+    def _exist?
+      @exist ||= ::File.exist?(path)
+    end
+
+    def _modified?
+      _mtime > _record_data[:mtime] || _mode_modified? || _content_modified?
+    end
+
+    def _mode_modified?
+      _mode != _record_data[:mode]
+    end
+
+    # Only useful on Darwin because of the file mtime second precision
+    #
+    def _content_modified?
+      _record_data[:md5] && _md5 != _record_data[:md5]
+    end
+
+    def _set_record_data
+      @data.merge!(_new_data)
+      _record.async.set_path(path, data)
+    end
+
+    def _unset_record_data
+      _record.async.unset_path(path)
+    end
+
+    # Only Darwin need md5 comparaison because of the file mtime second precision
+    #
+    def _new_data
+      data = { mtime: _mtime, mode: _mode }
+      data[:md5] = _md5 if RbConfig::CONFIG['target_os'] =~ /darwin/i
+      data
+    end
+
+    def _record_data
+      @_record_data ||= _record.future.file_data(path).value
+    end
+
+    def _record
+      Celluloid::Actor[:listen_record]
+    end
+
+    def _mtime
+      @mtime ||= _lstat.mtime.to_f
+    rescue
+      0.0
+    end
+
+    def _mode
+      @mode ||= _lstat.mode
+    rescue
+      nil
+    end
+
+    def _lstat
+      @lstat ||= ::File.lstat(path)
+    rescue
+      nil
+    end
+
+    def _md5
+      @md5 ||= Digest::MD5.file(path).digest
+    rescue
+      nil
+    end
+  end
+end