pry 0.9.12.6-i386-mingw32 → 0.10.0-i386-mingw32

data/lib/pry/commands/gem_open.rb

@@ -2,7 +2,7 @@ class Pry
   class Command::GemOpen < Pry::ClassCommand
     match 'gem-open'
     group 'Gems'
-    description 'Opens the working directory of the gem in your editor'
+    description 'Opens the working directory of the gem in your editor.'
     command_options :argument_required => true
 
     banner <<-'BANNER'

data/lib/pry/commands/gist.rb

@@ -2,8 +2,8 @@ class Pry
   class Command::Gist < Pry::ClassCommand
     match 'gist'
     group 'Misc'
-    description 'Playback a string variable or a method or a file as input.'
-    command_options :requires_gem => "jist"
+    description 'Upload code, docs, history to https://gist.github.com/.'
+    command_options :requires_gem => "gist"
 
     banner <<-'BANNER'
       Usage: gist [OPTIONS] [--help]
@@ -16,18 +16,18 @@ class Pry
     BANNER
 
     def setup
-      require 'jist'
+      require 'gist'
     end
 
     def options(opt)
       CodeCollector.inject_options(opt)
-      opt.on :login, "Authenticate the jist gem with GitHub"
+      opt.on :login, "Authenticate the gist gem with GitHub"
       opt.on :p, :public, "Create a public gist (default: false)", :default => false
       opt.on :clip, "Copy the selected content to clipboard instead, do NOT gist it", :default => false
     end
 
     def process
-      return Jist.login! if opts.present?(:login)
+      return ::Gist.login! if opts.present?(:login)
       cc = CodeCollector.new(args, opts, _pry_)
 
       if cc.content =~ /\A\s*\z/
@@ -45,7 +45,7 @@ class Pry
     end
 
     def clipboard_content(content)
-      Jist.copy(content)
+      ::Gist.copy(content)
       output.puts "Copied content to clipboard!"
     end
 
@@ -58,7 +58,7 @@ class Pry
           if code && code != ""
             content << code
             if code !~ /;\Z/
-              content << "#{comment_expression_result_for_gist(Pry.config.gist.inspecter.call(_pry_.output_array[corrected_index]))}"
+              content << "#{comment_expression_result_for_gist(_pry_.config.gist.inspecter.call(_pry_.output_array[corrected_index]))}"
             end
           end
         end
@@ -81,14 +81,14 @@ class Pry
     end
 
     def gist_content(content, filename)
-      response = Jist.gist(content, :filename => filename || "pry_gist.rb", :public => !!opts[:p])
+      response = ::Gist.gist(content, :filename => filename || "pry_gist.rb", :public => !!opts[:p])
       if response
         url = response['html_url']
         message = "Gist created at URL #{url}"
         begin
-          Jist.copy(url)
+          ::Gist.copy(url)
           message << ", which is now in the clipboard."
-        rescue Jist::ClipboardError
+        rescue ::Gist::ClipboardError
         end
 
         output.puts message
@@ -98,5 +98,4 @@ class Pry
 
   Pry::Commands.add_command(Pry::Command::Gist)
   Pry::Commands.alias_command 'clipit', 'gist --clip'
-  Pry::Commands.alias_command 'jist', 'gist'
 end

data/lib/pry/commands/help.rb

@@ -2,14 +2,14 @@ class Pry
   class Command::Help < Pry::ClassCommand
     match 'help'
     group 'Help'
-    description 'Show a list of commands or information about a specific command'
+    description 'Show a list of commands or information about a specific command.'
 
     banner <<-'BANNER'
       Usage: help [COMMAND]
 
-      With no arguments, help lists all the available commands in the current
-      command-set along with their description. When given a command name as an
-      argument, shows the help for that command.
+      With no arguments, help lists all the available commands along with their
+      descriptions. When given a command name as an argument, shows the help
+      for that command.
     BANNER
 
     # We only want to show commands that have descriptions, so that the
