Class: Puppet::Pops::Model::PNTransformer

Inherits:
Object
  • Object
show all
Extended by:
Concurrent::ThreadLocalSingleton
Defined in:
lib/puppet/pops/model/pn_transformer.rb

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Concurrent::ThreadLocalSingleton

singleton

Constructor Details

#initialize ⇒ PNTransformer

Returns a new instance of PNTransformer.



15
16
17
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 15

def initialize
  @visitor = Visitor.new(nil, 'transform', 0, 0)
end

Class Method Details

.transform(ast) ⇒ Object 



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

def self.transform(ast)
  singleton.transform(ast)
end

Instance Method Details

#binary_op(e, op) ⇒ Object 



336
337
338
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 336

def binary_op(e, op)
  PN::Call.new(op, transform(e.left_expr), transform(e.right_expr))
end

#block_as_entry(name, expr) ⇒ Object 



359
360
361
362
363
364
365
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 359

def block_as_entry(name, expr)
  if expr.is_a?(BlockExpression)
    transform(expr.statements).with_name(name)
  else
    transform([expr]).with_name(name)
  end
end

#call_to_pn(e, r, nr) ⇒ Object 



371
372
373
374
375
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 371

def call_to_pn(e, r, nr)
  entries = [transform(e.functor_expr).with_name('functor'), transform(e.arguments).with_name('args')]
  entries << transform(e.lambda).with_name('block') unless e.lambda.nil?
  PN::Map.new(entries).as_call(e.rval_required ? r : nr)
end

#definition_to_pn(e, type_name, parent = nil, return_type = nil) ⇒ Object 



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

def definition_to_pn(e, type_name, parent = nil, return_type = nil)
  entries = [PN::Literal.new(e.name).with_name('name')]
  entries << PN::Literal.new(parent).with_name('parent') unless parent.nil?
  entries << parameters_entry(e.parameters) unless e.parameters.empty?
  entries << block_as_entry('body', e.body) unless e.body.nil?
  entries << transform(return_type).with_name('returns') unless return_type.nil?
  PN::Map.new(entries).as_call(type_name)
end

#if_to_pn(e, name) ⇒ Object 



377
378
379
380
381
382
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 377

def if_to_pn(e, name)
  entries = [transform(e.test).with_name('test')]
  entries << block_as_entry('then', e.then_expr) unless is_nop?(e.then_expr)
  entries << block_as_entry('else', e.else_expr) unless is_nop?(e.else_expr)
  PN::Map.new(entries).as_call(name)
end

#is_nop?(e) ⇒ Boolean

Returns:

  • (Boolean) 


332
333
334
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 332

def is_nop?(e)
  e.nil? || e.is_a?(Nop)
end

#parameters_entry(parameters) ⇒ Object 



349
350
351
352
353
354
355
356
357
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 349

def parameters_entry(parameters)
  PN::Map.new(parameters.map do |p|
    entries = []
    entries << transform(p.type_expr).with_name('type') unless p.type_expr.nil?
    entries << PN::Literal(true).with_name('splat') if p.captures_rest
    entries << transform(p.value).with_name('value') unless p.value.nil?
    PN::Map.new(entries).with_name(p.name)
  end).with_name('params')
end

#pn_array(a) ⇒ Object 



367
368
369
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 367

def pn_array(a)
  a.map { |e| transform(e) }
end

#transform(ast) ⇒ Object 



19
20
21
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 19

def transform(ast)
  @visitor.visit_this_0(self, ast)
end

#transform_AccessExpression(e) ⇒ Object 



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

def transform_AccessExpression(e)
  PN::List.new([transform(e.left_expr)] + pn_array(e.keys)).as_call('access')
end

#transform_AndExpression(e) ⇒ Object 



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

def transform_AndExpression(e)
  binary_op(e, 'and')
end

#transform_ArithmeticExpression(e) ⇒ Object 



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

def transform_ArithmeticExpression(e)
  binary_op(e, e.operator)
end

#transform_Array(a) ⇒ Object 



35
36
37
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 35

def transform_Array(a)
  PN::List.new(pn_array(a))
end

#transform_AssignmentExpression(e) ⇒ Object 



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

def transform_AssignmentExpression(e)
  binary_op(e, e.operator)
end

#transform_AttributeOperation(e) ⇒ Object 



43
44
45
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 43

def transform_AttributeOperation(e)
  PN::Call.new(e.operator, PN::Literal.new(e.attribute_name), transform(e.value_expr))
