qiita_org 0.1.24 → 0.1.25

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

@@ -0,0 +1,180 @@
+require "guard/internals/plugins"
+require "guard/internals/groups"
+
+require "guard/options"
+
+module Guard
+  # @private api
+  module Internals
+    # TODO: split into a commandline class and session (plugins, groups)
+    # TODO: swap session and metadata
+    class Session
+      attr_reader :plugins
+      attr_reader :groups
+
+      DEFAULT_OPTIONS = {
+        clear: false,
+        debug: false,
+        no_bundler_warning: false,
+
+        # User defined scopes
+        group: [],
+        plugin: [],
+
+        # Notifier
+        notify: true,
+
+        # Interactor
+        no_interactions: false,
+
+        # Guardfile options:
+        # guardfile_contents
+        guardfile: nil,
+
+        # Listener options
+        # TODO: rename to watchdirs?
+        watchdir: Dir.pwd,
+        latency: nil,
+        force_polling: false,
+        wait_for_delay: nil,
+        listen_on: nil
+      }
+
+      def cmdline_groups
+        @cmdline_groups.dup.freeze
+      end
+
+      def cmdline_plugins
+        @cmdline_plugins.dup.freeze
+      end
+
+      def initialize(new_options)
+        @options = Options.new(new_options, DEFAULT_OPTIONS)
+
+        @plugins = Plugins.new
+        @groups = Groups.new
+
+        @cmdline_groups = @options[:group]
+        @cmdline_plugins = @options[:plugin]
+
+        @clear = @options[:clear]
+        @debug = @options[:debug]
+        @watchdirs = Array(@options[:watchdir])
+        @notify = @options[:notify]
+        @interactor_name = @options[:no_interactions] ? :sleep : :pry_wrapper
+
+        @guardfile_plugin_scope = []
+        @guardfile_group_scope = []
+        @guardfile_ignore = []
+        @guardfile_ignore_bang = []
+
+        @guardfile_notifier_options = {}
+      end
+
+      def guardfile_scope(scope)
+        opts = scope.dup
+
+        groups = Array(opts.delete(:groups))
+        group = Array(opts.delete(:group))
+        @guardfile_group_scope = Array(groups) + Array(group)
+
+        plugins = Array(opts.delete(:plugins))
+        plugin = Array(opts.delete(:plugin))
+        @guardfile_plugin_scope = Array(plugins) + Array(plugin)
+
+        fail "Unknown options: #{opts.inspect}" unless opts.empty?
+      end
+
+      # TODO: create a EvaluatorResult class?
+      attr_reader :guardfile_group_scope
+      attr_reader :guardfile_plugin_scope
+      attr_accessor :guardfile_ignore_bang
+
+      attr_reader :guardfile_ignore
+      def guardfile_ignore=(ignores)
+        @guardfile_ignore += Array(ignores).flatten
+      end
+
+      def clearing(on)
+        @clear = on
+      end
+
+      def clearing?
+        @clear
+      end
+
+      alias :clear? :clearing?
+
+      def debug?
+        @debug
+      end
+
+      def watchdirs
+        @watchdirs_from_guardfile ||= nil
+        @watchdirs_from_guardfile || @watchdirs
+      end
+
+      # set by Dsl with :directories() command
+      def watchdirs=(dirs)
+        dirs = [Dir.pwd] if dirs.empty?
+        @watchdirs_from_guardfile = dirs.map { |dir| File.expand_path dir }
+      end
+
+      def listener_args
+        if @options[:listen_on]
+          [:on, @options[:listen_on]]
+        else
+          listener_options = {}
+          [:latency, :force_polling, :wait_for_delay].each do |option|
+            listener_options[option] = @options[option] if @options[option]
+          end
+          expanded_watchdirs = watchdirs.map { |dir| File.expand_path dir }
+          [:to, *expanded_watchdirs, listener_options]
+        end
+      end
+
+      def evaluator_options
+        opts = { guardfile: @options[:guardfile] }
+        # TODO: deprecate :guardfile_contents
+        if @options[:guardfile_contents]
+          opts[:contents] = @options[:guardfile_contents]
+        end
+        opts
+      end
+
+      def notify_options
+        names = @guardfile_notifier_options.keys
+        return { notify: false } if names.include?(:off)
+
+        {
+          notify: @options[:notify],
+          notifiers: @guardfile_notifier_options
+        }
+      end
+
+      def guardfile_notification=(config)
+        @guardfile_notifier_options.merge!(config)
+      end
+
+      attr_reader :interactor_name
+
+      # TODO: call this from within action, not within interactor command
+      def convert_scope(entries)
+        scopes = { plugins: [], groups: [] }
+        unknown = []
+
+        entries.each do |entry|
+          if plugin = plugins.all(entry).first
+            scopes[:plugins] << plugin
+          elsif group = groups.all(entry).first
+            scopes[:groups] << group
+          else
+            unknown << entry
+          end
+        end
+
+        [scopes, unknown]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require "guard/group"
+
+require "guard/plugin_util"
+require "guard/internals/session"
+require "guard/internals/scope"
+require "guard/runner"
+
+module Guard
+  module Internals
+    class State
+      # Minimal setup for non-interactive commands (list, init, show, etc.)
+      def initialize(cmdline_opts)
+        @session = Session.new(cmdline_opts)
+
+        @scope = Scope.new
+
+        # NOTE: must be set before anything calls Guard::UI.debug
+        Debugging.start if session.debug?
+      end
+
+      attr_reader :scope
+      attr_reader :session
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Guard
+  module Internals
+    module Tracing
+      def self.trace(mod, meth)
+        meta = (class << mod; self; end)
+        original_meth = "original_#{meth}".to_sym
+
+        if mod.respond_to?(original_meth)
+          fail "ALREADY TRACED: #{mod}.#{meth}"
+        end
+
+        meta.send(:alias_method, original_meth, meth)
+        meta.send(:define_method, meth) do |*args, &block|
+          yield(*args) if block_given?
+          mod.send original_meth, *args, &block
+        end
+      end
+
+      def self.untrace(mod, meth)
+        meta = (class << mod; self; end)
+        original_meth = "original_#{meth}".to_sym
+
+        unless mod.respond_to?(original_meth)
+          fail "NOT TRACED: #{mod}.#{meth} (no method: #{original_meth})"
+        end
+
+        meta.send(:remove_method, meth)
+        meta.send(:alias_method, meth, original_meth)
+        meta.send(:undef_method, original_meth)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Guard
+  module Internals
+    module Traps
+      def self.handle(signal, &block)
+        return unless Signal.list.key?(signal)
+        Signal.trap(signal, &block)
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/guard-2.16.2/lib/guard/jobs/base.rb