@@ -37,7 +37,7 @@ class Pry
 
     # Display the index view, with headings and short descriptions per command.
     #
-    # @param Hash[String => Array[Commands]]
+    # @param [Hash<String, Array<Commands>>] groups
     def display_index(groups)
       help_text = []
 
@@ -49,18 +49,18 @@ class Pry
         end
       end
 
-      stagger_output(help_text.join("\n\n"))
+      _pry_.pager.page help_text.join("\n\n")
     end
 
     # Given a group name and an array of commands,
     # return the help string for those commands.
     #
     # @param [String] name The group name.
-    # @param [Array<Pry::Command>]] commands
+    # @param [Array<Pry::Command>] commands
     # @return [String] The generated help string.
     def help_text_for_commands(name, commands)
-      "#{text.bold(name)}\n" + commands.map do |command|
-        "  #{command.options[:listing].to_s.ljust(18)} #{command.description}"
+      "#{text.bold(name.capitalize)}\n" << commands.map do |command|
+        "  #{command.options[:listing].to_s.ljust(18)} #{command.description.capitalize}"
       end.join("\n")
     end
 
@@ -121,7 +121,7 @@ class Pry
     #
     # @param [Pry::Command] command
     def display_command(command)
-      stagger_output command.new.help
+      _pry_.pager.page command.new.help
     end
 
     # Find a subset of a hash that matches the user's search term.
@@ -130,8 +130,8 @@ class Pry
     # otherwise a sub-Hash with every key that matches the search will
     # be returned.
     #
-    # @param [String]  the search term
-    # @param [Hash]  the hash to search
+    # @param [String] search the search term
+    # @param [Hash] hash the hash to search
     def search_hash(search, hash)
       matching = {}
 
@@ -149,8 +149,8 @@ class Pry
 
     # Clean search terms to make it easier to search group names
     #
-    # @param String
-    # @return String
+    # @param [String] key
+    # @return [String]
     def normalize(key)
       key.downcase.gsub(/pry\W+/, '')
     end

data/lib/pry/commands/hist.rb

@@ -6,6 +6,7 @@ class Pry
 
     banner <<-'BANNER'
       Usage:   hist [--head|--tail]
+               hist --all
                hist --head N
                hist --tail N
                hist --show START..END
@@ -19,6 +20,7 @@ class Pry
     BANNER
 
     def options(opt)
+      opt.on :a, :all,    "Display all history"
       opt.on :H, :head,   "Display the first N items", :optional_argument => true, :as => Integer
       opt.on :T, :tail,   "Display the last N items", :optional_argument => true, :as => Integer
       opt.on :s, :show,   "Show the given range of lines", :optional_argument => true, :as => Range
@@ -28,11 +30,10 @@ class Pry
       opt.on     :save,   "Save history to a file", :argument => true, :as => Range
       opt.on :e, :'exclude-pry', "Exclude Pry commands from the history"
       opt.on :n, :'no-numbers',  "Omit line numbers"
-      opt.on :f, :flood,         "Do not use a pager to view text longer than one screen"
     end
 
     def process
-      @history = Pry::Code(Pry.history.to_a)
+      @history = find_history
 
       if opts.present?(:show)
         @history = @history.between(opts[:show])
@@ -54,7 +55,9 @@ class Pry
         end
 
       if opts.present?(:'exclude-pry')
-        @history = @history.select { |l, ln| !command_set.valid_command?(l) }
+        @history = @history.select do |loc|
+                     !command_set.valid_command?(loc.line)
+                   end
       end
 
       if opts.present?(:save)
@@ -75,7 +78,9 @@ class Pry
         @history = @history.with_line_numbers
       end
 
-      render_output(@history, opts)
+      _pry_.pager.open do |pager|
+        @history.print_to_output(pager, true)
+      end
     end
 
     def process_save