end

#transform_AttributesOperation(e) ⇒ Object 



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

def transform_AttributesOperation(e)
  PN::Call.new('splat-hash', transform(e.expr))
end

#transform_BlockExpression(e) ⇒ Object 



51
52
53
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 51

def transform_BlockExpression(e)
  transform(e.statements).as_call('block')
end

#transform_CallFunctionExpression(e) ⇒ Object 



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

def transform_CallFunctionExpression(e)
  call_to_pn(e, 'call-lambda', 'invoke-lambda')
end

#transform_CallMethodExpression(e) ⇒ Object 



59
60
61
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 59

def transform_CallMethodExpression(e)
  call_to_pn(e, 'call-method', 'invoke-method')
end

#transform_CallNamedFunctionExpression(e) ⇒ Object 



63
64
65
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 63

def transform_CallNamedFunctionExpression(e)
  call_to_pn(e, 'call', 'invoke')
end

#transform_CaseExpression(e) ⇒ Object 



67
68
69
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 67

def transform_CaseExpression(e)
  PN::Call.new('case', transform(e.test), transform(e.options))
end

#transform_CaseOption(e) ⇒ Object 



71
72
73
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 71

def transform_CaseOption(e)
  PN::Map.new([transform(e.values).with_name('when'), block_as_entry('then', e.then_expr)])
end

#transform_CollectExpression(e) ⇒ Object 



75
76
77
78
79
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 75

def transform_CollectExpression(e)
  entries = [transform(e.type_expr).with_name('type'), transform(e.query).with_name('query')]
  entries << transform(e.operations).with_name('ops') unless e.operations.empty?
  PN::Map.new(entries).as_call('collect')
end

#transform_ComparisonExpression(e) ⇒ Object 



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

def transform_ComparisonExpression(e)
  binary_op(e, e.operator)
end

#transform_ConcatenatedString(e) ⇒ Object 



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

def transform_ConcatenatedString(e)
  transform(e.segments).as_call('concat')
end

#transform_EppExpression(e) ⇒ Object 



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

def transform_EppExpression(e)
  e.body.nil? ? PN::Call.new('epp') : transform(e.body).as_call('epp')
end

#transform_ExportedQuery(e) ⇒ Object 



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

def transform_ExportedQuery(e)
  is_nop?(e.expr) ? PN::Call.new('exported-query') : PN::Call.new('exported-query', transform(e.expr))
end

#transform_Factory(e) ⇒ Object 



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

def transform_Factory(e)
  transform(e.model)
end

#transform_FunctionDefinition(e) ⇒ Object 



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

def transform_FunctionDefinition(e)
  definition_to_pn(e, 'function', nil, e.return_type)
end

#transform_HeredocExpression(e) ⇒ Object 



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

def transform_HeredocExpression(e)
  entries = []
  entries << PN::Literal.new(e.syntax).with_name('syntax') unless e.syntax == ''
  entries << transform(e.text_expr).with_name('text')
  PN::Map.new(entries).as_call('heredoc')
end

#transform_HostClassDefinition(e) ⇒ Object 



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

def transform_HostClassDefinition(e)
  definition_to_pn(e, 'class', e.parent_class)
end

#transform_IfExpression(e) ⇒ Object 



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

def transform_IfExpression(e)
  if_to_pn(e, 'if')
end

#transform_InExpression(e) ⇒ Object 



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

def transform_InExpression(e)
  binary_op(e, 'in')
end

#transform_KeyedEntry(e) ⇒ Object 



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

def transform_KeyedEntry(e)
  PN::Call.new('=>', transform(e.key), transform(e.value))
end

#transform_LambdaExpression(e) ⇒ Object 



128
129
130
131
132
133
134
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 128

def transform_LambdaExpression(e)
  entries = []
  entries << parameters_entry(e.parameters) unless e.parameters.empty?
  entries << transform(e.return_type).with_name('returns') unless e.return_type.nil?
  entries << block_as_entry('body', e.body) unless e.body.nil?
  PN::Map.new(entries).as_call('lambda')
end

#transform_LiteralBoolean(e) ⇒ Object 



136
137
138
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 136

def transform_LiteralBoolean(e)
  PN::Literal.new(e.value)
end

#transform_LiteralDefault(_) ⇒ Object 



140
141
142
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 140

def transform_LiteralDefault(_)
  PN::Call.new('default')
end

#transform_LiteralFloat(e) ⇒ Object 



