pry 0.12.0 → 0.14.0

data/lib/pry/code_object.rb

@@ -1,3 +1,5 @@
+# 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.
@@ -42,29 +44,30 @@ class Pry
       # @note If a module defined by C was extended with a lot of methods written
       #   in Ruby, this method would fail.
       def c_module?
-        if is_a?(WrappedModule)
+        return unless is_a?(WrappedModule)
 
-          method_locations = wrapped.methods(false).map do |m|
-            wrapped.method(m).source_location
-          end
+        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)
+        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 = method_locations.grep(nil).count
+        ruby_methods = method_locations.count - c_methods
 
-          c_methods > ruby_methods
-        end
+        c_methods > ruby_methods
       end
     end
 
     include Pry::Helpers::CommandHelpers
 
     class << self
-      def lookup(str, _pry_, options = {})
-        co = new(str, _pry_, options)
+      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
@@ -73,24 +76,25 @@ class Pry
 
     attr_accessor :str
     attr_accessor :target
-    attr_accessor :_pry_
+    attr_accessor :pry_instance
     attr_accessor :super_level
 
-    def initialize(str, _pry_, options = {})
+    def initialize(str, pry_instance, options = {})
       options = {
-        super: 0,
+        super: 0
       }.merge!(options)
 
       @str = str
-      @_pry_ = _pry_
-      @target = _pry_.current_context
+      @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
-      # TODO: just make it so find_command_by_match_or_listing doesn't
-      # raise?
-      _pry_.commands.find_command_by_match_or_listing(str) rescue nil
+      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
@@ -112,8 +116,8 @@ class Pry
 
     # 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()
+      # 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)
 
@@ -123,22 +127,22 @@ class Pry
           Pry::Method(obj)
         elsif !obj.is_a?(Module)
           Pry::WrappedModule(obj.class)
-        else
-          nil
         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
+      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
@@ -182,14 +186,12 @@ class Pry
     # @param [Object] obj
     # @param [Fixnum] super_level How far up the super chain to ascend.
     def lookup_super(obj, super_level)
-      return nil if !obj
+      return unless obj
 
       sup = obj.super(super_level)
-      if !sup
-        raise Pry::CommandError, "No superclass found for #{obj.wrapped}"
-      else
-        sup
-      end
+      raise Pry::CommandError, "No superclass found for #{obj.wrapped}" unless sup
+
+      sup
     end
   end
 end

data/lib/pry/color_printer.rb

@@ -1,65 +1,66 @@
-# PP subclass for streaming inspect output in color.
+# frozen_string_literal: true
+
+require 'pp'
+require 'English'
+
 class Pry
+  # PP subclass for streaming inspect output in color.
   class ColorPrinter < ::PP
-    OBJ_COLOR = begin
-      code = CodeRay::Encoders::Terminal::TOKEN_COLORS[:keyword]
-      if code.start_with? "\e"
-        code
-      else
-        "\e[0m\e[0;#{code}m"
+    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
 
-    CodeRay::Encoders::Terminal::TOKEN_COLORS[:comment][:self] = "\e[1;34m"
-
-    def self.pp(obj, out = $>, width = 79, newline = "\n")
-      q = ColorPrinter.new(out, width, newline)
-      q.guard_inspect_key { q.pp obj }
-      q.flush
-      out << "\n"
+    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 text(str, width = str.length)
-      # Don't recolorize output with color [Issue #751]
-      if str.include?("\e[")
-        super "#{str}\e[0m", width
-      elsif str.start_with?('#<') || str == '=' || str == '>'
-        super highlight_object_literal(str), width
-      else
-        super CodeRay.scan(str, :ruby).term, width
-      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 pp(obj)
-      if String === obj
-        # Avoid calling Ruby 2.4+ String#pretty_print that prints multiline
-        # Strings prettier
-        text(obj.inspect)
+    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
-      end
-    rescue => e
-      raise if e.is_a? Pry::Pager::StopPaging
-
-      begin
-        str = obj.inspect
-      rescue Exception 
-        # Read the class name off of the singleton class to provide a default
-        # inspect.
-        singleton = class << obj; self; end
-        ancestors = Pry::Method.safe_send(singleton, :ancestors)
-        klass  = ancestors.reject { |k| k == singleton }.first
-        obj_id = obj.__id__.to_s(16) rescue 0
-        str    = "#<#{klass}:0x#{obj_id}>"
+        super(SyntaxHighlighter.highlight(str), max_width)
       end
