qiita_org 0.1.20 → 0.1.25

data/gems/ruby/2.7.0/gems/guard-2.16.2/lib/guard/guardfile/generator.rb

@@ -0,0 +1,128 @@
+require "guard/ui"
+require "guard/plugin_util"
+
+# Add Pathname#binwrite to 1.9.3
+unless Pathname.instance_methods.include?(:binwrite)
+  class Pathname
+    def binwrite(*args)
+      IO.binwrite(to_s, *args)
+    end
+  end
+end
+
+module Guard
+  module Guardfile
+    # This class is responsible for generating the Guardfile and adding Guard'
+    # plugins' templates into it.
+    #
+    # @see Guard::CLI
+    #
+    class Generator
+      require "guard"
+      require "guard/ui"
+
+      INFO_TEMPLATE_ADDED =
+        "%s template added to Guardfile, feel free to edit it"
+
+      # The Guardfile template for `guard init`
+      GUARDFILE_TEMPLATE = File.expand_path(
+        "../../../guard/templates/Guardfile",
+        __FILE__
+      )
+
+      # The location of user defined templates
+      begin
+        HOME_TEMPLATES = Pathname.new("~/.guard/templates").expand_path
+      rescue ArgumentError
+        # home isn't defined.  Set to the root of the drive.  Trust that there
+        # won't be user defined templates there
+        HOME_TEMPLATES = Pathname.new("/").expand_path
+      end
+
+      class Error < RuntimeError
+      end
+
+      class NoSuchPlugin < Error
+        attr_reader :plugin_name, :class_name
+
+        def initialize(plugin_name)
+          @plugin_name = plugin_name
+          @class_name = plugin_name.delete("-").capitalize
+        end
+
+        def message
+          "Could not load 'guard/#{plugin_name}'"\
+          " or '~/.guard/templates/#{plugin_name}'"\
+          " or find class Guard::#{class_name}\n"
+        end
+      end
+
+      # Creates the initial Guardfile template when it does not
+      # already exist.
+      #
+      # @see Guard::CLI#init
+      #
+      def create_guardfile
+        path = Pathname.new("Guardfile").expand_path
+        if path.exist?
+          _ui(:error, "Guardfile already exists at #{path}")
+          abort
+        end
+
+        _ui(:info, "Writing new Guardfile to #{path}")
+        FileUtils.cp(GUARDFILE_TEMPLATE, path.to_s)
+      end
+
+      # Adds the Guardfile template of a Guard plugin to an existing Guardfile.
+      #
+      # @see Guard::CLI#init
+      #
+      # @param [String] plugin_name the name of the Guard plugin or template to
+      #   initialize
+      #
+      def initialize_template(plugin_name)
+        guardfile = Pathname.new("Guardfile")
+
+        plugin_util = PluginUtil.new(plugin_name)
+        # TODO: change to "valid?" method
+        plugin_class = plugin_util.plugin_class(fail_gracefully: true)
+        if plugin_class
+          begin
+            plugin_util.add_to_guardfile
+          rescue Errno::ENOENT => error
+            # TODO: refactor
+            template = plugin_class.template(plugin_util.plugin_location)
+            _ui(:error, "Found class #{plugin_class} but loading it's template"\
+              "failed: '#{template}'")
+            _ui(:error, "Error is: #{error}")
+            return
+          end
+          return
+        end
+
+        template_code = (HOME_TEMPLATES + plugin_name).read
+        guardfile.binwrite(format("\n%s\n", template_code), open_args: ["a"])
+
+        _ui(:info, format(INFO_TEMPLATE_ADDED, plugin_name))
+
+      rescue Errno::ENOENT
+        fail NoSuchPlugin, plugin_name.downcase
+      end
+
+      # Adds the templates of all installed Guard implementations to an
+      # existing Guardfile.
+      #
+      # @see Guard::CLI#init
+      #
+      def initialize_all_templates
+        PluginUtil.plugin_names.each { |g| initialize_template(g) }
+      end
+
+      private
+
+      def _ui(*args)
+        UI.send(*args)
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/guard-2.16.2/lib/guard/interactor.rb

@@ -0,0 +1,53 @@
+require "forwardable"
+
+module Guard
+  class Interactor
+    # Initializes the interactor. This configures
+    # Pry and creates some custom commands and aliases
+    # for Guard.
+    #
+    def initialize(no_interaction = false)
+      @interactive = !no_interaction && self.class.enabled?
+
+      # TODO: only require the one used
+      require "guard/jobs/sleep"
+      require "guard/jobs/pry_wrapper"
+
+      job_klass = interactive? ? Jobs::PryWrapper : Jobs::Sleep
+      @idle_job = job_klass.new(self.class.options)
+    end
+
+    def interactive?
+      @interactive
+    end
+
+    extend Forwardable
+    delegate [:foreground, :background, :handle_interrupt] => :idle_job
+
+    # TODO: everything below is just so the DSL can set options
+    # before setup() is called, which makes it useless for when
+    # Guardfile is reevaluated
+    class << self
+      def options
+        @options ||= {}
+      end
+
+      # Pass options to interactor's job when it's created
+      attr_writer :options
+
+      # TODO: allow custom user idle jobs, e.g. [:pry, :sleep, :exit, ...]
+      def enabled?
+        @enabled || @enabled.nil?
+      end
+
+      alias_method :enabled, :enabled?
+
+      # TODO: handle switching interactors during runtime?
+      attr_writer :enabled
+    end
+
+    private
+
+    attr_reader :idle_job
+  end
+end

