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

data/lib/pry/inspector.rb

@@ -0,0 +1,27 @@
+class Pry::Inspector
+  MAP = {
+    "default" => {
+      value: Pry::DEFAULT_PRINT,
+      description: <<-DESCRIPTION.each_line.map(&:lstrip!)
+        The default Pry inspector. It has paging and color support, and uses
+        pretty_inspect when printing an object.
+      DESCRIPTION
+    },
+
+    "simple" => {
+      value: Pry::SIMPLE_PRINT,
+      description: <<-DESCRIPTION.each_line.map(&:lstrip)
+        A simple inspector that uses #puts and #inspect when printing an
+        object. It has no pager, color, or pretty_inspect support.
+      DESCRIPTION
+    },
+
+    "clipped" => {
+      value: Pry::CLIPPED_PRINT,
+      description: <<-DESCRIPTION.each_line.map(&:lstrip)
+        The clipped inspector has the same features as the 'simple' inspector
+        but prints large objects as a smaller string.
+      DESCRIPTION
+    }
+  }
+end

data/lib/pry/last_exception.rb

@@ -0,0 +1,61 @@
+#
+# {Pry::LastException} is a proxy class who wraps an Exception object for
+# {Pry#last_exception}. it extends the exception object with methods that
+# help pry commands be useful.
+#
+# the original exception object is not modified and method calls are forwarded
+# to the wrapped exception object.
+#
+class Pry::LastException < BasicObject
+  attr_accessor :bt_index
+
+  def initialize(e)
+    @e = e
+    @bt_index = 0
+    @file, @line = bt_source_location_for(0)
+  end
+
+  def method_missing(name, *args, &block)
+    if @e.respond_to?(name)
+      @e.public_send(name, *args, &block)
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(name, include_private = false)
+    @e.respond_to?(name)
+  end
+
+  #
+  # @return [String]
+  #  returns the path to a file for the current backtrace. see {#bt_index}.
+  #
+  def file
+    @file
+  end
+
+  #
+  # @return [Fixnum]
+  #  returns the line for the current backtrace. see {#bt_index}.
+  #
+  def line
+    @line
+  end
+
+  # @return [Exception]
+  #   returns the wrapped exception
+  #
+  def wrapped_exception
+    @e
+  end
+
+  def bt_source_location_for(index)
+    backtrace[index] =~ /(.*):(\d+)/
+    [$1, $2.to_i]
+  end
+
+  def inc_bt_index
+    @bt_index = (@bt_index + 1) % backtrace.size
+  end
+end

data/lib/pry/method.rb

@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 require 'pry/helpers/documentation_helpers'
 
 class Pry
@@ -19,10 +18,10 @@ class Pry
   class Method
     require 'pry/method/weird_method_locator'
     require 'pry/method/disowned'
+    require 'pry/method/patcher'
 
     extend Helpers::BaseHelpers
     include Helpers::BaseHelpers
-    include RbxMethod if rbx?
     include Helpers::DocumentationHelpers
     include CodeObject::Helpers
 
@@ -31,8 +30,7 @@ class Pry
       # search in, find and return the requested method wrapped in a `Pry::Method`
       # instance.
       #
-      # @param [String, nil] name The name of the method to retrieve, or `nil` to
-      #   delegate to `from_binding` instead.
+      # @param [String] name The name of the method to retrieve.
       # @param [Binding] target The context in which to search for the method.
       # @param [Hash] options
       # @option options [Boolean] :instance Look for an instance method if `name` doesn't
@@ -40,13 +38,16 @@ class Pry
       # @option options [Boolean] :methods Look for a bound/singleton method if `name` doesn't
       #   contain any context.
       # @return [Pry::Method, nil] A `Pry::Method` instance containing the requested
-      #   method, or `nil` if no method could be located matching the parameters.
+      #   method, or `nil` if name is `nil` or no method could be located matching the parameters.
       def from_str(name, target=TOPLEVEL_BINDING, options={})
         if name.nil?
-          from_binding(target)
+          nil
         elsif name.to_s =~ /(.+)\#(\S+)\Z/
           context, meth_name = $1, $2
           from_module(target.eval(context), meth_name, target)
+        elsif name.to_s =~ /(.+)(\[\])\Z/
+          context, meth_name = $1, $2
+          from_obj(target.eval(context), meth_name, target)
         elsif name.to_s =~ /(.+)(\.|::)(\S+)\Z/
           context, meth_name = $1, $3
           from_obj(target.eval(context), meth_name, target)
