pry 0.9.10pre1-i386-mingw32 → 0.9.11-i386-mingw32

data/lib/pry/helpers/text.rb

@@ -33,7 +33,7 @@ class Pry
         #
         # @param  [String, #to_s] text
         # @return [String] _text_ stripped of any color codes.
-        def strip_color text
+        def strip_color(text)
           text.to_s.gsub(/\e\[.*?(\d)+m/ , '')
         end
 
@@ -42,7 +42,7 @@ class Pry
         #
         # @param [String, #to_s] text
         # @return [String] _text_
-        def bold text
+        def bold(text)
           Pry.color ? "\e[1m#{text}\e[0m" : text.to_s
         end
 
@@ -59,7 +59,7 @@ class Pry
         # Executes the block with `Pry.color` set to false.
         # @yield
         # @return [void]
-        def no_color &block
+        def no_color(&block)
           boolean = Pry.config.color
           Pry.config.color = false
           yield
@@ -70,7 +70,7 @@ class Pry
         # Executes the block with `Pry.config.pager` set to false.
         # @yield
         # @return [void]
-        def no_pager &block
+        def no_pager(&block)
           boolean = Pry.config.pager
           Pry.config.pager = false
           yield

data/lib/pry/history_array.rb

@@ -89,6 +89,11 @@ class Pry
       ((@count - size)...@count).map { |n| @hash[n] }
     end
 
+    def pop!
+      @hash.delete @count - 1
+      @count -= 1
+    end
+
     def inspect
       "#<#{self.class} size=#{size} first=#{@count - size} max_size=#{max_size}>"
     end

data/lib/pry/hooks.rb

@@ -244,9 +244,7 @@ class Pry
     # @param [Symbol] hook_name Name of the hook.
     # @return [Boolean] Whether the hook by the name `hook_name`
     def hook_exists?(event_name, hook_name)
-      !!@hooks[event_name].find { |name, _| name == hook_name }
+      !!(@hooks[event_name] && @hooks[event_name].find { |name, _| name == hook_name })
     end
-    private :hook_exists?
-
   end
 end

data/lib/pry/indent.rb

@@ -17,9 +17,12 @@ class Pry
   class Indent
     include Helpers::BaseHelpers
 
+    # Raised if {#module_nesting} would not work.
+    class UnparseableNestingError < StandardError; end
+
     # @return [String] String containing the spaces to be inserted before the next line.
     attr_reader :indent_level
-    
+
     # @return [Array<String>] The stack of open tokens.
     attr_reader :stack
 
@@ -51,6 +54,9 @@ class Pry
     # a single-line.
     SINGLELINE_TOKENS = %w(if while until unless rescue)
 
+    # Which tokens can be followed by an optional "do" keyword.
+    OPTIONAL_DO_TOKENS = %w(for while until)
+
     # Collection of token types that should be ignored. Without this list
     # keywords such as "class" inside strings would cause the code to be
     # indented incorrectly.
@@ -73,6 +79,32 @@ class Pry
     # don't affect the surrounding code.
     MIDWAY_TOKENS = %w(when else elsif ensure rescue)
 
+    # Clean the indentation of a fragment of ruby.
+    #
+    # @param [String] str
+    # @return [String]
+    def self.indent(str)
+      new.indent(str)
+    end
+
+    # Get the module nesting at the given point in the given string.
+    #
+    # NOTE If the line specified contains a method definition, then the nesting
+    # at the start of the method definition is used. Otherwise the nesting from
+    # the end of the line is used.
+    #
+    # @param [String] str The ruby code to analyze
+    # @param [Fixnum] line_number The line number (starting from 1)
+    # @return [Array<String>]
+    def self.nesting_at(str, line_number)
+      indent = new
+      lines = str.split("\n")
+      n = line_number - 1
+      to_indent = lines[0...n] + (lines[n] || "").split("def").first(1)
+      indent.indent(to_indent.join("\n") + "\n")
+      indent.module_nesting
+    end
+
     def initialize
       reset
     end
@@ -84,6 +116,8 @@ class Pry
       @heredoc_queue = []
       @close_heredocs = {}
       @string_start = nil
+      @awaiting_class = false
+      @module_nesting = []
       self
     end
 
@@ -129,7 +163,6 @@ class Pry
         new_prefix = prefix + SPACES * after
 
         line = prefix + line.lstrip unless previously_in_string
-        line = line.rstrip + "\n"   unless in_string?
 
         output += line
 
@@ -138,7 +171,7 @@ class Pry
 
       @indent_level = prefix
 
-      return output.gsub(/\s+$/, '')
+      return output
     end
 
     # Get the indentation for the start of the next line.
@@ -192,7 +225,9 @@ class Pry
         last_token, last_kind = token, kind unless kind == :space
         next if IGNORE_TOKENS.include?(kind)
 
-        seen_for_at << add_after if token == "for"
+        track_module_nesting(token, kind)
+
+        seen_for_at << add_after if OPTIONAL_DO_TOKENS.include?(token)
 
         if kind == :delimiter
           track_delimiter(token)
@@ -200,7 +235,8 @@ class Pry
           @stack << token
           add_after += 1
         elsif token == OPEN_TOKENS[@stack.last]
-          @stack.pop
+          popped = @stack.pop
+          track_module_nesting_end(popped)
           if add_after == 0
             remove_before += 1
           else
@@ -282,6 +318,68 @@ class Pry
       "puts #{open_delimiters.join(", ")}"
     end
 
+    # Update the internal state relating to module nesting.
+    #
+    # It's responsible for adding to the @module_nesting array, which looks
+    # something like:
+    #
+    # [ ["class", "Foo"], ["module", "Bar::Baz"], ["class <<", "self"] ]
+    #
+    # A nil value in the @module_nesting array happens in two places: either
+    # when @awaiting_token is true and we're still waiting for the string to
+    # fill that space, or when a parse was rejected.
+    #
+    # At the moment this function is quite restricted about what formats it will
+    # parse, for example we disallow expressions after the class keyword. This
+    # could maybe be improved in the future.
+    #
+    # @param [String] token  a token from Coderay
+    # @param [Symbol] kind  the kind of that token
+    def track_module_nesting(token, kind)
+      if kind == :keyword && (token == "class" || token == "module")
+        @module_nesting << [token, nil]
+        @awaiting_class = true
+      elsif @awaiting_class
+        if kind == :operator && token == "<<" && @module_nesting.last[0] == "class"
+          @module_nesting.last[0] = "class <<"
+          @awaiting_class = true
+        elsif kind == :class && token =~ /\A(self|[A-Z:][A-Za-z0-9_:]*)\z/
+          @module_nesting.last[1] = token if kind == :class
+          @awaiting_class = false
+        else
+          # leave @nesting[-1][
+          @awaiting_class = false
+        end
+      end
+    end
+
+    # Update the internal state relating to module nesting on 'end'.
+    #
+    # If the current 'end' pairs up with a class or a module then we should
+    # pop an array off of @module_nesting
+    #
+    # @param [String] token  a token from Coderay
+    # @param [Symbol] kind  the kind of that token
+    def track_module_nesting_end(token, kind=:keyword)
+      if kind == :keyword && (token == "class" || token == "module")
+        @module_nesting.pop
+      end
+    end
+
+    # Return a list of strings which can be used to re-construct the Module.nesting at
+    # the current point in the file.
+    #
+    # Returns nil if the syntax of the file was not recognizable.
+    #
+    # @return [Array<String>]
+    def module_nesting
+      @module_nesting.map do |(kind, token)|
+        raise UnparseableNestingError, @module_nesting.inspect if token.nil?
+
+        "#{kind} #{token}"
+      end
+    end
+
     # Return a string which, when printed, will rewrite the previous line with
     # the correct indentation. Mostly useful for fixing 'end'.
     #
@@ -294,7 +392,7 @@ class Pry
       full_line = prompt + code
       whitespace = ' ' * overhang
 
-      _, cols = screen_size
+      _, cols = TerminalInfo.screen_size
 
       cols = cols.to_i
       lines = cols != 0 ? (full_line.length / cols + 1) : 1
@@ -309,29 +407,5 @@ class Pry
 
       "#{move_up}#{prompt}#{colorize_code(code)}#{whitespace}#{move_down}"
     end
-
-    # Return a pair of [rows, columns] which gives the size of the window.
-    #
-    # If the window size cannot be determined, return nil.
-    def screen_size
-      [
-         # io/console adds a winsize method to IO streams.
-         $stdout.tty? && $stdout.respond_to?(:winsize) && $stdout.winsize,
-
-         # Some readlines also provides get_screen_size.
-         Readline.respond_to?(:get_screen_size) && Readline.get_screen_size,
-
-         # Otherwise try to use the environment (this may be out of date due
-         # to window resizing, but it's better than nothing).
-         [ENV["ROWS"], ENV["COLUMNS"],
-
-         # If the user is running within ansicon, then use the screen size
-         # that it reports (same caveats apply as with ROWS and COLUMNS)
-         ENV['ANSICON'] =~ /\((.*)x(.*)\)/ && [$2, $1]
-        ]
-      ].detect do |(_, cols)|
-        cols.to_i > 0
-      end
-    end
   end
 end

data/lib/pry/method.rb

@@ -17,8 +17,11 @@ class Pry
   # This class wraps the normal `Method` and `UnboundMethod` classes
   # to provide extra functionality useful to Pry.
   class Method
+    extend Helpers::BaseHelpers
+    include Helpers::BaseHelpers
     include RbxMethod if Helpers::BaseHelpers.rbx?
     include Helpers::DocumentationHelpers
+    include CodeObject::Helpers
 
     class << self
       # Given a string representing a method name and optionally a binding to
@@ -40,18 +43,21 @@ class Pry
           from_binding(target)
         elsif name.to_s =~ /(.+)\#(\S+)\Z/
           context, meth_name = $1, $2
-          from_module(target.eval(context), meth_name)
-        elsif name.to_s =~ /(.+)\.(\S+)\Z/
-          context, meth_name = $1, $2
-          from_obj(target.eval(context), meth_name)
+          from_module(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)
         elsif options[:instance]
-          from_module(target.eval("self"), name)
+          from_module(target.eval("self"), name, target)
         elsif options[:methods]
-          from_obj(target.eval("self"), name)
+          from_obj(target.eval("self"), name, target)
         else
           from_str(name, target, :instance => true) or
             from_str(name, target, :methods => true)
         end
+
+      rescue Pry::RescuableException
+        nil
       end
 
       # Given a `Binding`, try to extract the `::Method` it originated from and
@@ -62,12 +68,16 @@ class Pry
       # @return [Pry::Method, nil]
       #
       def from_binding(b)
-        meth_name = b.eval('__method__')
+        meth_name = b.eval('::Kernel.__method__')
         if [:__script__, nil].include?(meth_name)
           nil
         else
           method = begin
-                     new(b.eval("Object.instance_method(:method).bind(self).call(#{meth_name.to_s.inspect})"))
+                     if Object === b.eval('self')
+                       new(Kernel.instance_method(:method).bind(b.eval("self")).call(meth_name))
+                     else
+                       new(b.eval('class << self; self; end.instance_method(::Kernel.__method__).bind(self)'))
+                     end
                    rescue NameError, NoMethodError
                      Disowned.new(b.eval('self'), meth_name.to_s)
                    end
@@ -106,15 +116,32 @@ class Pry
         end
       end
 
+      # In order to support 2.0 Refinements we need to look up methods
+      # inside the relevant Binding.
+      # @param [Object] obj The owner/receiver of the method.
+      # @param [Symbol] method_name The name of the method.
+      # @param [Symbol] method_type The type of method: :method or :instance_method
+      # @param [Binding] target The binding where the method is looked up.
+      # @return [Method, UnboundMethod] The 'refined' method object.
+      def lookup_method_via_binding(obj, method_name, method_type, target=TOPLEVEL_BINDING)
+        Pry.current[:obj] = obj
+        Pry.current[:name] = method_name
+        receiver = obj.is_a?(Module) ? "Module" : "Kernel"
+        target.eval("::#{receiver}.instance_method(:#{method_type}).bind(Pry.current[:obj]).call(Pry.current[:name])")
+      ensure
+        Pry.current[:obj] = Pry.current[:name] = nil
+      end
+
       # Given a `Class` or `Module` and the name of a method, try to
       # instantiate a `Pry::Method` containing the instance method of
       # that name. Return `nil` if no such method exists.
       #
       # @param [Class, Module] klass
       # @param [String] name
+      # @param [Binding] target The binding where the method is looked up.
       # @return [Pry::Method, nil]
-      def from_class(klass, name)
-        new(safe_send(klass, :instance_method, name)) rescue nil
+      def from_class(klass, name, target=TOPLEVEL_BINDING)
+        new(lookup_method_via_binding(klass, name, :instance_method, target)) rescue nil
       end
       alias from_module from_class
 
@@ -124,9 +151,10 @@ class Pry
       #
       # @param [Object] obj
       # @param [String] name
+      # @param [Binding] target The binding where the method is looked up.
       # @return [Pry::Method, nil]
-      def from_obj(obj, name)
-        new(safe_send(obj, :method, name)) rescue nil
+      def from_obj(obj, name, target=TOPLEVEL_BINDING)
+        new(lookup_method_via_binding(obj, name, :method, target)) rescue nil
       end
 
       # Get all of the instance methods of a `Class` or `Module`
@@ -183,15 +211,6 @@ class Pry
         end.flatten(1)
       end
 
-      # Acts like send but ignores any methods defined below Object or Class in the
-      # inheritance hierarchy.
-      # This is required to introspect methods on objects like Net::HTTP::Get that
-      # have overridden the `method` method.
-      def safe_send(obj, method, *args, &block)
-        (Module === obj ? Module : Object).instance_method(method).bind(obj).call(*args, &block)
-      end
-      public :safe_send
-
       # Get the singleton classes of superclasses that could define methods on
       # the given class object, and any modules they include.
       # If a module is included at multiple points in the ancestry, only
@@ -229,6 +248,12 @@ class Pry
       @wrapped_owner ||= Pry::WrappedModule.new(owner)
     end
 
+    # Get underlying object wrapped by this Pry::Method instance
+    # @return [Method, UnboundMethod, Proc]
+    def wrapped
+      @method
+    end
+
     # Is the method undefined? (aka `Disowned`)
     # @return [Boolean] false
     def undefined?
@@ -403,6 +428,24 @@ class Pry
       source_file == Pry.eval_path
     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|
+        pair.include?(name) &&
+          owner.instance_method(pair.first) == owner.instance_method(pair.last)
+      end.flatten
+      alias_list.delete(name)
+
+      alias_list.map(&:to_s)
+    end
+
     # @return [Boolean] Is the method definitely an alias?
     def alias?
       name != original_name
@@ -475,7 +518,8 @@ class Pry
           end
           next_owner = ancestors[i] or return nil
         end
-        next_owner.instance_method(name) rescue nil
+
+        safe_send(next_owner, :instance_method, name) rescue nil
       end
 
       # @param [String] first_ln The first line of a method definition.

data/lib/pry/module_candidate.rb

@@ -8,18 +8,21 @@ class Pry
     # It provides access to the source, documentation, line and file
     # for a monkeypatch (reopening) of a class/module.
     class Candidate
+      include Pry::Helpers::DocumentationHelpers
+      include Pry::CodeObject::Helpers
       extend Forwardable
 
       # @return [String] The file where the module definition is located.
       attr_reader :file
+      alias_method :source_file, :file
 
       # @return [Fixnum] The line where the module definition is located.
       attr_reader :line
+      alias_method :source_line, :line
 
       # Methods to delegate to associated `Pry::WrappedModule instance`.
       to_delegate = [:lines_for_file, :method_candidates, :name, :wrapped,
-                     :yard_docs?, :number_of_candidates, :process_doc,
-                     :strip_leading_whitespace]
+                     :yard_docs?, :number_of_candidates]
 
       def_delegators :@wrapper, *to_delegate
       private(*to_delegate)
