Class: IRB::Command::Ls

Inherits:
Base show all
Defined in:
lib/irb/command/ls.rb

Defined Under Namespace

Classes: EvaluationError

Instance Attribute Summary

Attributes inherited from Base

#irb_context

Instance Method Summary collapse

Methods inherited from Base

category, description, execute, help_message, #initialize

Constructor Details

This class inherits a constructor from IRB::Command::Base

Instance Method Details

#class_method_map(classes, dumped_mods) ⇒ Object

[View source]

84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
# File 'lib/irb/command/ls.rb', line 84

def class_method_map(classes, dumped_mods)
  dumped_methods = Array.new
  classes.map do |mod|
    next if dumped_mods.include? mod

    dumped_mods << mod

    methods = mod.public_instance_methods(false).select do |method|
      if dumped_methods.include? method
        false
      else
        dumped_methods << method
        true
      end
    end

    [mod, methods]
  end.compact
end

#dump_methods(o, klass, obj) ⇒ Object

[View source]

69
70
71
72
73
74
75
76
77
78
79
80
81
82
# File 'lib/irb/command/ls.rb', line 69

def dump_methods(o, klass, obj)
  singleton_class = begin obj.singleton_class; rescue TypeError; nil end
  dumped_mods = Array.new
  ancestors = klass.ancestors
  ancestors = ancestors.reject { |c| c >= Object } if klass < Object
  singleton_ancestors = (singleton_class&.ancestors || []).reject { |c| c >= Class }

  # singleton_class' ancestors should be at the front
  maps = class_method_map(singleton_ancestors, dumped_mods) + class_method_map(ancestors, dumped_mods)
  maps.each do |mod, methods|
    name = mod == singleton_class ? "#{klass}.methods" : "#{mod}#methods"
    o.dump(name, methods)
  end
end

#evaluate(code) ⇒ Object

[View source]

25
26
27
28
29
30
# File 'lib/irb/command/ls.rb', line 25

def evaluate(code)
  @irb_context.workspace.binding.eval(code)
rescue Exception => e
  puts "#{e.class}: #{e.message}"
  raise EvaluationError
end

#execute(arg) ⇒ Object

[View source]

32
33
34
35
36
37
38
39
40
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
67
# File 'lib/irb/command/ls.rb', line 32

def execute(arg)
  if match = arg.match(/\A(?<target>.+\s|)(-g|-G)\s+(?<grep>.+)$/)
    target = match[:target]
    grep = Regexp.new(match[:grep])
  elsif match = arg.match(/\A((?<target>.+),|)\s*grep:(?<grep>.+)/)
    # Legacy style `ls obj, grep: /regexp/`
    # Evaluation order should be eval(target) then eval(grep)
    target = match[:target] || ''
    grep_regexp_code = match[:grep]
  else
    target = arg.strip
  end

  if target.empty?
    obj = irb_context.workspace.main
    locals = irb_context.workspace.binding.local_variables
  else
    obj = evaluate(target)
  end

  if grep_regexp_code
    grep = evaluate(grep_regexp_code)
  end

  o = Output.new(grep: grep)

  klass  = (obj.class == Class || obj.class == Module ? obj : obj.class)

  o.dump("constants", obj.constants) if obj.respond_to?(:constants)
  dump_methods(o, klass, obj)
  o.dump("instance variables", obj.instance_variables)
  o.dump("class variables", klass.class_variables)
  o.dump("locals", locals) if locals
  o.print_result
rescue EvaluationError
end