Class: Parser::AST::Node

Inherits:
Object
  • Object
show all
Defined in:
lib/synvert/node_ext.rb

Instance Method Summary collapse

Instance Method Details

#arguments ⇒ Object 



26
27
28
29
30
31
32
33
34
35
36
37
 
# File 'lib/synvert/node_ext.rb', line 26

def arguments
  case self.type
  when :send
    self.children[2..-1]
  when :block
    self.children[1].children
  when :defined?
    self.children
  else
    raise NotImplementedError.new "arguments is not handled for #{self.inspect}"
  end
end

#body ⇒ Object 



47
48
49
50
51
52
53
 
# File 'lib/synvert/node_ext.rb', line 47

def body
  if :block == self.type
    self.children[2]
  else
    raise NotImplementedError.new "body is not handled for #{self.inspect}"
  end
end

#caller ⇒ Object 



39
40
41
42
43
44
45
 
# File 'lib/synvert/node_ext.rb', line 39

def caller
  if :block == self.type
    self.children[0]
  else
    raise NotImplementedError.new "caller is not handled for #{self.inspect}"
  end
end

#condition ⇒ Object 



55
56
57
58
59
60
61
 
# File 'lib/synvert/node_ext.rb', line 55

def condition
  if :if == self.type
    self.children[0]
  else
    raise NotImplementedError.new "condition is not handled for #{self.inspect}"
  end
end

#grep_node(options) ⇒ Object 



82
83
84
85
86
 
# File 'lib/synvert/node_ext.rb', line 82

def grep_node(options)
  self.recursive_children do |child|
    return child if child.match?(options)
  end
end

#indent ⇒ Object 



69
70
71
 
# File 'lib/synvert/node_ext.rb', line 69

def indent
  self.loc.expression.column
end

#match?(instance, options) ⇒ Boolean

Returns:



88
89
90
91
92
93
94
95
96
97
98
99
100
 
# File 'lib/synvert/node_ext.rb', line 88

def match?(instance, options)
  flat_hash(options).keys.all? do |multi_keys|
    if multi_keys.last == :any
      actual_values = actual_value(self, instance, multi_keys[0...-1])
      expected = expected_value(options, multi_keys)
      actual_values.any? { |actual| match_value?(instance, actual, expected) }
    else
      actual = actual_value(self, instance, multi_keys)
      expected = expected_value(options, multi_keys)
      match_value?(instance, actual, expected)
    end
  end
end

#message ⇒ Object 



18
19
20
21
22
23
24
 
# File 'lib/synvert/node_ext.rb', line 18

def message
  if :send == self.type
    self.children[1]
  else
    raise NotImplementedError.new "message is not handled for #{self.inspect}"
  end
end

#name ⇒ Object 



2
3
4
5
6
7
8
 
# File 'lib/synvert/node_ext.rb', line 2

def name
  if [:class, :def].include? self.type
    self.children[0]
  else
    raise NotImplementedError.new "name is not handled for #{self.inspect}"
  end
end

#receiver ⇒ Object 



10
11
12
13
14
15
16
 
# File 'lib/synvert/node_ext.rb', line 10

def receiver
  if :send == self.type
    self.children[0]
  else
    raise NotImplementedError.new "receiver is not handled for #{self.inspect}"
  end
end

#recursive_children ⇒ Object 



73
74
75
76
77
78
79
80
 
# File 'lib/synvert/node_ext.rb', line 73

def recursive_children
  self.children.each do |child|
    if Parser::AST::Node === child
      yield child
      child.recursive_children { |c| yield c }
    end
  end
end

#rewritten_source(code) ⇒ Object 



102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
# File 'lib/synvert/node_ext.rb', line 102

def rewritten_source(code)
  code.gsub(/{{(.*?)}}/m) do
    evaluated = self.instance_eval $1
    case evaluated
    when Parser::AST::Node
      source = evaluated.loc.expression.source_buffer.source
      source[evaluated.loc.expression.begin_pos...evaluated.loc.expression.end_pos]
    when Array
      source = evaluated.first.loc.expression.source_buffer.source
      source[evaluated.first.loc.expression.begin_pos...evaluated.last.loc.expression.end_pos]
    when String
      evaluated
    else
      raise NotImplementedError.new "rewritten_source is not handled for #{evaluated.inspect}"
    end
  end
end

#source(instance) ⇒ Object 



63
64
65
66
67
 
# File 'lib/synvert/node_ext.rb', line 63

def source(instance)
  if self.loc.expression
    instance.current_source[self.loc.expression.begin_pos...self.loc.expression.end_pos]
  end
end