Class: Puppet::Pops::Model::ModelTreeDumper

Inherits:
TreeDumper show all
Defined in:
lib/puppet/pops/model/model_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

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

x prints as (slice x y)



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

def dump_AccessExpression o
  if o.keys.size <= 1
    ["slice", do_dump(o.left_expr), do_dump(o.keys[0])]
  else
    ["slice", do_dump(o.left_expr), do_dump(o.keys)]
  end
end

#dump_AndExpression(o) ⇒ Object 



77
78
79
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 77

def dump_AndExpression o
  ["&&", do_dump(o.left_expr), do_dump(o.right_expr)]
end

#dump_ArithmeticExpression(o) ⇒ Object 



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

def dump_ArithmeticExpression o
  [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
end

#dump_Array(o) ⇒ Object 



6
7
8
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 6

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

#dump_AssignmentExpression(o) ⇒ Object 



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

def dump_AssignmentExpression o
  [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
end

#dump_AttributeOperation(o) ⇒ Object

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



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

def dump_AttributeOperation o
  [o.attribute_name, o.operator, do_dump(o.value_expr)]
end

#dump_BlockExpression(o) ⇒ Object 



182
183
184
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 182

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

#dump_CallMethodExpression(o) ⇒ Object

def dump_CallNamedFunctionExpression o

  result = [o.rval_required ? "call" : "invoke", do_dump(o.functor_expr)]
  o.arguments.collect {|a| result << do_dump(a) }
  result
end



283
284
285
286
287
288
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 283

def dump_CallMethodExpression o
  result = [o.rval_required ? "call-method" : "invoke-method", do_dump(o.functor_expr)]
  o.arguments.collect {|a| result << do_dump(a) }
  result << do_dump(o.lambda) if o.lambda
  result
end

#dump_CallNamedFunctionExpression(o) ⇒ Object

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



271
272
273
274
275
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 271

def dump_CallNamedFunctionExpression o
  result = [o.rval_required ? "call" : "invoke", do_dump(o.functor_expr)]
  o.arguments.collect {|a| result << do_dump(a) }
  result
end

#dump_CaseExpression(o) ⇒ Object 



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

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

#dump_CaseOption(o) ⇒ Object 



298
299
300
301
302
303
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 298

def dump_CaseOption o
  result = ["when"]
  result << o.values.collect {|x| do_dump(x) }
  result << ["then", do_dump(o.then_expr) ]
  result
end

#dump_CollectExpression(o) ⇒ Object 



48
49
50
51
52
53
54
55
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 48

def dump_CollectExpression o
  result = ["collect", do_dump(o.type_expr), :indent, :break, do_dump(o.query), :indent]
  o.operations do |ao|
    result << :break << do_dump(ao)
  end
  result += [:dedent, :dedent ]
  result
end

#dump_ComparisonExpression(o) ⇒ Object 



73
74
75
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 73

def dump_ComparisonExpression o
  [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
end

#dump_ConcatenatedString(o) ⇒ Object

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



187
188
189
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 187

def dump_ConcatenatedString o
  ["cat"] + o.segments.collect {|x| do_dump(x)}
end

#dump_ExportedQuery(o) ⇒ Object 



57
58
59
60
61
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 57

def dump_ExportedQuery o
  result = ["<<| |>>"]
  result += dump_QueryExpression(o) unless is_nop?(o.expr)
  result
end

#dump_Factory(o) ⇒ Object 



27
28
29
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 27

def dump_Factory o
  do_dump(o.current)
end

#dump_HostClassDefinition(o) ⇒ Object 



191
192
193
194
195
196
197
198
199
200
201
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 191

def dump_HostClassDefinition o
  result = ["class", o.name]
  result << ["inherits", o.parent_class] if o.parent_class
  result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
  if o.body
    result << do_dump(o.body)
  else
    result << []
  end
  result
end

#dump_IfExpression(o) ⇒ Object 



248
249
250
251
252
253
254
255
256
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 248

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

#dump_ImportExpression(o) ⇒ Object 



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

def dump_ImportExpression o
  ["import"] + o.files.collect {|f| do_dump(f) }
end

#dump_InExpression(o) ⇒ Object 



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

def dump_InExpression o
  ["in", do_dump(o.left_expr), do_dump(o.right_expr)]
end

#dump_InstanceReferences(o) ⇒ Object 



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

def dump_InstanceReferences o
  ["instances", do_dump(o.type_name)] + o.names.collect {|n| do_dump(n) }
end

#dump_KeyedEntry(o) ⇒ Object 



114
115
116
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 114

def dump_KeyedEntry o
  [do_dump(o.key), do_dump(o.value)]
end

#dump_LambdaExpression(o) ⇒ Object 



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

def dump_LambdaExpression o
  result = ["lambda"]
  result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
  if o.body
    result << do_dump(o.body)
  else
    result << []
  end
  result
end

#dump_LiteralDefault(o) ⇒ Object 



141
142
143
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 141

def dump_LiteralDefault o
  ":default"
end

#dump_LiteralHash(o) ⇒ Object 



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

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

#dump_LiteralList(o) ⇒ Object 



106
107
108
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 106

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

#dump_LiteralNumber(o) ⇒ Object 



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

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



149
150
151
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 149

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

#dump_LiteralString(o) ⇒ Object 



122
123
124
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 122

def dump_LiteralString o
  "'#{o.value}'"
end

#dump_LiteralText(o) ⇒ Object 



126
127
128
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 126

def dump_LiteralText o
  o.value
end

#dump_LiteralUndef(o) ⇒ Object 



145
146
147
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 145

def dump_LiteralUndef o
  ":undef"
end

#dump_LiteralValue(o) ⇒ Object 



23
24
25
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 23

def dump_LiteralValue o
  o.value.to_s
end

#dump_MatchesExpression(o) ⇒ Object 



44
45
46
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 44

def dump_MatchesExpression o
  [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
end

#dump_MatchExpression(o) ⇒ Object 



118
119
120
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 118

def dump_MatchExpression o
  [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
end

#dump_NamedAccessExpression(o) ⇒ Object 



157
158
159
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 157

def dump_NamedAccessExpression o
  [".", do_dump(o.left_expr), do_dump(o.right_expr)]
end

#dump_NilClass(o) ⇒ Object 



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

def dump_NilClass o
  "()"
end

#dump_NodeDefinition(o) ⇒ Object 



203
204
205
206
207
208
209
210
211
212
213
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 203

def dump_NodeDefinition o
  result = ["node"]
  result << ["matches"] + o.host_matches.collect {|m| do_dump(m) }
  result << ["parent", do_dump(o.parent)] if o.parent
  if o.body
    result << do_dump(o.body)
  else
    result << []
  end
  result
end

#dump_Nop(o) ⇒ Object 



153
154
155
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 153

def dump_Nop o
  ":nop"
end

#dump_NotExpression(o) ⇒ Object 



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

def dump_NotExpression o
  ['!', dump(o.expr)]
end

#dump_Object(o) ⇒ Object 



345
346
347
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 345

def dump_Object o
  [o.class.to_s, o.to_s]
end

#dump_OrExpression(o) ⇒ Object 



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

def dump_OrExpression o
  ["||", do_dump(o.left_expr), do_dump(o.right_expr)]
end

#dump_Parameter(o) ⇒ Object

Produces parameters as name, or (= name value)



236
237
238
239
240
241
242
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 236

def dump_Parameter o
  if o.value
    ["=", o.name, do_dump(o.value)]
  else
    o.name
  end
end

#dump_ParenthesizedExpression(o) ⇒ Object 



244
245
246
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 244

def dump_ParenthesizedExpression o
  do_dump(o.expr)
end

#dump_QueryExpression(o) ⇒ Object 



69
70
71
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 69

def dump_QueryExpression o
  [do_dump(o.expr)]
end

#dump_RelationshipExpression(o) ⇒ Object 



305
306
307
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 305

def dump_RelationshipExpression o
  [o.operator.to_s, do_dump(o.left_expr), do_dump(o.right_expr)]
end

#dump_ResourceBody(o) ⇒ Object 



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

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

#dump_ResourceDefaultsExpression(o) ⇒ Object 



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

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

#dump_ResourceExpression(o) ⇒ Object 



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

def dump_ResourceExpression o
  form = o.form == :regular ? '' : o.form.to_s + "-"
  result = [form+"resource", do_dump(o.type_name), :indent]
  o.bodies.each do |b|
    result << :break << do_dump(b)
  end
  result << :dedent
  result
end

#dump_ResourceOverrideExpression(o) ⇒ Object 



226
227
228
229
230
231
232
233
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 226

def dump_ResourceOverrideExpression o
  result = ["override", do_dump(o.resources), :indent]
  o.operations.each do |p|
    result << :break << do_dump(p)
  end
  result << :dedent
  result
end

#dump_ResourceTypeDefinition(o) ⇒ Object 



215
216
217
218
219
220
221
222
223
224
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 215

def dump_ResourceTypeDefinition o
  result = ["define", o.name]
  result << ["parameters"] + o.parameters.collect {|p| do_dump(p) } if o.parameters.size() > 0
  if o.body
    result << do_dump(o.body)
  else
    result << []
  end
  result
end

#dump_SelectorEntry(o) ⇒ Object 



341
342
343
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 341

def dump_SelectorEntry o
  [do_dump(o.matching_expr), "=>", do_dump(o.value_expr)]
end

#dump_SelectorExpression(o) ⇒ Object 



337
338
339
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 337

def dump_SelectorExpression o
  ["?", do_dump(o.left_expr)] + o.selectors.collect {|x| do_dump(x) }
end

#dump_TextExpression(o) ⇒ Object

Interpolation (to string) shown as (str expr)



174
175
176
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 174

def dump_TextExpression o
  ["str", do_dump(o.expr)]
end

#dump_UnaryMinusExpression(o) ⇒ Object 



178
179
180
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 178

def dump_UnaryMinusExpression o
  ['-', do_dump(o.expr)]
end

#dump_UnlessExpression(o) ⇒ Object 



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

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

#dump_VariableExpression(o) ⇒ Object 



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

def dump_VariableExpression o
  "$#{dump(o.expr)}"
end

#dump_VirtualQuery(o) ⇒ Object 



63
64
65
66
67
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 63

def dump_VirtualQuery o
  result = ["<| |>"]
  result += dump_QueryExpression(o) unless is_nop?(o.expr)
  result
end

#is_nop?(o) ⇒ Boolean

Returns:

  • (Boolean) 


349
350
351
 
# File 'lib/puppet/pops/model/model_tree_dumper.rb', line 349

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