pry 0.9.9.6pre2-java → 0.9.10-java

data/lib/pry/helpers/documentation_helpers.rb

@@ -4,14 +4,14 @@ class Pry
     # This class contains methods useful for extracting
     # documentation from methods and classes.
     module DocumentationHelpers
-      def process_rdoc(comment, code_type)
+      def process_rdoc(comment)
         comment = comment.dup
-        comment.gsub(/<code>(?:\s*\n)?(.*?)\s*<\/code>/m) { Pry.color ? CodeRay.scan($1, code_type).term : $1 }.
+        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, code_type).term : $1 }.
-          gsub(/`(?:\s*\n)?([^\e]*?)\s*`/) { "`#{Pry.color ? CodeRay.scan($1, code_type).term : $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}`" }
       end
 
       def process_yardoc_tag(comment, tag)
@@ -31,13 +31,13 @@ class Pry
 
       def process_yardoc(comment)
         yard_tags = ["param", "return", "option", "yield", "attr", "attr_reader", "attr_writer",
-                     "deprecate", "example"]
+                     "deprecate", "example", "raise"]
         (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)
+      def process_comment_markup(comment)
+        process_yardoc process_rdoc(comment)
       end
 
       # @param [String] code

data/lib/pry/helpers/options_helpers.rb

@@ -9,7 +9,7 @@ class Pry
         opt.on :M, "instance-methods", "Operate on instance methods."
         opt.on :m, :methods, "Operate on methods."
         opt.on :s, :super, "Select the 'super' method. Can be repeated to traverse the ancestors.", :as => :count
-        opt.on :c, :context, "Select object context to run under.", true do |context|
+        opt.on :c, :context, "Select object context to run under.", :argument => true do |context|
           @method_target = Pry.binding_for(target.eval(context))
         end
       end

data/lib/pry/helpers/text.rb

@@ -46,19 +46,18 @@ class Pry
           Pry.color ? "\e[1m#{text}\e[0m" : text.to_s
         end
 
-        # Returns _text_ in the default foreground colour.
+        # Returns `text` in the default foreground colour.
         # Use this instead of "black" or "white" when you mean absence of colour.
         #
-        # @param [String, #to_s]
-        # @return [String] _text_
+        # @param [String, #to_s] text
+        # @return [String]
         def default(text)
           text.to_s
         end
         alias_method :bright_default, :bold
 
-        # Executes _block_ with _Pry.color_ set to false.
-        #
-        # @param [Proc]
+        # Executes the block with `Pry.color` set to false.
+        # @yield
         # @return [void]
         def no_color &block
           boolean = Pry.config.color
@@ -68,9 +67,8 @@ class Pry
           Pry.config.color = boolean
         end
 
-        # Executes _block_ with _Pry.config.pager_ set to false.
-        #
-        # @param [Proc]
+        # Executes the block with `Pry.config.pager` set to false.
+        # @yield
         # @return [void]
         def no_pager &block
           boolean = Pry.config.pager

data/lib/pry/history.rb

@@ -4,9 +4,13 @@ class Pry
   class History
     attr_accessor :loader, :saver, :pusher, :clearer
 
+    # @return [Fixnum] Number of lines in history when Pry first loaded.
+    attr_reader :original_lines
+
     def initialize
       @history = []
       @saved_lines = 0
+      @original_lines = 0
       restore_default_behavior
     end
 
@@ -25,7 +29,7 @@ class Pry
         @pusher.call(line.chomp)
         @history << line.chomp
       end
-      @saved_lines = @history.length
+      @saved_lines = @original_lines = @history.length
     end
 
     # Write this session's history using `History.saver`.
@@ -58,6 +62,15 @@ class Pry
       @saved_lines = 0
     end
 
+    # @return [Fixnum] The number of lines in history.
+    def history_line_count
+      @history.count
+    end
+
+    def session_line_count
+      @history.count - @original_lines
+    end
+
     # Return an Array containing all stored history.
     # @return [Array<String>] An Array containing all lines of history loaded
     #   or entered by the user in the current session.
@@ -89,7 +102,7 @@ class Pry
         File.open(history_file, 'a') do |f|
           lines.each { |ln| f.puts ln }
         end
