pry 0.9.12.6-java → 0.10.0-java

data/lib/pry/module_candidate.rb

@@ -29,8 +29,8 @@ class Pry
                           :number_of_candidates]
 
       def_delegators :@wrapper, *(private_delegates + public_delegates)
-      private *private_delegates
-      public *public_delegates
+      private(*private_delegates)
+      public(*public_delegates)
 
       # @raise [Pry::CommandError] If `rank` is out of bounds.
       # @param [Pry::WrappedModule] wrapper The associated
@@ -112,13 +112,13 @@ class Pry
       # @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)
+        @first_method_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_method_source_location ||= method_candidates[@rank].last.source_location
       end
 
       # Return the number of lines between the start of the class definition
@@ -131,16 +131,6 @@ class Pry
 
         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

data/lib/pry/object_path.rb

@@ -0,0 +1,82 @@
+class Pry
+  # `ObjectPath` implements the resolution of "object paths", which are strings
+  # that are similar to filesystem paths but meant for traversing Ruby objects.
+  # Examples of valid object paths include:
+  #
+  #     x
+  #     @foo/@bar
+  #     "string"/upcase
+  #     Pry/Method
+  #
+  # Object paths are mostly relevant in the context of the `cd` command.
+  # @see https://github.com/pry/pry/wiki/State-navigation
+  class ObjectPath
+    SPECIAL_TERMS = ["", "::", ".", ".."]
+
+    # @param [String] path_string The object path expressed as a string.
+    # @param [Array<Binding>] current_stack The current state of the binding
+    #   stack.
+    def initialize(path_string, current_stack)
+      @path_string   = path_string
+      @current_stack = current_stack
+    end
+
+    # @return [Array<Binding>] a new stack resulting from applying the given
+    #   path to the current stack.
+    def resolve
+      scanner = StringScanner.new(@path_string.strip)
+      stack   = @current_stack.dup
+
+      begin
+        next_segment  = ""
+
+        loop do
+          # Scan for as long as we don't see a slash
+          next_segment << scanner.scan(/[^\/]*/)
+
+          if complete?(next_segment) || scanner.eos?
+            scanner.getch # consume the slash
+            break
+          else
+            next_segment << scanner.getch # append the slash
+          end
+        end
+
+        case next_segment.chomp
+        when ""
+          stack = [stack.first]
+        when "::"
+          stack.push(TOPLEVEL_BINDING)
+        when "."
+          next
+        when ".."
+          stack.pop unless stack.size == 1
+        else
+          stack.push(Pry.binding_for(stack.last.eval(next_segment)))
+        end
+      rescue RescuableException => e
+        return handle_failure(next_segment, e)
+      end until scanner.eos?
+
+      stack
+    end
+
+    private
+
+    def complete?(segment)
+      SPECIAL_TERMS.include?(segment) || Pry::Code.complete_expression?(segment)
+    end
+
+    def handle_failure(context, err)
+      msg = [
+        "Bad object path: #{@path_string.inspect}",
+        "Failed trying to resolve: #{context.inspect}",
+        "Exception: #{err.inspect}"
+      ].join("\n")
+
+      raise CommandError.new(msg).tap { |e|
+        e.set_backtrace err.backtrace
+      }
+    end
+  end
+end

data/lib/pry/output.rb

@@ -0,0 +1,50 @@
+class Pry
+  class Output
+    attr_reader :_pry_
+
+    def initialize(_pry_)
+      @_pry_ = _pry_
+    end
+
+    def puts(*objs)
+      return print "\n" if objs.empty?
+
+      objs.each do |obj|
+        if ary = Array.try_convert(obj)
+          puts(*ary)
+        else
+          print "#{obj.to_s.chomp}\n"
+        end
+      end
+
+      nil
+    end
+
+    def print(*objs)
+      objs.each do |obj|
+        _pry_.config.output.print decolorize_maybe(obj.to_s)
+      end
+
+      nil
+    end
+    alias << print
+    alias write print
+
+    # If _pry_.config.color is currently false, removes ansi escapes from the string.
+    def decolorize_maybe(str)
+      if _pry_.config.color
+        str
+      else
+        Helpers::Text.strip_color str
+      end
+    end
+
+    def method_missing(name, *args, &block)
+      _pry_.config.output.send(name, *args, &block)
+    end
+
+    def respond_to_missing?(*a)
+      _pry_.config.respond_to?(*a)
+    end
+  end
+end

