Class: Puppet::Pops::Model::AstTreeDumper

Inherits:
TreeDumper show all
Defined in:
lib/puppet/pops/model/ast_tree_dumper.rb

Overview

Dumps a Pops::Model in reverse polish notation; i.e. LISP style The intention is to use this for debugging output TODO: BAD NAME - A DUMP is a Ruby Serialization

Constant Summary collapse

AST = 
Puppet::Parser::AST
Model = 
Puppet::Pops::Model

Instance Attribute Summary

Attributes inherited from TreeDumper

#indent_count

Instance Method Summary collapse

Methods inherited from TreeDumper

#do_dump, #dump, #format, #format_r, #indent, #initialize

Constructor Details

This class inherits a constructor from Puppet::Pops::Model::TreeDumper

Instance Method Details

#_dump_ParameterArray(o) ⇒ Object

Puppet AST encodes a parameter as a one or two slot Array. This is not a polymorph dump method.



273
274
275
276
277
278
279
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 273

def _dump_ParameterArray o
  if o.size == 2
    ["=", o[0], do_dump(o[1])]
  else
    o[0]
  end
end

#dump_ArithmeticOperator(o) ⇒ Object 



28
29
30
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 28

def dump_ArithmeticOperator o
  [o.operator.to_s, do_dump(o.lval), do_dump(o.rval)]
end

#dump_Array(o) ⇒ Object 



112
113
114
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 112

def dump_Array o
  o.collect {|e| do_dump(e) }
end

#dump_ASTArray(o) ⇒ Object 



116
117
118
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 116

def dump_ASTArray o
  ["[]"] + o.children.collect {|x| do_dump(x)}
end

#dump_ASTHash(o) ⇒ Object 



120
121
122
123
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 120

def dump_ASTHash o
  ["{}"] + o.value.sort_by{|k,v| k.to_s}.collect {|x| [do_dump(x[0]), do_dump(x[1])]}
#    ["{}"] + o.value.collect {|x| [do_dump(x[0]), do_dump(x[1])]}
end

#dump_BlockExpression(o) ⇒ Object 



185
186
187
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 185

def dump_BlockExpression o
  ["block"] + o.children.collect {|x| do_dump(x) }
end

#dump_Boolean(o) ⇒ Object 



85
86
87
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 85

def dump_Boolean o
  o.to_s
end

#dump_BooleanOperator(o) ⇒ Object 



89
90
91
92
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 89

def dump_BooleanOperator o
  operator = o.operator == 'and' ? '&&' : '||'
  [operator, do_dump(o.lval), do_dump(o.rval)]
end

#dump_CaseOpt(o) ⇒ Object 



319
320
321
322
323
324
325
326
327
328
329
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 319

def dump_CaseOpt o
  result = ["when"]
  result << o.value.collect {|x| do_dump(x) }
  # A bit of trickery to get it into the same shape as Pops output
  if is_nop?(o.statements)
    result << ["then", []]  # Puppet AST has a nop if there is no body
  else
    result << ["then", do_dump(o.statements) ]
  end
  result
end

#dump_CaseStatement(o) ⇒ Object 



311
312
313
314
315
316
317
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 311

def dump_CaseStatement o
  result = ["case", do_dump(o.test), :indent]
  o.options.each do |s|
    result << :break << do_dump(s)
  end
  result << :dedent
end

#dump_Collection(o) ⇒ Object

The AST Collection knows about exported or virtual query, not the query.



52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 52

def dump_Collection o
  result = ["collect", do_dump(o.type), :indent, :break]
  if o.form == :virtual
    q = ["<| |>"]
  else
    q = ["<<| |>>"]
  end
  q << do_dump(o.query) unless is_nop?(o.query)
  q <<  :indent
  result << q
  o.override do |ao|
    result << :break << do_dump(ao)
  end
  result += [:dedent, :dedent ]
  result
end

#dump_CollExpr(o) ⇒ Object 



69
70
71
72
73
74
75
76
77
78
79
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 69

def dump_CollExpr o
  operator = case o.oper
  when 'and'
    '&&'
  when 'or'
    '||'
  else
    o.oper
  end
  [operator, do_dump(o.test1), do_dump(o.test2)]
end

#dump_ComparisonOperator(o) ⇒ Object 



81
82
83
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 81

def dump_ComparisonOperator o
  [o.operator.to_s, do_dump(o.lval), do_dump(o.rval)]
end

#dump_Concat(o) ⇒ Object

Interpolated strings are shown as (cat seg0 seg1 … segN)



190
191
192
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 190

def dump_Concat o
  ["cat"] + o.value.collect {|x| x.is_a?(AST::String) ? " "+do_dump(x) : ["str", do_dump(x)]}
end

#dump_Default(o) ⇒ Object 



152
153
154
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 152

def dump_Default o
  ":default"
