pry 0.9.10pre1-java → 0.9.11-java

data/lib/pry/commands/help.rb

@@ -0,0 +1,164 @@
+class Pry
+  class Command::Help < Pry::ClassCommand
+    match 'help'
+    group 'Help'
+    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.
+    BANNER
+
+    # We only want to show commands that have descriptions, so that the
+    # easter eggs don't show up.
+    def visible_commands
+      visible = {}
+      commands.each do |key, command|
+        visible[key] = command if command.description && !command.description.empty?
+      end
+      visible
+    end
+
+    # Get a hash of available commands grouped by the "group" name.
+    def command_groups
+      visible_commands.values.group_by(&:group)
+    end
+
+    def process
+      if args.empty?
+        display_index(command_groups)
+      else
+        display_search(args.first)
+      end
+    end
+
+    # Display the index view, with headings and short descriptions per command.
+    #
+    # @param Hash[String => Array[Commands]]
+    def display_index(groups)
+      help_text = []
+
+      sorted_group_names(groups).each do |group_name|
+        commands = sorted_commands(groups[group_name])
+
+        if commands.any?
+           help_text << help_text_for_commands(group_name, commands)
+        end
+      end
+
+      stagger_output(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
+    # @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}"
+      end.join("\n")
+    end
+
+    # @param [Hash] groups
+    # @return [Array<String>] An array of sorted group names.
+    def sorted_group_names(groups)
+      groups.keys.sort_by(&method(:group_sort_key))
+    end
+
+    # Sort an array of commands by their `listing` name.
+    #
+    # @param [Array<Pry::Command>] commands The commands to sort
+    # @return [Array<Pry::Command>] commands sorted by listing name.
+    def sorted_commands(commands)
+      commands.sort_by{ |command| command.options[:listing].to_s }
+    end
+
+    # Display help for an individual command or group.
+    #
+    # @param [String] search  The string to search for.
+    def display_search(search)
+      if command = command_set.find_command_for_help(search)
+        display_command(command)
+      else
+        display_filtered_search_results(search)
+      end
+    end
+
+    # Display help for a searched item, filtered first by group
+    # and if that fails, filtered by command name.
+    #
+    # @param [String] search The string to search for.
+    def display_filtered_search_results(search)
+      groups = search_hash(search, command_groups)
+
+      if groups.size > 0
+        display_index(groups)
+      else
+        display_filtered_commands(search)
+      end
+    end
+
+    # Display help for a searched item, filtered by group
+    #
+    # @param [String] search The string to search for.
+    def display_filtered_commands(search)
+      filtered = search_hash(search, visible_commands)
+      raise CommandError, "No help found for '#{args.first}'" if filtered.empty?
+
+      if filtered.size == 1
+        display_command(filtered.values.first)
+      else
+        display_index({"'#{search}' commands" => filtered.values})
+      end
+    end
+
+    # Display help for an individual command.
+    #
+    # @param [Pry::Command] command
+    def display_command(command)
+      stagger_output command.new.help
+    end
+
+    # Find a subset of a hash that matches the user's search term.
+    #
+    # If there's an exact match a Hash of one element will be returned,
+    # 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
+    def search_hash(search, hash)
+      matching = {}
+
+      hash.each_pair do |key, value|
+        next unless key.is_a?(String)
+        if normalize(key) == normalize(search)
+          return {key => value}
+        elsif normalize(key).start_with?(normalize(search))
+          matching[key] = value
+        end
+      end
+
+      matching
+    end
+
+    # Clean search terms to make it easier to search group names
+    #
+    # @param String
+    # @return String
+    def normalize(key)
+      key.downcase.gsub(/pry\W+/, '')
+    end
+
+    def group_sort_key(group_name)
+      [%w(Help Context Editing Introspection Input_and_output Navigating_pry Gems Basic Commands).index(group_name.gsub(' ', '_')) || 99, group_name]
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Help)
+end

data/lib/pry/commands/hist.rb

