pry 0.9.8.4 → 0.9.9

data/lib/pry/default_commands/hist.rb

@@ -32,21 +32,25 @@ class Pry
         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.between(1, opts[:head] || 10)
+              @history.take_lines(1, opts[:head] || 10)
             when opts.present?(:tail)
-              @history.between(-(opts[:tail] || 10), -1)
+              @history.take_lines(-(opts[:tail] || 10), opts[:tail] || 10)
             when opts.present?(:show)
               @history.between(opts[:show])
             else
               @history
             end
 
-          if opts.present?(:grep)
-            @history = @history.grep(opts[:grep])
-          end
-
           if opts.present?(:'exclude-pry')
             @history = @history.select { |l, ln| !command_set.valid_command?(l) }
           end

data/lib/pry/default_commands/introspection.rb

@@ -3,23 +3,127 @@ require 'tempfile'
 class Pry
   module DefaultCommands
 
+    # For show-doc and show-source
+    module ModuleIntrospectionHelpers
+      attr_accessor :module_object
+
+      def module?(name)
+        self.module_object = Pry::WrappedModule.from_str(name, target)
+      end
+
+      def method?
+        !!method_object
+      rescue CommandError
+        false
+      end
+
+      def process(name)
+        if module?(name)
+          code_or_doc = process_module
+        else method?
+          code_or_doc = process_method
+        end
+
+        render_output(code_or_doc, opts)
+      end
+
+      def module_start_line(mod, candidate=0)
+        if opts.present?(:'base-one')
+          1
+        else
+          mod.source_line_for_candidate(candidate)
+        end
+      end
+
+      def use_line_numbers?
+        opts.present?(:b) || opts.present?(:l)
+      end
+    end
+
     Introspection = Pry::CommandSet.new do
 
-      create_command "show-doc", "Show the comments above METH. Aliases: \?", :shellwords => false do |*args|
+      create_command "show-doc", "Show the comments above METH. Aliases: \?", :shellwords => false do
+        include ModuleIntrospectionHelpers
+        include Helpers::DocumentationHelpers
+        extend Helpers::BaseHelpers
+
         banner <<-BANNER
           Usage: show-doc [OPTIONS] [METH]
+          Aliases: ?
+
           Show the comments above method METH. Tries instance methods first and then methods by default.
-          e.g show-doc hello_method
+          e.g show-doc hello_method    # docs for hello_method
+          e.g show-doc Pry             # docs for Pry class
+          e.g show-doc Pry -a          # docs for all definitions of Pry class (all monkey patches)
         BANNER
 
+        options :requires_gem => "ruby18_source_location" if mri_18?
+
+        def setup
+          require 'ruby18_source_location' if mri_18?
+        end
+
         def options(opt)
           method_options(opt)
           opt.on :l, "line-numbers", "Show line numbers."
           opt.on :b, "base-one", "Show line numbers but start numbering at 1 (useful for `amend-line` and `play` commands)."
           opt.on :f, :flood, "Do not use a pager to view text longer than one screen."
+          opt.on :a, :all, "Show docs for all definitions and monkeypatches of the module (modules only)"
         end
 
-        def process
+        def process_module
+          if opts.present?(:all)
+            all_modules
+          else
+            normal_module
+          end
+        end
+
+        def normal_module
+          mod = module_object
+
+          # source_file reveals the underlying .c file in case of core
+          # classes on MRI. This is different to source_location, which
+          # will return nil.
+          if mod.yard_docs?
+            file_name, line = mod.source_file, nil
+          else
+            file_name, line = mod.source_location
+          end
+
+          if mod.doc.empty?
+            output.puts "No documentation found."
+            ""
+          else
+            set_file_and_dir_locals(file_name) if !mod.yard_docs?
+            doc = ""
+            doc << mod.doc
+
+            doc = Code.new(doc, module_start_line(mod), :text).
+              with_line_numbers(use_line_numbers?).to_s
+
+            doc.insert(0, "\n#{Pry::Helpers::Text.bold('From:')} #{file_name} @ line #{line ? line : "N/A"}:\n\n")
+          end
+        end
+
+        def all_modules
+          mod = module_object
+
+          doc = ""
+          doc << "Found #{mod.number_of_candidates} candidates for `#{mod.name}` definition:\n"
+          mod.number_of_candidates.times do |v|
+            begin
+              doc << "\nCandidate #{v+1}/#{mod.number_of_candidates}: #{mod.source_file_for_candidate(v)} @ #{mod.source_line_for_candidate(v)}:\n\n"
+              dc = mod.doc_for_candidate(v)
+              doc << (dc.empty? ? "No documentation found.\n" : dc)
+            rescue Pry::RescuableException
+              next
+            end
+          end
+          doc
+        end
+
+        def process_method
           meth = method_object
           raise Pry::CommandError, "No documentation found." if meth.doc.nil? || meth.doc.empty?
 