@@ -113,10 +118,9 @@ class Pry
       # further.
       check_for_juxtaposed_replay(replay_sequence)
 
-      _pry_.input_stack.push _pry_.input
-      _pry_.input = StringIO.new(replay_sequence)
-      # eval_string << "#{@history.raw}\n"
-      # run "show-input" unless _pry_.complete_expression?(eval_string)
+      replay_sequence.lines.each do |line|
+        _pry_.eval line, :generated => true
+      end
     end
 
     # Checks +replay_sequence+ for the presence of neighboring replay calls.
@@ -154,6 +158,21 @@ class Pry
         false
       end
     end
+
+    # Finds history depending on the given switch.
+    #
+    # @return [Pry::Code] if it finds `--all` (or `-a`) switch, returns all
+    #   entries in history. Without the switch returns only the entries from the
+    #   current Pry session.
+    def find_history
+      h = if opts.present?(:all)
+            Pry.history.to_a
+          else
+            Pry.history.to_a.last(Pry.history.session_line_count)
+          end
+      # The last value in history will be the 'hist' command itself.
+      Pry::Code(h[0..-2])
+    end
   end
 
   Pry::Commands.add_command(Pry::Command::Hist)

data/lib/pry/commands/install_command.rb

@@ -15,35 +15,37 @@ class Pry
       require 'rubygems/dependency_installer' unless defined? Gem::DependencyInstaller
       command = find_command(name)
 
+      unless command
+        output.puts "Command #{ text.green(name) } is not found"
+        return
+      end
+
       if command_dependencies_met?(command.options)
-        output.puts "Dependencies for #{command.name} are met. Nothing to do."
+        output.puts "Dependencies for #{ text.green(name) } are met. Nothing to do"
         return
       end
 
-      output.puts "Attempting to install `#{name}` command..."
+      output.puts "Attempting to install #{ text.green(name) } command..."
       gems_to_install = Array(command.options[:requires_gem])
 
       gems_to_install.each do |g|
         next if Rubygem.installed?(g)
-        output.puts "Installing `#{g}` gem..."
-
-        begin
-          Gem::DependencyInstaller.new.install(g)
-        rescue Gem::GemNotFoundException
-          raise CommandError, "Required Gem: `#{g}` not found. Aborting command installation."
-        end
+        output.puts "Installing #{ text.green(g) } gem..."
+        Rubygem.install(g)
       end
 
-      Gem.refresh
       gems_to_install.each do |g|
         begin
           require g
         rescue LoadError
-          raise CommandError, "Required Gem: `#{g}` installed but not found?!. Aborting command installation."
+          fail_msg = "Required gem #{ text.green(g) } installed but not found."
+          fail_msg += " Aborting command installation\n"
+          fail_msg += 'Tips: 1. Check your PATH; 2. Run `bundle update`'
+          raise CommandError, fail_msg
         end
       end
 
-      output.puts "Installation of `#{name}` successful! Type `help #{name}` for information"
+      output.puts "Installation of #{ text.green(name) } successful! Type `help #{name}` for information"
     end
   end
 

data/lib/pry/commands/list_inspectors.rb

@@ -0,0 +1,35 @@
+class Pry::Command::ListInspectors < Pry::ClassCommand
+  match 'list-inspectors'
+  group 'Input and Output'
+  description 'List the inspector procs available for use.'
+  banner <<-BANNER
+    Usage: list-inspectors
+
+    List the inspector procs available to print return values. You can use
+    change-inspector to switch between them.
+  BANNER
+
+  def process
+    output.puts heading("Available inspectors") + "\n"
+    inspector_map.each do |name, inspector|
+      output.write "Name: #{text.bold(name)}"
+      output.puts selected_inspector?(inspector) ? selected_text : ""
+      output.puts inspector[:description]
+      output.puts
+    end
+  end
+
+private
+  def inspector_map
+    Pry::Inspector::MAP
+  end
+
+  def selected_text
+    text.red " (selected) "
+  end
+
+  def selected_inspector?(inspector)
+    _pry_.print == inspector[:value]
+  end
+  Pry::Commands.add_command(self)
+end

