talon_one 2.0.0 → 2.4.0

data/vendor/bundle/ruby/2.7.0/gems/pry-0.13.1/lib/pry/code/code_range.rb

@@ -1,73 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Code
-    # Represents a range of lines in a code listing.
-    #
-    # @api private
-    class CodeRange
-      # @param [Integer] start_line
-      # @param [Integer?] end_line
-      def initialize(start_line, end_line = nil)
-        @start_line = start_line
-        @end_line   = end_line
-        force_set_end_line
-      end
-
-      # @param [Array<LOC>] lines
-      # @return [Range]
-      def indices_range(lines)
-        Range.new(*indices(lines))
-      end
-
-      private
-
-      attr_reader :start_line
-
-      attr_reader :end_line
-
-      # If `end_line` is equal to `nil`, then calculate it from the first
-      # parameter, `start_line`. Otherwise, leave it as it is.
-      # @return [void]
-      def force_set_end_line
-        if start_line.is_a?(Range)
-          set_end_line_from_range
-        else
-          @end_line ||= start_line
-        end
-      end
-
-      # Finds indices of `start_line` and `end_line` in the given Array of
-      # +lines+.
-      #
-      # @param [Array<LOC>] lines
-      # @return [Array<Integer>]
-      def indices(lines)
-        [find_start_index(lines), find_end_index(lines)]
-      end
-
-      # @return [Integer]
-      def find_start_index(lines)
-        return start_line if start_line < 0
-
-        lines.index { |loc| loc.lineno >= start_line } || lines.length
-      end
-
-      # @return [Integer]
-      def find_end_index(lines)
-        return end_line if end_line < 0
-
-        (lines.index { |loc| loc.lineno > end_line } || 0) - 1
-      end
-
-      # For example, if the range is 4..10, then `start_line` would be equal to
-      # 4 and `end_line` to 10.
-      # @return [void]
-      def set_end_line_from_range
-        @end_line = start_line.last
-        @end_line -= 1 if start_line.exclude_end?
-        @start_line = start_line.first
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/pry-0.13.1/lib/pry/code/loc.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  class Code
-    # Represents a line of code (which may, in fact, contain multiple lines if
-    # the entirety was eval'd as a single unit following the `edit` command).
-    #
-    # A line of code is a tuple, which consists of a line and a line number. A
-    # `LOC` object's state (namely, the line parameter) can be changed via
-    # instance methods.  `Pry::Code` heavily uses this class.
-    #
-    # @api private
-    # @example
-    #   loc = LOC.new("def example\n  :example\nend", 1)
-    #   puts loc.line
-    #   def example
-    #     :example
-    #   end
-    #   #=> nil
-    #
-    #   loc.indent(3)
-    #   loc.line #=> "   def example\n  :example\nend"
-    class LOC
-      # @return [Array<String, Integer>]
-      attr_reader :tuple
-
-      # @param [String] line The line of code.
-      # @param [Integer] lineno The position of the +line+.
-      def initialize(line, lineno)
-        @tuple = [line.chomp, lineno.to_i]
-      end
-
-      # @return [Boolean]
-      def ==(other)
-        other.tuple == tuple
-      end
-
-      def dup
-        self.class.new(line, lineno)
-      end
-
-      # @return [String]
-      def line
-        tuple.first
-      end
-
-      # @return [Integer]
-      def lineno
-        tuple.last
-      end
-
-      # Paints the `line` of code.
-      #
-      # @param [Symbol] code_type
-      # @return [void]
-      def colorize(code_type)
-        tuple[0] = SyntaxHighlighter.highlight(line, code_type)
-      end
-
-      # Prepends the line number `lineno` to the `line`.
-      #
-      # @param [Integer] max_width
-      # @return [void]
-      def add_line_number(max_width = 0, color = false)
-        padded = lineno.to_s.rjust(max_width)
-        colorized_lineno =
-          if color
-            Pry::Helpers::BaseHelpers.colorize_code(padded)
-          else
-            padded
-          end
-        properly_padded_line = handle_multiline_entries_from_edit_command(line, max_width)
-        tuple[0] = "#{colorized_lineno}: #{properly_padded_line}"
-      end
-
-      # Prepends a marker "=>" or an empty marker to the +line+.
-      #
-      # @param [Integer] marker_lineno If it is equal to the `lineno`, then
-      #   prepend a hashrocket. Otherwise, an empty marker.
-      # @return [void]
-      def add_marker(marker_lineno)
-        tuple[0] =
-          if lineno == marker_lineno
-            " => #{line}"
-          else
-            "    #{line}"
-          end
-      end
-
-      # Indents the `line` with +distance+ spaces.
-      #
-      # @param [Integer] distance
-      # @return [void]
-      def indent(distance)
-        tuple[0] = "#{' ' * distance}#{line}"
-      end
-
-      def handle_multiline_entries_from_edit_command(line, max_width)
-        line.split("\n").map.with_index do |inner_line, i|
-          i.zero? ? inner_line : "#{' ' * (max_width + 2)}#{inner_line}"
-        end.join("\n")
-      end
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/pry-0.13.1/lib/pry/code_object.rb

