pry 0.10.1 → 0.14.1

data/lib/pry/code/loc.rb

@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+
 class Pry
   class Code
-
-    # Represents a line of code. A line of code is a tuple, which consists of a
-    # line and a line number. A `LOC` object's state (namely, the line
-    # parameter) can be changed via instance methods. `Pry::Code` heavily uses
-    # this class.
+    # Represents a line of code (which may, in fact, contain multiple lines if
+    # the entirety was eval'd as a single unit following the `edit` command).
+    #
+    # A line of code is a tuple, which consists of a line and a line number. A
+    # `LOC` object's state (namely, the line parameter) can be changed via
+    # instance methods.  `Pry::Code` heavily uses this class.
     #
     # @api private
     # @example
@@ -18,7 +21,6 @@ class Pry
     #   loc.indent(3)
     #   loc.line #=> "   def example\n  :example\nend"
     class LOC
-
       # @return [Array<String, Integer>]
       attr_reader :tuple
 
@@ -52,7 +54,7 @@ class Pry
       # @param [Symbol] code_type
       # @return [void]
       def colorize(code_type)
-        tuple[0] = CodeRay.scan(line, code_type).term
+        tuple[0] = SyntaxHighlighter.highlight(line, code_type)
       end
 
       # Prepends the line number `lineno` to the `line`.
@@ -61,8 +63,14 @@ class Pry
       # @return [void]
       def add_line_number(max_width = 0, color = false)
         padded = lineno.to_s.rjust(max_width)
-        colorized_lineno = color ? Pry::Helpers::BaseHelpers.colorize_code(padded) : padded
-        tuple[0] = "#{ colorized_lineno }: #{ line }"
+        colorized_lineno =
+          if color
+            Pry::Helpers::BaseHelpers.colorize_code(padded)
+          else
+            padded
+          end
+        properly_padded_line = handle_multiline_entries_from_edit_command(line, max_width)
+        tuple[0] = "#{colorized_lineno}: #{properly_padded_line}"
       end
 
       # Prepends a marker "=>" or an empty marker to the +line+.
@@ -73,9 +81,9 @@ class Pry
       def add_marker(marker_lineno)
         tuple[0] =
           if lineno == marker_lineno
-            " => #{ line }"
+            " => #{line}"
           else
-            "    #{ line }"
+            "    #{line}"
           end
       end
 
@@ -84,9 +92,14 @@ class Pry
       # @param [Integer] distance
       # @return [void]
       def indent(distance)
-        tuple[0] = "#{ ' ' * distance }#{ line }"
+        tuple[0] = "#{' ' * distance}#{line}"
       end
-    end
 
+      def handle_multiline_entries_from_edit_command(line, max_width)
+        line.split("\n").map.with_index do |inner_line, i|
+          i.zero? ? inner_line : "#{' ' * (max_width + 2)}#{inner_line}"
+        end.join("\n")
+      end
+    end
   end
 end

data/lib/pry/code.rb

@@ -1,6 +1,6 @@
-require 'pry/code/loc'
-require 'pry/code/code_range'
-require 'pry/code/code_file'
+# frozen_string_literal: true
+
+require 'method_source'
 
 class Pry
   class << self
@@ -66,7 +66,7 @@ class Pry
       # @param [Integer, nil] start_line The line number to start on, or nil to
       #   use the method's original line numbers.
       # @return [Code]
-      def from_module(mod, candidate_rank = 0, start_line=nil)
+      def from_module(mod, candidate_rank = 0, start_line = nil)
         candidate = Pry::WrappedModule(mod).candidate(candidate_rank)
         start_line ||= candidate.line
         new(candidate.source, start_line, :ruby)
@@ -85,26 +85,23 @@ class Pry
     # @param [Integer?] start_line
     # @param [Symbol?] code_type
     def initialize(lines = [], start_line = 1, code_type = :ruby)
-      if lines.is_a? String
-        lines = lines.lines
+      lines = lines.lines if lines.is_a? String
+      @lines = lines.each_with_index.map do |line, lineno|
+        LOC.new(line, lineno + start_line.to_i)
       end
-      @lines = lines.each_with_index.map { |line, lineno|
-        LOC.new(line, lineno + start_line.to_i) }
       @code_type = code_type
