pry 0.9.8.4 → 0.9.9

data/lib/pry/default_commands/misc.rb

@@ -1,6 +1,7 @@
 class Pry
   module DefaultCommands
     Misc = Pry::CommandSet.new do
+
       command "toggle-color", "Toggle syntax highlighting." do
         Pry.color = !Pry.color
         output.puts "Syntax highlighting #{Pry.color ? "on" : "off"}"

data/lib/pry/default_commands/navigating_pry.rb

@@ -72,19 +72,13 @@ class Pry
 
         def process
           if _pry_.binding_stack.one?
-            # when breaking out of top-level then behave like `exit-all`
-            process_exit_all
+            _pry_.run_command "exit-all #{arg_string}"
           else
             # otherwise just pop a binding and return user supplied value
             process_pop_and_return
           end
         end
 
-        def process_exit_all
-          _pry_.binding_stack.clear
-          throw(:breakout, target.eval(arg_string))
-        end
-
         def process_pop_and_return
           popped_object = _pry_.binding_stack.pop.eval('self')
 
@@ -111,4 +105,3 @@ class Pry
     end
   end
 end
-

data/lib/pry/helpers/base_helpers.rb

@@ -110,6 +110,14 @@ class Pry
         RbConfig::CONFIG['ruby_install_name'] == 'rbx'
       end
 
+      def mri_18?
+        RUBY_VERSION =~ /1.8/ && RbConfig::CONFIG['ruby_install_name'] == 'ruby'
+      end
+
+      def mri_19?
+        RUBY_VERSION =~ /1.9/ && RbConfig::CONFIG['ruby_install_name'] == 'ruby'
+      end
+
       # a simple pager for systems without `less`. A la windows.
       def simple_pager(text, output=output())
         text_array = text.lines.to_a
@@ -138,7 +146,7 @@ class Pry
           # Sys.
           $stdout
         end
-          
+
         if text.lines.count < page_size || !Pry.pager
           out.puts text
           return
@@ -151,7 +159,7 @@ class Pry
           lesspipe { |less| less.puts text }
         end
       rescue Errno::ENOENT
-        simple_pager(text, output)
+        simple_pager(text, out)
       rescue Errno::EPIPE
       end
 

data/lib/pry/helpers/command_helpers.rb

@@ -77,48 +77,13 @@ class Pry
         header << "#{Pry::Helpers::Text.bold("Number of lines:")} #{content.each_line.count.to_s}\n"
       end
 