@@ -1,197 +0,0 @@
-# frozen_string_literal: true
-
-class Pry
-  # This class is responsible for taking a string (identifying a
-  # command/class/method/etc) and returning the relevant type of object.
-  # For example, if the user looks up "show-source" then  a
-  # `Pry::Command` will be returned. Alternatively, if the user passes in "Pry#repl" then
-  # a `Pry::Method` object will be returned.
-  #
-  # The `CodeObject.lookup` method is responsible for 1. figuring out what kind of
-  # object the user wants (applying precedence rules in doing so -- i.e methods
-  # get precedence over commands with the same name) and 2. Returning
-  # the appropriate object. If the user fails to provide a string
-  # identifer for the object (i.e they pass in `nil` or "") then the
-  # object looked up will be the 'current method' or 'current class'
-  # associated with the Binding.
-  #
-  # TODO: This class is a clusterfuck. We need a much more robust
-  # concept of what a "Code Object" really is. Currently
-  # commands/classes/candidates/methods and so on just share a very
-  # ill-defined interface.
-  class CodeObject
-    module Helpers
-      # we need this helper as some Pry::Method objects can wrap Procs
-      # @return [Boolean]
-      def real_method_object?
-        is_a?(::Method) || is_a?(::UnboundMethod)
-      end
-
-      def c_method?
-        real_method_object? && source_type == :c
-      end
-
-      def module_with_yard_docs?
-        is_a?(WrappedModule) && yard_docs?
-      end
-
-      def command?
-        is_a?(Module) && self <= Pry::Command
-      end
-
-      # @return [Boolean] `true` if this module was defined by means of the C API,
-      #   `false` if it's a Ruby module.
-      # @note If a module defined by C was extended with a lot of methods written
-      #   in Ruby, this method would fail.
-      def c_module?
-        return unless is_a?(WrappedModule)
-
-        method_locations = wrapped.methods(false).map do |m|
-          wrapped.method(m).source_location
-        end
-
-        method_locations.concat(
-          wrapped.instance_methods(false).map do |m|
-            wrapped.instance_method(m).source_location
-          end
-        )
-
-        c_methods = method_locations.grep(nil).count
-        ruby_methods = method_locations.count - c_methods
-
-        c_methods > ruby_methods
-      end
-    end
-
-    include Pry::Helpers::CommandHelpers
-
-    class << self
-      def lookup(str, pry_instance, options = {})
-        co = new(str, pry_instance, options)
-
-        co.default_lookup || co.method_or_class_lookup ||
-          co.command_lookup || co.empty_lookup
-      end
-    end
-
-    attr_accessor :str
-    attr_accessor :target
-    attr_accessor :pry_instance
-    attr_accessor :super_level
-
-    def initialize(str, pry_instance, options = {})
-      options = {
-        super: 0
-      }.merge!(options)
-
-      @str = str
-      @pry_instance = pry_instance
-      @target = pry_instance.current_context
-      @super_level = options[:super]
-    end
-
-    # TODO: just make it so find_command_by_match_or_listing doesn't raise?
-    def command_lookup
-      pry_instance.commands.find_command_by_match_or_listing(str)
-    rescue StandardError
-      nil
-    end
-
-    # when no paramter is given (i.e CodeObject.lookup(nil)), then we
-    # lookup the 'current object' from the binding.
-    def empty_lookup
-      return nil if str && !str.empty?
-
-      obj = if internal_binding?(target)
-              mod = target_self.is_a?(Module) ? target_self : target_self.class
-              Pry::WrappedModule(mod)
-            else
-              Pry::Method.from_binding(target)
-            end
-
-      # respect the super level (i.e user might have specified a
-      # --super flag to show-source)
-      lookup_super(obj, super_level)
-    end
-
-    # lookup variables and constants and `self` that are not modules
-    def default_lookup
-      # we skip instance methods as we want those to fall through to
-      # method_or_class_lookup()
-      if safe_to_evaluate?(str) && !looks_like_an_instance_method?(str)
-        obj = target.eval(str)
-
-        # restrict to only objects we KNOW for sure support the full API
-        # Do NOT support just any object that responds to source_location
-        if sourcable_object?(obj)
-          Pry::Method(obj)
-        elsif !obj.is_a?(Module)
-          Pry::WrappedModule(obj.class)
-        end
-      end
-    rescue Pry::RescuableException
-      nil
-    end
-
-    def method_or_class_lookup
-      obj =
-        case str
-        when /\S+\(\)\z/
-          Pry::Method.from_str(str.sub(/\(\)\z/, ''), target) ||
-          Pry::WrappedModule.from_str(str, target)
-        else
-          Pry::WrappedModule.from_str(str, target) ||
-          Pry::Method.from_str(str, target)
-        end
-
-      lookup_super(obj, super_level)
-    end
-
-    private
-
-    def sourcable_object?(obj)
-      [::Proc, ::Method, ::UnboundMethod].any? { |o| obj.is_a?(o) }
-    end
-
-    # Returns true if `str` looks like a method, i.e Klass#method
-    # We need to consider this case because method lookups should fall
-    # through to the `method_or_class_lookup()` method but a
-    # defined?() on a "Klass#method` string will see the `#` as a
-    # comment and only evaluate the `Klass` part.
-    # @param [String] str
-    # @return [Boolean] Whether the string looks like an instance method.
-    def looks_like_an_instance_method?(str)
-      str =~ /\S#\S/
-    end
-
-    # We use this method to decide whether code is safe to eval. Method's are
-    # generally not, but everything else is.
-    # TODO: is just checking != "method" enough??
-    # TODO: see duplication of this method in Pry::WrappedModule
-    # @param [String] str The string to lookup
-    # @return [Boolean]
-    def safe_to_evaluate?(str)
-      return true if str.strip == "self"
-      return false if str =~ /%/
-
-      kind = target.eval("defined?(#{str})")
-      kind =~ /variable|constant/
-    end
-
-    def target_self
-      target.eval('self')
-    end
-
-    # grab the nth (`super_level`) super of `obj
-    # @param [Object] obj
-    # @param [Fixnum] super_level How far up the super chain to ascend.
-    def lookup_super(obj, super_level)
-      return unless obj
-
-      sup = obj.super(super_level)
-      raise Pry::CommandError, "No superclass found for #{obj.wrapped}" unless sup
-
-      sup
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/pry-0.13.1/lib/pry/color_printer.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'pp'
-require 'English'
-
-class Pry
-  # PP subclass for streaming inspect output in color.
-  class ColorPrinter < ::PP
-    Pry::SyntaxHighlighter.overwrite_coderay_comment_token!
-
-    def self.default(_output, value, pry_instance)
-      pry_instance.pager.open do |pager|
-        pager.print pry_instance.config.output_prefix
-        pp(value, pager, pry_instance.output.width - 1)
-      end
-    end
-
-    def self.pp(obj, output = $DEFAULT_OUTPUT, max_width = 79)
-      queue = ColorPrinter.new(output, max_width, "\n")
-      queue.guard_inspect_key { queue.pp(obj) }
-      queue.flush
-      output << "\n"
-    end
-
-    def pp(object)
-      return super unless object.is_a?(String)
-
-      # Avoid calling Ruby 2.4+ String#pretty_print that prints multiline
-      # Strings prettier
-      text(object.inspect)
-    rescue StandardError => exception
-      raise if exception.is_a?(Pry::Pager::StopPaging)
-
-      text(highlight_object_literal(inspect_object(object)))
-    end
-
-    def text(str, max_width = str.length)
-      if str.include?("\e[")
-        super("#{str}\e[0m", max_width)
-      elsif str.start_with?('#<') || %w[= >].include?(str)
-        super(highlight_object_literal(str), max_width)
-      else
-        super(SyntaxHighlighter.highlight(str), max_width)
-      end
-    end
-
-    private
-
-    def highlight_object_literal(object_literal)
-      code = Pry::SyntaxHighlighter.keyword_token_color
-      obj_color = code.start_with?("\e") ? code : "\e[0m\e[0;#{code}m"
-      "#{obj_color}#{object_literal}\e[0m"
-    end
-
-    def inspect_object(object)
-      object.inspect
-    rescue StandardError
-      # Read the class name off of the singleton class to provide a default
-      # inspect.
-      singleton = class << object; self; end
-      ancestors = Pry::Method.safe_send(singleton, :ancestors)
-      klass = ancestors.find { |k| k != singleton }
-      "#<#{klass}:0x#{object.__id__.to_s(16)}>"
-    end
-  end
-end