-      rescue Errno::EACCES => error
+      rescue Errno::EACCES
         # We should probably create an option Pry.show_warnings?!?!?!
         warn 'Unable to write to your history file, history not saved'
       end

data/lib/pry/hooks.rb

@@ -173,7 +173,7 @@ class Pry
 
     # Return a specific hook for a given event.
     # @param [Symbol] event_name The name of the event.
-    # @param [Symbol[ hook_name The name of the hook
+    # @param [Symbol] hook_name The name of the hook
     # @return [#call] The requested hook.
     # @example
     #   my_hooks = Pry::Hooks.new.add_hook(:before_session, :say_hi) { puts "hi!" }

data/lib/pry/indent.rb

@@ -17,8 +17,11 @@ class Pry
   class Indent
     include Helpers::BaseHelpers
 
-    # String containing the spaces to be inserted before the next line.
+    # @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
 
     # The amount of spaces to insert for each indent level.
     SPACES = '  '
@@ -106,8 +109,7 @@ class Pry
     # @return [String] The indented version of +input+.
     #
     def indent(input)
-      output      = ''
-      open_tokens = OPEN_TOKENS.keys
+      output = ''
       prefix = indent_level
 
       input.lines.each do |line|
@@ -234,8 +236,8 @@ class Pry
 
     # Given a string of Ruby code, use CodeRay to export the tokens.
     #
-    # @param String  The Ruby to lex.
-    # @return [Array]  An Array of pairs of [token_value, token_type]
+    # @param [String] string The Ruby to lex
+    # @return [Array] An Array of pairs of [token_value, token_type]
     def tokenize(string)
       tokens = CodeRay.scan(string, :ruby)
       tokens = tokens.tokens.each_slice(2) if tokens.respond_to?(:tokens) # Coderay 1.0.0
@@ -248,7 +250,7 @@ class Pry
     # normal strings (which can't be nested) we assume that CodeRay correctly pairs
     # open-and-close delimiters so we don't bother checking what they are.
     #
-    # @param String  The token (of type :delimiter)
+    # @param [String] token The token (of type :delimiter)
     def track_delimiter(token)
       case token
       when /^<<-(["'`]?)(.*)\\1/
@@ -297,7 +299,7 @@ class Pry
       cols = cols.to_i
       lines = cols != 0 ? (full_line.length / cols + 1) : 1
 
-      if defined?(Win32::Console)
+      if Pry::Helpers::BaseHelpers.windows_ansi?
         move_up   = "\e[#{lines}F"
         move_down = "\e[#{lines}E"
       else
@@ -320,9 +322,14 @@ class Pry
          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 better than nothing).
-         [ENV["ROWS"], ENV["COLUMNS"]]
-      ].detect do |(rows, cols)|
+         # 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

data/lib/pry/method.rb

@@ -63,7 +63,7 @@ class Pry
       #
       def from_binding(b)
         meth_name = b.eval('__method__')
-        if [:__script__, nil, :__binding__, :__binding_impl__].include?(meth_name)
+        if [:__script__, nil].include?(meth_name)
           nil
         else
           method = begin
@@ -210,7 +210,7 @@ class Pry
     # A new instance of `Pry::Method` wrapping the given `::Method`, `UnboundMethod`, or `Proc`.
     #
     # @param [::Method, UnboundMethod, Proc] method
-    # @param [Hash] known_info, can be used to pre-cache expensive to compute stuff.
+    # @param [Hash] known_info Can be used to pre-cache expensive to compute stuff.
     # @return [Pry::Method]
     def initialize(method, known_info={})
       @method = method
@@ -253,17 +253,29 @@ class Pry
                       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
+                    # 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
 
+    # Can we get the source code for this method?
+    # @return [Boolean]
+    def source?
+      !!source
+    rescue MethodSource::SourceNotFoundError
+      false
+    end
+
     # @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.
@@ -273,12 +285,10 @@ 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 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."
-             strip_leading_hash_and_whitespace_from_ruby_comments(doc_for_pry_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
@@ -438,10 +448,10 @@ class Pry
 
       # FIXME: a very similar method to this exists on WrappedModule: extract_doc_for_candidate
       def doc_for_pry_method
-        _, line = source_location
+        _, line_num = source_location
 
         buffer = ""
-        Pry.line_buffer[0..(line - 1)].each do |line|
+        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*$/)
@@ -454,8 +464,8 @@ class Pry
         buffer
       end
 
