pry 0.10.0.pre2-universal-mingw32

data/lib/pry/code/code_file.rb

@@ -0,0 +1,103 @@
+class Pry
+  class CodeFile
+    DEFAULT_EXT = '.rb'
+
+    # List of all supported languages.
+    # @return [Hash]
+    EXTENSIONS = {
+      %w(.py)        => :python,
+      %w(.js)        => :javascript,
+      %w(.css)       => :css,
+      %w(.xml)       => :xml,
+      %w(.php)       => :php,
+      %w(.html)      => :html,
+      %w(.diff)      => :diff,
+      %w(.java)      => :java,
+      %w(.json)      => :json,
+      %w(.c .h)      => :c,
+      %w(.rhtml)     => :rhtml,
+      %w(.yaml .yml) => :yaml,
+      %w(.cpp .hpp .cc .h cxx) => :cpp,
+      %w(.rb .ru .irbrc .gemspec .pryrc) => :ruby,
+    }
+
+    # @return [Symbol] The type of code stored in this wrapper.
+    attr_reader :code_type
+
+    # @param [String] filename The name of a file with code to be detected
+    # @param [Symbol] code_type The type of code the `filename` contains
+    def initialize(filename, code_type = type_from_filename(filename))
+      @filename = filename
+      @code_type = code_type
+    end
+
+    # @return [String] The code contained in the current `@filename`.
+    def code
+      if @filename == Pry.eval_path
+        Pry.line_buffer.drop(1)
+      elsif Pry::Method::Patcher.code_for(@filename)
+        Pry::Method::Patcher.code_for(@filename)
+      elsif RbxPath.is_core_path?(@filename)
+        File.read(RbxPath.convert_path_to_full(@filename))
+      else
+        path = abs_path
+        @code_type = type_from_filename(path)
+        File.read(path)
+      end
+    end
+
+    private
+
+    # @raise [MethodSource::SourceNotFoundError] if the `filename` is not
+    #   readable for some reason.
+    # @return [String] absolute path for the given `filename`.
+    def abs_path
+      code_path.detect { |path| readable?(path) } or
+        raise MethodSource::SourceNotFoundError,
+              "Cannot open #{ @filename.inspect } for reading."
+    end
+
+    # @param [String] path
+    # @return [Boolean] if the path, with or without the default ext,
+    #   is a readable file then `true`, otherwise `false`.
+    def readable?(path)
+      File.readable?(path) && !File.directory?(path) or
+        File.readable?(path << DEFAULT_EXT)
+    end
+
+    # @return [Array] All the paths that contain code that Pry can use for its
+    #   API's. Skips directories.
+    def code_path
+      [from_pwd, from_pry_init_pwd, *from_load_path]
+    end
+
+    # @param [String] filename
+    # @param [Symbol] default (:unknown) the file type to assume if none could be
+    #   detected.
+    # @return [Symbol, nil] The CodeRay type of a file from its extension, or
+    #   `nil` if `:unknown`.
+    def type_from_filename(filename, default = :unknown)
+      _, @code_type = EXTENSIONS.find do |k, _|
+        k.any? { |ext| ext == File.extname(filename) }
+      end
+
+      code_type || default
+    end
+
+    # @return [String]
+    def from_pwd
+      File.expand_path(@filename, Dir.pwd)
+    end
+
+    # @return [String]
+    def from_pry_init_pwd
+      File.expand_path(@filename, Pry::INITIAL_PWD)
+    end
+
+    # @return [String]
+    def from_load_path
+      $LOAD_PATH.map { |path| File.expand_path(@filename, path) }
+    end
+
+  end
+end

data/lib/pry/code/code_range.rb

