pry 0.9.11.4-java → 0.9.12-java

data/lib/pry/completion.rb

@@ -71,9 +71,18 @@ class Pry
         # get new target for 1/2 and find candidates for 3
         path, input = build_path(input)
 
-        unless path.call.empty?
-          target, _ = Pry::Helpers::BaseHelpers.context_from_object_path(path.call, pry)
-          target = target.last
+        # We silence warnings here or Ruby 1.8 cries about "multiple values for
+        # block 0 for 1".
+        Helpers::BaseHelpers.silence_warnings do
+          unless path.call.empty?
+            target = begin
+              ctx = Helpers::BaseHelpers.context_from_object_path(path.call, pry)
+              ctx.first
+            rescue Pry::CommandError
+              []
+            end
+            target = target.last
+          end
         end
 
         begin
@@ -283,7 +292,7 @@ class Pry
       contexts = input.chomp('/').split(/\//)
       input = contexts[-1]
 
-      path = proc do |input|
+      path = Proc.new do |input|
         p = contexts[0..-2].push(input).join('/')
         p += '/' if trailing_slash && !input.nil?
         p

data/lib/pry/helpers/base_helpers.rb

@@ -83,12 +83,15 @@ class Pry
         defined?(Win32::Console) || ENV['ANSICON']
       end
 
-      # are we on Jruby platform?
       def jruby?
         RbConfig::CONFIG['ruby_install_name'] == 'jruby'
       end
 
-      # are we on rbx platform?
+      def jruby_19?
+        RbConfig::CONFIG['ruby_install_name'] == 'jruby' &&
+          RbConfig::CONFIG['ruby_version'] == '1.9'
+      end
+
       def rbx?
         RbConfig::CONFIG['ruby_install_name'] == 'rbx'
       end

data/lib/pry/helpers/command_helpers.rb

@@ -84,7 +84,9 @@ class Pry
         text = text.sub(/^[ \t]+$/, '')
 
         # Find the longest common whitespace to all indented lines
-        margin = text.scan(/^[ \t]*(?=[^ \t\n])/).inject do |current_margin, next_indent|
+        # Ignore lines containing just -- or ++ as these seem to be used by
+        # comment authors as delimeters.
+        margin = text.scan(/^[ \t]*(?!--\n|\+\+\n)(?=[^ \t\n])/).inject do |current_margin, next_indent|
           if next_indent.start_with?(current_margin)
             current_margin
           elsif current_margin.start_with?(next_indent)

data/lib/pry/helpers/documentation_helpers.rb

@@ -4,14 +4,18 @@ class Pry
     # This class contains methods useful for extracting
     # documentation from methods and classes.
     module DocumentationHelpers
+
+      module_function
+
       def process_rdoc(comment)
+        return comment unless Pry.color
         comment = comment.dup
-        comment.gsub(/<code>(?:\s*\n)?(.*?)\s*<\/code>/m) { Pry.color ? CodeRay.scan($1, :ruby).term : $1 }.
-          gsub(/<em>(?:\s*\n)?(.*?)\s*<\/em>/m) { Pry.color ? "\e[1m#{$1}\e[0m": $1 }.
-          gsub(/<i>(?:\s*\n)?(.*?)\s*<\/i>/m) { Pry.color ? "\e[1m#{$1}\e[0m" : $1 }.
-          gsub(/\B\+(\w*?)\+\B/)  { Pry.color ? "\e[32m#{$1}\e[0m": $1 }.
-          gsub(/((?:^[ \t]+.+(?:\n+|\Z))+)/)  { Pry.color ? CodeRay.scan($1, :ruby).term : $1 }.
-          gsub(/`(?:\s*\n)?([^\e]*?)\s*`/) { "`#{Pry.color ? CodeRay.scan($1, :ruby).term : $1}`" }
+        comment.gsub(/<code>(?:\s*\n)?(.*?)\s*<\/code>/m) { CodeRay.scan($1, :ruby).term }.
+          gsub(/<em>(?:\s*\n)?(.*?)\s*<\/em>/m) { "\e[1m#{$1}\e[0m" }.
+          gsub(/<i>(?:\s*\n)?(.*?)\s*<\/i>/m) { "\e[1m#{$1}\e[0m" }.
+          gsub(/\B\+(\w+?)\+\B/)  { "\e[32m#{$1}\e[0m" }.
+          gsub(/((?:^[ \t]+.+(?:\n+|\Z))+)/)  { CodeRay.scan($1, :ruby).term }.
+          gsub(/`(?:\s*\n)?([^\e]*?)\s*`/) { "`#{CodeRay.scan($1, :ruby).term}`" }
       end
 
       def process_yardoc_tag(comment, tag)
@@ -46,10 +50,17 @@ class Pry
         code.sub(/\A\s*\/\*.*?\*\/\s*/m, '')
       end
 
+      # Given a string that makes up a comment in a source-code file parse out the content
+      # that the user is intended to read. (i.e. without leading indentation, #-characters
+      # or shebangs)
+      #
       # @param [String] comment
       # @return [String]
-      def strip_leading_hash_and_whitespace_from_ruby_comments(comment)
+      def get_comment_content(comment)
         comment = comment.dup
+        # Remove #!/usr/bin/ruby
+        comment.gsub!(/\A\#!.*$/, '')
+        # Remove leading empty comment lines
         comment.gsub!(/\A\#+?$/, '')
         comment.gsub!(/^\s*#/, '')
         strip_leading_whitespace(comment)

data/lib/pry/helpers/table.rb

@@ -3,7 +3,7 @@ class Pry
     def self.tablify_or_one_line(heading, things)
       plain_heading = Pry::Helpers::Text.strip_color(heading)
       attempt = Table.new(things, :column_count => things.size)
-      if attempt.fits_on_line?(TerminalInfo.width! - plain_heading.size - 2)
+      if attempt.fits_on_line?(Terminal.width! - plain_heading.size - 2)
         "#{heading}: #{attempt}\n"
       else
         "#{heading}: \n#{tablify_to_screen_width(things, :indent => '  ')}\n"
@@ -13,16 +13,16 @@ class Pry
     def self.tablify_to_screen_width(things, options = {})
       things = things.compact
       if indent = options[:indent]
-        usable_width = TerminalInfo.width! - indent.size
+        usable_width = Terminal.width! - indent.size
         tablify(things, usable_width).to_s.gsub(/^/, indent)
       else
-        tablify(things, TerminalInfo.width!).to_s
+        tablify(things, Terminal.width!).to_s
       end
     end
 
     def self.tablify(things, line_length)
       table = Table.new(things, :column_count => things.size)
-      table.column_count -= 1 until 0 == table.column_count or
+      table.column_count -= 1 until 1 == table.column_count or
         table.fits_on_line?(line_length)
       table
     end

data/lib/pry/indent.rb

@@ -1,12 +1,6 @@
 require 'coderay'
 
 class Pry
-  # Load io-console if possible, so that we can use $stdout.winsize.
-  begin
-    require 'io/console'
-  rescue LoadError
-  end
-
   ##
   # Pry::Indent is a class that can be used to indent a number of lines
   # containing Ruby code similar as to how IRB does it (but better). The class
@@ -389,10 +383,11 @@ class Pry
     #   the difference in length between the old line and the new one).
     # @return [String]
     def correct_indentation(prompt, code, overhang=0)
+      prompt = prompt.delete("\001\002")
       full_line = prompt + code
       whitespace = ' ' * overhang
 
-      _, cols = TerminalInfo.screen_size
+      _, cols = Terminal.screen_size
 
       cols = cols.to_i
       lines = cols != 0 ? (full_line.length / cols + 1) : 1

data/lib/pry/method.rb

@@ -17,9 +17,12 @@ class Pry
   # This class wraps the normal `Method` and `UnboundMethod` classes
   # to provide extra functionality useful to Pry.
   class Method
+    require 'pry/method/weird_method_locator'
+    require 'pry/method/disowned'
+
     extend Helpers::BaseHelpers
     include Helpers::BaseHelpers
-    include RbxMethod if Helpers::BaseHelpers.rbx?
+    include RbxMethod if rbx?
     include Helpers::DocumentationHelpers
     include CodeObject::Helpers
 
@@ -82,37 +85,11 @@ class Pry
                      Disowned.new(b.eval('self'), meth_name.to_s)
                    end
 
-          # it's possible in some cases that the method we find by this approach is a sub-method of
-          # the one we're currently in, consider:
-          #
-          # class A; def b; binding.pry; end; end
-          # class B < A; def b; super; end; end
-          #
-          # Given that we can normally find the source_range of methods, and that we know which
-          # __FILE__ and __LINE__ the binding is at, we can hope to disambiguate these cases.
-          #
-          # This obviously won't work if the source is unavaiable for some reason, or if both
-          # methods have the same __FILE__ and __LINE__, or if we're in rbx where b.eval('__LINE__')
-          # is broken.
-          #
-          guess = method
-
-          while guess
-            # needs rescue if this is a Disowned method or a C method or something...
-            # TODO: Fix up the exception handling so we don't need a bare rescue
-            if (guess.source_file && guess.source_range rescue false) &&
-                File.expand_path(guess.source_file) == File.expand_path(b.eval('__FILE__')) &&
-                guess.source_range.include?(b.eval('__LINE__'))
-              return guess
-            else
-              guess = guess.super
-            end
+          if WeirdMethodLocator.weird_method?(method, b)
+            WeirdMethodLocator.new(method, b).get_method || method
+          else
+            method
           end
-
-          # Uhoh... none of the methods in the chain had the right __FILE__ and __LINE__
-          # This may be caused by rbx https://github.com/rubinius/rubinius/issues/953,
-          # or other unknown circumstances (TODO: we should warn the user when this happens)
-          method
         end
       end
 
@@ -196,6 +173,19 @@ class Pry
         ([klass] + klass.ancestors).uniq
       end
 
+      def method_definition?(name, definition_line)
+        singleton_method_definition?(name, definition_line) ||
+          instance_method_definition?(name, definition_line)
+      end
+
+      def singleton_method_definition?(name, definition_line)
+        /^define_singleton_method\(?\s*[:\"\']#{name}|^def\s*self\.#{name}/ =~ definition_line.strip
+      end
+
+      def instance_method_definition?(name, definition_line)
+        /^define_method\(?\s*[:\"\']#{name}|^def\s*#{name}/ =~ definition_line.strip
+      end
+
       private
 
       # See all_from_class and all_from_obj.
@@ -310,12 +300,12 @@ class Pry
           info = pry_doc_info
           info.docstring if info
         when :ruby
-          if Helpers::BaseHelpers.rbx? && !pry_method?
-            strip_leading_hash_and_whitespace_from_ruby_comments(core_doc)
+          if rbx? && !pry_method?
+            get_comment_content(core_doc)
           elsif pry_method?
-            strip_leading_hash_and_whitespace_from_ruby_comments(doc_for_pry_method)
+            get_comment_content(doc_for_pry_method)
           else
-            strip_leading_hash_and_whitespace_from_ruby_comments(@method.comment)
+            get_comment_content(@method.comment)
           end
         end
     end
@@ -327,7 +317,7 @@ class Pry
     end
 
     def source_location
-      if @method.source_location && Helpers::BaseHelpers.rbx?
+      if @method.source_location && rbx?
         file, line = @method.source_location
         [RbxPath.convert_path_to_full(file), line]
       else
@@ -339,7 +329,7 @@ class Pry
     #   `nil` if the filename is unavailable.
     def source_file
       if source_location.nil?
-        if !Helpers::BaseHelpers.rbx? and source_type == :c
+        if !rbx? and source_type == :c
           info = pry_doc_info
           info.file if info
         end
@@ -423,6 +413,21 @@ class Pry
       !!(source_file and source_file =~ /(\(.*\))|<.*>/)
     end
 
+    # @return [Boolean] Whether the method is unbound.
+    def unbound_method?
+      is_a?(::UnboundMethod)
+    end
+
+    # @return [Boolean] Whether the method is bound.
+    def bound_method?
+      is_a?(::Method)
+    end
+
+    # @return [Boolean] Whether the method is a singleton method.
+    def singleton_method?
+      wrapped_owner.singleton_class?
+    end
+
     # @return [Boolean] Was the method defined within the Pry REPL?
     def pry_method?
       source_file == Pry.eval_path
@@ -479,113 +484,68 @@ class Pry
     end
 
     private
-      # @return [YARD::CodeObjects::MethodObject]
-      # @raise [CommandError] Raises when the method can't be found or `pry-doc` isn't installed.
-      def pry_doc_info
-        if Pry.config.has_pry_doc
-          Pry::MethodInfo.info_for(@method) or raise CommandError, "Cannot locate this method: #{name}. (source_location returns nil)"
-        else
-          raise CommandError, "Cannot locate this method: #{name}. Try `gem install pry-doc` to get access to Ruby Core documentation."
-        end
-      end
-
-      # FIXME: a very similar method to this exists on WrappedModule: extract_doc_for_candidate
-      def doc_for_pry_method
-        _, line_num = source_location
-
-        buffer = ""
-        Pry.line_buffer[0..(line_num - 1)].each do |line|
-          # Add any line that is a valid ruby comment,
-          # but clear as soon as we hit a non comment line.
-          if (line =~ /^\s*#/) || (line =~ /^\s*$/)
-            buffer << line.lstrip
-          else
-            buffer.replace("")
-          end
-        end
 
-        buffer
-      end
-
-      # @param [Class, Module] ancestors The ancestors to investigate
-      # @return [Method] The unwrapped super-method
-      def super_using_ancestors(ancestors, times=1)
-        next_owner = self.owner
-        times.times do
-          i = ancestors.index(next_owner) + 1
-          while ancestors[i] && !(ancestors[i].method_defined?(name) || ancestors[i].private_method_defined?(name))
-            i += 1
-          end
-          next_owner = ancestors[i] or return nil
+    # @return [YARD::CodeObjects::MethodObject]
+    # @raise [CommandError] when the method can't be found or `pry-doc` isn't installed.
+    def pry_doc_info
+      if Pry.config.has_pry_doc
+        Pry::MethodInfo.info_for(@method) or raise CommandError, "Cannot locate this method: #{name}. (source_location returns nil)"
+      else
+        fail_msg = "Cannot locate this method: #{name}."
+        if mri_18? || mri_19?
+          fail_msg += ' Try `gem-install pry-doc` to get access to Ruby Core documentation.'
         end
-
-        safe_send(next_owner, :instance_method, name) rescue nil
+        raise CommandError, fail_msg
       end
+    end
 
-      # @param [String] first_ln The first line of a method definition.
-      # @return [String, nil]
-      def method_name_from_first_line(first_ln)
-        return nil if first_ln.strip !~ /^def /
+    # FIXME: a very similar method to this exists on WrappedModule: extract_doc_for_candidate
+    def doc_for_pry_method
+      _, line_num = source_location
 
-        tokens = CodeRay.scan(first_ln, :ruby)
-        tokens = tokens.tokens.each_slice(2) if tokens.respond_to?(:tokens)
-        tokens.each_cons(2) do |t1, t2|
-          if t2.last == :method || t2.last == :ident && t1 == [".", :operator]
-            return t2.first
-          end
+      buffer = ""
+      Pry.line_buffer[0..(line_num - 1)].each do |line|
+        # Add any line that is a valid ruby comment,
+        # but clear as soon as we hit a non comment line.
+        if (line =~ /^\s*#/) || (line =~ /^\s*$/)
+          buffer << line.lstrip
+        else
+          buffer.replace("")
         end
-
-        nil
       end
 
-    # A Disowned Method is one that's been removed from the class on which it was defined.
-    #
-    # e.g.
-    # class C
-    #   def foo
-    #     C.send(:undefine_method, :foo)
-    #     Pry::Method.from_binding(binding)
-    #   end
-    # end
-    #
-    # In this case we assume that the "owner" is the singleton class of the receiver.
-    #
-    # This occurs mainly in Sinatra applications.
-    class Disowned < Method
-      attr_reader :receiver, :name
+      buffer
+    end
 
-      # Create a new Disowned method.
-      #
-      # @param [Object] receiver
-      # @param [String] method_name
-      def initialize(receiver, method_name)
-        @receiver, @name = receiver, method_name
+    # @param [Class, Module] ancestors The ancestors to investigate
+    # @return [Method] The unwrapped super-method
+    def super_using_ancestors(ancestors, times=1)
+      next_owner = self.owner
+      times.times do
+        i = ancestors.index(next_owner) + 1
+        while ancestors[i] && !(ancestors[i].method_defined?(name) || ancestors[i].private_method_defined?(name))
+          i += 1
+        end
+        next_owner = ancestors[i] or return nil
       end
 
-      # Is the method undefined? (aka `Disowned`)
-      # @return [Boolean] true
-      def undefined?
-        true
-      end
+      safe_send(next_owner, :instance_method, name) rescue nil
+    end
 
-      # Can we get the source for this method?
-      # @return [Boolean] false
-      def source?
-        false
-      end
+    # @param [String] first_ln The first line of a method definition.
+    # @return [String, nil]
+    def method_name_from_first_line(first_ln)
+      return nil if first_ln.strip !~ /^def /
 
-      # Get the hypothesized owner of the method.
-      #
-      # @return [Object]
-      def owner
-        class << receiver; self; end
+      tokens = CodeRay.scan(first_ln, :ruby)
+      tokens = tokens.tokens.each_slice(2) if tokens.respond_to?(:tokens)
+      tokens.each_cons(2) do |t1, t2|
+        if t2.last == :method || t2.last == :ident && t1 == [".", :operator]
+          return t2.first
+        end
       end
 
-      # Raise a more useful error message instead of trying to forward to nil.
-      def method_missing(meth_name, *args, &block)
-        raise "Cannot call '#{meth_name}' on an undef'd method." if method(:name).respond_to?(meth_name)
-        Object.instance_method(:method_missing).bind(self).call(meth_name, *args, &block)
-      end
+      nil
     end
   end
 end