Class: ParseTreeArray

Inherits:
Array
  • Object
show all
Defined in:
lib/mri_args.rb

Constant Summary collapse

R2R = 
Object.const_defined?(:Ruby2Ruby) ? Ruby2Ruby : RubyToRuby

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.translate(*args) ⇒ Object 



7
8
9
10
11
12
13
14
15
16
17
18
19
 
# File 'lib/mri_args.rb', line 7

def self.translate(*args)
  sexp = ParseTree.translate(*args)
  # ParseTree.translate returns [nil] if called on an inherited method, so walk
  # up the inheritance chain to find the class that the method was defined in
  unless sexp.first
    klass = args.first.ancestors.detect do |klass| 
      klass.public_instance_methods(false).include?(args.last.to_s)
    end
    sexp = ParseTree.translate(klass, args.last) if klass
  end
  sexp = Unifier.new.process(sexp)
  self.new(sexp)
end

Instance Method Details

#arg_nodes ⇒ Object 



30
31
32
33
34
35
 
# File 'lib/mri_args.rb', line 30

def arg_nodes
  self[1..-1].inject([]) do |sum,item|
    sum << [item] unless item.is_a?(Array)
    sum
  end
end

#deep_array_node(type = nil) ⇒ Object 



21
22
23
24
25
26
27
28
 
# File 'lib/mri_args.rb', line 21

def deep_array_node(type = nil)
  each do |node|
    return ParseTreeArray.new(node) if node.is_a?(Array) && (!type || node[0] == type)
    next unless node.is_a?(Array)
    return ParseTreeArray.new(node).deep_array_node(type)
  end
  nil
end

#get_args ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/mri_args.rb', line 37

def get_args
  if arg_node = deep_array_node(:args)
    # method defined with def keyword
    args = arg_node.arg_nodes
    default_node = arg_node.deep_array_node(:block)
    return [args, []] unless default_node
  else
    # assuming method defined with Module#define_method
    return [[],[]]
  end
  
  # if it was defined with def, and we found the default_node,
  # that should bring us back to regularly scheduled programming..
  lasgns = default_node[1..-1]
  lasgns.each do |asgn|
    args.assoc(asgn[1]) << eval(R2R.new.process(asgn[2]))
  end
  [args, (default_node[1..-1].map { |asgn| asgn[1] })]
end