@@ -0,0 +1,71 @@
+class Pry
+  class Code
+
+    # Represents a range of lines in a code listing.
+    #
+    # @api private
+    class CodeRange
+
+      # @param [Integer] start_line
+      # @param [Integer?] end_line
+      def initialize(start_line, end_line = nil)
+        @start_line = start_line
+        @end_line   = end_line
+        force_set_end_line
+      end
+
+      # @param [Array<LOC>] lines
+      # @return [Range]
+      def indices_range(lines)
+        Range.new(*indices(lines))
+      end
+
+      private
+
+      def start_line; @start_line; end
+      def end_line; @end_line; end
+
+      # If `end_line` is equal to `nil`, then calculate it from the first
+      # parameter, `start_line`. Otherwise, leave it as it is.
+      # @return [void]
+      def force_set_end_line
+        if start_line.is_a?(Range)
+          set_end_line_from_range
+        else
+          @end_line ||= start_line
+        end
+      end
+
+      # Finds indices of `start_line` and `end_line` in the given Array of
+      # +lines+.
+      #
+      # @param [Array<LOC>] lines
+      # @return [Array<Integer>]
+      def indices(lines)
+        [find_start_index(lines), find_end_index(lines)]
+      end
+
+      # @return [Integer]
+      def find_start_index(lines)
+        return start_line if start_line < 0
+        lines.index { |loc| loc.lineno >= start_line } || lines.length
+      end
+
+      # @return [Integer]
+      def find_end_index(lines)
+        return end_line if end_line < 0
+        (lines.index { |loc| loc.lineno > end_line } || 0) - 1
+      end
+
+      # For example, if the range is 4..10, then `start_line` would be equal to
+      # 4 and `end_line` to 10.
+      # @return [void]
+      def set_end_line_from_range
+        @end_line = start_line.last
+        @end_line -= 1 if start_line.exclude_end?
+        @start_line = start_line.first
+      end
+    end
+
+  end
+end

data/lib/pry/code/loc.rb

@@ -0,0 +1,92 @@
+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.
+    #
+    # @api private
+    # @example
+    #   loc = LOC.new("def example\n  :example\nend", 1)
+    #   puts loc.line
+    #   def example
+    #     :example
+    #   end
+    #   #=> nil
+    #
+    #   loc.indent(3)
+    #   loc.line #=> "   def example\n  :example\nend"
+    class LOC
+
+      # @return [Array<String, Integer>]
+      attr_reader :tuple
+
+      # @param [String] line The line of code.
+      # @param [Integer] lineno The position of the +line+.
+      def initialize(line, lineno)
+        @tuple = [line.chomp, lineno.to_i]
+      end
+
+      # @return [Boolean]
+      def ==(other)
+        other.tuple == tuple
+      end
+
+      def dup
+        self.class.new(line, lineno)
+      end
+
+      # @return [String]
+      def line
+        tuple.first
+      end
+
+      # @return [Integer]
+      def lineno
+        tuple.last
+      end
+
+      # Paints the `line` of code.
+      #
+      # @param [Symbol] code_type
+      # @return [void]
+      def colorize(code_type)
+        tuple[0] = CodeRay.scan(line, code_type).term
+      end
+
+      # Prepends the line number `lineno` to the `line`.
+      #
+      # @param [Integer] max_width
+      # @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 }"
+      end
+
+      # Prepends a marker "=>" or an empty marker to the +line+.
+      #
+      # @param [Integer] marker_lineno If it is equal to the `lineno`, then
+      #   prepend a hashrocket. Otherwise, an empty marker.
+      # @return [void]
+      def add_marker(marker_lineno)
+        tuple[0] =
+          if lineno == marker_lineno
+            " => #{ line }"
+          else
+            "    #{ line }"
+          end
+      end
+
+      # Indents the `line` with +distance+ spaces.
+      #
+      # @param [Integer] distance
+      # @return [void]
+      def indent(distance)
+        tuple[0] = "#{ ' ' * distance }#{ line }"
+      end
+    end
+
+  end
+end

data/lib/pry/code_object.rb