data/lib/pry/commands/list_prompts.rb

@@ -0,0 +1,35 @@
+class Pry::Command::ListPrompts < Pry::ClassCommand
+  match 'list-prompts'
+  group 'Input and Output'
+  description 'List the prompts available for use.'
+  banner <<-BANNER
+    Usage: list-prompts
+
+    List the available prompts. You can use change-prompt to switch between
+    them.
+  BANNER
+
+  def process
+    output.puts heading("Available prompts") + "\n"
+    prompt_map.each do |name, prompt|
+      output.write "Name: #{text.bold(name)}"
+      output.puts selected_prompt?(prompt) ? selected_text : ""
+      output.puts prompt[:description]
+      output.puts
+    end
+  end
+
+private
+  def prompt_map
+    Pry::Prompt::MAP
+  end
+
+  def selected_text
+    text.red " (selected) "
+  end
+
+  def selected_prompt?(prompt)
+    _pry_.prompt == prompt[:value]
+  end
+  Pry::Commands.add_command(self)
+end

data/lib/pry/commands/ls.rb

@@ -1,38 +1,64 @@
+require 'pry/commands/ls/ls_entity'
 class Pry
   class Command::Ls < Pry::ClassCommand
+    DEFAULT_OPTIONS = {
+      :heading_color            => :bright_blue,
+      :public_method_color      => :default,
+      :private_method_color     => :blue,
+      :protected_method_color   => :blue,
+      :method_missing_color     => :bright_red,
+      :local_var_color          => :yellow,
+      :pry_var_color            => :default,     # e.g. _, _pry_, _file_
+      :instance_var_color       => :blue,        # e.g. @foo
+      :class_var_color          => :bright_blue, # e.g. @@foo
+      :global_var_color         => :default,     # e.g. $CODERAY_DEBUG, $eventmachine_library
+      :builtin_global_color     => :cyan,        # e.g. $stdin, $-w, $PID
+      :pseudo_global_color      => :cyan,        # e.g. $~, $1..$9, $LAST_MATCH_INFO
+      :constant_color           => :default,     # e.g. VERSION, ARGF
+      :class_constant_color     => :blue,        # e.g. Object, Kernel
+      :exception_constant_color => :magenta,     # e.g. Exception, RuntimeError
+      :unloaded_constant_color  => :yellow,      # Any constant that is still in .autoload? state
+      :separator                => "  ",
+      :ceiling                  => [Object, Module, Class]
+    }
+
+
     match 'ls'
     group 'Context'
     description 'Show the list of vars and methods in the current scope.'
     command_options :shellwords => false, :interpolate => false
 
-    def options(opt)
-      opt.banner unindent <<-'BANNER'
-        Usage: ls [-m|-M|-p|-pM] [-q|-v] [-c|-i] [Object]
-               ls [-g] [-l]
+    banner <<-'BANNER'
+      Usage: ls [-m|-M|-p|-pM] [-q|-v] [-c|-i] [Object]
+             ls [-g] [-l]
 
-        ls shows you which methods, constants and variables are accessible to Pry. By
-        default it shows you the local variables defined in the current shell, and any
-        public methods or instance variables defined on the current object.
+      ls shows you which methods, constants and variables are accessible to Pry. By
+      default it shows you the local variables defined in the current shell, and any
+      public methods or instance variables defined on the current object.
 
-        The colours used are configurable using Pry.config.ls.*_color, and the separator
-        is Pry.config.ls.separator.
+      The colours used are configurable using Pry.config.ls.*_color, and the separator
+      is Pry.config.ls.separator.
 