+
+      @with_marker = @with_indentation = @with_line_numbers = nil
     end
 
     # Append the given line. +lineno+ is one more than the last existing
     # line, unless specified otherwise.
     #
     # @param [String] line
-    # @param [Integer?] lineno
-    # @return [String] The inserted line.
-    def push(line, lineno = nil)
-      if lineno.nil?
-        lineno = @lines.last.lineno + 1
-      end
-      @lines.push(LOC.new(line, lineno))
-      line
+    # @return [void]
+    def push(line)
+      line_number = @lines.any? ? @lines.last.lineno + 1 : 1
+      @lines.push(LOC.new(line, line_number))
     end
     alias << push
 
@@ -118,6 +115,16 @@ class Pry
       end
     end
 
+    # Filter the lines using the given block.
+    #
+    # @yield [LOC]
+    # @return [Code]
+    def reject(&block)
+      alter do
+        @lines = @lines.reject(&block)
+      end
+    end
+
     # Remove all lines that aren't in the given range, expressed either as a
     # `Range` object or a first and last line number (inclusive). Negative
     # indices count from the end of the array of lines.
@@ -199,6 +206,7 @@ class Pry
     # @return [Code]
     def grep(pattern)
       return self unless pattern
+
       pattern = Regexp.new(pattern)
 
       select do |loc|
@@ -240,30 +248,25 @@ class Pry
       end
     end
 
-    # @return [String]
-    def inspect
-      Object.instance_method(:to_s).bind(self).call
-    end
-
     # @return [Integer] the number of digits in the last line.
     def max_lineno_width
-      @lines.length > 0 ? @lines.last.lineno.to_s.length : 0
+      !@lines.empty? ? @lines.last.lineno.to_s.length : 0
     end
 
     # @return [String] a formatted representation (based on the configuration of
     #   the object).
     def to_s
-      print_to_output("", false)
+      print_to_output(''.dup, false)
     end
 
     # @return [String] a (possibly highlighted) copy of the source code.
     def highlighted
-      print_to_output("", true)
+      print_to_output(''.dup, true)
     end
 
     # Writes a formatted representation (based on the configuration of the
     # object) to the given output, which must respond to `#<<`.
-    def print_to_output(output, color=false)
+    def print_to_output(output, color = false)
       @lines.each do |loc|
         loc = loc.dup
         loc.colorize(@code_type)              if color
@@ -289,15 +292,14 @@ class Pry
     # @param [Integer] line_number (1-based)
     # @return [String] the code.
     def expression_at(line_number, consume = 0)
-      self.class.expression_at(raw, line_number, :consume => consume)
+      self.class.expression_at(raw, line_number, consume: consume)
     end
 
     # Get the (approximate) Module.nesting at the give line number.
     #
     # @param [Integer] line_number line number starting from 1
-    # @param [Module] top_module the module in which this code exists
     # @return [Array<Module>] a list of open modules.
-    def nesting_at(line_number, top_module = Object)
+    def nesting_at(line_number)
       Pry::Indent.nesting_at(raw, line_number)
     end
 
@@ -330,10 +332,27 @@ class Pry
     end
 
     # Forward any missing methods to the output of `#to_s`.
-    def method_missing(name, *args, &block)
-      to_s.send(name, *args, &block)
+    def method_missing(method_name, *args, &block)
+      if (string = to_s).respond_to?(method_name)
+        string.__send__(method_name, *args, &block)
+      else
+        super
+      end
+    end
+    undef =~ if method_defined?(:=~)
+
+    # Check whether String responds to missing methods.
+    def respond_to_missing?(method_name, include_private = false)
+      ''.respond_to?(method_name, include_private) || super
+    end
+
+    if RUBY_VERSION.start_with?('1.9')
+      # @todo This is needed for Ruby 1.9 support where `lines` return an
+      #   Enumerator. Newer Rubies return an Array
+      def lines
+        super.to_a
+      end
     end
-    undef =~
 
     protected
 

data/lib/pry/code_object.rb

@@ -1,5 +1,6 @@
-class Pry
+# frozen_string_literal: true
 
