pry 0.9.12.6-java → 0.10.0-java

data/lib/pry/commands/ls/constants.rb

@@ -0,0 +1,47 @@
+require 'pry/commands/ls/interrogatable'
+
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class Constants < Pry::Command::Ls::Formatter
+      include Pry::Command::Ls::Interrogatable
+
+
+      def initialize(interrogatee, no_user_opts, opts, _pry_)
+        super(_pry_)
+        @interrogatee = interrogatee
+        @no_user_opts = no_user_opts
+        @default_switch = opts[:constants]
+        @verbose_switch = opts[:verbose]
+      end
+
+      def correct_opts?
+        super || (@no_user_opts && interrogating_a_module?)
+      end
+
+      def output_self
+        mod = interrogatee_mod
+        constants = WrappedModule.new(mod).constants(@verbose_switch)
+        output_section('constants', grep.regexp[format(mod, constants)])
+      end
+
+      private
+
+      def format(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
+
+    end
+  end
+end

data/lib/pry/commands/ls/formatter.rb

@@ -0,0 +1,49 @@
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class Formatter
+      attr_accessor :grep
+      attr_reader :_pry_
+
+      def initialize(_pry_)
+        @_pry_ = _pry_
+        @target = _pry_.current_context
+      end
+
+      def write_out
+        return false unless correct_opts?
+        output_self
+      end
+
+      private
+
+      def color(type, str)
+        Pry::Helpers::Text.send _pry_.config.ls["#{type}_color"], str
+      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 = Pry::Helpers::Text.bold(color(:heading, heading))
+        Pry::Helpers.tablify_or_one_line(fancy_heading, body)
+      end
+
+      def format_value(value)
+        Pry::ColorPrinter.pp(value, '')
+      end
+
+      def correct_opts?
+        @default_switch
+      end
+
+      def output_self
+        raise NotImplementedError
+      end
+
+      def grep
+        @grep || proc { |x| x }
+      end
+
+    end
+  end
+end

data/lib/pry/commands/ls/globals.rb

@@ -0,0 +1,48 @@
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class Globals < Pry::Command::Ls::Formatter
+
+      # Taken from "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)
+
+      def initialize(opts, _pry_)
+        super(_pry_)
+        @default_switch = opts[:globals]
+      end
+
+      def output_self
+        variables = format(@target.eval('global_variables'))
+        output_section('global variables', grep.regexp[variables])
+      end
+
+      private
+
+      def format(globals)
+        globals.map(&:to_s).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
+
+    end
+  end
+end

data/lib/pry/commands/ls/grep.rb

@@ -0,0 +1,21 @@
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class Grep
+
+      def initialize(grep_regexp)
+        @grep_regexp = grep_regexp
+      end
+
+      def regexp
+        proc { |x|
+          if x.instance_of?(Array)
+            x.grep(@grep_regexp)
+          else
+            x =~ @grep_regexp
+          end
+        }
+      end
+
+    end
+  end
+end

data/lib/pry/commands/ls/instance_vars.rb

@@ -0,0 +1,39 @@
+require 'pry/commands/ls/interrogatable'
+
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class InstanceVars < Pry::Command::Ls::Formatter
+      include Pry::Command::Ls::Interrogatable
+
+      def initialize(interrogatee, no_user_opts, opts, _pry_)
+        super(_pry_)
+        @interrogatee = interrogatee
+        @no_user_opts = no_user_opts
+        @default_switch = opts[:ivars]
+      end
+
+      def correct_opts?
+        super || @no_user_opts
+      end
+
+      def output_self
+        ivars = if Object === @interrogatee
+                  Pry::Method.safe_send(@interrogatee, :instance_variables)
+                else
+                  [] #TODO: BasicObject support
+                end
+        kvars = Pry::Method.safe_send(interrogatee_mod, :class_variables)
+        ivars_out = output_section('instance variables', format(:instance_var, ivars))
+        kvars_out = output_section('class variables', format(:class_var, kvars))
+        ivars_out + kvars_out
+      end
+
+      private
+
+      def format(type, vars)
+        vars.sort_by { |var| var.to_s.downcase }.map { |var| color(type, var) }
+      end
+
+    end
+  end
+end

data/lib/pry/commands/ls/interrogatable.rb

@@ -0,0 +1,18 @@
+module Pry::Command::Ls::Interrogatable
+
+  private
+
+  def interrogating_a_module?
+    Module === @interrogatee
+  end
+
+  def interrogatee_mod
+    if interrogating_a_module?
+      @interrogatee
+    else
+      singleton = Pry::Method.singleton_class_of(@interrogatee)
+      singleton.ancestors.grep(::Class).reject { |c| c == singleton }.first
+    end
+  end
+
+end

data/lib/pry/commands/ls/jruby_hacks.rb

@@ -0,0 +1,49 @@
+module Pry::Command::Ls::JRubyHacks
+
+  private
+
+  # 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
+
+end

data/lib/pry/commands/ls/local_names.rb

@@ -0,0 +1,35 @@
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class LocalNames < Pry::Command::Ls::Formatter
+
+      def initialize(no_user_opts, args, _pry_)
+        super(_pry_)
+        @no_user_opts = no_user_opts
+        @args = args
+        @sticky_locals = _pry_.sticky_locals
+      end
+
+      def correct_opts?
+        super || (@no_user_opts && @args.empty?)
+      end
+
+      def output_self
+        local_vars = grep.regexp[@target.eval('local_variables')]
+        output_section('locals', format(local_vars))
+      end
+
+      private
+
+      def format(locals)
+        locals.sort_by(&:downcase).map do |name|
+          if @sticky_locals.include?(name.to_sym)
+            color(:pry_var, name)
+          else
+            color(:local_var, name)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/pry/commands/ls/local_vars.rb

@@ -0,0 +1,39 @@
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class LocalVars < Pry::Command::Ls::Formatter
+
+      def initialize(opts, _pry_)
+        super(_pry_)
+        @default_switch = opts[:locals]
+        @sticky_locals = _pry_.sticky_locals
+      end
+
+      def output_self
+        name_value_pairs = @target.eval('local_variables').reject { |e|
+          @sticky_locals.keys.include?(e.to_sym)
+        }.map { |name|
+          [name, (@target.eval(name.to_s))]
+        }
+        format(name_value_pairs).join('')
+      end
+
+      private
+
+      def format(name_value_pairs)
+        name_value_pairs.sort_by { |name, value|
+          value.to_s.size
+        }.reverse.map { |name, value|
+          colorized_assignment_style(name, format_value(value))
+        }
+      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
+
+    end
+  end
+end

data/lib/pry/commands/ls/ls_entity.rb

@@ -0,0 +1,70 @@
+require 'pry/commands/ls/grep'
+require 'pry/commands/ls/formatter'
+require 'pry/commands/ls/globals'
+require 'pry/commands/ls/constants'
+require 'pry/commands/ls/methods'
+require 'pry/commands/ls/self_methods'
+require 'pry/commands/ls/instance_vars'
+require 'pry/commands/ls/local_names'
+require 'pry/commands/ls/local_vars'
+
+class Pry
+  class Command::Ls < Pry::ClassCommand
+
+    class LsEntity
+      attr_reader :_pry_
+
+      def initialize(opts)
+        @interrogatee = opts[:interrogatee]
+        @no_user_opts = opts[:no_user_opts]
+        @opts = opts[:opts]
+        @args = opts[:args]
+        @grep = Grep.new(Regexp.new(opts[:opts][:G] || '.'))
+        @_pry_ = opts.delete(:_pry_)
+      end
+
+      def entities_table
+        entities.map(&:write_out).reject { |o| !o }.join('')
+      end
+
+      private
+
+      def grep(entity)
+        entity.tap { |o| o.grep = @grep }
+      end
+
+      def globals
+        grep Globals.new(@opts, _pry_)
+      end
+
+      def constants
+        grep Constants.new(@interrogatee, @no_user_opts, @opts, _pry_)
+      end
+
+      def methods
+        grep(Methods.new(@interrogatee, @no_user_opts, @opts, _pry_))
+      end
+
+      def self_methods
+        grep SelfMethods.new(@interrogatee, @no_user_opts, @opts, _pry_)
+      end
+
+      def instance_vars
+        grep InstanceVars.new(@interrogatee, @no_user_opts, @opts, _pry_)
+      end
+
+      def local_names
+        grep LocalNames.new(@no_user_opts, @args, _pry_)
+      end
+
+      def local_vars
+        LocalVars.new(@opts, _pry_)
+      end
+
+      def entities
+        [globals, constants, methods, self_methods, instance_vars, local_names,
+          local_vars]
+      end
+    end
+  end
+end

data/lib/pry/commands/ls/methods.rb

@@ -0,0 +1,57 @@
+require 'pry/commands/ls/methods_helper'
+require 'pry/commands/ls/interrogatable'
+
+class Pry
+  class Command::Ls < Pry::ClassCommand
+    class Methods < Pry::Command::Ls::Formatter
+
+      include Pry::Command::Ls::Interrogatable
+      include Pry::Command::Ls::MethodsHelper
+
+      def initialize(interrogatee, no_user_opts, opts, _pry_)
+        super(_pry_)
+        @interrogatee = interrogatee
+        @no_user_opts = no_user_opts
+        @default_switch = opts[:methods]
+        @instance_methods_switch = opts['instance-methods']
+        @ppp_switch = opts[:ppp]
+        @jruby_switch = opts['all-java']
+        @quiet_switch = opts[:quiet]
+        @verbose_switch = opts[:verbose]
+      end
+
+      def output_self
+        methods = all_methods.group_by(&:owner)
+        # Reverse the resolution order so that the most useful information
+        # appears right by the prompt.
+        resolution_order.take_while(&below_ceiling).reverse.map do |klass|
+          methods_here = (methods[klass] || []).select { |m| grep.regexp[m.name] }
+          heading = "#{ Pry::WrappedModule.new(klass).method_prefix }methods"
+          output_section(heading, format(methods_here))
+        end.join('')
+      end
+
+      private
+
+      def correct_opts?
+        super || @instance_methods_switch || @ppp_switch || @no_user_opts
+      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
+        ceiling = if @quiet_switch
+                    [Pry::Method.safe_send(interrogatee_mod, :ancestors)[1]] +
+                      _pry_.config.ls.ceiling
+                  elsif @verbose_switch
+                    []
+                  else
+                    _pry_.config.ls.ceiling.dup
+                  end
+        lambda { |klass| !ceiling.include?(klass) }
+      end
+
+    end
+  end
+end