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 



29
30
31
32
33
34
35
36
37
38
39
40
 
# File 'lib/synvert/node_ext.rb', line 29

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 



50
51
52
53
54
55
56
57
58
59
 
# File 'lib/synvert/node_ext.rb', line 50

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

#caller ⇒ Object 



42
43
44
45
46
47
48
 
# File 'lib/synvert/node_ext.rb', line 42

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

#condition ⇒ Object 



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

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

#indent ⇒ Object 



107
108
109
 
# File 'lib/synvert/node_ext.rb', line 107

def indent
  self.loc.expression.column
end

#key ⇒ Object 



85
86
87
88
89
90
91
 
# File 'lib/synvert/node_ext.rb', line 85

def key
  if :pair == self.type
    self.children.first
  else
    raise NotImplementedError.new "key is not handled for #{self.inspect}"
  end
end

#keys ⇒ Object 



69
70
71
72
73
74
75
 
# File 'lib/synvert/node_ext.rb', line 69

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

#match?(instance, rules) ⇒ Boolean

Returns:

  • (Boolean) 


120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
 
# File 'lib/synvert/node_ext.rb', line 120

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

#message ⇒ Object 



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

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
9
10
11
 
# File 'lib/synvert/node_ext.rb', line 2

def name
  case self.type
  when :class, :module, :def
    self.children[0]
  when :defs
    self.children[1]
  else
    raise NotImplementedError.new "name is not handled for #{self.inspect}"
  end
end

#receiver ⇒ Object 



13
14
15
16
17
18
19
 
# File 'lib/synvert/node_ext.rb', line 13

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 



111
112
113
114
115
116
117
118
 
# File 'lib/synvert/node_ext.rb', line 111

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 



138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
 
# File 'lib/synvert/node_ext.rb', line 138

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
      if evaluated.size > 0
        source = evaluated.first.loc.expression.source_buffer.source
        source[evaluated.first.loc.expression.begin_pos...evaluated.last.loc.expression.end_pos]
      end
    when String
      evaluated
    when NilClass
      'nil'
    else
      raise NotImplementedError.new "rewritten_source is not handled for #{evaluated.inspect}"
    end
  end
end

#source(instance) ⇒ Object 



101
102
103
104
105
 
# File 'lib/synvert/node_ext.rb', line 101

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

#value ⇒ Object 



93
94
95
96
97
98
99
 
# File 'lib/synvert/node_ext.rb', line 93

def value
  if :pair == self.type
    self.children.last
  else
    raise NotImplementedError.new "value is not handled for #{self.inspect}"
  end
end

#values ⇒ Object 



77
78
79
80
81
82
83
 
# File 'lib/synvert/node_ext.rb', line 77

def values
  if :hash == self.type
    self.children.map { |child| child.children[1] }
  else
    raise NotImplementedError.new "keys is not handled for #{self.inspect}"
  end
end