Class: Parser::AST::Node

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

Overview

Parser::AST::Node monkey patch.

Instance Method Summary collapse

Instance Method Details

#arguments ⇒ Array<Parser::AST::Node>

Get arguments node of :send, :block or :defined? node.

Returns:

Raises:



46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/synvert/core/node_ext.rb', line 46

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

#body ⇒ Array<Parser::AST::Node>

Get body node of :begin or :block node.

Returns:

Raises:



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

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

#caller ⇒ Parser::AST::Node

Get caller node of :block node.

Returns:

Raises:



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

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

#condition ⇒ Parser::AST::Node

Get condition node of :if node.

Returns:

Raises:



90
91
92
93
94
95
96
 
# File 'lib/synvert/core/node_ext.rb', line 90

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

#has_key?(key) ⇒ Boolean

Test if hash node contains specified key.

Parameters:

  • key (Object) —

    value.

Returns:

  • (Boolean) —

    true if specified key exists.

Raises:



127
128
129
130
131
132
133
 
# File 'lib/synvert/core/node_ext.rb', line 127

def has_key?(key)
  if :hash == self.type
    self.children.any? { |pair_node| pair_node.key.to_value == key }
  else
    raise Synvert::Core::MethodNotSupported.new "has_key? is not handled for #{self.inspect}"
  end
end

#hash_value(key) ⇒ Parser::AST::Node

Get hash value node according to specified key.

Parameters:

  • key (Object) —

    value.

Returns:

Raises:



140
141
142
143
144
145
146
147
 
# File 'lib/synvert/core/node_ext.rb', line 140

def hash_value(key)
  if :hash == self.type
    value_node = self.children.find { |pair_node| pair_node.key.to_value == key }
    value_node ? value_node.value : nil
  else
    raise Synvert::Core::MethodNotSupported.new "has_key? is not handled for #{self.inspect}"
  end
end

#indent ⇒ Integer

Get the indent of current node.

Returns:

  • (Integer) —

    indent.



209
210
211
 
# File 'lib/synvert/core/node_ext.rb', line 209

def indent
  self.loc.expression.column
end

#key ⇒ Parser::AST::Node

Get key node of hash :pair node.

Returns:

Raises:



153
154
155
156
157
158
159
 
# File 'lib/synvert/core/node_ext.rb', line 153

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

#keys ⇒ Array<Parser::AST::Node>

Get keys node of :hash node.

Returns:

Raises:



102
103
104
105
106
107
108
 
# File 'lib/synvert/core/node_ext.rb', line 102

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

#match?(rules) ⇒ Boolean

Match current node with rules.

Parameters:

  • rules (Hash) —

    rules to match.

Returns:

  • (Boolean) —

    true if matches.



230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
 
# File 'lib/synvert/core/node_ext.rb', line 230

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

#message ⇒ Parser::AST::Node

Get message node of :send node.

Returns:

Raises:



34
35
36
37
38
39
40
 
# File 'lib/synvert/core/node_ext.rb', line 34

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

#name ⇒ Parser::AST::Node

Get name node of :class, :module, :def and :defs node.

Returns:

Raises:



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

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

#receiver ⇒ Parser::AST::Node

Get receiver node of :send node.

Returns:

Raises:



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

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

#recursive_children {|child| ... } ⇒ Object

Recursively iterate all child nodes of current node.

Yields:

  • (child) —

    Gives a child node.

Yield Parameters:



217
218
219
220
221
222
223
224
 
# File 'lib/synvert/core/node_ext.rb', line 217

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) ⇒ String

Get rewritten source code.

Examples:

node.rewritten_source("create({{arguments}})") #=> "create(:post)"

Parameters:

  • code (String) —

    raw code.

Returns:

  • (String) —

    rewritten code, replace string in block } in raw code.

Raises:



255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
 
# File 'lib/synvert/core/node_ext.rb', line 255

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 Synvert::Core::MethodNotSupported.new "rewritten_source is not handled for #{evaluated.inspect}"
    end
  end
end

#to_source ⇒ String

Get the source code of current node.

Returns:

  • (String) —

    source code.



199
200
201
202
203
204
 
# File 'lib/synvert/core/node_ext.rb', line 199

def to_source
  instance = Synvert::Rewriter::Instance.current
  if self.loc.expression
    instance.current_source[self.loc.expression.begin_pos...self.loc.expression.end_pos]
  end
end

#to_value ⇒ Object

Return the exact value.

Returns:

  • (Object) —

    exact value.

Raises:



177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
 
# File 'lib/synvert/core/node_ext.rb', line 177

def to_value
  case self.type
  when :int, :str, :sym
    self.children.last
  when :true
    true
  when :false
    false
  when :array
    self.children.map(&:to_value)
  when :irange
    (self.children.first.to_value..self.children.last.to_value)
  when :begin
    self.children.first.to_value
  else
    raise Synvert::Core::MethodNotSupported.new "to_value is not handled for #{self.inspect}"
  end
end

#value ⇒ Parser::AST::Node

Get value node of hash :pair node.

Returns:

Raises:



165
166
167
168
169
170
171
 
# File 'lib/synvert/core/node_ext.rb', line 165

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

#values ⇒ Array<Parser::AST::Node>

Get values node of :hash node.

Returns:

Raises:



114
115
116
117
118
119
120
 
# File 'lib/synvert/core/node_ext.rb', line 114

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