-
-      text highlight_object_literal(str)
     end
 
     private
 
     def highlight_object_literal(object_literal)
-      "#{OBJ_COLOR}#{object_literal}\e[0m"
+      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/lib/pry/command.rb

@@ -1,19 +1,28 @@
+# frozen_string_literal: true
+
 require 'delegate'
-require 'pry/helpers/documentation_helpers'
+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.
+  # {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
+    def VOID_VALUE.inspect
+      "void"
+    end
 
     # Properties of the command itself (as passed as arguments to
     # {CommandSet#command} or {CommandSet#create_command}).
@@ -45,8 +54,8 @@ class Pry
         @command_options
       end
       # backward compatibility
-      alias_method :options, :command_options
-      alias_method :options=, :command_options=
+      alias options command_options
+      alias options= command_options=
 
       # Define or get the command's banner
       def banner(arg = nil)
@@ -70,43 +79,25 @@ class Pry
       def source_file
         Array(block.source_location).first
       end
-      alias_method :file, :source_file
+      alias file source_file
 
       def source_line
         Array(block.source_location).last
       end
-      alias_method :line, :source_line
+      alias line source_line
 
       def default_options(match)
         {
-          requires_gem: [],
           keep_retval: false,
           argument_required: false,
           interpolate: true,
           shellwords: true,
-          listing: (String === match ? match : match.inspect),
+          listing: (match.is_a?(String) ? match : match.inspect),
           use_prefix: true,
           takes_block: false
         }
       end
-    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
-
-    class << self
       def name
         super.to_s == "" ? "#<class(Pry::Command #{match.inspect})>" : super
       end
@@ -116,7 +107,7 @@ class Pry
       end
 
       def command_name
-        self.options[:listing]
+        options[:listing]
       end
 
       # Create a new command with the given properties.
@@ -161,24 +152,21 @@ class Pry
       # @return [Fixnum]
       def match_score(val)
         if command_regex =~ val
-          Regexp.last_match.size > 1 ? Regexp.last_match.begin(1) : Regexp.last_match.end(0)
+          if Regexp.last_match.size > 1
+            Regexp.last_match.begin(1)
+          else
+            Regexp.last_match.end(0)
+          end
         else
           -1
         end
       end
 
-      # @deprecated Replaced with {Pry::Hooks#add_hook}. Left for compatibility.
-      # Store hooks to be run before or after the command body.
-      def hooks
-        Pry.hooks
-      end
-
       def command_regex
-        pr = Pry.respond_to?(:config) ? Pry.config.command_prefix : ""
-        prefix = convert_to_regex(pr)
+        prefix = convert_to_regex(Pry.config.command_prefix)
         prefix = "(?:#{prefix})?" unless options[:use_prefix]
 
-        /^#{prefix}#{convert_to_regex(match)}(?!\S)/
+        /\A#{prefix}#{convert_to_regex(match)}(?!\S)/
       end
 
       def convert_to_regex(obj)
@@ -195,21 +183,24 @@ class Pry
       # manually overridden if necessary.
       # Group should not be changed once it is initialized.
       def group(name = nil)
-        @group ||= if name
-                     name
-                   else
-                     case Pry::Method(block).source_file
-                     when %r{/pry/.*_commands/(.*).rb}
-                       $1.capitalize.gsub(/_/, " ")
-                     when %r{(pry-\w+)-([\d\.]+([\w\.]+)?)}
-                       name, version = $1, $2
-                       "#{name} (v#{version})"
-                     when /pryrc/
-                       "pryrc"
-                     else
-                       "(other)"
-                     end
-                   end
+        @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
 
@@ -223,7 +214,8 @@ class Pry
     attr_accessor :context
     attr_accessor :command_set
     attr_accessor :hooks