144
145
146
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 144

def transform_LiteralFloat(e)
  PN::Literal.new(e.value)
end

#transform_LiteralHash(e) ⇒ Object 



148
149
150
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 148

def transform_LiteralHash(e)
  transform(e.entries).as_call('hash')
end

#transform_LiteralInteger(e) ⇒ Object 



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

def transform_LiteralInteger(e)
  vl = PN::Literal.new(e.value)
  e.radix == 10 ? vl : PN::Map.new([PN::Literal.new(e.radix).with_name('radix'), vl.with_name('value')]).as_call('int')
end

#transform_LiteralList(e) ⇒ Object 



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

def transform_LiteralList(e)
  transform(e.values).as_call('array')
end

#transform_LiteralRegularExpression(e) ⇒ Object 



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

def transform_LiteralRegularExpression(e)
  PN::Literal.new(Types::PRegexpType.regexp_to_s(e.value)).as_call('regexp')
end

#transform_LiteralString(e) ⇒ Object 



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

def transform_LiteralString(e)
  PN::Literal.new(e.value)
end

#transform_LiteralUndef(_) ⇒ Object 



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

def transform_LiteralUndef(_)
  PN::Literal.new(nil)
end

#transform_MatchExpression(e) ⇒ Object 



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

def transform_MatchExpression(e)
  binary_op(e, e.operator)
end

#transform_NamedAccessExpression(e) ⇒ Object 



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

def transform_NamedAccessExpression(e)
  binary_op(e, '.')
end

#transform_NilClass(e) ⇒ Object

Some elements may have a nil element instead of a Nop Expression



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

def transform_NilClass(e)
  PN::Call.new('nop')
end

#transform_NodeDefinition(e) ⇒ Object 



181
182
183
184
185
186
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 181

def transform_NodeDefinition(e)
  entries = [transform(e.host_matches).with_name('matches')]
  entries << transform(e.parent).with_name('parent') unless e.parent.nil?
  entries << block_as_entry('body', e.body) unless e.body.nil?
  PN::Map.new(entries).as_call('node')
end

#transform_Nop(_) ⇒ Object 



188
189
190
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 188

def transform_Nop(_)
  PN::Call.new('nop')
end

#transform_NotExpression(e) ⇒ Object 



197
198
199
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 197

def transform_NotExpression(e)
  PN::Call.new('!', transform(e.expr))
end

#transform_OrExpression(e) ⇒ Object 



201
202
203
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 201

def transform_OrExpression(e)
  binary_op(e, 'or')
end

#transform_Parameter(e) ⇒ Object 



205
206
207
208
209
210
211
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 205

def transform_Parameter(e)
  entries = [PN::Literal.new(e.name).with_name('name')]
  entries << transform(e.type_expr).with_name('type') unless e.type_expr.nil?
  entries << PN::Literal.new(true).with_name('splat') if e.captures_rest
  entries << transform(e.value).with_name('value') unless e.value.nil?
  PN::Map.new(entries).with_name('param')
end

#transform_ParenthesizedExpression(e) ⇒ Object 



213
214
215
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 213

def transform_ParenthesizedExpression(e)
  PN::Call.new('paren', transform(e.expr))
end

#transform_PlanDefinition(e) ⇒ Object 



217
218
219
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 217

def transform_PlanDefinition(e)
  definition_to_pn(e, 'plan', nil, e.return_type)
end

#transform_Program(e) ⇒ Object 



221
222
223
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 221

def transform_Program(e)
  transform(e.body)
end

#transform_QualifiedName(e) ⇒ Object 



225
226
227
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 225

def transform_QualifiedName(e)
  PN::Call.new('qn', PN::Literal.new(e.value))
end

#transform_QualifiedReference(e) ⇒ Object 



229
230
231
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 229

def transform_QualifiedReference(e)
  PN::Call.new('qr', PN::Literal.new(e.cased_value))
end

#transform_RelationshipExpression(e) ⇒ Object 



233
234
235
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 233

def transform_RelationshipExpression(e)
  binary_op(e, e.operator)
end

#transform_RenderExpression(e) ⇒ Object 



237
238
239
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 237

def transform_RenderExpression(e)
  PN::Call.new('render', transform(e.expr))
end

#transform_RenderStringExpression(e) ⇒ Object 



241
242
243
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 241

def transform_RenderStringExpression(e)
  PN::Literal.new(e.value).as_call('render-s')
end

