Class: Pry::Method

Inherits:
Object show all
Extended by:
Helpers::BaseHelpers
Includes:
CodeObject::Helpers, Helpers::BaseHelpers, Helpers::DocumentationHelpers
Defined in:
lib/pry/method.rb,
lib/pry/method/patcher.rb,
lib/pry/method/disowned.rb,
lib/pry/method/weird_method_locator.rb

Overview

This class wraps the normal Method and UnboundMethod classes to provide extra functionality useful to Pry.

Direct Known Subclasses

Disowned

Defined Under Namespace

Classes: Disowned, Patcher, WeirdMethodLocator

Constant Summary

Constants included from Helpers::DocumentationHelpers

Helpers::DocumentationHelpers::YARD_TAGS

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Helpers::BaseHelpers

colorize_code, find_command, heading, highlight, not_a_real_file?, safe_send, silence_warnings, stagger_output, use_ansi_codes?

Methods included from CodeObject::Helpers

#c_method?, #c_module?, #command?, #module_with_yard_docs?, #real_method_object?

Methods included from Helpers::DocumentationHelpers

#get_comment_content, get_comment_content, process_comment_markup, #process_comment_markup, #process_rdoc, process_rdoc, #process_yardoc, process_yardoc, process_yardoc_tag, #process_yardoc_tag, #strip_comments_from_c_code, strip_comments_from_c_code, #strip_leading_whitespace, strip_leading_whitespace

Constructor Details

#initialize(method, known_info = {}) ⇒ Pry::Method

A new instance of Pry::Method wrapping the given ::Method, UnboundMethod, or Proc.

Parameters:

  • method (::Method, UnboundMethod, Proc)
  • known_info (Hash) (defaults to: {})

    Can be used to pre-cache expensive to compute stuff.


258
259
260
261
# File 'lib/pry/method.rb', line 258

def initialize(method, known_info = {})
  @method = method
  @visibility = known_info[:visibility]
end

Dynamic Method Handling

This class handles dynamic methods through the method_missing method

#method_missing(method_name, *args, &block) ⇒ Object

Delegate any unknown calls to the wrapped method.


498
499
500
501
502
503
504
# File 'lib/pry/method.rb', line 498

def method_missing(method_name, *args, &block)
  if @method.respond_to?(method_name)
    @method.__send__(method_name, *args, &block)
  else
    super
  end
end

Class Method Details

.all_from_class(klass, include_super = true) ⇒ Array[Pry::Method]

Get all of the instance methods of a Class or Module

Parameters:

  • klass (Class, Module)
  • include_super (Boolean) (defaults to: true)

    Whether to include methods from ancestors.

Returns:


159
160
161
162
163
164
165
166
167
168
169
170
# File 'lib/pry/method.rb', line 159

def all_from_class(klass, include_super = true)
  %w[public protected private].flat_map do |visibility|
    safe_send(
      klass, :"#{visibility}_instance_methods", include_super
    ).map do |method_name|
      new(
        safe_send(klass, :instance_method, method_name),
        visibility: visibility.to_sym
      )
    end
  end
end

.all_from_obj(obj, include_super = true) ⇒ Array[Pry::Method]

Get all of the methods on an Object

Parameters:

  • obj (Object)
  • include_super (Boolean) (defaults to: true)

    indicates whether or not to include methods from ancestors.

Returns:


182
183
184
# File 'lib/pry/method.rb', line 182

def all_from_obj(obj, include_super = true)
  all_from_class(singleton_class_of(obj), include_super)
end

.from_binding(binding) ⇒ Pry::Method?

Given a Binding, try to extract the ::Method it originated from and use it to instantiate a Pry::Method. Return nil if this isn't possible.

Parameters:

  • binding (Binding)

Returns:


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
# File 'lib/pry/method.rb', line 75

def from_binding(binding)
  meth_name = binding.eval('::Kernel.__method__')
  if [:__script__, nil].include?(meth_name)
    nil
  else
    method =
      begin
        if Object === binding.eval('self') # rubocop:disable Style/CaseEquality
          new(
            Kernel.instance_method(:method)
              .bind(binding.eval("self"))
              .call(meth_name)
          )
        else
          str = 'class << self; self; end' \
                '.instance_method(::Kernel.__method__).bind(self)'
          new(binding.eval(str))
        end
      rescue NameError, NoMethodError # rubocop:disable Lint/ShadowedException
        Disowned.new(binding.eval('self'), meth_name.to_s)
      end

    if WeirdMethodLocator.weird_method?(method, binding)
      WeirdMethodLocator.new(method, binding).find_method || method
    else
      method
    end
  end