-    attr_accessor :_pry_
+    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`
@@ -233,6 +225,47 @@ class Pry
     #   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
@@ -243,8 +276,8 @@ class Pry
     # @example
     #   run "amend-line",  "5", 'puts "hello world"'
     def run(command_string, *args)
-      command_string = _pry_.config.command_prefix.to_s + command_string
-      complete_string = "#{command_string} #{args.join(" ")}".rstrip
+      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
 
@@ -252,40 +285,19 @@ class Pry
       command_set.to_hash
     end
 
-    #
-    # @deprecated
-    #   Please use black(), white(), etc directly instead (as you would with helper
-    #   functions from BaseHelpers and CommandHelpers)
-    #
-    # @return [Module]
-    #   Returns Pry::Helpers::Text
-    #
-    def text
-      Pry::Helpers::Text
-    end
-
     def void
       VOID_VALUE
     end
 
-    include Pry::Helpers::BaseHelpers
-    include Pry::Helpers::CommandHelpers
-    include Pry::Helpers::Text
-
-    # 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_        = context[:pry_instance]
+    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
+    def target_self
+      target.eval('self')
+    end
 
     # @return [Hash] Pry commands can store arbitrary state
     #   here. This state persists between subsequent command invocations.
@@ -295,7 +307,7 @@ class Pry
     #   state.my_state = "my state"  # this will not conflict with any
     #                                # `state.my_state` used in another command.
     def state
-      _pry_.command_state[match] ||= Pry::Config.from_hash({})
+      self.class.state
     end
 
     # Revaluate the string (str) and perform interpolation.
@@ -316,12 +328,15 @@ class Pry
     # 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.match(%r{\A\s*[-+*/%&|^]*=})
+      collision_type ||= 'local-variable' if arg_string =~ %r{\A\s*[-+*/%&|^]*=}
 
       if collision_type
-        output.puts "#{text.bold('WARNING:')} Calling Pry command '#{command_match}', which conflicts with a #{collision_type}.\n\n"
+        output.puts(
+          "#{Helpers::Text.bold('WARNING:')} Calling Pry command '#{command_match}', " \
+          "which conflicts with a #{collision_type}.\n\n"
+        )
       end
-    rescue Pry::RescuableException
+    rescue Pry::RescuableException # rubocop:disable Lint/HandleExceptions
     end
 
     # Extract necessary information from a line that Command.matches? this
@@ -339,12 +354,14 @@ class Pry
     # @param [String] val The line of input
     # @return [Array]
     def tokenize(val)
-      val.replace(interpolate_string(val)) if command_options[:interpolate]
+      val = interpolate_string(val) if command_options[:interpolate]
 
       self.class.command_regex =~ val
 
       # please call Command.matches? before Command#call_safely
-      raise CommandError, "fatal: called a command which didn't match?!" unless Regexp.last_match
+      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)
@@ -357,11 +374,16 @@ class Pry
       # process and pass a block if one is found
       pass_block(arg_string) if command_options[:takes_block]
 
-      if arg_string
-        args = command_options[:shellwords] ? Shellwords.shellwords(arg_string) : arg_string.split(" ")
-      else
-        args = []
-      end
+      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
@@ -372,7 +394,9 @@ class Pry
     def process_line(line)
       command_match, arg_string, captures, args = tokenize(line)
 
-      check_for_command_collision(command_match, arg_string) if Pry.config.collision_warning
+      if Pry.config.collision_warning
+        check_for_command_collision(command_match, arg_string)
+      end
 
       self.arg_string = arg_string
       self.captures = captures
@@ -380,38 +404,15 @@ class Pry
       call_safely(*(captures + args))
     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 = $~ && $~.offset(0)[0]
-
-      return if !block_index
-
-      block_init_string = arg_string.slice!(block_index..-1)[1..-1]
-      prime_string = "proc #{block_init_string}\n"
-
-      if !Pry::Code.complete_expression?(prime_string)
-        block_string = _pry_.r(target, prime_string)
-      else
-        block_string = prime_string
-      end
-
-      begin
-        self.command_block = target.eval(block_string)
-      rescue Pry::RescuableException
-        raise CommandError, "Incomplete block definition."
-      end
+    # Generate completions for this command
+    #
+    # @param [String] _search The line typed so far
+    # @return [Array<String>]  Completion words
+    def complete(_search)
+      []
     end
 
-    private :pass_block
+    private
 
     # Run the command with the given `args`.
     #
@@ -422,15 +423,6 @@ class Pry
     # @return [Object] The return value of the `#call` method, or
     #   {Command::VOID_VALUE}.
     def call_safely(*args)