data/gems/ruby/2.7.0/gems/guard-2.16.2/lib/guard/internals/debugging.rb

@@ -0,0 +1,68 @@
+# Because it's used by Sheller
+require "open3"
+require "logger"
+
+require "guard/ui"
+
+require "guard/internals/tracing"
+
+module Guard
+  # @private api
+  module Internals
+    class Debugging
+      class << self
+        TRACES = [
+          [Kernel, :system],
+          [Kernel, :spawn],
+          [Kernel, :`],
+          [Open3, :popen3]
+        ]
+
+        # Sets up debugging:
+        #
+        # * aborts on thread exceptions
+        # * Set the logging level to `:debug`
+        # * traces execution of Kernel.system and backtick calls
+        def start
+          return if @started ||= false
+          @started = true
+
+          Thread.abort_on_exception = true
+
+          UI.level = Logger::DEBUG
+
+          TRACES.each { |mod, meth| _trace(mod, meth, &method(:_notify)) }
+          @traced = true
+        end
+
+        def stop
+          return unless @started ||= false
+          UI.level = Logger::INFO
+          _reset
+        end
+
+        private
+
+        def _notify(*args)
+          UI.debug "Command execution: #{args.join(' ')}"
+        end
+
+        # reset singleton - called by tests
+        def _reset
+          @started = false
+          return unless @traced
+          TRACES.each { |mod, meth| _untrace(mod, meth) }
+          @traced = false
+        end
+
+        def _trace(mod, meth, &block)
+          Tracing.trace(mod, meth, &block)
+        end
+
+        def _untrace(mod, meth)
+          Tracing.untrace(mod, meth)
+        end
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/guard-2.16.2/lib/guard/internals/groups.rb

@@ -0,0 +1,40 @@
+require "guard/group"
+
+module Guard
+  # @private api
+  module Internals
+    class Groups
+      DEFAULT_GROUPS = [:common, :default]
+
+      def initialize
+        @groups = DEFAULT_GROUPS.map { |name| Group.new(name) }
+      end
+
+      def all(filter = nil)
+        return @groups if filter.nil?
+        matcher = matcher_for(filter)
+        @groups.select { |group| matcher.call(group) }
+      end
+
+      def add(name, options = {})
+        all(name).first || Group.new(name, options).tap do |group|
+          fail if name == :specs && options.empty?
+          @groups << group
+        end
+      end
+
+      private
+
+      def matcher_for(filter)
+        case filter
+        when String, Symbol
+          ->(group) { group.name == filter.to_sym }
+        when Regexp
+          ->(group) { group.name.to_s =~ filter }
+        else
+          fail "Invalid filter: #{filter.inspect}"
+        end
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/guard-2.16.2/lib/guard/internals/helpers.rb

@@ -0,0 +1,13 @@
+module Guard
+  # @private api
+  module Internals
+    module Helpers
+      def _relative_pathname(path)
+        full_path = Pathname(path)
+        full_path.relative_path_from(Pathname.pwd)
+      rescue ArgumentError
+        full_path
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/guard-2.16.2/lib/guard/internals/plugins.rb

@@ -0,0 +1,53 @@
+require "guard/plugin_util"
+require "guard/group"
+require "guard/plugin"
+
+module Guard
+  # @private api
+  module Internals
+    class Plugins
+      def initialize
+        @plugins = []
+      end
+
+      def all(filter = nil)
+        return @plugins if filter.nil?
+        matcher = matcher_for(filter)
+        @plugins.select { |plugin| matcher.call(plugin) }
+      end
+
+      def remove(plugin)
+        @plugins.delete(plugin)
+      end
+
+      # TODO: should it allow duplicates? (probably yes because of different
+      # configs or groups)
+      def add(name, options)
+        @plugins << PluginUtil.new(name).initialize_plugin(options)
+      end
+
+      private
+
+      def matcher_for(filter)
+        case filter
+        when String, Symbol
+          shortname = filter.to_s.downcase.delete("-")
+          ->(plugin) { plugin.name == shortname }
+        when Regexp
+          ->(plugin) { plugin.name =~ filter }
+        when Hash
+          lambda do |plugin|
+            filter.all? do |k, v|
+              case k
+              when :name
+                plugin.name == v.to_s.downcase.delete("-")
+              when :group
+                plugin.group.name == v.to_sym
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/guard-2.16.2/lib/guard/internals/queue.rb

@@ -0,0 +1,51 @@
+module Guard
+  module Internals
+    class Queue
+      def initialize(commander)
+        @commander = commander
+        @queue = ::Queue.new
+      end
+
+      # Process the change queue, running tasks within the main Guard thread
+      def process
+        actions = []
+        changes = { modified: [], added: [], removed: [] }
+
+        while pending?
+          if (item = @queue.pop).first.is_a?(Symbol)
+            actions << item
+          else
+            item.each { |key, value| changes[key] += value }
+          end
+        end
+
+        _run_actions(actions)
+        return if changes.values.all?(&:empty?)
+        Runner.new.run_on_changes(*changes.values)
+      end
+
+      def pending?
+        !@queue.empty?
+      end
+
+      def <<(changes)
+        @queue << changes
+      end
+
+      private
+
+      def _run_actions(actions)
+        actions.each do |action_args|
+          args = action_args.dup
+          namespaced_action = args.shift
+          action = namespaced_action.to_s.sub(/^guard_/, "")
+          if @commander.respond_to?(action)
+            @commander.send(action, *args)
+          else
+            fail "Unknown action: #{action.inspect}"
+          end
+        end
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/guard-2.16.2/lib/guard/internals/scope.rb

@@ -0,0 +1,121 @@
+require "guard"
+
+module Guard
+  # @private api
+  module Internals
+    class Scope
+      def initialize
+        @interactor_plugin_scope = []
+        @interactor_group_scope = []
+      end
+
+      def to_hash
+        {
+          plugins: _hashify_scope(:plugin),
+          groups: _hashify_scope(:group)
+        }.dup.freeze
+      end
+
+      # TODO: refactor
+      def grouped_plugins(scope = { plugins: [], groups: [] })
+        items = nil
+        plugins = _find_non_empty_scope(:plugins, scope)
+        if plugins
+          items = Array(plugins).map { |plugin| _instantiate(:plugin, plugin) }
+        end
+
+        unless items
+          # TODO: no coverage here!!
+          found = _find_non_empty_scope(:groups, scope)
+          found ||= Guard.state.session.groups.all
+          groups = Array(found).map { |group| _instantiate(:group, group) }
+          if groups.any? { |g| g.name == :common }
+            items = groups
+          else
+            items = ([_instantiate(:group, :common)] + Array(found)).compact
+          end
+        end
+
+        items.map do |plugin_or_group|
+          group = nil
+          plugins = [plugin_or_group]
+          if plugin_or_group.is_a?(Group)
+            # TODO: no coverage here!
+            group = plugin_or_group
+            plugins = Guard.state.session.plugins.all(group: group.name)
+          end
+          [group, plugins]
+        end
+      end
+
+      def from_interactor(scope)
+        @interactor_plugin_scope = Array(scope[:plugins])
+        @interactor_group_scope = Array(scope[:groups])
+      end
+
+      def titles(scope = nil)
+        hash = scope || to_hash
+        plugins = hash[:plugins]
+        groups = hash[:groups]
+        return plugins.map(&:title) unless plugins.nil? || plugins.empty?
+        return hash[:groups].map(&:title) unless groups.nil? || groups.empty?
+        ["all"]
+      end
+
+      private
+
+      # TODO: move to session
+      def _scope_names(new_scope, name)
+        items = Array(new_scope[:"#{name}s"] || new_scope[name]) if items.empty?
+
+        # Convert objects to names
+        items.map { |p| p.respond_to?(:name) ? p.name : p }
+      end
+
+      # TODO: let the Plugins and Groups classes handle this?
+      # TODO: why even instantiate?? just to check if it exists?
+      def _hashify_scope(type)
+        # TODO: get cmdline passed to initialize above?
+        cmdline = Array(Guard.state.session.send("cmdline_#{type}s"))
+        guardfile = Guard.state.session.send(:"guardfile_#{type}_scope")
+        interactor = instance_variable_get(:"@interactor_#{type}_scope")
+
+        # TODO: session should decide whether to use cmdline or guardfile -
+        # since it has access to both variables
+        items = [interactor, cmdline, guardfile].detect do |source|
+          !source.empty?
+        end
+
+        # TODO: not tested when groups/plugins given don't exist
+
+        # TODO: should already be instantiated
+        Array(items).map do |obj|
+          if obj.respond_to?(:name)
+            obj
+          else
+            name = obj
+            (type == :group ? _groups : _plugins).all(name).first
+          end
+        end.compact
+      end
+
+      def _instantiate(meth, obj)
+        # TODO: no coverage
+        return obj unless obj.is_a?(Symbol) || obj.is_a?(String)
+        Guard.state.session.send("#{meth}s".to_sym).all(obj).first
+      end
+
+      def _find_non_empty_scope(type, local_scope)
+        [Array(local_scope[type]), to_hash[type]].map(&:compact).detect(&:any?)
+      end
+
+      def _groups
+        Guard.state.session.groups
+      end
+
+      def _plugins
+        Guard.state.session.plugins
+      end
+    end
+  end
+end