#transform_ReservedWord(e) ⇒ Object 



245
246
247
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 245

def transform_ReservedWord(e)
  PN::Literal.new(e.word).as_call('reserved')
end

#transform_ResourceBody(e) ⇒ Object 



249
250
251
252
253
254
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 249

def transform_ResourceBody(e)
  PN::Map.new([
    transform(e.title).with_name('title'),
    transform(e.operations).with_name('ops')
  ]).as_call('resource_body')
end

#transform_ResourceDefaultsExpression(e) ⇒ Object 



256
257
258
259
260
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 256

def transform_ResourceDefaultsExpression(e)
  entries = [transform(e.type_ref).with_name('type'), transform(e.operations).with_name('ops')]
  entries << PN::Literal.new(e.form).with_name('form') unless e.form == 'regular'
  PN::Map.new(entries).as_call('resource-defaults')
end

#transform_ResourceExpression(e) ⇒ Object 



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

def transform_ResourceExpression(e)
  entries = [
    transform(e.type_name).with_name('type'),
    PN::List.new(pn_array(e.bodies).map { |body| body[0] }).with_name('bodies')
  ]
  entries << PN::Literal.new(e.form).with_name('form') unless e.form == 'regular'
  PN::Map.new(entries).as_call('resource')
end

#transform_ResourceOverrideExpression(e) ⇒ Object 



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

def transform_ResourceOverrideExpression(e)
  entries = [transform(e.resources).with_name('resources'), transform(e.operations).with_name('ops')]
  entries << PN::Literal.new(e.form).with_name('form') unless e.form == 'regular'
  PN::Map.new(entries).as_call('resource-override')
end

#transform_ResourceTypeDefinition(e) ⇒ Object 



277
278
279
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 277

def transform_ResourceTypeDefinition(e)
  definition_to_pn(e, 'define')
end

#transform_SelectorEntry(e) ⇒ Object 



281
282
283
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 281

def transform_SelectorEntry(e)
  PN::Call.new('=>', transform(e.matching_expr), transform(e.value_expr))
end

#transform_SelectorExpression(e) ⇒ Object 



285
286
287
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 285

def transform_SelectorExpression(e)
  PN::Call.new('?', transform(e.left_expr), transform(e.selectors))
end

#transform_TextExpression(e) ⇒ Object 



289
290
291
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 289

def transform_TextExpression(e)
  PN::Call.new('str', transform(e.expr))
end

#transform_TypeAlias(e) ⇒ Object 



293
294
295
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 293

def transform_TypeAlias(e)
  PN::Call.new('type-alias', PN::Literal.new(e.name), transform(e.type_expr))
end

#transform_TypeDefinition(e) ⇒ Object 



297
298
299
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 297

def transform_TypeDefinition(e)
  PN::Call.new('type-definition', PN::Literal.new(e.name), PN::Literal.new(e.parent), transform(e.body))
end

#transform_TypeMapping(e) ⇒ Object 



301
302
303
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 301

def transform_TypeMapping(e)
  PN::Call.new('type-mapping', transform(e.type_expr), transform(e.mapping_expr))
end

#transform_UnaryMinusExpression(e) ⇒ Object 



305
306
307
308
309
310
311
312
313
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 305

def transform_UnaryMinusExpression(e)
  if e.expr.is_a?(LiteralValue)
    v = e.expr.value
    if v.is_a?(Numeric)
      return PN::Literal.new(-v)
    end
  end
  PN::Call.new('-', transform(e.expr))
end

#transform_UnfoldExpression(e) ⇒ Object 



315
316
317
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 315

def transform_UnfoldExpression(e)
  PN::Call.new('unfold', transform(e.expr))
end

#transform_UnlessExpression(e) ⇒ Object 



319
320
321
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 319

def transform_UnlessExpression(e)
  if_to_pn(e, 'unless')
end

#transform_VariableExpression(e) ⇒ Object 



323
324
325
326
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 323

def transform_VariableExpression(e)
  ne = e.expr
  PN::Call.new('var', ne.is_a?(Model::QualifiedName) ? PN::Literal.new(ne.value) : transform(ne))
end

#transform_VirtualQuery(e) ⇒ Object 



328
329
330
 
# File 'lib/puppet/pops/model/pn_transformer.rb', line 328

def transform_VirtualQuery(e)
  is_nop?(e.expr) ? PN::Call.new('virtual-query') : PN::Call.new('virtual-query', transform(e.expr))
end