@@ -0,0 +1,172 @@
+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
+  # `Pry::Command` will be returned. Alternatively, if the user passes in "Pry#repl" then
+  # a `Pry::Method` object will be returned.
+  #
+  # The `CodeObject.lookup` method is responsible for 1. figuring out what kind of
+  # object the user wants (applying precedence rules in doing so -- i.e methods
+  # get precedence over commands with the same name) and 2. Returning
+  # the appropriate object. If the user fails to provide a string
+  # identifer for the object (i.e they pass in `nil` or "") then the
+  # object looked up will be the 'current method' or 'current class'
+  # associated with the Binding.
+  #
+  # TODO: This class is a clusterfuck. We need a much more robust
+  # concept of what a "Code Object" really is. Currently
+  # commands/classes/candidates/methods and so on just share a very
+  # ill-defined interface.
+  class CodeObject
+    module Helpers
+      # we need this helper as some Pry::Method objects can wrap Procs
+      # @return [Boolean]
+      def real_method_object?
+        is_a?(::Method) || is_a?(::UnboundMethod)
+      end
+
+      def c_method?
+        real_method_object? && source_type == :c
+      end
+
+      def module_with_yard_docs?
+        is_a?(WrappedModule) && yard_docs?
+      end
+
+      def command?
+        is_a?(Module) && self <= Pry::Command
+      end
+    end
+
+    include Pry::Helpers::CommandHelpers
+
+    class << self
+      def lookup(str, _pry_, options={})
+        co = new(str, _pry_, options)
+
+        co.default_lookup || co.method_or_class_lookup ||
+          co.command_lookup || co.empty_lookup
+      end
+    end
+
+    attr_accessor :str
+    attr_accessor :target
+    attr_accessor :_pry_
+    attr_accessor :super_level
+
+    def initialize(str, _pry_, options={})
+      options = {
+        :super => 0,
+      }.merge!(options)
+
+      @str = str
+      @_pry_ = _pry_
+      @target = _pry_.current_context
+      @super_level = options[:super]
+    end
+
+    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
+    end
+
+    # when no paramter is given (i.e CodeObject.lookup(nil)), then we
+    # lookup the 'current object' from the binding.
+    def empty_lookup
+      return nil if str && !str.empty?
+
+      obj = if internal_binding?(target)
+              mod = target_self.is_a?(Module) ? target_self : target_self.class
+              Pry::WrappedModule(mod)
+            else
+              Pry::Method.from_binding(target)
+            end
+
+      # respect the super level (i.e user might have specified a
+      # --super flag to show-source)
+      lookup_super(obj, super_level)
+    end
+
+    # 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()
+      if safe_to_evaluate?(str) && !looks_like_an_instance_method?(str)
+        obj = target.eval(str)
+
+        # restrict to only objects we KNOW for sure support the full API
+        # Do NOT support just any object that responds to source_location
+        if sourcable_object?(obj)
+          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
+
+      lookup_super(obj, super_level)
+    end
+
+    private
+
+    def sourcable_object?(obj)
+      [::Proc, ::Method, ::UnboundMethod].any? { |o| obj.is_a?(o) }
+    end
+
+    # Returns true if `str` looks like a method, i.e Klass#method
+    # We need to consider this case because method lookups should fall
+    # through to the `method_or_class_lookup()` method but a
+    # defined?() on a "Klass#method` string will see the `#` as a
+    # comment and only evaluate the `Klass` part.
+    # @param [String] str
+    # @return [Boolean] Whether the string looks like an instance method.
+    def looks_like_an_instance_method?(str)
+      str =~ /\S#\S/
+    end
+
+    # We use this method to decide whether code is safe to eval. Method's are
+    # generally not, but everything else is.
+    # TODO: is just checking != "method" enough??
+    # TODO: see duplication of this method in Pry::WrappedModule
+    # @param [String] str The string to lookup
+    # @return [Boolean]
+    def safe_to_evaluate?(str)
+      return true if str.strip == "self"
+      kind = target.eval("defined?(#{str})")
+      kind =~ /variable|constant/
+    end
+
+    def target_self
+      target.eval('self')
+    end
+
+    # grab the nth (`super_level`) super of `obj
+    # @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
+
+      sup = obj.super(super_level)
+      if !sup
+        raise Pry::CommandError, "No superclass found for #{obj.wrapped}"
+      else
+        sup
+      end
+    end
+  end
+end

data/lib/pry/color_printer.rb

@@ -0,0 +1,55 @@
+# PP subclass for streaming inspect output in color.
+class Pry
+  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"
+      end
+    end
+
+    CodeRay::Encoders::Terminal::TOKEN_COLORS[:comment][:self] = "\e[1;34m"
+
+    def self.pp(obj, out = $>, width = 79)
+      q = ColorPrinter.new(out, width)
+      q.guard_inspect_key { q.pp obj }
+      q.flush
+      out << "\n"
+    end
+
+    def text(str, width = str.length)
+      # Don't recolorize output with color [Issue #751]
+      if str.include?("\e[")
+        super "#{str}\e[0m", width
+      elsif str.start_with?('#<') || str == '=' || str == '>'
+        super highlight_object_literal(str), width
+      else
+        super CodeRay.scan(str, :ruby).term, width
+      end
+    end
+
+    def pp(obj)
+      super
+    rescue => e
+      raise if e.is_a? Pry::Pager::StopPaging
+
+      # Read the class name off of the singleton class to provide a default
+      # inspect.
+      singleton = class << obj; 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"
+    end
+  end
+end