@@ -139,15 +140,34 @@ class Pry
       # @param [Boolean] include_super Whether to include methods from ancestors.
       # @return [Array[Pry::Method]]
       def all_from_class(klass, include_super=true)
-        all_from_common(klass, :instance_method, include_super)
+        %w(public protected private).map do |visibility|
+          safe_send(klass, :"#{visibility}_instance_methods", include_super).map do |method_name|
+            new(safe_send(klass, :instance_method, method_name), :visibility => visibility.to_sym)
+          end
+        end.flatten(1)
       end
 
+      #
       # Get all of the methods on an `Object`
+      #
       # @param [Object] obj
-      # @param [Boolean] include_super Whether to include methods from ancestors.
+      #
+      # @param [Boolean] include_super
+      #   indicates whether or not to include methods from ancestors.
+      #
       # @return [Array[Pry::Method]]
+      #
       def all_from_obj(obj, include_super=true)
-        all_from_common(obj, :method, include_super)
+        all_from_class(singleton_class_of(obj), include_super)
+      end
+
+      #
+      # @deprecated
+      #  please use {#all_from_obj} instead.
+      #  the `method_type` argument is ignored.
+      #
+      def all_from_common(obj, method_type = nil, include_super=true)
+        all_from_obj(obj, include_super)
       end
 
       # Get every `Class` and `Module`, in order, that will be checked when looking
@@ -158,7 +178,7 @@ class Pry
         if Class === obj
           singleton_class_resolution_order(obj) + instance_resolution_order(Class)
         else
-          klass = singleton_class(obj) rescue obj.class
+          klass = singleton_class_of(obj) rescue obj.class
           instance_resolution_order(klass)
         end
       end
@@ -170,7 +190,7 @@ class Pry
       # @return [Array[Class, Module]]
       def instance_resolution_order(klass)
         # include klass in case it is a singleton class,
-        ([klass] + klass.ancestors).uniq
+        ([klass] + Pry::Method.safe_send(klass, :ancestors)).uniq
       end
 
       def method_definition?(name, definition_line)
@@ -179,26 +199,11 @@ class Pry
       end
 
       def singleton_method_definition?(name, definition_line)