@@ -30,12 +134,20 @@ class Pry
           output.puts "#{text.bold("Signature:")} #{meth.signature}"
           output.puts
 
-          if opts.present?(:b) || opts.present?(:l)
+          if use_line_numbers?
             doc = Code.new(doc, start_line, :text).
-              with_line_numbers(true)
+              with_line_numbers(true).to_s
           end
 
-          render_output(doc, opts)
+          doc
+        end
+
+        def module_start_line(mod, candidate=0)
+          if opts.present?(:'base-one')
+            1
+          else
+            mod.source_line_for_candidate(candidate) - mod.doc_for_candidate(candidate).lines.count
+          end
         end
 
         def start_line
@@ -45,12 +157,11 @@ class Pry
             (method_object.source_line - method_object.doc.lines.count) || 1
           end
         end
-
       end
 
       alias_command "?", "show-doc"
 
-      create_command "stat", "View method information and set _file_ and _dir_ locals.", :shellwords => false do |*args|
+      create_command "stat", "View method information and set _file_ and _dir_ locals.", :shellwords => false do
         banner <<-BANNER
             Usage: stat [OPTIONS] [METH]
             Show method information for method METH and set _file_ and _dir_ locals.
@@ -77,45 +188,87 @@ class Pry
         end
       end
 
-      create_command "show-method" do
-        description "Show the source for METH. Aliases: $, show-source"
+      create_command "show-source" do
+        include ModuleIntrospectionHelpers
+        extend Helpers::BaseHelpers
+
+        description "Show the source for METH or CLASS. Aliases: $, show-method"
 
         banner <<-BANNER
-          Usage: show-method [OPTIONS] [METH]
-          Aliases: $, show-source
+          Usage: show-source [OPTIONS] [METH|CLASS]
+          Aliases: $, show-method
 
-          Show the source for method METH. Tries instance methods first and then methods by default.
+          Show the source for method METH or CLASS. Tries instance methods first and then methods by default.
 
-          e.g: `show-method hello_method`
-          e.g: `show-method -m hello_method`
-          e.g: `show-method Pry#rep`
+          e.g: `show-source hello_method`
+          e.g: `show-source -m hello_method`
+          e.g: `show-source Pry#rep`         # source for Pry#rep method
+          e.g: `show-source Pry`             # source for Pry class
+          e.g: `show-source Pry -a`          # source for all Pry class definitions (all monkey patches)
 
           https://github.com/pry/pry/wiki/Source-browsing#wiki-Show_method
         BANNER
 
-        command_options(
-          :shellwords => false
-        )
+        options :shellwords => false
+        options :requires_gem => "ruby18_source_location" if mri_18?
+
+        def setup
+          require 'ruby18_source_location' if mri_18?
+        end
 
         def options(opt)
           method_options(opt)
           opt.on :l, "line-numbers", "Show line numbers."
           opt.on :b, "base-one", "Show line numbers but start numbering at 1 (useful for `amend-line` and `play` commands)."
           opt.on :f, :flood, "Do not use a pager to view text longer than one screen."
+          opt.on :a, :all, "Show source for all definitions and monkeypatches of the module (modules only)"
         end
 
-        def process
+        def process_method
           raise CommandError, "Could not find method source" unless method_object.source
 
-          output.puts make_header(method_object)
-          output.puts "#{text.bold("Owner:")} #{method_object.owner || "N/A"}"
-          output.puts "#{text.bold("Visibility:")} #{method_object.visibility}"
-          output.puts
+          code = ""
+          code << make_header(method_object)
+          code << "#{text.bold("Owner:")} #{method_object.owner || "N/A"}\n"
+          code << "#{text.bold("Visibility:")} #{method_object.visibility}\n"
+          code << "\n"
 
-          code = Code.from_method(method_object, start_line).
-                   with_line_numbers(use_line_numbers?)
+          code << Code.from_method(method_object, start_line).
+                   with_line_numbers(use_line_numbers?).to_s
+        end
 