-      unless dependencies_met?
-        gems_needed = Array(command_options[:requires_gem])
-        gems_not_installed = gems_needed.select { |g| !Rubygem.installed?(g) }
-        output.puts "\nThe command '#{command_name}' is #{text.bold("unavailable")} because it requires the following gems to be installed: #{(gems_not_installed.join(", "))}"
-        output.puts "-"
-        output.puts "Type `install-command #{command_name}` to install the required gems and activate this command."
-        return void
-      end
-
       if command_options[:argument_required] && args.empty?
         raise CommandError, "The command '#{command_name}' requires an argument."
       end
@@ -449,26 +441,41 @@ class Pry
       Symbol.instance_eval { define_method(:call, call_method) } if call_method
     end
 
-    # Are all the gems required to use this command installed?
-    #
-    # @return  Boolean
-    def dependencies_met?
-      @dependencies_met ||= command_dependencies_met?(command_options)
-    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]
 
-    # Generate completions for this command
-    #
-    # @param [String] _search The line typed so far
-    # @return [Array<String>]  Completion words
-    def complete(_search)
-      []
-    end
+      return unless block_index
 
-    private
+      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}"
-      (self.hooks || self.class.hooks).get_hooks(event_name).values
+      (hooks || Pry.hooks || self.class.hooks).get_hooks(event_name).values
     end
 
     def before_hooks
@@ -494,230 +501,20 @@ class Pry
       ret
     end
 
-    # Fix the number of arguments we pass to a block to avoid arity warnings.
-    # @param [Fixnum] arity The arity of the block
-    # @param [Array] args The arguments to pass
-    # @return [Array] A (possibly shorter) array of the arguments to pass
-    def correct_arg_arity(arity, args)
-      case
-      when arity < 0
+    # 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 arity == 0
+      when 0
         []
-      when arity > 0
-        args.values_at(*(0..(arity - 1)).to_a)
-      end
-    end
-  end
-
-  # A super-class for Commands that are created with a single block.
-  #
-  # This class ensures that the block is called with the correct number of arguments
-  # and the right context.
-  #
-  # Create subclasses using {Pry::CommandSet#command}.
-  class BlockCommand < Command
-    # backwards compatibility
-    alias_method :opts, :context
-
-    # Call the block that was registered with this command.
-    # @param [Array<String>] args The arguments passed
-    # @return [Object] The return value of the block
-    def call(*args)
-      instance_exec(*correct_arg_arity(block.arity, args), &block)
-    end
-
-    def help
-      "#{command_options[:listing].to_s.ljust(18)} #{description}"
-    end
-  end
-
-  # A super-class of Commands with structure.
-  #
-  # This class implements the bare-minimum functionality that a command should
-  # have, namely a --help switch, and then delegates actual processing to its
-  # subclasses.
-  #
-  # Create subclasses using {Pry::CommandSet#create_command}, and override the
-  # `options(opt)` method to set up an instance of Pry::Slop, and the `process`
-  # method to actually run the command. If necessary, you can also override
-  # `setup` which will be called before `options`, for example to require any
-  # gems your command needs to run, or to set up state.
-  class ClassCommand < Command
-    class << self
-      # Ensure that subclasses inherit the options, description and
-      # match from a ClassCommand super class.
-      def inherited(klass)
-        klass.match match
-        klass.description description
-        klass.command_options options
-      end
-
-      def source
-        source_object.source
-      end
-
-      def doc
-        new.help
-      end
-
-      def source_location
-        source_object.source_location
-      end
-
-      def source_file
-        source_object.source_file
-      end
-      alias_method :file, :source_file
-
-      def source_line
-        source_object.source_line
-      end
-      alias_method :line, :source_line
-
-      private
-
-      # The object used to extract the source for the command.
-      #
-      # This should be a `Pry::Method(block)` for a command made with `create_command`
-      # and a `Pry::WrappedModule(self)` for a command that's a standard class.
-      # @return [Pry::WrappedModule, Pry::Method]
-      def source_object
-        @source_object ||= if name =~ /^[A-Z]/
-                             Pry::WrappedModule(self)
-                           else
-                             Pry::Method(block)
-                           end
-      end
-    end
-
-    attr_accessor :opts
-    attr_accessor :args
-
-    # Set up `opts` and `args`, and then call `process`.
-    #
-    # This method will display help if necessary.
-    #
-    # @param [Array<String>] args The arguments passed
-    # @return [Object] The return value of `process` or VOID_VALUE
-    def call(*args)
-      setup
-
-      self.opts = slop
-      self.args = self.opts.parse!(args)
-
-      if opts.present?(:help)
-        output.puts slop.help
-        void
       else