data/lib/pry/pager.rb

@@ -1,63 +1,132 @@
+require 'pry/terminal'
+
+# A pager is an `IO`-like object that accepts text and either prints it
+# immediately, prints it one page at a time, or streams it to an external
+# program to print one page at a time.
 class Pry::Pager
-  # @param [String] text
-  #   A piece of text to run through a pager.
-  # @param [Symbol?] pager
-  #   `:simple` -- Use the pure ruby pager.
-  #   `:system` -- Use the system pager (less) or the environment variable
-  #                $PAGER if set.
-  #   `nil`     -- Infer what pager to use from the environment.  What this
-  #                really means is that JRuby and systems that do not have
-  #                access to 'less' will run through the pure ruby pager.
-  def self.page(text, pager = nil)
-    case pager
-    when nil
-      no_pager = !SystemPager.available?
-      if no_pager || Pry::Helpers::BaseHelpers.jruby?
-        SimplePager.new(text).page
-      else
-        SystemPager.new(text).page
-      end
-    when :simple
-      SimplePager.new(text).page
-    when :system
-      SystemPager.new(text).page
-    else
-      raise "'#{pager}' is not a recognized pager."
+  class StopPaging < StandardError
+  end
+
+  attr_reader :_pry_
+
+  def initialize(_pry_)
+    @_pry_ = _pry_
+  end
+
+  # Send the given text through the best available pager (if `Pry.config.pager` is
+  # enabled).
+  # If you want to send text through in chunks as you generate it, use `open` to
+  # get a writable object instead.
+  # @param [String] text A piece of text to run through a pager.
+  # @param [IO] output (`$stdout`) An object to send output to.
+  def page(text)
+    open do |pager|
+      pager << text
     end
   end
 
-  def self.page_size
-    @page_size ||= Pry::Terminal.height!
+  # Yields a pager object (`NullPager`, `SimplePager`, or `SystemPager`).  All
+  # pagers accept output with `#puts`, `#print`, `#write`, and `#<<`.
+  # @param [IO] output (`$stdout`) An object to send output to.
+  def open
+    pager = best_available
+    yield pager
+  rescue StopPaging
+  ensure
+    pager.close if pager
   end
 
-  def initialize(text)
-    @text = text
+  private
+
+  attr_reader :output
+  def enabled?; !!@enabled; end
+
+  # Return an instance of the "best" available pager class -- `SystemPager` if
+  # possible, `SimplePager` if `SystemPager` isn't available, and `NullPager`
+  # if the user has disabled paging. All pagers accept output with `#puts`,
+  # `#print`, `#write`, and `#<<`. You must call `#close` when you're done
+  # writing output to a pager, and you must rescue `Pry::Pager::StopPaging`.
+  # These requirements can be avoided by using `.open` instead.
+  # @param [#<<] output ($stdout) An object to send output to.
+  def best_available
+    if !_pry_.config.pager
+      NullPager.new(_pry_.output)
+    elsif !SystemPager.available? || Pry::Helpers::BaseHelpers.jruby?
+      SimplePager.new(_pry_.output)
+    else
+      SystemPager.new(_pry_.output)
+    end
   end
 