@@ -61,7 +64,7 @@ class Pry
         return @doc if @doc
         raise CommandError, "Could not locate doc for #{wrapped}!" if file.nil?
 
-        @doc = process_doc(Pry::Code.from_file(file).comment_describing(line))
+        @doc = strip_leading_hash_and_whitespace_from_ruby_comments(Pry::Code.from_file(file).comment_describing(line))
       end
 
       # @return [Array, nil] A `[String, Fixnum]` pair representing the
@@ -70,27 +73,35 @@ class Pry
       def source_location
         return @source_location if @source_location
 
-        mod_type_string = wrapped.class.to_s.downcase
         file, line = first_method_source_location
-
         return nil if !file.is_a?(String)
 
-        class_regexes = [/^\s*#{mod_type_string}\s*(\w*)(::)?#{wrapped.name.split(/::/).last}/,
-                         /^\s*(::)?#{wrapped.name.split(/::/).last}\s*?=\s*?#{wrapped.class}/,
-                         /^\s*(::)?#{wrapped.name.split(/::/).last}\.(class|instance)_eval/]
-
-        host_file_lines = lines_for_file(file)
-
-        search_lines = host_file_lines[0..(line - 2)]
-        idx = search_lines.rindex { |v| class_regexes.any? { |r| r =~ v } }
-
-        @source_location = [file,  idx + 1]
+        @source_location = [file,  first_line_of_module_definition(file, line)]
       rescue Pry::RescuableException
         nil
       end
 
       private
 
+      # Locate the first line of the module definition.
+      # @param [String] file The file that contains the module
+      #   definition (somewhere).
+      # @param [Fixnum] line The module definition should appear
+      #   before this line (if it exists).
+      # @return [Fixnum] The line where the module is defined. This
+      #   line number is one-indexed.
+      def first_line_of_module_definition(file, line)
+        searchable_lines = lines_for_file(file)[0..(line - 2)]
+        searchable_lines.rindex { |v| class_regexes.any? { |r| r =~ v } } + 1
+      end
+
+      def class_regexes
+        mod_type_string = wrapped.class.to_s.downcase
+        [/^\s*#{mod_type_string}\s+(?:(?:\w*)::)*?#{wrapped.name.split(/::/).last}/,
+         /^\s*(::)?#{wrapped.name.split(/::/).last}\s*?=\s*?#{wrapped.class}/,
+         /^\s*(::)?#{wrapped.name.split(/::/).last}\.(class|instance)_eval/]
+      end
+
       # This method is used by `Candidate#source_location` as a
       # starting point for the search for the candidate's definition.
       # @return [Array] The source location of the base method used to