end

#dump_Definition(o) ⇒ Object 



232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 232

def dump_Definition o
  # ok, this is even crazier that Hostclass. The name of the define does not have an accessor
  # and some things are in the context (but not the name). Parameters are called arguments and they
  # are in a Ruby Array where each parameter is an array of 1 or 2 elements.
  #
  context = o.context
  name = o.instance_variable_get("@name")
  args = context[:arguments]
  code = context[:code]
  result = ["define", name]
  result << ["parameters"] + args.collect {|p| _dump_ParameterArray(p) } if args && args.size() > 0
  if is_nop?(code)
    result << []
  else
    result << do_dump(code)
  end
  result
end

#dump_Factory(o) ⇒ Object 



24
25
26
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 24

def dump_Factory o
  do_dump(o.current)
end

#dump_Function(o) ⇒ Object

Produces (invoke name args…) when not required to produce an rvalue, and (call name args … ) otherwise.



294
295
296
297
298
299
300
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 294

def dump_Function o
  # somewhat ugly as Function hides its "ftype" instance variable
  result = [o.instance_variable_get("@ftype") == :rvalue ? "call" : "invoke", do_dump(o.name)]
  o.arguments.collect {|a| result << do_dump(a) }
  result << do_dump(o.pblock) if o.pblock
  result
end

#dump_HashOrArrayAccess(o) ⇒ Object

x prints as (slice x y)



46
47
48
49
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 46

def dump_HashOrArrayAccess o
  var = o.variable.is_a?(String) ? "$#{o.variable}" : do_dump(o.variable)
  ["slice", var, do_dump(o.key)]
end

#dump_Hostclass(o) ⇒ Object 



194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 194

def dump_Hostclass o
  # ok, this is kind of crazy stuff in the AST, information in a context instead of in AST, and
  # parameters are in a Ruby Array with each parameter being an Array...
  #
  context = o.context
  args = context[:arguments]
  parent = context[:parent]
  result = ["class", o.name]
  result << ["inherits", parent] if parent
  result << ["parameters"] + args.collect {|p| _dump_ParameterArray(p) } if args && args.size() > 0
  if is_nop?(o.code)
    result << []
  else
    result << do_dump(o.code)
  end
  result
end

#dump_HostName(o) ⇒ Object

Hostname is tricky, it is either a bare word, a string, or default, or regular expression Least evil, all strings except default are quoted



37
38
39
40
41
42
43
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 37

def dump_HostName o
  result = do_dump o.value
  unless o.value.is_a? AST::Regex
    result = result == "default" ? ":default" : "'#{result}'"
  end
  result
end

#dump_IfStatement(o) ⇒ Object 



281
282
283
284
285
286
287
288
289
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 281

def dump_IfStatement o
  result = ["if", do_dump(o.test), :indent, :break,
    ["then", :indent, do_dump(o.statements), :dedent]]
  result +=
  [:break,
    ["else", :indent, do_dump(o.else), :dedent],
    :dedent] unless is_nop? o.else
  result
end

#dump_InOperator(o) ⇒ Object 



94
95
96
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 94

def dump_InOperator o
  ["in", do_dump(o.lval), do_dump(o.rval)]
end

#dump_Lambda(o) ⇒ Object 



141
142
143
144
145
146
147
148
149
150
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 141

def dump_Lambda o
  result = ["lambda"]
  result << ["parameters"] + o.parameters.collect {|p| _dump_ParameterArray(p) } if o.parameters.size() > 0
  if o.children == []
    result << [] # does not have a lambda body
  else
    result << do_dump(o.children)
  end
  result
end

#dump_LiteralNumber(o) ⇒ Object 



11
12
13
14
15
16
17
18
19
20
21
22
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 11

def dump_LiteralNumber o
  case o.radix
  when 10
    o.value.to_s
  when 8
    "0%o" % o.value
  when 16
    "0x%X" % o.value
  else
    "bad radix:" + o.value.to_s
  end
end

#dump_MatchOperator(o) ⇒ Object 



125
126
127
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 125

def dump_MatchOperator o
  [o.operator.to_s, do_dump(o.lval), do_dump(o.rval)]
end

#dump_MethodCall(o) ⇒ Object 



302
303
304
305
306
307
308
309
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 302

def dump_MethodCall o
  # somewhat ugly as Method call (does the same as function) and hides its "ftype" instance variable
  result = [o.instance_variable_get("@ftype") == :rvalue ? "call-method" : "invoke-method",
    [".", do_dump(o.receiver), do_dump(o.name)]]
  o.arguments.collect {|a| result << do_dump(a) }
  result << do_dump(o.lambda) if o.lambda
  result
end

#dump_Minus(o) ⇒ Object 



181
182
183
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 181

def dump_Minus o
  ['-', do_dump(o.value)]