-      # @param [Class,Module] the ancestors to investigate
-      # @return [Method] the unwrapped super-method
+      # @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
@@ -504,8 +514,8 @@ class Pry
       #
       # @param [Object] receiver
       # @param [String] method_name
-      def initialize(*args)
-        @receiver, @name = *args
+      def initialize(receiver, method_name)
+        @receiver, @name = receiver, method_name
       end
 
       # Is the method undefined? (aka `Disowned`)
@@ -514,6 +524,12 @@ class Pry
         true
       end
 
+      # Can we get the source for this method?
+      # @return [Boolean] false
+      def source?
+        false
+      end
+
       # Get the hypothesized owner of the method.
       #
       # @return [Object]

data/lib/pry/module_candidate.rb

@@ -0,0 +1,130 @@
+require 'pry/helpers/documentation_helpers'
+require 'forwardable'
+
+class Pry
+  class WrappedModule
+
+    # This class represents a single candidate for a module/class definition.
+    # It provides access to the source, documentation, line and file
+    # for a monkeypatch (reopening) of a class/module.
+    class Candidate
+      extend Forwardable
+
+      # @return [String] The file where the module definition is located.
+      attr_reader :file
+
+      # @return [Fixnum] The line where the module definition is located.
+      attr_reader :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]
+
+      def_delegators :@wrapper, *to_delegate
+      private(*to_delegate)
+
+      # @raise [Pry::CommandError] If `rank` is out of bounds.
+      # @param [Pry::WrappedModule] wrapper The associated
+      #   `Pry::WrappedModule` instance that owns the candidates.
+      # @param [Fixnum] rank The rank of the candidate to
+      #   retrieve. Passing 0 returns 'primary candidate' (the candidate with largest
+      #   number of methods), passing 1 retrieves candidate with
+      #   second largest number of methods, and so on, up to
+      #   `Pry::WrappedModule#number_of_candidates() - 1`
+      def initialize(wrapper, rank)
+        @wrapper = wrapper
+
+        if number_of_candidates <= 0
+          raise CommandError, "Cannot find a definition for #{name} module!"
+        elsif rank > (number_of_candidates - 1)
+          raise CommandError, "No such module candidate. Allowed candidates range is from 0 to #{number_of_candidates - 1}"
+        end
+
+        @rank = rank
+        @file, @line = source_location
+      end
+
+      # @raise [Pry::CommandError] If source code cannot be found.
+      # @return [String] The source for the candidate, i.e the
+      #   complete module/class definition.
+      def source
+        return @source if @source
+        raise CommandError, "Could not locate source for #{wrapped}!" if file.nil?
+
+        @source = strip_leading_whitespace(Pry::Code.from_file(file).expression_at(line, number_of_lines_in_first_chunk))
+      end
+
+      # @raise [Pry::CommandError] If documentation cannot be found.
+      # @return [String] The documentation for the candidate.
+      def doc
+        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))
+      end
+
+      # @return [Array, nil] A `[String, Fixnum]` pair representing the
+      #   source location (file and line) for the candidate or `nil`
+      #   if no source location found.
+      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]
+      rescue Pry::RescuableException
+        nil
+      end
+
+      private
+
+      # 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
+      #   calculate the source location of the candidate.
+      def first_method_source_location
+        @first_method_source_location ||= adjusted_source_location(method_candidates[@rank].first.source_location)
+      end
+
+      # @return [Array] The source location of the last method in this
+      #   candidate's module definition.
+      def last_method_source_location
+        @end_method_source_location ||= adjusted_source_location(method_candidates[@rank].last.source_location)
+      end
+
+      # Return the number of lines between the start of the class definition
+      # and the start of the last method. We use this value so we can
+      # quickly grab these lines from the file (without having to
+      # check each intervening line for validity, which is expensive) speeding up source extraction.
+      # @return [Fixum] Number of lines.
+      def number_of_lines_in_first_chunk
+        end_method_line = last_method_source_location.last
+
+        end_method_line - line
+      end
+
+      def adjusted_source_location(sl)
+        file, line = sl
+
+        if file && RbxPath.is_core_path?(file)
+          file = RbxPath.convert_path_to_full(file)
+        end
+
+        [file, line]
+      end
+    end
+  end
+end