-        Pry.config.ls.ceiling is used to hide methods defined higher up in the
-        inheritance chain, this is by default set to [Object, Module, Class] so that
-        methods defined on all Objects are omitted. The -v flag can be used to ignore
-        this setting and show all methods, while the -q can be used to set the ceiling
-        much lower and show only methods defined on the object or its direct class.
-      BANNER
+      Pry.config.ls.ceiling is used to hide methods defined higher up in the
+      inheritance chain, this is by default set to [Object, Module, Class] so that
+      methods defined on all Objects are omitted. The -v flag can be used to ignore
+      this setting and show all methods, while the -q can be used to set the ceiling
+      much lower and show only methods defined on the object or its direct class.
 
-      opt.on :m, :methods,   "Show public methods defined on the Object (default)"
-      opt.on :M, "instance-methods", "Show methods defined in a Module or Class"
+      Also check out `find-method` command (run `help find-method`).
+    BANNER
+
+
+    def options(opt)
+      opt.on :m, :methods,   "Show public methods defined on the Object"
+      opt.on :M, "instance-methods", "Show public methods defined in a Module or Class"
       opt.on :p, :ppp,       "Show public, protected (in yellow) and private (in green) methods"
       opt.on :q, :quiet,     "Show only methods defined on object.singleton_class and object.class"
       opt.on :v, :verbose,   "Show methods and constants on all super-classes (ignores Pry.config.ls.ceiling)"
       opt.on :g, :globals,   "Show global variables, including those builtin to Ruby (in cyan)"
       opt.on :l, :locals,    "Show hash of local vars, sorted by descending size"
-      opt.on :c, :constants, "Show constants, highlighting classes (in blue), and exceptions (in purple).\n" +
-      " " * 32 +             "Constants that are pending autoload? are also shown (in yellow)"
+      opt.on :c, :constants, "Show constants, highlighting classes (in blue), and exceptions (in purple).\n" <<
+      " " * 32 <<            "Constants that are pending autoload? are also shown (in yellow)"
       opt.on :i, :ivars,     "Show instance variables (in blue) and class variables (in bright blue)"
       opt.on :G, :grep,      "Filter output by regular expression", :argument => true
 
@@ -41,297 +67,47 @@ class Pry
       end
     end
 
-    attr_reader :object_to_interrogate, :has_user_specified_any_options, :grep, :grep_regex
+    # Exclude -q, -v and --grep because they,
+    # don't specify what the user wants to see.
+    def no_user_opts?
+      !(opts[:methods] || opts['instance-methods'] || opts[:ppp] ||
+        opts[:globals] || opts[:locals] || opts[:constants] || opts[:ivars])
+    end
 
     def process
-      @object_to_interrogate = args.empty? ? target_self : target.eval(args.join(" "))
-
-      # exclude -q, -v and --grep because they don't specify what the user wants to see.
-      @has_user_specified_any_options = (opts.present?(:methods) || opts.present?(:'instance-methods') || opts.present?(:ppp) ||
-                                          opts.present?(:globals) || opts.present?(:locals) || opts.present?(:constants) ||
-                                          opts.present?(:ivars))
-
-      @grep_regex, @grep = [Regexp.new(opts[:G] || "."), lambda{ |x| x.grep(@grep_regex) }]
-
+      @interrogatee = args.empty? ? target_self : target.eval(args.join(' '))
       raise_errors_if_arguments_are_weird
+      ls_entity = LsEntity.new({
+        :interrogatee => @interrogatee,
+        :no_user_opts => no_user_opts?,
+        :opts => opts,
+        :args => args,
+        :_pry_ => _pry_
+      })
 
-      all_output = [
-        write_out_globals,
-        write_out_constants,
-        write_out_methods,
-        write_out_self_methods,
-        write_out_ivars,
-        write_out_local_names,
-        write_out_locals,
-      ].compact.join("")
-
-      stagger_output(all_output)
+      _pry_.pager.page ls_entity.entities_table
     end
 
     private
 