@@ -0,0 +1,161 @@
+class Pry
+  class Command::Hist < Pry::ClassCommand
+    match 'hist'
+    group 'Editing'
+    description 'Show and replay Readline history.'
+
+    banner <<-'BANNER'
+      Usage:   hist [--head|--tail]
+               hist --head N
+               hist --tail N
+               hist --show START..END
+               hist --grep PATTERN
+               hist --clear
+               hist --replay START..END
+               hist --save [START..END] FILE
+      Aliases: history
+
+      Show and replay Readline history.
+    BANNER
+
+    def options(opt)
+      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
+      opt.on :G, :grep,   "Show lines matching the given pattern", :argument => true, :as => String
+      opt.on :c, :clear , "Clear the current session's history"
+      opt.on :r, :replay, "Replay a line or range of lines", :argument => true, :as => Range
+      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)
+
+      if opts.present?(:show)
+        @history = @history.between(opts[:show])
+      end
+
+      if opts.present?(:grep)
+        @history = @history.grep(opts[:grep])
+      end
+
+      @history = case
+        when opts.present?(:head)
+          @history.take_lines(1, opts[:head] || 10)
+        when opts.present?(:tail)
+          @history.take_lines(-(opts[:tail] || 10), opts[:tail] || 10)
+        when opts.present?(:show)
+          @history.between(opts[:show])
+        else
+          @history
+        end
+
+      if opts.present?(:'exclude-pry')
+        @history = @history.select { |l, ln| !command_set.valid_command?(l) }
+      end
+
+      if opts.present?(:save)
+        process_save
+      elsif opts.present?(:clear)
+        process_clear
+      elsif opts.present?(:replay)
+        process_replay
+      else
+        process_display
+      end
+    end
+
+    private
+
+    def process_display
+      unless opts.present?(:'no-numbers')
+        @history = @history.with_line_numbers
+      end
+
+      render_output(@history, opts)
+    end
+
+    def process_save
+      case opts[:save]
+      when Range
+        @history = @history.between(opts[:save])
+
+        unless args.first
+          raise CommandError, "Must provide a file name."
+        end
+
+        file_name = File.expand_path(args.first)
+      when String
+        file_name = File.expand_path(opts[:save])
+      end
+
+      output.puts "Saving history in #{file_name}..."
+
+      File.open(file_name, 'w') { |f| f.write(@history.raw) }
+
+      output.puts "History saved."
+    end
+
+    def process_clear
+      Pry.history.clear
+      output.puts "History cleared."
+    end
+
+    def process_replay
+      @history = @history.between(opts[:r])
+      replay_sequence = @history.raw
+
+      # If we met follow-up "hist" call, check for the "--replay" option
+      # presence. If "hist" command is called with other options, proceed
+      # 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)
+    end
+
+    # Checks +replay_sequence+ for the presence of neighboring replay calls.
+    # @example
+    #   [1] pry(main)> hist --show 46894
+    #   46894: hist --replay 46675..46677
+    #   [2] pry(main)> hist --show 46675..46677
+    #   46675: 1+1
+    #   46676: a = 100
+    #   46677: hist --tail
+    #   [3] pry(main)> hist --replay 46894
+    #   Error: Replay index 46894 points out to another replay call: `hist -r 46675..46677`
+    #   [4] pry(main)>
+    #
+    # @raise [Pry::CommandError] If +replay_sequence+ contains another
+    #   "hist --replay" call
+    # @param [String] replay_sequence The sequence of commands to be replayed
+    #   (per saltum)
+    # @return [Boolean] `false` if +replay_sequence+ does not contain another
+    #   "hist --replay" call
+    def check_for_juxtaposed_replay(replay_sequence)
+      if replay_sequence =~ /\Ahist(?:ory)?\b/
+        # Create *fresh* instance of Options for parsing of "hist" command.
+        _slop = self.slop
+        _slop.parse replay_sequence.split(' ')[1..-1]
+
+        if _slop.present?(:r)
+          replay_sequence = replay_sequence.split("\n").join('; ')
+          index = opts[:r]
+          index = index.min if index.min == index.max || index.max.nil?
+
+          raise CommandError, "Replay index #{ index } points out to another replay call: `#{ replay_sequence }`"
+        end
+      else
+        false
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::Hist)
+  Pry::Commands.alias_command 'history', 'hist'
+end