-  class SimplePager < Pry::Pager
-    def page
-      # The pager size minus the number of lines used by the simple pager info bar.
-      page_size = Pry::Pager.page_size - 3
-      text_array = @text.lines.to_a
-
-      text_array.each_slice(page_size) do |chunk|
-        puts chunk.join
-        break if chunk.size < page_size
-        if text_array.size > page_size
-          puts "\n<page break> --- Press enter to continue ( q<enter> to break ) --- <page break>"
-          break if Readline.readline.chomp == "q"
+  # `NullPager` is a "pager" that actually just prints all output as it comes
+  # in. Used when `Pry.config.pager` is false.
+  class NullPager
+    def initialize(out)
+      @out = out
+    end
+
+    def puts(str)
+      print "#{str.chomp}\n"
+    end
+
+    def print(str)
+      write str
+    end
+    alias << print
+
+    def write(str)
+      @out.write str
+    end
+
+    def close
+    end
+
+    private
+
+    def height
+      @height ||= Pry::Terminal.height!
+    end
+
+    def width
+      @width ||= Pry::Terminal.width!
+    end
+  end
+
+  # `SimplePager` is a straightforward pure-Ruby pager. We use it on JRuby and
+  # when we can't find a usable external pager.
+  class SimplePager < NullPager
+    def initialize(*)
+      super
+      @tracker = PageTracker.new(height - 3, width)
+    end
+
+    def write(str)
+      str.lines.each do |line|
+        @out.print line
+        @tracker.record line
+
+        if @tracker.page?
+          @out.print "\n"
+          @out.print "\e[0m"
+          @out.print "<page break> --- Press enter to continue " \
+                     "( q<enter> to break ) --- <page break>\n"
+          raise StopPaging if Readline.readline("").chomp == "q"
+          @tracker.reset
         end
       end
     end
   end
 
-  class SystemPager < Pry::Pager
+  # `SystemPager` buffers output until we're pretty sure it's at least a page
+  # long, then invokes an external pager and starts streaming output to it. If
+  # `#close` is called before then, it just prints out the buffered content.
+  class SystemPager < NullPager
     def self.default_pager
       pager = ENV["PAGER"] || ""
 
       # Default to less, and make sure less is being passed the correct options
-      if pager.strip.empty? or pager =~ /^less\s*/
-        pager = "less -R -S -F -X"
+      if pager.strip.empty? or pager =~ /^less\b/
+        pager = "less -R -F -X"
       end
 
       pager
@@ -67,7 +136,8 @@ class Pry::Pager
       if @system_pager.nil?
         @system_pager = begin
           pager_executable = default_pager.split(' ').first
-          `which #{ pager_executable }`
+          `which #{pager_executable}`
+          $?.success?
         rescue
           false
         end
@@ -78,13 +148,88 @@ class Pry::Pager
 
     def initialize(*)
       super
-      @pager = SystemPager.default_pager
+      @tracker = PageTracker.new(height, width)
+      @buffer  = ""
+    end
+
+    def write(str)
+      if invoked_pager?
+        write_to_pager str
+      else
+        @tracker.record str
+        @buffer << str
+
+        if @tracker.page?
+          write_to_pager @buffer
+        end
+      end
+    rescue Errno::EPIPE
+      raise StopPaging
     end
 
-    def page
-      IO.popen(@pager, 'w') do |io|
-        io.write @text
+    def close
+      if invoked_pager?
+        pager.close
+      else
+        @out.puts @buffer
       end
     end
+
+    private
+
+    def write_to_pager(text)
+      pager.write @out.decolorize_maybe(text)
+    end
+
+    def invoked_pager?
+      @pager
+    end
+
+    def pager
+      @pager ||= IO.popen(self.class.default_pager, 'w')
+    end
+  end
+
+  # `PageTracker` tracks output to determine whether it's likely to take up a
+  # whole page. This doesn't need to be super precise, but we can use it for
+  # `SimplePager` and to avoid invoking the system pager unnecessarily.
+  #
+  # One simplifying assumption is that we don't need `#page?` to return `true`
+  # on the basis of an incomplete line. Long lines should be counted as
+  # multiple lines, but we don't have to transition from `false` to `true`
+  # until we see a newline.
+  class PageTracker
+    def initialize(rows, cols)
+      @rows, @cols = rows, cols
+      reset
+    end
+
+    def record(str)
+      str.lines.each do |line|
+        if line.end_with? "\n"
+          @row += ((@col + line_length(line) - 1) / @cols) + 1
+          @col  = 0
+        else
+          @col += line_length(line)
+        end
+      end
+    end
+
+    def page?
+      @row >= @rows
+    end
+
+    def reset
+      @row = 0
+      @col = 0
+    end
+
+    private
+
+    # Approximation of the printable length of a given line, without the
+    # newline and without ANSI color codes.
+    def line_length(line)
+      line.chomp.gsub(/\e\[[\d;]*m/, '').length
+    end
   end
 end