end

.from_class(klass, name, target = TOPLEVEL_BINDING) ⇒ Pry::Method? Also known as: from_module

Given a Class or Module and the name of a method, try to instantiate a Pry::Method containing the instance method of that name. Return nil if no such method exists.

Parameters:

  • klass (Class, Module)
  • name (String)
  • target (Binding) (defaults to: TOPLEVEL_BINDING)

    The binding where the method is looked up.

Returns:


134
135
136
137
138
# File 'lib/pry/method.rb', line 134

def from_class(klass, name, target = TOPLEVEL_BINDING)
  new(lookup_method_via_binding(klass, name, :instance_method, target))
rescue StandardError
  nil
end

.from_obj(obj, name, target = TOPLEVEL_BINDING) ⇒ Pry::Method?

Given an object and the name of a method, try to instantiate a Pry::Method containing the method of that name bound to that object. Return nil if no such method exists.

Parameters:

  • obj (Object)
  • name (String)
  • target (Binding) (defaults to: TOPLEVEL_BINDING)

    The binding where the method is looked up.

Returns:


149
150
151
152
153
# File 'lib/pry/method.rb', line 149

def from_obj(obj, name, target = TOPLEVEL_BINDING)
  new(lookup_method_via_binding(obj, name, :method, target))
rescue StandardError
  nil
end

.from_str(name, target = TOPLEVEL_BINDING, options = {}) ⇒ Pry::Method?

Given a string representing a method name and optionally a binding to search in, find and return the requested method wrapped in a Pry::Method instance.

Parameters:

  • name (String)

    The name of the method to retrieve.

  • target (Binding) (defaults to: TOPLEVEL_BINDING)

    The context in which to search for the method.

  • options (Hash) (defaults to: {})

Options Hash (options):

  • :instance (Boolean)

    Look for an instance method if name doesn't contain any context.

  • :methods (Boolean)

    Look for a bound/singleton method if name doesn't contain any context.

Returns:

  • (Pry::Method, nil)

    A Pry::Method instance containing the requested method, or nil if name is nil or no method could be located matching the parameters.


41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
# File 'lib/pry/method.rb', line 41

def from_str(name, target = TOPLEVEL_BINDING, options = {})
  if name.nil?
    nil
  elsif name.to_s =~ /(.+)\#(\S+)\Z/
    context = Regexp.last_match(1)
    meth_name = Regexp.last_match(2)
    from_module(target.eval(context), meth_name, target)
  elsif name.to_s =~ /(.+)(\[\])\Z/
    context = Regexp.last_match(1)
    meth_name = Regexp.last_match(2)
    from_obj(target.eval(context), meth_name, target)
  elsif name.to_s =~ /(.+)(\.|::)(\S+)\Z/
    context = Regexp.last_match(1)
    meth_name = Regexp.last_match(3)
    from_obj(target.eval(context), meth_name, target)
  elsif options[:instance]
    from_module(target.eval("self"), name, target)
  elsif options[:methods]
    from_obj(target.eval("self"), name, target)
  else
    from_str(name, target, instance: true) ||
      from_str(name, target, methods: true)
  end
rescue Pry::RescuableException
  nil
end

.instance_method_definition?(name, definition_line) ⇒ Boolean

Returns:

  • (Boolean)

225
226
227
228
229
230
# File 'lib/pry/method.rb', line 225

