qiita_org 0.1.24 → 0.1.25

data/gems/ruby/2.7.0/gems/listen-3.3.1/lib/listen/adapter/linux.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Listen
+  module Adapter
+    # @see https://github.com/nex3/rb-inotify
+    class Linux < Base
+      OS_REGEXP = /linux/i
+
+      DEFAULTS = {
+        events: [
+          :recursive,
+          :attrib,
+          :create,
+          :modify,
+          :delete,
+          :move,
+          :close_write
+        ],
+        wait_for_delay: 0.1
+      }.freeze
+
+      private
+
+      WIKI_URL = 'https://github.com/guard/listen'\
+        '/wiki/Increasing-the-amount-of-inotify-watchers'.freeze
+
+      INOTIFY_LIMIT_MESSAGE = <<-EOS.gsub(/^\s*/, '')
+        FATAL: Listen error: unable to monitor directories for changes.
+        Visit #{WIKI_URL} for info on how to fix this.
+      EOS
+
+      def _configure(directory, &callback)
+        require 'rb-inotify'
+        @worker ||= ::INotify::Notifier.new
+        @worker.watch(directory.to_s, *options.events, &callback)
+      rescue Errno::ENOSPC
+        abort(INOTIFY_LIMIT_MESSAGE)
+      end
+
+      def _run
+        @worker.run
+      end
+
+      def _process_event(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
+        path = Pathname.new(event.watcher.path) + event.name
+        rel_path = path.relative_path_from(dir).to_s
+
+        Listen.logger.debug { "inotify: #{rel_path} (#{event.flags.inspect})" }
+
+        if /1|true/ =~ ENV['LISTEN_GEM_SIMULATE_FSEVENT']
+          if (event.flags & [:moved_to, :moved_from]) || _dir_event?(event)
+            rel_path = path.dirname.relative_path_from(dir).to_s
+          end
+          _queue_change(:dir, dir, rel_path, {})
+          return
+        end
+
+        return if _skip_event?(event)
+
+        cookie_params = event.cookie.zero? ? {} : { cookie: event.cookie }
+
+        # Note: don't pass options to force rescanning the directory, so we can
+        # detect moving/deleting a whole tree
+        if _dir_event?(event)
+          _queue_change(:dir, dir, rel_path, cookie_params)
+          return
+        end
+
+        params = cookie_params.merge(change: _change(event.flags))
+
+        _queue_change(:file, dir, rel_path, params)
+      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
+        _dir_event?(event) && (event.flags & [:close, :modify]).any?
+      end
+
+      def _change(event_flags)
+        { modified:   [:attrib, :close_write],
+          moved_to:   [:moved_to],
+          moved_from: [:moved_from],
+          added:      [:create],
+          removed:    [: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 _stop
+        @worker&.close
+
+        super
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/listen-3.3.1/lib/listen/adapter/polling.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+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 }.freeze
+
+      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/gems/ruby/2.7.0/gems/listen-3.3.1/lib/listen/adapter/windows.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+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
+        Listen.logger.debug format('wdm - load failed: %s:%s', $ERROR_INFO,
+                            $ERROR_POSITION * "\n")
+
+        Kernel.warn BUNDLER_DECLARE_GEM
+        false
+      end
+
+      private
+
+      def _configure(dir)
+        require 'wdm'
+        Listen.logger.debug 'wdm - starting...'
+        @worker ||= WDM::Monitor.new
+        @worker.watch_recursively(dir.to_s, :files) do |change|
+          yield([:file, change])
+        end
+
+        @worker.watch_recursively(dir.to_s, :directories) do |change|
+          yield([:dir, change])
+        end
+
+        events = [:attributes, :last_write]
+        @worker.watch_recursively(dir.to_s, *events) do |change|
+          yield([:attr, change])
+        end
+      end
+
+      def _run
+        @worker.run!
+      end
+
+      def _process_event(dir, event)
+        Listen.logger.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, {})
+            # 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
+        Listen.logger.error format('wdm - callback (%s): %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/gems/ruby/2.7.0/gems/listen-3.3.1/lib/listen/backend.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'listen/adapter'
+require 'listen/adapter/base'
+require 'listen/adapter/config'
+
+require 'forwardable'
+
+# This class just aggregates configuration object to avoid Listener specs
+# from exploding with huge test setup blocks
+module Listen
+  class Backend
+    extend Forwardable
+
+    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
+
+    delegate start: :adapter
+    delegate stop: :adapter
+
+    attr_reader :min_delay_between_events
+
+    private
+
+    attr_reader :adapter
+  end
+end

data/gems/ruby/2.7.0/gems/listen-3.3.1/lib/listen/change.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+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)
+      elsif 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
+    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/gems/ruby/2.7.0/gems/listen-3.3.1/lib/listen/cli.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+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, 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/gems/ruby/2.7.0/gems/listen-3.3.1/lib/listen/directory.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+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(_children(path))
+
+      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(_children(path))
+        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.ascendant_of?(base, other)
+      other.ascend do |ascendant|
+        break true if base == ascendant
+      end
+    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
+
+    def self._children(path)
+      return path.children unless RUBY_ENGINE == 'jruby'
+
+      # JRuby inconsistency workaround, see:
+      # https://github.com/jruby/jruby/issues/3840
+      exists = path.exist?
+      directory = path.directory?
+      return path.children unless exists && !directory
+      raise Errno::ENOTDIR, path.to_s
+    end
+  end
+end