data/lib/pry/commands/import_set.rb

@@ -0,0 +1,22 @@
+class Pry
+  class Command::ImportSet < Pry::ClassCommand
+    match 'import-set'
+    group 'Commands'
+    # TODO: Provide a better description with examples and a general conception
+    # of this command.
+    description 'Import a Pry command set.'
+
+    banner <<-'BANNER'
+      Import a Pry command set.
+    BANNER
+
+    def process(command_set_name)
+      raise CommandError, "Provide a command set name" if command_set.nil?
+
+      set = target.eval(arg_string)
+      _pry_.commands.import set
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::ImportSet)
+end

data/lib/pry/commands/install_command.rb

@@ -0,0 +1,51 @@
+class Pry
+  class Command::InstallCommand < Pry::ClassCommand
+    match 'install-command'
+    group 'Commands'
+    description 'Install a disabled command.'
+
+    banner <<-'BANNER'
+      Usage: install-command COMMAND
+
+      Installs the gems necessary to run the given COMMAND. You will generally not
+      need to run this unless told to by an error message.
+    BANNER
+
+    def process(name)
+      require 'rubygems/dependency_installer' unless defined? Gem::DependencyInstaller
+      command = find_command(name)
+
+      if command_dependencies_met?(command.options)
+        output.puts "Dependencies for #{command.name} are met. Nothing to do."
+        return
+      end
+
+      output.puts "Attempting to install `#{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
+      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."
+        end
+      end
+
+      output.puts "Installation of `#{name}` successful! Type `help #{name}` for information"
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::InstallCommand)
+end

data/lib/pry/commands/jump_to.rb

@@ -0,0 +1,29 @@
+class Pry
+  class Command::JumpTo < Pry::ClassCommand
+    match 'jump-to'
+    group 'Navigating Pry'
+    description 'Jump to a binding further up the stack.'
+
+    banner <<-'BANNER'
+      Jump to a binding further up the stack, popping all bindings below.
+    BANNER
+
+    def process(break_level)
+      break_level = break_level.to_i
+      nesting_level = _pry_.binding_stack.size - 1
+
+      case break_level
+      when nesting_level
+        output.puts "Already at nesting level #{nesting_level}"
+      when (0...nesting_level)
+        _pry_.binding_stack.slice!(break_level + 1, _pry_.binding_stack.size)
+
+      else
+        max_nest_level = nesting_level - 1
+        output.puts "Invalid nest level. Must be between 0 and #{max_nest_level}. Got #{break_level}."
+      end
+    end
+  end
+
+  Pry::Commands.add_command(Pry::Command::JumpTo)
+end

data/lib/pry/commands/ls.rb

@@ -0,0 +1,339 @@
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    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]
+
+        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.
+
+        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
+
+      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"
+      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 :i, :ivars,     "Show instance variables (in blue) and class variables (in bright blue)"
+      opt.on :G, :grep,      "Filter output by regular expression", :argument => true
+
+      if jruby?
+        opt.on :J, "all-java", "Show all the aliases for methods from java (default is to show only prettiest)"
+      end
+    end
+
+    attr_reader :object_to_interrogate, :has_user_specified_any_options, :grep, :grep_regex
+
+    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) }]
+
+      raise_errors_if_arguments_are_weird
+
+      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)
+    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
+      [
+        ["-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"))])
+    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 = mod.constants
+      constants -= (mod.ancestors - [mod]).map(&:constants).flatten unless 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))
+      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?
+      table = Pry::Helpers.tablify_to_screen_width(body)
+      "#{text.bold(color(:heading, heading))}: \n#{table}\n"
+    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)
+end