-    # http://ruby.runpaint.org/globals, and running "puts global_variables.inspect".
-    BUILTIN_GLOBALS = %w($" $$ $* $, $-0 $-F $-I $-K $-W $-a $-d $-i $-l $-p $-v $-w $. $/ $\\
-                         $: $; $< $= $> $0 $ARGV $CONSOLE $DEBUG $DEFAULT_INPUT $DEFAULT_OUTPUT
-                         $FIELD_SEPARATOR $FILENAME $FS $IGNORECASE $INPUT_LINE_NUMBER
-                         $INPUT_RECORD_SEPARATOR $KCODE $LOADED_FEATURES $LOAD_PATH $NR $OFS
-                         $ORS $OUTPUT_FIELD_SEPARATOR $OUTPUT_RECORD_SEPARATOR $PID $PROCESS_ID
-                         $PROGRAM_NAME $RS $VERBOSE $deferr $defout $stderr $stdin $stdout)
-
-    # $SAFE and $? are thread-local, the exception stuff only works in a rescue clause,
-    # everything else is basically a local variable with a $ in its name.
-    PSEUDO_GLOBALS = %w($! $' $& $` $@ $? $+ $_ $~ $1 $2 $3 $4 $5 $6 $7 $8 $9
-                       $CHILD_STATUS $SAFE $ERROR_INFO $ERROR_POSITION $LAST_MATCH_INFO
-                       $LAST_PAREN_MATCH $LAST_READ_LINE $MATCH $POSTMATCH $PREMATCH)
-
-    # Get all the methods that we'll want to output
-    def all_methods(obj, instance_methods=false)
-      methods = if instance_methods || opts.present?(:'instance-methods')
-                  Pry::Method.all_from_class(obj)
-                else
-                  Pry::Method.all_from_obj(obj)
-                end
-
-      if jruby? && !opts.present?(:J)
-        methods = trim_jruby_aliases(methods)
-      end
-
-      methods.select{ |method| opts.present?(:ppp) || method.visibility == :public }
-    end
-
-    # JRuby creates lots of aliases for methods imported from java in an attempt to
-    # make life easier for ruby programmers.
-    # (e.g. getFooBar becomes get_foo_bar and foo_bar, and maybe foo_bar? if it
-    # returns a Boolean).
-    # The full transformations are in the assignAliases method of:
-    #   https://github.com/jruby/jruby/blob/master/src/org/jruby/javasupport/JavaClass.java
-    #
-    # This has the unfortunate side-effect of making the output of ls even more
-    # incredibly verbose than it normally would be for these objects; and so we filter
-    # out all but the nicest of these aliases here.
-    #
-    # TODO: This is a little bit vague, better heuristics could be used.
-    #       JRuby also has a lot of scala-specific logic, which we don't copy.
-    #
-    def trim_jruby_aliases(methods)
-      grouped = methods.group_by do |m|
-        m.name.sub(/\A(is|get|set)(?=[A-Z_])/, '').gsub(/[_?=]/, '').downcase
-      end
-
-      grouped.map do |key, values|
-        values = values.sort_by do |m|
-          rubbishness(m.name)
-        end
-
-        found = []
-        values.select do |x|
-          (!found.any?{ |y| x == y }) && found << x
-        end
-      end.flatten(1)
-    end
-
-    # When removing jruby aliases, we want to keep the alias that is "least rubbish"
-    # according to this metric.
-    def rubbishness(name)
-      name.each_char.map{ |x|
-        case x
-        when /[A-Z]/
-          1
-        when '?', '=', '!'
-          -2
-        else
-          0
-        end
-      }.inject(&:+) + (name.size / 100.0)
-    end
-
-    def resolution_order(obj)
-      opts.present?(:'instance-methods') ? Pry::Method.instance_resolution_order(obj) : Pry::Method.resolution_order(obj)
-    end
-
-    # Get a lambda that can be used with .take_while to prevent over-eager
-    # traversal of the Object's ancestry graph.
-    def below_ceiling(obj)
-      ceiling = if opts.present?(:quiet)
-                   [opts.present?(:'instance-methods') ? obj.ancestors[1] : obj.class.ancestors[1]] + Pry.config.ls.ceiling
-                 elsif opts.present?(:verbose)
-                   []
-                 else
-                   Pry.config.ls.ceiling.dup
-                 end
-
-      lambda { |klass| !ceiling.include?(klass) }
-    end
-
-    def raise_errors_if_arguments_are_weird
+    def error_list
+      any_args = args.any?
+      non_mod_interrogatee = !(Module === @interrogatee)
       [
-        ["-l does not make sense with a specified Object", :locals,             !args.empty?],
-        ["-g does not make sense with a specified Object", :globals,            !args.empty?],
-        ["-q does not make sense with -v",                 :quiet,              opts.present?(:verbose)],
-        ["-M only makes sense with a Module or a Class",   :'instance-methods', !interrogating_a_module?],
-        ["-c only makes sense with a Module or a Class",   :constants,          !args.empty? && !interrogating_a_module?],
-      ].each do |message, option, expression|
-        raise Pry::CommandError, message if opts.present?(option) && expression
-      end
-    end
-
-    def interrogating_a_module?
-      (Module === object_to_interrogate)
-    end
-
-    def write_out_globals
-      return unless opts.present?(:globals)
-
-      output_section("global variables", grep[format_globals(target.eval("global_variables"))])
+        ['-l does not make sense with a specified Object', :locals, any_args],
+        ['-g does not make sense with a specified Object', :globals, any_args],
+        ['-q does not make sense with -v',                 :quiet, opts.present?(:verbose)],
+        ['-M only makes sense with a Module or a Class',   'instance-methods', non_mod_interrogatee],
+        ['-c only makes sense with a Module or a Class',   :constants, any_args && non_mod_interrogatee]
+      ]
     end
 