-          render_output(code, opts)
+        def process_module
+          if opts.present?(:all)
+            all_modules
+          else
+            normal_module
+          end
+        end
+
+        def normal_module
+          mod = module_object
+
+          file_name, line = mod.source_location
+          set_file_and_dir_locals(file_name)
+          code = ""
+          code << "\n#{Pry::Helpers::Text.bold('From:')} #{file_name} @ line #{line}:\n\n"
+          code << Code.from_module(mod, module_start_line(mod)).with_line_numbers(use_line_numbers?).to_s
+        end
+
+        def all_modules
+          mod = module_object
+
+          code = ""
+          code << "Found #{mod.number_of_candidates} candidates for `#{mod.name}` definition:\n"
+          mod.number_of_candidates.times do |v|
+            begin
+              code << "\nCandidate #{v+1}/#{mod.number_of_candidates}: #{mod.source_file_for_candidate(v)} @ line #{mod.source_line_for_candidate(v)}:\n\n"
+              code << Code.new(mod.source_for_candidate(v), module_start_line(mod, v)).with_line_numbers(use_line_numbers?).to_s
+            rescue Pry::RescuableException
+              next
+            end
+          end
+          code
         end
 
         def use_line_numbers?
@@ -131,8 +284,8 @@ class Pry
         end
       end
 
-      alias_command "show-source", "show-method"
-      alias_command "$", "show-method"
+      alias_command "show-method", "show-source"
+      alias_command "$", "show-source"
 
       command "show-command", "Show the source for CMD." do |*args|
         target = target()
@@ -167,7 +320,7 @@ class Pry
           output.puts make_header(block)
           output.puts
 
-          code = Code.from_method(block).with_line_numbers(opts.present?(:'line-numbers'))
+          code = Code.from_method(block).with_line_numbers(opts.present?(:'line-numbers')).to_s
 
           render_output(code, opts)
         else

data/lib/pry/default_commands/ls.rb

@@ -30,11 +30,15 @@ class Pry
           opt.on :g, "globals", "Show global variables, including those builtin to Ruby (in cyan)"
           opt.on :l, "locals", "Show locals, including those provided by Pry (in red)"
 
-          opt.on :c, "constants", "Show constants, highlighting classes (in blue), and exceptions (in purple)"
+          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", :optional => false
+          if jruby?
+            opt.on :J, "all-java", "Show all the aliases for methods from java (default is to show only prettiest)"
+          end
         end
 
         def process
@@ -46,6 +50,7 @@ class Pry
                       opts.present?(:ivars))
 
           show_methods   = opts.present?(:methods) || opts.present?(:'instance-methods') || opts.present?(:ppp) || !has_opts
+          show_self_methods = (!has_opts && Module === obj)
           show_constants = opts.present?(:constants) || (!has_opts && Module === obj)
           show_ivars     = opts.present?(:ivars) || !has_opts
           show_locals    = opts.present?(:locals) || (!has_opts && args.empty?)
@@ -72,7 +77,7 @@ class Pry
 
           if show_methods
             # methods is a hash {Module/Class => [Pry::Methods]}
-            methods = all_methods(obj).select{ |method| opts.present?(:ppp) || method.visibility == :public }.group_by(&:owner)
+            methods = all_methods(obj).group_by(&:owner)
 
             # reverse the resolution order so that the most useful information appears right by the prompt
             resolution_order(obj).take_while(&below_ceiling(obj)).reverse.each do |klass|
@@ -81,10 +86,17 @@ class Pry
             end
           end
 
+          if show_self_methods
+            methods = all_methods(obj, true).select{ |m| m.owner == obj && m.name =~ grep_regex }
+            output_section "#{Pry::WrappedModule.new(obj).method_prefix}methods", format_methods(methods)
+          end
+
           if show_ivars
             klass = (Module === obj ? obj : obj.class)
-            output_section("instance variables", format_variables(:instance_var, grep[obj.__send__(:instance_variables)]))
-            output_section("class variables", format_variables(:class_var, grep[klass.__send__(:class_variables)]))
+            ivars = Pry::Method.safe_send(obj, :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
 
           if show_locals
@@ -109,8 +121,64 @@ class Pry
                            $LAST_PAREN_MATCH $LAST_READ_LINE $MATCH $POSTMATCH $PREMATCH)
 
         # Get all the methods that we'll want to output
-        def all_methods(obj)
-          opts.present?(:'instance-methods') ? Pry::Method.all_from_class(obj) : Pry::Method.all_from_obj(obj)
+        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)
@@ -152,7 +220,7 @@ class Pry
 
         def format_constants(mod, constants)
           constants.sort_by(&:downcase).map do |name|
-            if const = (!mod.autoload?(name) && mod.const_get(name) rescue nil)
+            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)
@@ -160,6 +228,8 @@ class Pry
               else
                 color(:constant, name)
               end
+            else
+              color(:unloaded_constant, name)
             end
           end
         end