+class Pry
   # This class is responsible for taking a string (identifying a
   # command/class/method/etc) and returning the relevant type of object.
   # For example, if the user looks up "show-source" then  a
@@ -37,13 +38,36 @@ class Pry
       def command?
         is_a?(Module) && self <= Pry::Command
       end
+
+      # @return [Boolean] `true` if this module was defined by means of the C API,
+      #   `false` if it's a Ruby module.
+      # @note If a module defined by C was extended with a lot of methods written
+      #   in Ruby, this method would fail.
+      def c_module?
+        return unless is_a?(WrappedModule)
+
+        method_locations = wrapped.methods(false).map do |m|
+          wrapped.method(m).source_location
+        end
+
+        method_locations.concat(
+          wrapped.instance_methods(false).map do |m|
+            wrapped.instance_method(m).source_location
+          end
+        )
+
+        c_methods = method_locations.grep(nil).count
+        ruby_methods = method_locations.count - c_methods
+
+        c_methods > ruby_methods
+      end
     end
 
     include Pry::Helpers::CommandHelpers
 
     class << self
-      def lookup(str, _pry_, options={})
-        co = new(str, _pry_, options)
+      def lookup(str, pry_instance, options = {})
+        co = new(str, pry_instance, options)
 
         co.default_lookup || co.method_or_class_lookup ||
           co.command_lookup || co.empty_lookup
@@ -52,24 +76,25 @@ class Pry
 
     attr_accessor :str
     attr_accessor :target
-    attr_accessor :_pry_
+    attr_accessor :pry_instance
     attr_accessor :super_level
 
-    def initialize(str, _pry_, options={})
+    def initialize(str, pry_instance, options = {})
       options = {
-        :super => 0,
+        super: 0
       }.merge!(options)
 
       @str = str
-      @_pry_ = _pry_
-      @target = _pry_.current_context
+      @pry_instance = pry_instance
+      @target = pry_instance.current_context
       @super_level = options[:super]
     end
 
+    # TODO: just make it so find_command_by_match_or_listing doesn't raise?
     def command_lookup
-      # TODO: just make it so find_command_by_match_or_listing doesn't
-      # raise?
-      _pry_.commands.find_command_by_match_or_listing(str) rescue nil
+      pry_instance.commands.find_command_by_match_or_listing(str)
+    rescue StandardError
+      nil
     end
 
     # when no paramter is given (i.e CodeObject.lookup(nil)), then we
@@ -91,8 +116,8 @@ class Pry
 
     # lookup variables and constants and `self` that are not modules
     def default_lookup
-
-      # we skip instance methods as we want those to fall through to method_or_class_lookup()
+      # we skip instance methods as we want those to fall through to
+      # method_or_class_lookup()
       if safe_to_evaluate?(str) && !looks_like_an_instance_method?(str)
         obj = target.eval(str)
 
@@ -102,22 +127,22 @@ class Pry
           Pry::Method(obj)
         elsif !obj.is_a?(Module)
           Pry::WrappedModule(obj.class)
-        else
-          nil
         end
       end
-
     rescue Pry::RescuableException
       nil
     end
 
     def method_or_class_lookup
-      obj = case str
-            when /\S+\(\)\z/
-              Pry::Method.from_str(str.sub(/\(\)\z/, ''),target) || Pry::WrappedModule.from_str(str, target)
-            else
-              Pry::WrappedModule.from_str(str,target) || Pry::Method.from_str(str, target)
-            end
+      obj =
+        case str
+        when /\S+\(\)\z/
+          Pry::Method.from_str(str.sub(/\(\)\z/, ''), target) ||
+          Pry::WrappedModule.from_str(str, target)
+        else
+          Pry::WrappedModule.from_str(str, target) ||
+          Pry::Method.from_str(str, target)
+        end
 
       lookup_super(obj, super_level)
     end
@@ -147,6 +172,8 @@ class Pry
     # @return [Boolean]
     def safe_to_evaluate?(str)
       return true if str.strip == "self"
+      return false if str =~ /%/
+
       kind = target.eval("defined?(#{str})")
       kind =~ /variable|constant/
     end
