Class: Object

Inherits:
BasicObject
Defined in:
lib/pry/core_extensions.rb

Instance Method Summary collapse

Instance Method Details

#__binding__ ⇒ Binding

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.

Returns:

  • (Binding) 


70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
 
# File 'lib/pry/core_extensions.rb', line 70

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 returned.

  # When you're cd'd into a class, methods you define should be added to it.
  if is_a?(Module)
    # A special case, for JRuby.
    # Module.new.class_eval("binding") has different behaviour than CRuby,
    # where this is not needed: class_eval("binding") vs class_eval{binding}.
    # Using a block works around the difference of behaviour on JRuby.
    # The scope is clear of local variables. Don't add any.
    #
    # This fixes the following two spec failures, at https://travis-ci.org/pry/pry/jobs/274470002
    # 1) ./spec/pry_spec.rb:360:in `block in (root)'
    # 2) ./spec/pry_spec.rb:366:in `block in (root)'
    return class_eval { binding } if Pry::Helpers::Platform.jruby? && name.nil?

    # class_eval sets both self and the default definee to this class.
    return class_eval("binding", __FILE__, __LINE__)
  end

  unless self.class.method_defined?(:__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 = {}) ⇒ Object

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.

Examples:

With a binding

binding.pry

On any object

"dummy".pry

With options

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

Parameters:

  • object (Object) (defaults to: nil) —

    the object or binding to pry (__deprecated__, use ‘object.pry`)

  • hash (Hash) (defaults to: {}) —

    the options hash

See Also:



43
44
45
46
47
48
49
 
# File 'lib/pry/core_extensions.rb', line 43

def pry(object = nil, hash = {})
  if object.nil? || Hash === object # rubocop:disable Style/CaseEquality
    Pry.start(self, object || {})
  else
    Pry.start(object, hash)
  end
end