-    def write_out_constants
-      return unless opts.present?(:constants) || (!has_user_specified_any_options && interrogating_a_module?)
-
-      mod = interrogating_a_module? ? object_to_interrogate : Object
-      constants = WrappedModule.new(mod).constants(opts.present?(:verbose))
-      output_section("constants", grep[format_constants(mod, constants)])
-    end
-
-    def write_out_methods
-      return unless opts.present?(:methods) || opts.present?(:'instance-methods') || opts.present?(:ppp) || !has_user_specified_any_options
-
-      # methods is a hash {Module/Class => [Pry::Methods]}
-      methods = all_methods(object_to_interrogate).group_by(&:owner)
-
-      output = ""
-      # reverse the resolution order so that the most useful information appears right by the prompt
-      resolution_order(object_to_interrogate).take_while(&below_ceiling(object_to_interrogate)).reverse.each do |klass|
-        methods_here = format_methods((methods[klass] || []).select{ |m| m.name =~ grep_regex })
-        output << output_section("#{Pry::WrappedModule.new(klass).method_prefix}methods", methods_here)
-      end
-      output
-    end
-
-    def write_out_self_methods
-      return unless (!has_user_specified_any_options && interrogating_a_module?)
-
-      methods = all_methods(object_to_interrogate, true).select{ |m| m.owner == object_to_interrogate && m.name =~ grep_regex }
-      output_section("#{Pry::WrappedModule.new(object_to_interrogate).method_prefix}methods", format_methods(methods))
-    end
-
-    def write_out_ivars
-      return unless opts.present?(:ivars) || !has_user_specified_any_options
-
-      klass = (interrogating_a_module? ? object_to_interrogate : object_to_interrogate.class)
-      ivars = Pry::Method.safe_send(object_to_interrogate, :instance_variables)
-      kvars = Pry::Method.safe_send(klass, :class_variables)
-      output_section("instance variables", format_variables(:instance_var, ivars)) +
-      output_section("class variables", format_variables(:class_var, kvars))
-    end
-
-    def write_out_local_names
-      return unless !has_user_specified_any_options && args.empty?
-
-      output_section("locals", format_local_names(grep[target.eval("local_variables")]))
-    end
-
-    def write_out_locals
-      return unless opts.present?(:locals)
-
-      loc_names = target.eval('local_variables').reject do |e|
-        _pry_.sticky_locals.keys.include? e.to_sym
-      end
-      name_value_pairs = loc_names.map do |name|
-        [name, (target.eval name.to_s)]
-      end
-      format_locals(name_value_pairs).join("")
-    end
-
-    # Format and colourise a list of methods.
-    def format_methods(methods)
-      methods.sort_by(&:name).map do |method|
-        if method.name == 'method_missing'
-          color(:method_missing, 'method_missing')
-        elsif method.visibility == :private
-          color(:private_method, method.name)
-        elsif method.visibility == :protected
-          color(:protected_method, method.name)
-        else
-          color(:public_method, method.name)
-        end
-      end
-    end
-
-    def format_variables(type, vars)
-      vars.sort_by(&:downcase).map{ |var| color(type, var) }
-    end
-
-    def format_constants(mod, constants)
-      constants.sort_by(&:downcase).map do |name|
-        if const = (!mod.autoload?(name) && (mod.const_get(name) || true) rescue nil)
-          if (const < Exception rescue false)
-            color(:exception_constant, name)
-          elsif (Module === mod.const_get(name) rescue false)
-            color(:class_constant, name)
-          else
-            color(:constant, name)
-          end
-        else
-          color(:unloaded_constant, name)
-        end
-      end
-    end
-
-    def format_globals(globals)
-      globals.sort_by(&:downcase).map do |name|
-        if PSEUDO_GLOBALS.include?(name)
-          color(:pseudo_global, name)
-        elsif BUILTIN_GLOBALS.include?(name)
-          color(:builtin_global, name)
-        else
-          color(:global_var, name)
-        end
-      end
-    end
-
-    def format_local_names(locals)
-      locals.sort_by(&:downcase).map do |name|
-        if _pry_.sticky_locals.include?(name.to_sym)
-          color(:pry_var, name)
-        else
-          color(:local_var, name)
-        end
-      end
-    end
-
-    def format_locals(name_value_pairs)
-      name_value_pairs.sort_by do |name, value|
-        value.to_s.size
-      end.reverse.map do |name, value|
-        colorized_assignment_style(name, format_value(value))
+    def raise_errors_if_arguments_are_weird
+      error_list.each do |message, option, invalid_expr|
+        raise Pry::CommandError, message if opts.present?(option) && invalid_expr
       end
     end
 
-    def colorized_assignment_style(lhs, rhs, desired_width = 7)
-      colorized_lhs = color(:local_var, lhs)
-      color_escape_padding = colorized_lhs.size - lhs.size
-      pad = desired_width + color_escape_padding
-      "%-#{pad}s = %s" % [color(:local_var, colorized_lhs), rhs]
-    end
-
-    def format_value(value)
-      accumulator = StringIO.new
-      Pry.output_with_default_format(accumulator, value, :hashrocket => false)
-      accumulator.string
-    end
-
-    # Add a new section to the output. Outputs nothing if the section would be empty.
-    def output_section(heading, body)
-      return "" if body.compact.empty?
-      fancy_heading = text.bold(color(:heading, heading))
-      Pry::Helpers.tablify_or_one_line(fancy_heading, body)
-    end
-
-    # Color output based on config.ls.*_color
-    def color(type, str)
-      text.send(Pry.config.ls.send(:"#{type}_color"), str)
-    end
   end
 
   Pry::Commands.add_command(Pry::Command::Ls)