class Object - pry-0.10.1 Documentation

# class Object

### Public Instance Methods

__binding__() click to toggle source

Return a binding object for the receiver.

The `self` of the binding is set to the current object, and it contains no local variables.

The default definee (yugui.jp/articles/846) is set such that:

- If `self` is a class or module, then new methods created in the binding will be defined in that class or module (as in `class Foo; end`).

- If `self` is a normal object, then new methods created in the binding will be defined on its singleton class (as in `class << self; end`).

- If `self` doesn’t have a real singleton class (i.e. it is a Fixnum, Float, Symbol, nil, true, or false), then new methods will be created on the object’s class (as in `self.class.class_eval{ }`)

Newly created constants, including classes and modules, will also be added to the default definee.

@return [Binding]

    # File lib/pry/core_extensions.rb, line 68
    def __binding__
      # If you ever feel like changing this method, be careful about variables
      # that you use. They shouldn't be inserted into the binding that will
      # eventually be returning.

      # When you're cd'd into a class, methods you define should be added to it.
      if is_a?(Module)
        # class_eval sets both self and the default definee to this class.
        return class_eval "binding"
      end

      unless respond_to?(:__pry__)
        # The easiest way to check whether an object has a working singleton class
        # is to try and define a method on it. (just checking for the presence of
        # the singleton class gives false positives for `true` and `false`).
        # __pry__ is just the closest method we have to hand, and using
        # it has the nice property that we can memoize this check.
        begin
          # instance_eval sets the default definee to the object's singleton class
          instance_eval(*Pry::BINDING_METHOD_IMPL)

        # If we can't define methods on the Object's singleton_class. Then we fall
        # back to setting the default definee to be the Object's class. That seems
        # nicer than having a REPL in which you can't define methods.
        rescue TypeError, Pry::FrozenObjectException
          # class_eval sets the default definee to self.class
          self.class.class_eval(*Pry::BINDING_METHOD_IMPL)
        end
      end

      __pry__
    end

pry(object=nil, hash={}) click to toggle source

Start a Pry REPL on self.

If `self` is a Binding then that will be used to evaluate expressions; otherwise a new binding will be created.

@param [Object] object the object or binding to pry

    (__deprecated__, use `object.pry`)

@param [Hash] hash the options hash @example With a binding

    binding.pry

@example On any object

    "dummy".pry

@example With options

    def my_method
      binding.pry :quiet => true
    end
    my_method()

@see Pry.start

    # File lib/pry/core_extensions.rb, line 41
    def pry(object=nil, hash={})
      if object.nil? || Hash === object
        Pry.start(self, object || {})
      else
        Pry.start(object, hash)
      end
    end

pry_eval(*eval_strs) click to toggle source

    # File lib/pry/test/helper.rb, line 88
    def pry_eval(*eval_strs)
      if eval_strs.first.is_a? String
        binding = Pry.toplevel_binding
      else
        binding = Pry.binding_for(eval_strs.shift)
      end

      pry_tester(binding).eval(*eval_strs)
    end

pry_tester(*args, &block) click to toggle source

    # File lib/pry/test/helper.rb, line 78
    def pry_tester(*args, &block)
      if args.length == 0 || args[0].is_a?(Hash)
        args.unshift(Pry.toplevel_binding)
      end

      PryTester.new(*args).tap do |t|
        (class << t; self; end).class_eval(&block) if block
      end
    end