-        process(*correct_arg_arity(method(:process).arity, args))
+        args.values_at(*(0..(method.arity - 1)).to_a)
       end
     end
-
-    # Return the help generated by Pry::Slop for this command.
-    def help
-      slop.help
-    end
-
-    # Return an instance of Pry::Slop that can parse either subcommands or the
-    # options that this command accepts.
-    def slop
-      Pry::Slop.new do |opt|
-        opt.banner(unindent(self.class.banner))
-        subcommands(opt)
-        options(opt)
-        opt.on :h, :help, 'Show this message.'
-      end
-    end
-
-    # Generate shell completions
-    # @param [String] search  The line typed so far
-    # @return [Array<String>]  the words to complete
-    def complete(search)
-      slop.flat_map do |opt|
-        [opt.long && "--#{opt.long} " || opt.short && "-#{opt.short}"]
-      end.compact + super
-    end
-
-    # A method called just before `options(opt)` as part of `call`.
-    #
-    # This method can be used to set up any context your command needs to run,
-    # for example requiring gems, or setting default values for options.
-    #
-    # @example
-    #   def setup
-    #     require 'gist'
-    #     @action = :method
-    #   end
-    def setup; end
-
-    # A method to setup Pry::Slop commands so it can parse the subcommands your
-    # command expects. If you need to set up default values, use `setup`
-    # instead.
-    #
-    # @example A minimal example
-    #   def subcommands(cmd)
-    #     cmd.command :download do |opt|
-    #       description 'Downloads a content from a server'
-    #
-    #       opt.on :verbose, 'Use verbose output'
-    #
-    #       run do |options, arguments|
-    #         ContentDownloader.download(options, arguments)
-    #       end
-    #     end
-    #   end
-    #
-    # @example Define the invokation block anywhere you want
-    #   def subcommands(cmd)
-    #     cmd.command :download do |opt|
-    #       description 'Downloads a content from a server'
-    #
-    #       opt.on :verbose, 'Use verbose output'
-    #     end
-    #   end
-    #
-    #   def process
-    #     # Perform calculations...
-    #     opts.fetch_command(:download).run do |options, arguments|
-    #       ContentDownloader.download(options, arguments)
-    #     end
-    #     # More calculations...
-    #   end
-    def subcommands(cmd); end
-
-    # A method to setup Pry::Slop so it can parse the options your command expects.
-    #
-    # @note Please don't do anything side-effecty in the main part of this
-    # method, as it may be called by Pry at any time for introspection reasons.
-    # If you need to set up default values, use `setup` instead.
-    #
-    # @example
-    #  def options(opt)
-    #    opt.banner "Gists methods or classes"
-    #    opt.on(:c, :class, "gist a class") do
-    #      @action = :class
-    #    end
-    #  end
-    def options(opt); end
-
-    # The actual body of your command should go here.
-    #
-    # The `opts` mehod can be called to get the options that Pry::Slop has passed,
-    # and `args` gives the remaining, unparsed arguments.
-    #
-    # The return value of this method is discarded unless the command was
-    # created with `:keep_retval => true`, in which case it is returned to the
-    # repl.
-    #
-    # @example
-    #   def process
-    #     if opts.present?(:class)
-    #       gist_class
-    #     else
-    #       gist_method
-    #     end
-    #   end
-    def process; raise CommandError, "command '#{command_name}' not implemented" end
   end
 end