@@ -159,14 +186,12 @@ class Pry
     # @param [Object] obj
     # @param [Fixnum] super_level How far up the super chain to ascend.
     def lookup_super(obj, super_level)
-      return nil if !obj
+      return unless obj
 
       sup = obj.super(super_level)
-      if !sup
-        raise Pry::CommandError, "No superclass found for #{obj.wrapped}"
-      else
-        sup
-      end
+      raise Pry::CommandError, "No superclass found for #{obj.wrapped}" unless sup
+
+      sup
     end
   end
 end

data/lib/pry/color_printer.rb

@@ -1,55 +1,66 @@
-# PP subclass for streaming inspect output in color.
+# frozen_string_literal: true
+
+require 'pp'
+require 'English'
+
 class Pry
+  # PP subclass for streaming inspect output in color.
   class ColorPrinter < ::PP
-    OBJ_COLOR = begin
-      code = CodeRay::Encoders::Terminal::TOKEN_COLORS[:keyword]
-      if code.start_with? "\e"
-        code
-      else
-        "\e[0m\e[0;#{code}m"
+    Pry::SyntaxHighlighter.overwrite_coderay_comment_token!
+
+    def self.default(_output, value, pry_instance)
+      pry_instance.pager.open do |pager|
+        pager.print pry_instance.config.output_prefix
+        pp(value, pager, pry_instance.output.width - 1)
       end
     end
 
-    CodeRay::Encoders::Terminal::TOKEN_COLORS[:comment][:self] = "\e[1;34m"
+    def self.pp(obj, output = $DEFAULT_OUTPUT, max_width = 79)
+      queue = ColorPrinter.new(output, max_width, "\n")
+      queue.guard_inspect_key { queue.pp(obj) }
+      queue.flush
+      output << "\n"
+    end
 
-    def self.pp(obj, out = $>, width = 79)
-      q = ColorPrinter.new(out, width)
-      q.guard_inspect_key { q.pp obj }
-      q.flush
-      out << "\n"
+    def pp(object)
+      return super unless object.is_a?(String)
+
+      # Avoid calling Ruby 2.4+ String#pretty_print that prints multiline
+      # Strings prettier
+      text(object.inspect)
+    rescue StandardError => exception
+      raise if exception.is_a?(Pry::Pager::StopPaging)
+
+      text(highlight_object_literal(inspect_object(object)))
     end
 
-    def text(str, width = str.length)
-      # Don't recolorize output with color [Issue #751]
+    def text(str, max_width = str.length)
       if str.include?("\e[")
-        super "#{str}\e[0m", width
-      elsif str.start_with?('#<') || str == '=' || str == '>'
-        super highlight_object_literal(str), width
+        super("#{str}\e[0m", max_width)
+      elsif str.start_with?('#<') || %w[= >].include?(str)
+        super(highlight_object_literal(str), max_width)
       else
-        super CodeRay.scan(str, :ruby).term, width
+        super(SyntaxHighlighter.highlight(str), max_width)
       end
     end
 
-    def pp(obj)
-      super
-    rescue => e
-      raise if e.is_a? Pry::Pager::StopPaging
+    private
 
+    def highlight_object_literal(object_literal)
+      code = Pry::SyntaxHighlighter.keyword_token_color
+      obj_color = code.start_with?("\e") ? code : "\e[0m\e[0;#{code}m"
+      "#{obj_color}#{object_literal}\e[0m"
+    end
+
+    def inspect_object(object)
+      object.inspect
+    rescue StandardError
       # Read the class name off of the singleton class to provide a default
       # inspect.
-      singleton = class << obj; self; end
+      singleton = class << object; self; end
       ancestors = Pry::Method.safe_send(singleton, :ancestors)
-      klass  = ancestors.reject { |k| k == singleton }.first
-      obj_id = obj.__id__.to_s(16) rescue 0
-      str    = "#<#{klass}:0x#{obj_id}>"
-
-      text highlight_object_literal(str)
-    end
-
-    private
-
-    def highlight_object_literal(object_literal)
-      "#{OBJ_COLOR}#{object_literal}\e[0m"
+      klass = ancestors.find { |k| k != singleton }
+      "#<#{klass}:0x#{object.__id__.to_s(16)}>"
     end
   end
 end