end

#dump_Name(o) ⇒ Object 



212
213
214
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 212

def dump_Name o
  o.value
end

#dump_NilClass(o) ⇒ Object 



169
170
171
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 169

def dump_NilClass o
  "()"
end

#dump_Node(o) ⇒ Object 



216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 216

def dump_Node o
  context = o.context
  parent = context[:parent]
  code = context[:code]

  result = ["node"]
  result << ["matches"] + o.names.collect {|m| do_dump(m) }
  result << ["parent", do_dump(parent)] if !is_nop?(parent)
  if is_nop?(code)
    result << []
  else
    result << do_dump(code)
  end
  result
end

#dump_Nop(o) ⇒ Object 



165
166
167
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 165

def dump_Nop o
  ":nop"
end

#dump_Not(o) ⇒ Object 



173
174
175
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 173

def dump_Not o
  ['!', dump(o.value)]
end

#dump_Object(o) ⇒ Object 



371
372
373
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 371

def dump_Object o
  ['dev-error-no-polymorph-dump-for:', o.class.to_s, o.to_s]
end

#dump_Regex(o) ⇒ Object

Note this is Regex (the AST kind), not Ruby Regexp



161
162
163
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 161

def dump_Regex o
  "/#{o.value.source}/"
end

#dump_Relationship(o) ⇒ Object 



31
32
33
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 31

def dump_Relationship o
  [o.arrow.to_s, do_dump(o.left), do_dump(o.right)]
end

#dump_Resource(o) ⇒ Object 



349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 349

def dump_Resource o
  if o.exported
    form = 'exported-'
  elsif o.virtual
    form = 'virtual-'
  else
    form = ''
  end
  result = [form+"resource", do_dump(o.type), :indent]
  o.instances.each do |b|
    result << :break << do_dump(b)
  end
  result << :dedent
  result
end

#dump_ResourceDefaults(o) ⇒ Object 



340
341
342
343
344
345
346
347
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 340

def dump_ResourceDefaults o
  result = ["resource-defaults", do_dump(o.type), :indent]
  o.parameters.each do |p|
    result << :break << do_dump(p)
  end
  result << :dedent
  result
end

#dump_ResourceInstance(o) ⇒ Object 



331
332
333
334
335
336
337
338
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 331

def dump_ResourceInstance o
  result = [do_dump(o.title), :indent]
  o.parameters.each do |p|
    result << :break << do_dump(p)
  end
  result << :dedent
  result
end

#dump_ResourceOverride(o) ⇒ Object 



261
262
263
264
265
266
267
268
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 261

def dump_ResourceOverride o
  result = ["override", do_dump(o.object), :indent]
  o.parameters.each do |p|
    result << :break << do_dump(p)
  end
  result << :dedent
  result
end

#dump_ResourceParam(o) ⇒ Object

Produces (name => expr) or (name +> expr)



107
108
109
110
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 107

def dump_ResourceParam o
  operator = o.add ? "+>" : "=>"
  [do_dump(o.param), operator, do_dump(o.value)]
end

#dump_ResourceReference(o) ⇒ Object 



251
252
253
254
255
256
257
258
259
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 251

def dump_ResourceReference o
  result = ["slice", do_dump(o.type)]
  if o.title.children.size == 1
    result << do_dump(o.title[0])
  else
    result << do_dump(o.title.children)
  end
  result
end

#dump_Selector(o) ⇒ Object 



365
366
367
368
369
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 365

def dump_Selector o
  values = o.values
  values = [values] unless values.instance_of? AST::ASTArray or values.instance_of? Array
  ["?", do_dump(o.param)] + values.collect {|x| do_dump(x) }
end

#dump_String(o) ⇒ Object

Dump a Ruby String in single quotes unless it is a number.



130
131
132
133
134
135
136
137
138
139
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 130

def dump_String o

  if o.is_a? String
    o               # A Ruby String, not quoted
  elsif Puppet::Pops::Utils.to_n(o.value)
    o.value         # AST::String that is a number without quotes
  else
    "'#{o.value}'"  # AST::String that is not a number
  end
end

#dump_Undef(o) ⇒ Object 



156
157
158
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 156

def dump_Undef o
  ":undef"
end

#dump_VarDef(o) ⇒ Object

$x = … $x += …



101
102
103
104
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 101

def dump_VarDef o
  operator = o.append ? "+=" : "="
  [operator, '$' + do_dump(o.name), do_dump(o.value)]
end

#dump_Variable(o) ⇒ Object 



177
178
179
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 177

def dump_Variable o
  "$#{dump(o.value)}"
end

#is_nop?(o) ⇒ Boolean

Returns:

  • (Boolean) 


375
376
377
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 375

def is_nop? o
  o.nil? || o.is_a?(Model::Nop) || o.is_a?(AST::Nop)
end