@@ -0,0 +1,21 @@
+module Guard
+  module Jobs
+    class Base
+      def initialize(_options)
+      end
+
+      # @return [Symbol] :stopped once job is finished
+      # @return [Symbol] :exit to tell Guard to terminate
+      def foreground
+      end
+
+      def background
+      end
+
+      # Signal handler calls this, so avoid actually doing
+      # anything other than signaling threads
+      def handle_interrupt
+      end
+    end
+  end
+end

data/gems/ruby/2.7.0/gems/guard-2.16.2/lib/guard/jobs/pry_wrapper.rb

@@ -0,0 +1,326 @@
+require "guard/commands/all"
+require "guard/commands/change"
+require "guard/commands/notification"
+require "guard/commands/pause"
+require "guard/commands/reload"
+require "guard/commands/scope"
+require "guard/commands/show"
+require "shellany/sheller"
+
+require "guard/jobs/base"
+
+module Guard
+  module Jobs
+    class TerminalSettings
+      def initialize
+        @settings = nil
+        @works = Shellany::Sheller.run("hash", "stty") || false
+      end
+
+      def restore
+        return unless configurable? && @settings
+        Shellany::Sheller.run("stty #{ @setting } 2>#{IO::NULL}")
+      end
+
+      def save
+        return unless configurable?
+        @settings = Shellany::Sheller.stdout("stty -g 2>#{IO::NULL}").chomp
+      end
+
+      def echo
+        return unless configurable?
+        Shellany::Sheller.run("stty echo 2>#{IO::NULL}")
+      end
+
+      def configurable?
+        @works
+      end
+    end
+
+    class PryWrapper < Base
+      # The default Ruby script to configure Guard Pry if the option `:guard_rc`
+      # is not defined.
+      GUARD_RC = "~/.guardrc"
+
+      # The default Guard Pry history file if the option `:history_file` is not
+      # defined.
+      HISTORY_FILE = "~/.guard_history"
+
+      # List of shortcuts for each interactor command
+      SHORTCUTS = {
+        help: "h",
+        all: "a",
+        reload: "r",
+        change: "c",
+        show: "s",
+        scope: "o",
+        notification: "n",
+        pause: "p",
+        exit: "e",
+        quit: "q"
+      }
+
+      def initialize(options)
+        @mutex = Mutex.new
+        @thread = nil
+        @terminal_settings = TerminalSettings.new
+
+        _setup(options)
+      end
+
+      def foreground
+        UI.debug "Start interactor"
+        @terminal_settings.save
+
+        _switch_to_pry
+        # TODO: rename :stopped to continue
+        _killed? ? :stopped : :exit
+      ensure
+        UI.reset_line
+        UI.debug "Interactor was stopped or killed"
+        @terminal_settings.restore
+      end
+
+      def background
+        _kill_pry
+      end
+
+      def handle_interrupt
+        thread = @thread
+        fail Interrupt unless thread
+        thread.raise Interrupt
+      end
+
+      private
+
+      attr_reader :thread
+
+      def _pry_config
+        Pry.config
+      end
+
+      def _pry_commands
+        Pry.commands
+      end
+
+      def _switch_to_pry
+        th = nil
+        @mutex.synchronize do
+          unless @thread
+            @thread = Thread.new { Pry.start }
+            @thread.join(0.5) # give pry a chance to start
+            th = @thread
+          end
+        end
+        # check for nill, because it might've been killed between the mutex and
+        # now
+        th.join unless th.nil?
+      end
+
+      def _killed?
+        th = nil
+        @mutex.synchronize { th = @thread }
+        th.nil?
+      end
+
+      def _kill_pry
+        @mutex.synchronize do
+          unless @thread.nil?
+            @thread.kill
+            @thread = nil # set to nil so we know we were killed
+          end
+        end
+      end
+
+      def _setup(options)
+        _pry_config.should_load_rc = false
+        _pry_config.should_load_local_rc = false
+
+        _configure_history_file(options[:history_file] || HISTORY_FILE)
+        _add_hooks(options)
+
+        Commands::All.import
+        Commands::Change.import
+        Commands::Notification.import
+        Commands::Pause.import
+        Commands::Reload.import
+        Commands::Show.import
+        Commands::Scope.import
+
+        _setup_commands
+        _configure_prompt
+      end
+
+      def _configure_history_file(history_file)
+        history_file_path = File.expand_path(history_file)
+
+        # Pry >= 0.13
+        if _pry_config.respond_to?(:history_file=)
+          _pry_config.history_file = history_file_path
+        else
+          _pry_config.history.file = history_file_path
+        end
+      end
+
+      # Add Pry hooks:
+      #
+      # * Load `~/.guardrc` within each new Pry session.
+      # * Load project's `.guardrc` within each new Pry session.
+      # * Restore prompt after each evaluation.
+      #
+      def _add_hooks(options)
+        _add_load_guard_rc_hook(Pathname(options[:guard_rc] || GUARD_RC))
+        _add_load_project_guard_rc_hook(Pathname.pwd + ".guardrc")
+        _add_restore_visibility_hook if @terminal_settings.configurable?
+      end
+
+      # Add a `when_started` hook that loads a global .guardrc if it exists.
+      #
+      def _add_load_guard_rc_hook(guard_rc)
+        _pry_config.hooks.add_hook :when_started, :load_guard_rc do
+          guard_rc.expand_path.tap { |p| load p if p.exist? }
+        end
+      end
+
+      # Add a `when_started` hook that loads a project .guardrc if it exists.
+      #
+      def _add_load_project_guard_rc_hook(guard_rc)
+        _pry_config.hooks.add_hook :when_started, :load_project_guard_rc do
+          load guard_rc if guard_rc.exist?
+        end
+      end
+
+      # Add a `after_eval` hook that restores visibility after a command is
+      # eval.
+      def _add_restore_visibility_hook
+        _pry_config.hooks.add_hook :after_eval, :restore_visibility do
+          @terminal_settings.echo
+        end
+      end
+
+      def _setup_commands
+        _replace_reset_command
+        _create_run_all_command
+        _create_command_aliases
+        _create_guard_commands
+        _create_group_commands
+      end
+
+      # Replaces reset defined inside of Pry with a reset that
+      # instead restarts guard.
+      #
+      def _replace_reset_command
+        _pry_commands.command "reset", "Reset the Guard to a clean state." do
+          output.puts "Guard reset."
+          exec "guard"
+        end
+      end
+
+      # Creates a command that triggers the `:run_all` action
+      # when the command is empty (just pressing enter on the
+      # beginning of a line).
+      #
+      def _create_run_all_command
+        _pry_commands.block_command(/^$/, "Hit enter to run all") do
+          Pry.run_command "all"
+        end
+      end
+
+      # Creates command aliases for the commands: `help`, `reload`, `change`,
+      # `scope`, `notification`, `pause`, `exit` and `quit`, which will be the
+      # first letter of the command.
+      #
+      def _create_command_aliases
+        SHORTCUTS.each do |command, shortcut|
+          _pry_commands.alias_command shortcut, command.to_s
+        end
+      end
+
+      # Create a shorthand command to run the `:run_all`
+      # action on a specific Guard plugin. For example,
+      # when guard-rspec is available, then a command
+      # `rspec` is created that runs `all rspec`.
+      #
+      def _create_guard_commands
+        Guard.state.session.plugins.all.each do |guard_plugin|
+          cmd = "Run all #{guard_plugin.title}"
+          _pry_commands.create_command guard_plugin.name, cmd do
+            group "Guard"
+
+            def process
+              Pry.run_command "all #{ match }"
+            end
+          end
+        end
+      end
+
+      # Create a shorthand command to run the `:run_all`
+      # action on a specific Guard group. For example,
+      # when you have a group `frontend`, then a command
+      # `frontend` is created that runs `all frontend`.
+      #
+      def _create_group_commands
+        Guard.state.session.groups.all.each do |group|
+          next if group.name == :default
+
+          cmd = "Run all #{group.title}"
+          _pry_commands.create_command group.name.to_s, cmd do
+            group "Guard"
+
+            def process
+              Pry.run_command "all #{ match }"
+            end
+          end
+        end
+      end
+
+      # Configures the pry prompt to see `guard` instead of
+      # `pry`.
+      #
+      def _configure_prompt
+        prompt_procs = [_prompt(">"), _prompt("*")]
+        prompt =
+          if Pry::Prompt.is_a?(Class)
+            Pry::Prompt.new("Guard", "Guard Pry prompt", prompt_procs)
+          else
+            prompt_procs
+          end
+
+        _pry_config.prompt = prompt
+      end
+
+      # Returns the plugins scope, or the groups scope ready for display in the
+      # prompt.
+      #
+      def _scope_for_prompt
+        titles = Guard.state.scope.titles.join(",")
+        titles == "all" ? "" : titles + " "
+      end
+
+      # Returns a proc that will return itself a string ending with the given
+      # `ending_char` when called.
+      #
+      def _prompt(ending_char)
+        proc do |target_self, nest_level, pry|
+          process = Guard.listener.paused? ? "pause" : "guard"
+          level = ":#{ nest_level }" unless nest_level.zero?
+
+          "[#{ _history(pry) }] #{ _scope_for_prompt }#{ process }"\
+            "(#{ _clip_name(target_self) })#{ level }#{ ending_char } "
+        end
+      end
+
+      def _clip_name(target)
+        Pry.view_clip(target)
+      end
+
+      def _history(pry)
+        if pry.respond_to?(:input_ring)
+          pry.input_ring.size
+        else
+          pry.input_array.size
+        end
+      end
+    end
+  end
+end