def instance_method_definition?(name, definition_line)
  regexp =
    /^define_method\(?\s*[:\"\']#{Regexp.escape(name)}|
     ^def\s*#{Regexp.escape(name)}/x
  regexp =~ definition_line.strip
end

.instance_resolution_order(klass) ⇒ Array[Class, Module]

Get every Class and Module, in order, that will be checked when looking for methods on instances of the given Class or Module. This does not treat singleton classes of classes specially.

Parameters:

  • klass (Class, Module)

Returns:

  • (Array[Class, Module])

208
209
210
211
# File 'lib/pry/method.rb', line 208

def instance_resolution_order(klass)
  # include klass in case it is a singleton class,
  ([klass] + Pry::Method.safe_send(klass, :ancestors)).uniq
end

.lookup_method_via_binding(obj, method_name, method_type, target = TOPLEVEL_BINDING) ⇒ Method, UnboundMethod

In order to support 2.0 Refinements we need to look up methods inside the relevant Binding.

Parameters:

  • obj (Object)

    The owner/receiver of the method.

  • method_name (Symbol)

    The name of the method.

  • method_type (Symbol)

    The type of method: :method or :instance_method

  • target (Binding) (defaults to: TOPLEVEL_BINDING)

    The binding where the method is looked up.

Returns:

  • (Method, UnboundMethod)

    The 'refined' method object.


112
113
114
115
116
117
118
119
120
121
122
123
124
# File 'lib/pry/method.rb', line 112

def lookup_method_via_binding(
  obj, method_name, method_type, target = TOPLEVEL_BINDING
)
  Pry.current[:obj] = obj
  Pry.current[:name] = method_name
  receiver = obj.is_a?(Module) ? "Module" : "Kernel"
  target.eval(
    "::#{receiver}.instance_method(:#{method_type})" \
    ".bind(Pry.current[:obj]).call(Pry.current[:name])"
  )
ensure
  Pry.current[:obj] = Pry.current[:name] = nil
end

.method_definition?(name, definition_line) ⇒ Boolean

Returns:

  • (Boolean)

213
214
215
216
# File 'lib/pry/method.rb', line 213

def method_definition?(name, definition_line)
  singleton_method_definition?(name, definition_line) ||
    instance_method_definition?(name, definition_line)
end

.resolution_order(obj) ⇒ Array[Class, Module]

Get every Class and Module, in order, that will be checked when looking for an instance method to call on this object.

Parameters:

Returns:

  • (Array[Class, Module])

190
191
192
193
194
195
196
197
198
199
200
201
# File 'lib/pry/method.rb', line 190

def resolution_order(obj)
  if Class === obj # rubocop:disable Style/CaseEquality
    singleton_class_resolution_order(obj) + instance_resolution_order(Class)
  else
    klass = begin
              singleton_class_of(obj)
            rescue StandardError
              obj.class
            end
    instance_resolution_order(klass)
  end
end

.singleton_class_of(obj) ⇒ Object


245
246
247
248
249
# File 'lib/pry/method.rb', line 245

def singleton_class_of(obj)
  class << obj; self; end
rescue TypeError # can't define singleton. Fixnum, Symbol, Float, ...
  obj.class
end

.singleton_class_resolution_order(klass) ⇒ Object

Get the singleton classes of superclasses that could define methods on the given class object, and any modules they include. If a module is included at multiple points in the ancestry, only the lowest copy will be returned.


236
237
238
239
240
241
242
243
# File 'lib/pry/method.rb', line 236

def singleton_class_resolution_order(klass)
  ancestors = Pry::Method.safe_send(klass, :ancestors)
  resolution_order = ancestors.grep(Class).flat_map do |anc|
    [singleton_class_of(anc), *singleton_class_of(anc).included_modules]
  end

  resolution_order.reverse.uniq.reverse - Class.included_modules
end

.singleton_method_definition?(name, definition_line) ⇒ Boolean

Returns:

  • (Boolean)

218
219
220
221
222
223
# File 'lib/pry/method.rb', line 218

def singleton_method_definition?(name, definition_line)
  regexp =
    /^define_singleton_method\(?\s*[:\"\']#{Regexp.escape(name)}|
     ^def\s*self\.#{Regexp.escape(name)}/x
  regexp =~ definition_line.strip
end

Instance Method Details

#==(other) ⇒ Boolean

Returns:

  • (Boolean)

478
479
480
481
482
# File 'lib/pry/method.rb', line 478

def ==(other)
  return other == @method if other.is_a?(Pry::Method)

  @method == other
end

#alias?Boolean

Returns Is the method definitely an alias?

Returns:

  • (Boolean)

    Is the method definitely an alias?


473
474
475
# File 'lib/pry/method.rb', line 473

def alias?
  name != original_name
end

#aliasesArray<String>

Returns All known aliases for the method.

Returns:

  • (Array<String>)

    All known aliases for the method.


456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
# File 'lib/pry/method.rb', line 456

def aliases
  owner = @method.owner
  # Avoid using `to_sym` on {Method#name}, which returns a `String`, because
  # it won't be garbage collected.
  name = @method.name

  all_methods_to_compare = owner.instance_methods | owner.private_instance_methods
  alias_list = all_methods_to_compare.combination(2).select do |pair|
    pair.include?(name) &&
      owner.instance_method(pair.first) == owner.instance_method(pair.last)
  end.flatten
  alias_list.delete(name)

  alias_list.map(&:to_s)
end

#bound_method?Boolean

Returns Whether the method is bound.

Returns:

  • (Boolean)

    Whether the method is bound.


441
442
443
# File 'lib/pry/method.rb', line 441

def bound_method?
  is_a?(::Method)
end

#c_sourceObject (private)


572
573
574
575
# File 'lib/pry/method.rb', line 572

def c_source
  info = pry_doc_info
  strip_comments_from_c_code(info.source) if info && info.source
end

#commentObject


510
511
512
# File 'lib/pry/method.rb', line 510

def comment
  Pry::Code.from_file(source_file).comment_describing(source_line)
end

#docString?

Returns The documentation for the method, or nil if it's unavailable.

Returns:

  • (String, nil)

    The documentation for the method, or nil if it's unavailable.


324
325
326
327
328
329
330
331
332
333
# File 'lib/pry/method.rb', line 324

def doc
  @doc ||=
    case source_type
    when :c
      info = pry_doc_info
      info.docstring if info
    when :ruby
      get_comment_content(comment)
    end
end

#dynamically_defined?Boolean

Returns Was the method defined outside a source file?

Returns:

  • (Boolean)

    Was the method defined outside a source file?


431
432
433
# File 'lib/pry/method.rb', line 431

def dynamically_defined?
  !!(source_file && source_file =~ /(\(.*\))|<.*>/)
end

#is_a?(klass) ⇒ Boolean Also known as: kind_of?

Parameters:

  • klass (Class)

Returns:

  • (Boolean)

486
487
488
# File 'lib/pry/method.rb', line 486

def is_a?(klass)
  (klass == Pry::Method) || @method.is_a?(klass)
end

#method_name_from_first_line(first_ln) ⇒ String? (private)

Parameters:

  • first_ln (String)

    The first line of a method definition.

Returns:

  • (String, nil)

558
559
560
561
562
563
564
565
566
567
568
569
570
# File 'lib/pry/method.rb', line 558

def method_name_from_first_line(first_ln)
  return nil if first_ln.strip !~ /^def /

  tokens = SyntaxHighlighter.tokenize(first_ln)
  tokens = tokens.tokens.each_slice(2) if tokens.respond_to?(:tokens)
  tokens.each_cons(2) do |t1, t2|
    if t2.last == :method || t2.last == :ident && t1 == [".", :operator]
      return t2.first
    end
  end

  nil
end

#nameString

Get the name of the method as a String, regardless of the underlying Method#name type.

Returns:

  • (String)

267
268
269
# File 'lib/pry/method.rb', line 267

def name
  @method.name.to_s
end

#name_with_ownerString

Get the name of the method including the class on which it was defined.

Examples:

method(:puts).method_name
=> "Kernel.puts"

Returns:

  • (String)

294
295
296
# File 'lib/pry/method.rb', line 294

def name_with_owner
  "#{wrapped_owner.method_prefix}#{name}"
end

#original_nameString?

Returns The original name the method was defined under, before any aliasing, or nil if it can't be determined.

Returns:

  • (String, nil)

    The original name the method was defined under, before any aliasing, or nil if it can't be determined.


424
425
426
427
428
# File 'lib/pry/method.rb', line 424

def original_name
  return nil if source_type != :ruby

  method_name_from_first_line(source.lines.first)
end

#pry_doc_infoYARD::CodeObjects::MethodObject (private)

Returns:

  • (YARD::CodeObjects::MethodObject)

Raises:

  • (CommandError)

    when the method can't be found or pry-doc isn't installed.


518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
# File 'lib/pry/method.rb', line 518

def pry_doc_info
  if defined?(PryDoc)
    Pry::MethodInfo.info_for(@method) ||
      raise(
        CommandError,
        "Cannot locate this method: #{name}. (source_location returns nil)"
      )
  else
    fail_msg = "Cannot locate this method: #{name}."
    if Helpers::Platform.mri?
      fail_msg += " Invoke the 'gem-install pry-doc' Pry command to get " \
                  "access to Ruby Core documentation.\n"
    end
    raise CommandError, fail_msg
  end
end

#pry_method?Boolean

Returns Was the method defined within the Pry REPL?

Returns:

  • (Boolean)

    Was the method defined within the Pry REPL?


451
452
453
# File 'lib/pry/method.rb', line 451

def pry_method?
  source_file == Pry.eval_path
end

#redefine(source) ⇒ Object

Update the live copy of the method's source.


309
310
311
312
# File 'lib/pry/method.rb', line 309

def redefine(source)
  Patcher.new(self).patch_in_ram source
  Pry::Method(owner.instance_method(name))
end

#respond_to?(method_name, include_all = false) ⇒ Boolean

Parameters:

  • method_name (String, Symbol)

Returns:

  • (Boolean)

493
494
495
# File 'lib/pry/method.rb', line 493

def respond_to?(method_name, include_all = false)
  super || @method.respond_to?(method_name, include_all)
end

#respond_to_missing?(method_name, include_private = false) ⇒ Boolean

Returns:

  • (Boolean)

506
507
508
# File 'lib/pry/method.rb', line 506

def respond_to_missing?(method_name, include_private = false)
  @method.respond_to?(method_name) || super
end

#ruby_sourceObject (private)


577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
# File 'lib/pry/method.rb', line 577

def ruby_source
  # Clone of `MethodSource.source_helper` that knows to use our
  # hacked version of `source_location` for our input buffer for methods
  # defined in `(pry)`.
  file, line = *source_location
  unless file
    raise SourceNotFoundError, "Could not locate source for #{name_with_owner}!"
  end

  begin
    code = Pry::Code.from_file(file).expression_at(line)
  rescue SyntaxError => e
    raise MethodSource::SourceNotFoundError, e.message
  end
  strip_leading_whitespace(code)
end

#signatureString

Returns A representation of the method's signature, including its name and parameters. Optional and "rest" parameters are marked with * and block parameters with &. Keyword arguments are shown with : If the parameter names are unavailable, they're given numbered names instead. Paraphrased from awesome_print gem.

Returns:

  • (String)

    A representation of the method's signature, including its name and parameters. Optional and "rest" parameters are marked with * and block parameters with &. Keyword arguments are shown with : If the parameter names are unavailable, they're given numbered names instead. Paraphrased from awesome_print gem.


386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
# File 'lib/pry/method.rb', line 386

def signature
  if respond_to?(:parameters)
    args = parameters.inject([]) do |args_array, (arg_type, name)|
      name ||= (arg_type == :block ? 'block' : "arg#{args_array.size + 1}")
      args_array.push(
        case arg_type
        when :req    then name.to_s
        when :opt    then "#{name}=?"
        when :rest   then "*#{name}"
        when :block  then "&#{name}"
        when :key    then "#{name}:?"
        when :keyreq then "#{name}:"
        else '?'
        end
      )
    end
  else
    args = (1..arity.abs).map { |i| "arg#{i}" }
    args[-1] = "*#{args[-1]}" if arity < 0
  end

  "#{name}(#{args.join(', ')})"
end

#singleton_method?Boolean

Returns Whether the method is a singleton method.

Returns:

  • (Boolean)

    Whether the method is a singleton method.


446
447
448
# File 'lib/pry/method.rb', line 446

def singleton_method?
  wrapped_owner.singleton_class?
end

#sourceString?

Returns The source code of the method, or nil if it's unavailable.

Returns:

  • (String, nil)

    The source code of the method, or nil if it's unavailable.


299
300
301
302
303
304
305
306
# File 'lib/pry/method.rb', line 299

def source
  @source ||= case source_type
              when :c
                c_source
              when :ruby
                ruby_source
              end
end

#source?Boolean

Can we get the source code for this method?

Returns:

  • (Boolean)

316
317
318
319
320
# File 'lib/pry/method.rb', line 316

def source?
  !!source
rescue MethodSource::SourceNotFoundError
  false
end

#source_fileString?

Returns The name of the file the method is defined in, or nil if the filename is unavailable.

Returns:

  • (String, nil)

    The name of the file the method is defined in, or nil if the filename is unavailable.


343
344
345
346
347
348
349
350
351
352
# File 'lib/pry/method.rb', line 343

def source_file
  if source_location.nil?
    if source_type == :c
      info = pry_doc_info
      info.file if info
    end
  else
    source_location.first
  end
end

#source_lineFixnum?

Returns The line of code in source_file which begins the method's definition, or nil if that information is unavailable.

Returns:

  • (Fixnum, nil)

    The line of code in source_file which begins the method's definition, or nil if that information is unavailable.


356
357
358
# File 'lib/pry/method.rb', line 356

def source_line
  source_location.nil? ? nil : source_location.last
end

#source_rangeRange?

Returns The range of lines in source_file which contain the method's definition, or nil if that information is unavailable.

Returns:

  • (Range, nil)

    The range of lines in source_file which contain the method's definition, or nil if that information is unavailable.


362
363
364
# File 'lib/pry/method.rb', line 362

def source_range
  source_location.nil? ? nil : (source_line)..(source_line + source.lines.count - 1)
end

#source_typeSymbol

Returns The source type of the method. The options are :ruby for Ruby methods or :c for methods written in C.

Returns:

  • (Symbol)

    The source type of the method. The options are :ruby for Ruby methods or :c for methods written in C.


337
338
339
# File 'lib/pry/method.rb', line 337

def source_type
  source_location.nil? ? :c : :ruby
end

#super(times = 1) ⇒ Pry::Method?

Returns The wrapped method that is called when you use "super" in the body of this method.

Returns:

  • (Pry::Method, nil)

    The wrapped method that is called when you use "super" in the body of this method.


412
413
414
415
416
417
418
419
420
# File 'lib/pry/method.rb', line 412

def super(times = 1)
  if @method.is_a?(UnboundMethod)
    sup = super_using_ancestors(Pry::Method.instance_resolution_order(owner), times)
  else
    sup = super_using_ancestors(Pry::Method.resolution_order(receiver), times)
    sup &&= sup.bind(receiver)
  end
  Pry::Method.new(sup) if sup
end

#super_using_ancestors(ancestors, times = 1) ⇒ Method (private)

Returns The unwrapped super-method

Parameters:

  • ancestors (Class, Module)

    The ancestors to investigate

Returns:

  • (Method)

    The unwrapped super-method


537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
# File 'lib/pry/method.rb', line 537

def super_using_ancestors(ancestors, times = 1)
  next_owner = owner
  times.times do
    i = ancestors.index(next_owner) + 1
    while ancestors[i] &&
          !(ancestors[i].method_defined?(name) ||
            ancestors[i].private_method_defined?(name))
      i += 1
    end
    (next_owner = ancestors[i]) || (return nil)
  end

  begin
    safe_send(next_owner, :instance_method, name)
  rescue StandardError
    nil
  end
end

#unbound_method?Boolean

Returns Whether the method is unbound.

Returns:

  • (Boolean)

    Whether the method is unbound.


436
437
438
# File 'lib/pry/method.rb', line 436

def unbound_method?
  is_a?(::UnboundMethod)
end

#undefined?Boolean

Is the method undefined? (aka Disowned)

Returns:

  • (Boolean)

    false


285
286
287
# File 'lib/pry/method.rb', line 285

def undefined?
  false
end

#visibilitySymbol

Returns The visibility of the method. May be :public, :protected, or :private.

Returns:

  • (Symbol)

    The visibility of the method. May be :public, :protected, or :private.


368
369
370
371
372
373
374
375
376
377
378
379
# File 'lib/pry/method.rb', line 368

def visibility
  @visibility ||=
    if owner.public_instance_methods.any? { |m| m.to_s == name }
      :public
    elsif owner.protected_instance_methods.any? { |m| m.to_s == name }
      :protected
    elsif owner.private_instance_methods.any? { |m| m.to_s == name }
      :private
    else
      :none
    end
end

#wrappedMethod, ...

Get underlying object wrapped by this Pry::Method instance

Returns:

  • (Method, UnboundMethod, Proc)

279
280
281
# File 'lib/pry/method.rb', line 279

def wrapped
  @method
end

#wrapped_ownerPry::Module

Get the owner of the method as a Pry::Module

Returns:

  • (Pry::Module)

273
274
275
# File 'lib/pry/method.rb', line 273

def wrapped_owner
  @wrapped_owner ||= Pry::WrappedModule.new(owner)
end