class Pry::CodeObject - pry-0.10.1 Documentation

# class Pry::CodeObject

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.

### Attributes

_pry_[RW]
str[RW]
super_level[RW]
target[RW]

### Public Class Methods

lookup(str, _pry_, options={}) click to toggle source

    # File lib/pry/code_object.rb, line 45
    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

new(str, _pry_, options={}) click to toggle source

    # File lib/pry/code_object.rb, line 58
    def initialize(str, _pry_, options={})
      options = {
        :super => 0,
      }.merge!(options)

      @str = str
      @_pry_ = _pry_
      @target = _pry_.current_context
      @super_level = options[:super]
    end

### Public Instance Methods

command_lookup() click to toggle source

    # File lib/pry/code_object.rb, line 69
    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

default_lookup() click to toggle source

lookup variables and constants and `self` that are not modules

    # File lib/pry/code_object.rb, line 93
    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

empty_lookup() click to toggle source

when no paramter is given (i.e ::lookup), then we lookup the ‘current object’ from the binding.

    # File lib/pry/code_object.rb, line 77
    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

method_or_class_lookup() click to toggle source

    # File lib/pry/code_object.rb, line 114
    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