data/vendor/bundle/ruby/2.7.0/gems/pry-0.13.1/lib/pry/command.rb

@@ -1,520 +0,0 @@
-# frozen_string_literal: true
-
-require 'delegate'
-require 'shellwords'
-
-class Pry
-  # The super-class of all commands, new commands should be created by calling
-  # {Pry::CommandSet#command} which creates a BlockCommand or
-  # {Pry::CommandSet#create_command} which creates a ClassCommand. Please don't
-  # use this class directly.
-  class Command
-    extend Helpers::DocumentationHelpers
-    extend CodeObject::Helpers
-
-    include Pry::Helpers::BaseHelpers
-    include Pry::Helpers::CommandHelpers
-    include Pry::Helpers::Text
-
-    # represents a void return value for a command
-    VOID_VALUE = Object.new
-
-    # give it a nice inspect
-    def VOID_VALUE.inspect
-      "void"
-    end
-
-    # Properties of the command itself (as passed as arguments to
-    # {CommandSet#command} or {CommandSet#create_command}).
-    class << self
-      attr_writer :block
-      attr_writer :description
-      attr_writer :command_options
-      attr_writer :match
-
-      def match(arg = nil)
-        if arg
-          @command_options ||= default_options(arg)
-          @command_options[:listing] = arg.is_a?(String) ? arg : arg.inspect
-          @match = arg
-        end
-        @match ||= nil
-      end
-
-      # Define or get the command's description
-      def description(arg = nil)
-        @description = arg if arg
-        @description ||= nil
-      end
-
-      # Define or get the command's options
-      def command_options(arg = nil)
-        @command_options ||= default_options(match)
-        @command_options.merge!(arg) if arg
-        @command_options
-      end
-      # backward compatibility
-      alias options command_options
-      alias options= command_options=
-
-      # Define or get the command's banner
-      def banner(arg = nil)
-        @banner = arg if arg
-        @banner ||= description
-      end
-
-      def block
-        @block || instance_method(:process)
-      end
-
-      def source
-        file, line = block.source_location
-        strip_leading_whitespace(Pry::Code.from_file(file).expression_at(line))
-      end
-
-      def doc
-        new.help
-      end
-
-      def source_file
-        Array(block.source_location).first
-      end
-      alias file source_file
-
-      def source_line
-        Array(block.source_location).last
-      end
-      alias line source_line
-
-      def default_options(match)
-        {
-          keep_retval: false,
-          argument_required: false,
-          interpolate: true,
-          shellwords: true,
-          listing: (match.is_a?(String) ? match : match.inspect),
-          use_prefix: true,
-          takes_block: false
-        }
-      end
-
-      def name
-        super.to_s == "" ? "#<class(Pry::Command #{match.inspect})>" : super
-      end
-
-      def inspect
-        name
-      end
-
-      def command_name
-        options[:listing]
-      end
-
-      # Create a new command with the given properties.
-      # @param [String, Regex] match The thing that triggers this command
-      # @param [String] description The description to appear in `help`
-      # @param [Hash] options Behavioral options (see {Pry::CommandSet#command})
-      # @param [Module] helpers A module of helper functions to be included.
-      # @yield optional, used for BlockCommands
-      # @return [Class] (a subclass of {Pry::Command})
-      def subclass(match, description, options, helpers, &block)
-        klass = Class.new(self)
-        klass.send(:include, helpers)
-        klass.match = match
-        klass.description = description
-        klass.command_options = options
-        klass.block = block
-        klass
-      end
-
-      # Should this command be called for the given line?
-      # @param [String] val A line input at the REPL
-      # @return [Boolean]
-      def matches?(val)
-        command_regex =~ val
-      end
-
-      # How well does this command match the given line?
-      #
-      # Higher scores are better because they imply that this command matches
-      # the line more closely.
-      #
-      # The score is calculated by taking the number of characters at the start
-      # of the string that are used only to identify the command, not as part of
-      # the arguments.
-      #
-      # @example
-      #   /\.(.*)/.match_score(".foo") #=> 1
-      #   /\.*(.*)/.match_score("...foo") #=> 3
-      #   'hi'.match_score("hi there") #=> 2
-      #
-      # @param [String] val A line input at the REPL
-      # @return [Fixnum]
-      def match_score(val)
-        if command_regex =~ val
-          if Regexp.last_match.size > 1
-            Regexp.last_match.begin(1)
-          else
-            Regexp.last_match.end(0)
-          end
-        else
-          -1
-        end
-      end
-
-      def command_regex
-        prefix = convert_to_regex(Pry.config.command_prefix)
-        prefix = "(?:#{prefix})?" unless options[:use_prefix]
-
-        /\A#{prefix}#{convert_to_regex(match)}(?!\S)/
-      end
-
-      def convert_to_regex(obj)
-        case obj
-        when String
-          Regexp.escape(obj)
-        else
-          obj
-        end
-      end
-
-      # The group in which the command should be displayed in "help" output.
-      # This is usually auto-generated from directory naming, but it can be
-      # manually overridden if necessary.
-      # Group should not be changed once it is initialized.
-      def group(name = nil)
-        @group ||= begin
-          name || case Pry::Method(block).source_file
-                  when %r{/pry/.*_commands/(.*).rb}
-                    Regexp.last_match(1).capitalize.tr('_', " ")
-                  when /(pry-\w+)-([\d\.]+([\w\.]+)?)/
-                    name = Regexp.last_match(1)
-                    version = Regexp.last_match(2)
-                    "#{name} (v#{version})"
-                  when /pryrc/
-                    "pryrc"
-                  else
-                    "(other)"
-                  end
-        end
-      end
-
-      def state
-        Pry::CommandState.default.state_for(match)
-      end
-    end
-
-    # Properties of one execution of a command (passed by {Pry#run_command} as a hash of
-    # context and expanded in `#initialize`
-    attr_accessor :output
-    attr_accessor :target
-    attr_accessor :captures
-    attr_accessor :eval_string
-    attr_accessor :arg_string
-    attr_accessor :context
-    attr_accessor :command_set
-    attr_accessor :hooks
-    attr_accessor :pry_instance
-    alias _pry_= pry_instance=
-
-    # The block we pass *into* a command so long as `:takes_block` is
-    # not equal to `false`
-    # @example
-    #   my-command | do
-    #     puts "block content"
-    #   end
-    attr_accessor :command_block
-
-    # Instantiate a command, in preparation for calling it.
-    # @param [Hash] context The runtime context to use with this command.
-    def initialize(context = {})
-      self.context      = context
-      self.target       = context[:target]
-      self.output       = context[:output]
-      self.eval_string  = context[:eval_string]
-      self.command_set  = context[:command_set]
-      self.hooks        = context[:hooks]
-      self.pry_instance = context[:pry_instance]
-    end
-
-    # Make those properties accessible to instances
-    def name
-      self.class.name
-    end
-
-    def match
-      self.class.match
-    end
-
-    def description
-      self.class.description
-    end
-
-    def block
-      self.class.block
-    end
-
-    def command_options
-      self.class.options
-    end
-
-    def command_name
-      self.class.command_name
-    end
-
-    def source
-      self.class.source
-    end
-
-    # Run a command from another command.
-    # @param [String] command_string The string that invokes the command
-    # @param [Array] args Further arguments to pass to the command
-    # @example
-    #   run "show-input"
-    # @example
-    #   run ".ls"
-    # @example
-    #   run "amend-line",  "5", 'puts "hello world"'
-    def run(command_string, *args)
-      command_string = pry_instance.config.command_prefix.to_s + command_string
-      complete_string = "#{command_string} #{args.join(' ')}".rstrip
-      command_set.process_line(complete_string, context)
-    end
-
-    def commands
-      command_set.to_hash
-    end
-
-    def void
-      VOID_VALUE
-    end
-
-    def _pry_
-      Pry::Warning.warn('_pry_ is deprecated, use pry_instance instead')
-      pry_instance
-    end
-
-    # @return [Object] The value of `self` inside the `target` binding.
-    def target_self
-      target.eval('self')
-    end
-
-    # @return [Hash] Pry commands can store arbitrary state
-    #   here. This state persists between subsequent command invocations.
-    #   All state saved here is unique to the command, it does not
-    #   need to be namespaced.
-    # @example
-    #   state.my_state = "my state"  # this will not conflict with any
-    #                                # `state.my_state` used in another command.
-    def state
-      self.class.state
-    end
-
-    # Revaluate the string (str) and perform interpolation.
-    # @param [String] str The string to reevaluate with interpolation.
-    #
-    # @return [String] The reevaluated string with interpolations
-    #   applied (if any).
-    def interpolate_string(str)
-      dumped_str = str.dump
-      if dumped_str.gsub!(/\\\#\{/, '#{')
-        target.eval(dumped_str)
-      else
-        str
-      end
-    end
-
-    # Display a warning if a command collides with a local/method in
-    # the current scope.
-    def check_for_command_collision(command_match, arg_string)
-      collision_type = target.eval("defined?(#{command_match})")
-      collision_type ||= 'local-variable' if arg_string =~ %r{\A\s*[-+*/%&|^]*=}
-
-      if collision_type
-        output.puts(
-          "#{Helpers::Text.bold('WARNING:')} Calling Pry command '#{command_match}', " \
-          "which conflicts with a #{collision_type}.\n\n"
-        )
-      end
-    rescue Pry::RescuableException # rubocop:disable Lint/HandleExceptions
-    end
-
-    # Extract necessary information from a line that Command.matches? this
-    # command.
-    #
-    # Returns an array of four elements:
-    #
-    # ```
-    #  [String] the portion of the line that matched with the Command match
-    #  [String] a string of all the arguments (i.e. everything but the match)
-    #  [Array]  the captures caught by the command_regex
-    #  [Array]  the arguments obtained by splitting the arg_string
-    # ```
-    #
-    # @param [String] val The line of input
-    # @return [Array]
-    def tokenize(val)
-      val = interpolate_string(val) if command_options[:interpolate]
-
-      self.class.command_regex =~ val
-
-      # please call Command.matches? before Command#call_safely
-      unless Regexp.last_match
-        raise CommandError, "fatal: called a command which didn't match?!"
-      end
-
-      captures = Regexp.last_match.captures
-      pos = Regexp.last_match.end(0)
-
-      arg_string = val[pos..-1]
-
-      # remove the one leading space if it exists
-      arg_string.slice!(0) if arg_string.start_with?(" ")
-
-      # process and pass a block if one is found
-      pass_block(arg_string) if command_options[:takes_block]
-
-      args =
-        if arg_string
-          if command_options[:shellwords]
-            Shellwords.shellwords(arg_string)
-          else
-            arg_string.split(" ")
-          end
-        else
-          []
-        end
-
-      [val[0..pos].rstrip, arg_string, captures, args]
-    end
-
-    # Process a line that Command.matches? this command.
-    # @param [String] line The line to process
-    # @return [Object, Command::VOID_VALUE]
-    def process_line(line)
-      command_match, arg_string, captures, args = tokenize(line)
-
-      if Pry.config.collision_warning
-        check_for_command_collision(command_match, arg_string)
-      end
-
-      self.arg_string = arg_string
-      self.captures = captures
-
-      call_safely(*(captures + args))
-    end
-
-    # Generate completions for this command
-    #
-    # @param [String] _search The line typed so far
-    # @return [Array<String>]  Completion words
-    def complete(_search)
-      []
-    end
-
-    private
-
-    # Run the command with the given `args`.
-    #
-    # This is a public wrapper around `#call` which ensures all preconditions
-    # are met.
-    #
-    # @param [Array<String>] args The arguments to pass to this command.
-    # @return [Object] The return value of the `#call` method, or
-    #   {Command::VOID_VALUE}.
-    def call_safely(*args)
-      if command_options[:argument_required] && args.empty?
-        raise CommandError, "The command '#{command_name}' requires an argument."
-      end
-
-      ret = use_unpatched_symbol do
-        call_with_hooks(*args)
-      end
-      command_options[:keep_retval] ? ret : void
-    end
-
-    def use_unpatched_symbol
-      call_method = Symbol.method_defined?(:call) && Symbol.instance_method(:call)
-      Symbol.class_eval { undef :call } if call_method
-      yield
-    ensure
-      Symbol.instance_eval { define_method(:call, call_method) } if call_method
-    end
-
-    # Pass a block argument to a command.
-    # @param [String] arg_string The arguments (as a string) passed to the command.
-    #   We inspect these for a '| do' or a '| {' and if we find it we use it
-    #   to start a block input sequence. Once we have a complete
-    #   block, we save it to an accessor that can be retrieved from the command context.
-    #   Note that if we find the '| do' or '| {' we delete this and the
-    #   elements following it from `arg_string`.
-    def pass_block(arg_string)
-      # Workaround for weird JRuby bug where rindex in this case can return nil
-      # even when there's a match.
-      arg_string.scan(/\| *(?:do|\{)/)
-      block_index = $LAST_MATCH_INFO && $LAST_MATCH_INFO.offset(0)[0]
-
-      return unless block_index
-
-      block_init_string = arg_string.slice!(block_index..-1)[1..-1]
-      prime_string = "proc #{block_init_string}\n"
-
-      block_string =
-        if !Pry::Code.complete_expression?(prime_string)
-          pry_instance.r(target, prime_string)
-        else
-          prime_string
-        end
-
-      begin
-        self.command_block = target.eval(block_string)
-      rescue Pry::RescuableException
-        raise CommandError, "Incomplete block definition."
-      end
-    end
-
-    def find_hooks(event)
-      event_name = "#{event}_#{command_name}"
-      (hooks || Pry.hooks || self.class.hooks).get_hooks(event_name).values
-    end
-
-    def before_hooks
-      find_hooks('before')
-    end
-
-    def after_hooks
-      find_hooks('after')
-    end
-
-    # Run the `#call` method and all the registered hooks.
-    # @param [Array<String>] args The arguments to `#call`
-    # @return [Object] The return value from `#call`
-    def call_with_hooks(*args)
-      before_hooks.each { |block| instance_exec(*args, &block) }
-
-      ret = call(*args)
-
-      after_hooks.each do |block|
-        ret = instance_exec(*args, &block)
-      end
-
-      ret
-    end
-
-    # Normalize method arguments according to its arity.
-    #
-    # @param [Integer] method
-    # @param [Array] args
-    # @return [Array] a (possibly shorter) array of the arguments to pass
-    def normalize_method_args(method, args)
-      case method.arity
-      when -1
-        args
-      when 0
-        []
-      else
-        args.values_at(*(0..(method.arity - 1)).to_a)
-      end
-    end
-  end
-end