-        /^define_singleton_method\(?\s*[:\"\']#{name}|^def\s*self\.#{name}/ =~ definition_line.strip
+        /^define_singleton_method\(?\s*[:\"\']#{Regexp.escape(name)}|^def\s*self\.#{Regexp.escape(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.
-      # If method_type is :instance_method, obj must be a `Class` or a `Module`
-      # If method_type is :method, obj can be any `Object`
-      #
-      # N.B. we pre-cache the visibility here to avoid O(N²) behaviour in "ls".
-      def all_from_common(obj, method_type, include_super=true)
-        %w(public protected private).map do |visibility|
-          safe_send(obj, :"#{visibility}_#{method_type}s", include_super).map do |method_name|
-            new(safe_send(obj, method_type, method_name), :visibility => visibility.to_sym)
-          end
-        end.flatten(1)
+        /^define_method\(?\s*[:\"\']#{Regexp.escape(name)}|^def\s*#{Regexp.escape(name)}/ =~ definition_line.strip
       end
 
       # Get the singleton classes of superclasses that could define methods on
@@ -206,14 +211,21 @@ class Pry
       # If a module is included at multiple points in the ancestry, only
       # the lowest copy will be returned.
       def singleton_class_resolution_order(klass)
-        resolution_order = klass.ancestors.map do |anc|
-          [singleton_class(anc)] + singleton_class(anc).included_modules if anc.is_a?(Class)
-        end.compact.flatten(1)
+        ancestors = Pry::Method.safe_send(klass, :ancestors)
+        resolution_order = ancestors.grep(Class).map do |anc|
+          [singleton_class_of(anc), *singleton_class_of(anc).included_modules]
+        end.flatten(1)
 
         resolution_order.reverse.uniq.reverse - Class.included_modules
       end
 
-      def singleton_class(obj); class << obj; self; end end
+      def singleton_class_of(obj)
+        begin
+          class << obj; self; end
+        rescue TypeError # can't define singleton. Fixnum, Symbol, Float, ...
+          obj.class
+        end
+      end
     end
 
     # A new instance of `Pry::Method` wrapping the given `::Method`, `UnboundMethod`, or `Proc`.
@@ -263,26 +275,18 @@ class Pry
     def source
       @source ||= case source_type
                   when :c
-                    info = pry_doc_info
-                    if info and info.source
-                      code = strip_comments_from_c_code(info.source)
-                    end
+                    c_source
                   when :ruby
-                    # clone of MethodSource.source_helper that knows to use our
-                    # hacked version of source_location for rbx core methods, and
-                    # our input buffer for methods defined in (pry)
-                    file, line = *source_location
-                    raise SourceNotFoundError, "Could not locate source for #{name_with_owner}!" unless file
-
-                    begin
-                      code = Pry::Code.from_file(file).expression_at(line)
-                    rescue SyntaxError => e
-                      raise MethodSource::SourceNotFoundError.new(e.message)
-                    end
-                    strip_leading_whitespace(code)
+                    ruby_source
                   end
     end
 
+    # Update the live copy of the method's source.
+    def redefine(source)
+      Patcher.new(self).patch_in_ram source
+      Pry::Method(owner.instance_method(name))
+    end
+
     # Can we get the source code for this method?
     # @return [Boolean]
     def source?
@@ -293,20 +297,13 @@ class Pry
 
     # @return [String, nil] The documentation for the method, or `nil` if it's
     #   unavailable.
-    # @raise [CommandError] Raises when the method was defined in the REPL.
     def doc
       @doc ||= case source_type
         when :c
           info = pry_doc_info
           info.docstring if info
         when :ruby
-          if rbx? && !pry_method?
-            get_comment_content(core_doc)
-          elsif pry_method?
-            get_comment_content(doc_for_pry_method)
-          else
-            get_comment_content(@method.comment)
-          end
+          get_comment_content(comment)
         end
     end
 
@@ -316,15 +313,6 @@ class Pry
       source_location.nil? ? :c : :ruby
     end
 
-    def source_location
-      if @method.source_location && rbx?
-        file, line = @method.source_location
-        [RbxPath.convert_path_to_full(file), line]
-      else
-        @method.source_location
-      end
-    end
-
     # @return [String, nil] The name of the file the method is defined in, or
     #   `nil` if the filename is unavailable.
     def source_file
@@ -434,15 +422,14 @@ class Pry
     end
 
     # @return [Array<String>] All known aliases for the method.
-    # @note On Ruby 1.8 this method always returns an empty Array for methods
-    #   implemented in C.
     def aliases
       owner = @method.owner
       # Avoid using `to_sym` on {Method#name}, which returns a `String`, because
       # it won't be garbage collected.
       name = @method.name
 
-      alias_list = owner.instance_methods.combination(2).select do |pair|
+      all_methods_to_compare = owner.instance_methods | owner.private_instance_methods
+      alias_list = all_methods_to_compare.combination(2).select do |pair|
         pair.include?(name) &&
           owner.instance_method(pair.first) == owner.instance_method(pair.last)
       end.flatten
@@ -483,6 +470,10 @@ class Pry
       @method.send(method_name, *args, &block)
     end
 
+    def comment
+      Pry::Code.from_file(source_file).comment_describing(source_line)
+    end
+
     private
 
     # @return [YARD::CodeObjects::MethodObject]
@@ -492,31 +483,13 @@ class Pry
         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?
+        if mri?
           fail_msg += ' Try `gem-install pry-doc` to get access to Ruby Core documentation.'
         end
         raise CommandError, fail_msg
       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)
@@ -547,5 +520,27 @@ class Pry
 
       nil
     end
+
+    def c_source
+      info = pry_doc_info
+      if info and info.source
+        strip_comments_from_c_code(info.source)
+      end
+    end
+
+    def ruby_source
+      # clone of MethodSource.source_helper that knows to use our
+      # hacked version of source_location for rbx core methods, and
+      # our input buffer for methods defined in (pry)
+      file, line = *source_location
+      raise SourceNotFoundError, "Could not locate source for #{name_with_owner}!" unless file
+
+      begin
+        code = Pry::Code.from_file(file).expression_at(line)
+      rescue SyntaxError => e
+        raise MethodSource::SourceNotFoundError.new(e.message)
+      end
+      strip_leading_whitespace(code)
+    end
   end
 end

data/lib/pry/{commands/edit/method_patcher.rb → method/patcher.rb}

@@ -1,37 +1,38 @@
 class Pry
-  class Command::Edit
-    class MethodPatcher
-      attr_accessor :_pry_
-      attr_accessor :code_object
+  class Method
+    class Patcher
+      attr_accessor :method
 
-      def initialize(_pry_, code_object)
-        @_pry_ = _pry_
-        @code_object = code_object
+      @@source_cache = {}
+
+      def initialize(method)
+        @method = method
+      end
+
+      def self.code_for(filename)
+        @@source_cache[filename]
       end
 
       # perform the patch
-      def perform_patch
-        if code_object.alias?
+      def patch_in_ram(source)
+        if method.alias?
           with_method_transaction do
-            _pry_.evaluate_ruby patched_code
+            redefine source
           end
         else
-          _pry_.evaluate_ruby patched_code
+          redefine source
         end
       end
 
       private
 
-      def patched_code
-        @patched_code ||= wrap(Pry::Editor.edit_tempfile_with_content(adjusted_lines))
+      def redefine(source)
+        @@source_cache[cache_key] = source
+        TOPLEVEL_BINDING.eval wrap(source), cache_key
       end
 
-      # The method code adjusted so that the first line is rewritten
-      # so that def self.foo --> def foo
-      def adjusted_lines
-        lines = code_object.source.lines.to_a
-        lines[0] = definition_line_for_owner(lines.first)
-        lines
+      def cache_key
+        "pry-redefined(0x#{method.owner.object_id.to_s(16)}##{method.name})"
       end
 
       # Run some code ensuring that at the end target#meth_name will not have changed.
@@ -45,17 +46,17 @@ class Pry
       # @param [Module] target  The owner of the method
 
       def with_method_transaction
-        temp_name = "__pry_#{code_object.original_name}__"
-        co = code_object
-        code_object.owner.class_eval do
-          alias_method temp_name, co.original_name
+        temp_name = "__pry_#{method.original_name}__"
+        method = self.method
+        method.owner.class_eval do
+          alias_method temp_name, method.original_name
           yield
-          alias_method co.name, co.original_name
-          alias_method co.original_name, temp_name
+          alias_method method.name, method.original_name
+          alias_method method.original_name, temp_name
         end
 
       ensure
-        co.send(:remove_method, temp_name) rescue nil
+        method.send(:remove_method, temp_name) rescue nil
       end
 
       # Update the definition line so that it can be eval'd directly on the Method's
@@ -68,13 +69,13 @@ class Pry
       # This is necessarily done by String manipulation because we can't find out what
       # syntax is needed for the argument list by ruby-level introspection.
       #
-      # @param String   The original definition line. e.g. def self.foo(bar, baz=1)
-      # @return String  The new definition line. e.g. def foo(bar, baz=1)
-      def definition_line_for_owner(line)
-        if line =~ /^def (?:.*?\.)?#{Regexp.escape(code_object.original_name)}(?=[\(\s;]|$)/
-          "def #{code_object.original_name}#{$'}"
+      # @param [String] line The original definition line. e.g. def self.foo(bar, baz=1)
+      # @return [String]  The new definition line. e.g. def foo(bar, baz=1)
+      def definition_for_owner(line)
+        if line =~ /\Adef (?:.*?\.)?#{Regexp.escape(method.original_name)}(?=[\(\s;]|$)/
+          "def #{method.original_name}#{$'}"
         else
-          raise CommandError, "Could not find original `def #{code_object.original_name}` line to patch."
+          raise CommandError, "Could not find original `def #{method.original_name}` line to patch."
         end
       end
 
@@ -87,15 +88,17 @@ class Pry
 
       # Update the source code so that when it has the right owner when eval'd.
       #
-      # This (combined with definition_line_for_owner) is backup for the case that
+      # This (combined with definition_for_owner) is backup for the case that
       # wrap_for_nesting fails, to ensure that the method will stil be defined in
       # the correct place.
       #
       # @param [String] source  The source to wrap
       # @return [String]
       def wrap_for_owner(source)
-        Pry.current[:pry_owner] = code_object.owner
-        "Pry.current[:pry_owner].class_eval do\n#{source}\nend"
+        Pry.current[:pry_owner] = method.owner
+        owner_source = definition_for_owner(source)
+        visibility_fix = "#{method.visibility.to_s} #{method.name.to_sym.inspect}"
+        "Pry.current[:pry_owner].class_eval do; #{owner_source}\n#{visibility_fix}\nend"
       end
 
       # Update the new source code to have the correct Module.nesting.
@@ -111,10 +114,10 @@ class Pry
       # @param [String] source  The source to wrap.
       # @return [String]
       def wrap_for_nesting(source)
-        nesting = Pry::Code.from_file(code_object.source_file).nesting_at(code_object.source_line)
+        nesting = Pry::Code.from_file(method.source_file).nesting_at(method.source_line)
 
-        (nesting + [source] + nesting.map{ "end" } + [""]).join("\n")
-      rescue Pry::Indent::UnparseableNestingError => e
+        (nesting + [source] + nesting.map{ "end" } + [""]).join(";")
+      rescue Pry::Indent::UnparseableNestingError
         source
       end
     end