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.



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

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

#dump_ArithmeticOperator(o) ⇒ Object 



36
37
38
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 36

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

#dump_Array(o) ⇒ Object 



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

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

#dump_ASTArray(o) ⇒ Object 



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

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

#dump_ASTHash(o) ⇒ Object 



128
129
130
131
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 128

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 



193
194
195
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 193

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

#dump_Boolean(o) ⇒ Object 



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

def dump_Boolean o
  o.to_s
end

#dump_BooleanOperator(o) ⇒ Object 



97
98
99
100
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 97

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

#dump_CaseOpt(o) ⇒ Object 



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

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 



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

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.



60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 60

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 



77
78
79
80
81
82
83
84
85
86
87
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 77

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 



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

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)



198
199
200
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 198

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 



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

def dump_Default o
  ":default"
end

#dump_Definition(o) ⇒ Object 



240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 240

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_Expression(o) ⇒ Object 



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

def dump_Expression(o)
  "(pops-expression #{Puppet::Pops::Model::ModelTreeDumper.new().dump(o.value)})"
end

#dump_Factory(o) ⇒ Object 



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

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.



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

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)



54
55
56
57
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 54

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 



202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 202

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



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

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 



289
290
291
292
293
294
295
296
297
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 289

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 



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

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

#dump_Lambda(o) ⇒ Object 



149
150
151
152
153
154
155
156
157
158
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 149

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_LiteralFloat(o) ⇒ Object 



11
12
13
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 11

def dump_LiteralFloat o
  o.value.to_s
end

#dump_LiteralInteger(o) ⇒ Object 



15
16
17
18
19
20
21
22
23
24
25
26
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 15

def dump_LiteralInteger 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 



133
134
135
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 133

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

#dump_MethodCall(o) ⇒ Object 



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

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 



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

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

#dump_Name(o) ⇒ Object 



220
221
222
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 220

def dump_Name o
  o.value
end

#dump_NilClass(o) ⇒ Object 



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

def dump_NilClass o
  "()"
end

#dump_Node(o) ⇒ Object 



224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 224

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 



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

def dump_Nop o
  ":nop"
end

#dump_Not(o) ⇒ Object 



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

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

#dump_Object(o) ⇒ Object 



379
380
381
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 379

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



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

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

#dump_Relationship(o) ⇒ Object 



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

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

#dump_Resource(o) ⇒ Object 



357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 357

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 



348
349
350
351
352
353
354
355
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 348

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 



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

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 



269
270
271
272
273
274
275
276
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 269

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)



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

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

#dump_ResourceReference(o) ⇒ Object 



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

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 



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

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.



138
139
140
141
142
143
144
145
146
147
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 138

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 



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

def dump_Undef o
  ":undef"
end

#dump_VarDef(o) ⇒ Object

$x = … $x += …



109
110
111
112
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 109

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

#dump_Variable(o) ⇒ Object 



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

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

#is_nop?(o) ⇒ Boolean

Returns:

  • (Boolean) 


383
384
385
 
# File 'lib/puppet/pops/model/ast_tree_dumper.rb', line 383

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