-      def process_rdoc(comment, code_type)
-        comment = comment.dup
-        comment.gsub(/<code>(?:\s*\n)?(.*?)\s*<\/code>/m) { Pry.color ? CodeRay.scan($1, code_type).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, code_type).term : $1 }.
-          gsub(/`(?:\s*\n)?(.*?)\s*`/) { Pry.color ? CodeRay.scan($1, code_type).term : $1 }
-      end
-
-      def process_yardoc_tag(comment, tag)
-        in_tag_block = nil
-        comment.lines.map do |v|
-          if in_tag_block && v !~ /^\S/
-            Pry::Helpers::Text.strip_color Pry::Helpers::Text.strip_color(v)
-          elsif in_tag_block
-            in_tag_block = false
-            v
-          else
-            in_tag_block = true if v =~ /^@#{tag}/
-            v
-          end
-        end.join
-      end
-
-      def process_yardoc(comment)
-        yard_tags = ["param", "return", "option", "yield", "attr", "attr_reader", "attr_writer",
-                     "deprecate", "example"]
-        (yard_tags - ["example"]).inject(comment) { |a, v| process_yardoc_tag(a, v) }.
-          gsub(/^@(#{yard_tags.join("|")})/) { Pry.color ? "\e[33m#{$1}\e[0m": $1 }
-      end
-
-      def process_comment_markup(comment, code_type)
-        process_yardoc process_rdoc(comment, code_type)
-      end
-
-      def invoke_editor(file, line)
-        raise CommandError, "Please set Pry.config.editor or export $EDITOR" unless Pry.config.editor
+      def invoke_editor(file, line, reloading)
+        raise CommandError, "Please set Pry.config.editor or export $VISUAL or $EDITOR" unless Pry.config.editor
         if Pry.config.editor.respond_to?(:call)
-          editor_invocation = Pry.config.editor.call(file, line)
+          args = [file, line, reloading][0...(Pry.config.editor.arity)]
+          editor_invocation = Pry.config.editor.call(*args)
         else
-          editor_invocation = "#{Pry.config.editor} #{start_line_syntax_for_editor(file, line)}"
+          editor_invocation = "#{Pry.config.editor} #{blocking_flag_for_editor(reloading)} #{start_line_syntax_for_editor(file, line)}"
         end
         return nil unless editor_invocation
 
@@ -138,6 +103,22 @@ class Pry
         end
       end
 
+      # Some editors that run outside the terminal allow you to control whether or
+      # not to block the process from which they were launched (in this case, Pry).
+      # For those editors, return the flag that produces the desired behavior.
+      def blocking_flag_for_editor(block)
+        case Pry.config.editor
+        when /^emacsclient/
+          '--no-wait' unless block
+        when /^[gm]vim/
+          '--nofork' if block
+        when /^jedit/
+          '-wait' if block
+        when /^mate/, /^subl/
+          '-w' if block
+        end
+      end
+
       # Return the syntax for a given editor for starting the editor
       # and moving to a particular line within that file
       def start_line_syntax_for_editor(file_name, line_number)
@@ -153,6 +134,8 @@ class Pry
           "+#{line_number} #{file_name}"
         when /^mate/, /^geany/
           "-l #{line_number} #{file_name}"
+        when /^subl/
+          "#{file_name}:#{line_number}"
         when /^uedit32/
           "#{file_name}/#{line_number}"
         when /^jedit/

data/lib/pry/helpers/documentation_helpers.rb

@@ -0,0 +1,65 @@
+class Pry
+  module Helpers
+
+    # This class contains methods useful for extracting
+    # documentation from methods and classes.
+    module DocumentationHelpers
+      def process_rdoc(comment, code_type)
+        comment = comment.dup
+        comment.gsub(/<code>(?:\s*\n)?(.*?)\s*<\/code>/m) { Pry.color ? CodeRay.scan($1, code_type).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, code_type).term : $1 }.
+          gsub(/`(?:\s*\n)?(.*?)\s*`/) { Pry.color ? CodeRay.scan($1, code_type).term : $1 }
+      end
+
+      def process_yardoc_tag(comment, tag)
+        in_tag_block = nil
+        comment.lines.map do |v|
+          if in_tag_block && v !~ /^\S/
+            Pry::Helpers::Text.strip_color Pry::Helpers::Text.strip_color(v)
+          elsif in_tag_block
+            in_tag_block = false
+            v
+          else
+            in_tag_block = true if v =~ /^@#{tag}/
+            v
+          end
+        end.join
+      end
+
+      def process_yardoc(comment)
+        yard_tags = ["param", "return", "option", "yield", "attr", "attr_reader", "attr_writer",
+                     "deprecate", "example"]
+        (yard_tags - ["example"]).inject(comment) { |a, v| process_yardoc_tag(a, v) }.
+          gsub(/^@(#{yard_tags.join("|")})/) { Pry.color ? "\e[33m#{$1}\e[0m": $1 }
+      end
+
+      def process_comment_markup(comment, code_type)
+        process_yardoc process_rdoc(comment, code_type)
+      end
+
+      # @param [String] code
+      # @return [String]
+      def strip_comments_from_c_code(code)
+        code.sub(/\A\s*\/\*.*?\*\/\s*/m, '')
+      end
+
+      # @param [String] comment
+      # @return [String]
+      def strip_leading_hash_and_whitespace_from_ruby_comments(comment)
+        comment = comment.dup
+        comment.gsub!(/\A\#+?$/, '')
+        comment.gsub!(/^\s*#/, '')
+        strip_leading_whitespace(comment)
+      end
+
+      # @param [String] text
+      # @return [String]
+      def strip_leading_whitespace(text)
+        Pry::Helpers::CommandHelpers.unindent(text)
+      end
+    end
+  end
+end

data/lib/pry/indent.rb

@@ -1,6 +1,14 @@
 require 'coderay'
 
 class Pry
+  begin
+    require 'io/console'
+  rescue LoadError
+    IO_CONSOLE_AVAILABLE = false
+  else
+    IO_CONSOLE_AVAILABLE = true
+  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
@@ -187,12 +195,17 @@ class Pry
     # Return a string which, when printed, will rewrite the previous line with
     # the correct indentation. Mostly useful for fixing 'end'.
     #
-    # @param [String] full_line The full line of input, including the prompt.
+    # @param [String] prompt The user's prompt
+    # @param [String] code   The code the user just typed in.
     # @param [Fixnum] overhang (0) The number of chars to erase afterwards (i.e.,
     #   the difference in length between the old line and the new one).
     # @return [String]
-    def correct_indentation(full_line, overhang=0)
-      if Readline.respond_to?(:get_screen_size)
+    def correct_indentation(prompt, code, overhang=0)
+      full_line = prompt + code
+      if IO_CONSOLE_AVAILABLE && $stdout.tty?
+        _, cols = $stdout.winsize
+        lines = full_line.length / cols + 1
+      elsif Readline.respond_to?(:get_screen_size)
         _, cols = Readline.get_screen_size
         lines = full_line.length / cols + 1
       elsif ENV['COLUMNS'] && ENV['COLUMNS'] != ''
@@ -211,7 +224,7 @@ class Pry
       end
       whitespace = ' ' * overhang
 
-      "#{move_up}#{full_line}#{whitespace}#{move_down}"
+      "#{move_up}#{prompt}#{CodeRay.scan(code, :ruby).term}#{whitespace}#{move_down}"
     end
   end
 end

data/lib/pry/method.rb

@@ -1,4 +1,6 @@
 # -*- coding: utf-8 -*-
+require 'pry/helpers/documentation_helpers'
+
 class Pry
   class << self
     # If the given object is a `Pry::Method`, return it unaltered. If it's
@@ -12,8 +14,11 @@ class Pry
     end
   end
 
+  # This class wraps the normal `Method` and `UnboundMethod` classes
+  # to provide extra functionality useful to Pry.
   class Method
     include RbxMethod if Helpers::BaseHelpers.rbx?
+    include Helpers::DocumentationHelpers
 
     class << self
       # Given a string representing a method name and optionally a binding to
@@ -62,7 +67,7 @@ class Pry
           nil
         else
           method = begin
-                     new(b.eval("method(#{meth_name.to_s.inspect})"))
+                     new(b.eval("Object.instance_method(:method).bind(self).call(#{meth_name.to_s.inspect})"))
                    rescue NameError, NoMethodError
                      Disowned.new(b.eval('self'), meth_name.to_s)
                    end
@@ -126,16 +131,18 @@ class Pry
 
       # Get all of the instance methods of a `Class` or `Module`
       # @param [Class,Module] klass
+      # @param [Boolean] include_super Whether to include methods from ancestors.
       # @return [Array[Pry::Method]]
-      def all_from_class(klass)
-        all_from_common(klass, :instance_method)
+      def all_from_class(klass, include_super=true)
+        all_from_common(klass, :instance_method, include_super)
       end
 
       # Get all of the methods on an `Object`
       # @param [Object] obj
+      # @param [Boolean] include_super Whether to include methods from ancestors.
       # @return [Array[Pry::Method]]
-      def all_from_obj(obj)
-        all_from_common(obj, :method)
+      def all_from_obj(obj, include_super=true)
+        all_from_common(obj, :method, include_super)
       end
 
       # Get every `Class` and `Module`, in order, that will be checked when looking
@@ -168,9 +175,9 @@ class Pry
       # 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)
+      def all_from_common(obj, method_type, include_super=true)
         %w(public protected private).map do |visibility|
-          safe_send(obj, :"#{visibility}_#{method_type}s").map do |method_name|
+          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)
@@ -183,6 +190,7 @@ class Pry
       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.
@@ -239,21 +247,21 @@ class Pry
     # @return [String, nil] The source code of the method, or `nil` if it's unavailable.
     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
-        when :ruby
-          if Helpers::BaseHelpers.rbx? && core?
-            code = core_code
-          elsif pry_method?
-            code = Pry.new(:input => StringIO.new(Pry.line_buffer[source_line..-1].join), :prompt => proc {""}, :hooks => Pry::Hooks.new).r
-          else
-            code = @method.source
-          end
-          strip_leading_whitespace(code)
-        end
+                  when :c
+                    info = pry_doc_info
+                    if info and info.source
+                      code = strip_comments_from_c_code(info.source)
+                    end
+                  when :ruby
+                    if Helpers::BaseHelpers.rbx? && !pry_method?
+                      code = core_code
+                    elsif pry_method?
+                      code = Pry::Code.retrieve_complete_expression_from(Pry.line_buffer[source_line..-1])
+                    else
+                      code = @method.source
+                    end
+                    strip_leading_whitespace(code)
+                  end
     end
 
     # @return [String, nil] The documentation for the method, or `nil` if it's
@@ -265,10 +273,12 @@ class Pry
           info = pry_doc_info
           info.docstring if info
         when :ruby
-          if Helpers::BaseHelpers.rbx? && core?
-            strip_leading_hash_and_whitespace_from_ruby_comments(core_doc)
+           if Helpers::BaseHelpers.rbx? && !pry_method?
+             strip_leading_hash_and_whitespace_from_ruby_comments(core_doc)
           elsif pry_method?
-            raise CommandError, "Can't view doc for a REPL-defined method."
+           # raise CommandError, "Can't view doc for a REPL-defined
+     # method."
+             strip_leading_hash_and_whitespace_from_ruby_comments(doc_for_pry_method)
           else
             strip_leading_hash_and_whitespace_from_ruby_comments(@method.comment)
           end
@@ -281,6 +291,15 @@ class Pry
       source_location.nil? ? :c : :ruby
     end
 
+    def source_location
+      if @method.source_location && Helpers::BaseHelpers.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
@@ -303,7 +322,7 @@ class Pry
     # @return [Range, nil] The range of lines in `source_file` which contain
     #    the method's definition, or `nil` if that information is unavailable.
     def source_range
-      source_location.nil? ? nil : (source_line)...(source_line + source.lines.count)
+      source_location.nil? ? nil : (source_line)..(source_line + source.lines.count - 1)
     end
 
     # @return [Symbol] The visibility of the method. May be `:public`,
@@ -382,7 +401,7 @@ class Pry
     # @return [Boolean]
     def ==(obj)
       if obj.is_a? Pry::Method
-        super
+        obj == @method
       else
         @method == obj
       end
@@ -411,31 +430,28 @@ class Pry
       # @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}."
+          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
 
-      # @param [String] code
-      # @return [String]
-      def strip_comments_from_c_code(code)
-        code.sub(/\A\s*\/\*.*?\*\/\s*/m, '')
-      end
+      # FIXME: a very similar method to this exists on WrappedModule: extract_doc_for_candidate
+      def doc_for_pry_method
+        _, line = source_location
 
-      # @param [String] comment
-      # @return [String]
-      def strip_leading_hash_and_whitespace_from_ruby_comments(comment)
-        comment = comment.dup
-        comment.gsub!(/\A\#+?$/, '')
-        comment.gsub!(/^\s*#/, '')
-        strip_leading_whitespace(comment)
-      end
+        buffer = ""
+        Pry.line_buffer[0..(line - 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
 
-      # @param [String] text
-      # @return [String]
-      def strip_leading_whitespace(text)
-        Pry::Helpers::CommandHelpers.unindent(text)
+        buffer
       end
 
       # @param [Class,Module] the ancestors to investigate