class Puppet::Pops::Model::PNTransformer

   # File lib/puppet/pops/model/pn_transformer.rb
15 def initialize
16   @visitor = Visitor.new(nil, 'transform', 0, 0)
17 end

   # File lib/puppet/pops/model/pn_transformer.rb
11 def self.transform(ast)
12   singleton.transform(ast)
13 end

    # File lib/puppet/pops/model/pn_transformer.rb
336 def binary_op(e, op)
337   PN::Call.new(op, transform(e.left_expr), transform(e.right_expr))
338 end

    # File lib/puppet/pops/model/pn_transformer.rb
359 def block_as_entry(name, expr)
360   if expr.is_a?(BlockExpression)
361     transform(expr.statements).with_name(name)
362   else
363     transform([expr]).with_name(name)
364   end
365 end

    # File lib/puppet/pops/model/pn_transformer.rb
371 def call_to_pn(e, r, nr)
372   entries = [transform(e.functor_expr).with_name('functor'), transform(e.arguments).with_name('args')]
373   entries << transform(e.lambda).with_name('block') unless e.lambda.nil?
374   PN::Map.new(entries).as_call(e.rval_required ? r : nr)
375 end

    # File lib/puppet/pops/model/pn_transformer.rb
340 def definition_to_pn(e, type_name, parent = nil, return_type = nil)
341   entries = [PN::Literal.new(e.name).with_name('name')]
342   entries << PN::Literal.new(parent).with_name('parent') unless parent.nil?
343   entries << parameters_entry(e.parameters) unless e.parameters.empty?
344   entries << block_as_entry('body', e.body) unless e.body.nil?
345   entries << transform(return_type).with_name('returns') unless return_type.nil?
346   PN::Map.new(entries).as_call(type_name)
347 end

    # File lib/puppet/pops/model/pn_transformer.rb
377 def if_to_pn(e, name)
378   entries = [transform(e.test).with_name('test')]
379   entries << block_as_entry('then', e.then_expr) unless is_nop?(e.then_expr)
380   entries << block_as_entry('else', e.else_expr) unless is_nop?(e.else_expr)
381   PN::Map.new(entries).as_call(name)
382 end

    # File lib/puppet/pops/model/pn_transformer.rb
332 def is_nop?(e)
333   e.nil? || e.is_a?(Nop)
334 end

    # File lib/puppet/pops/model/pn_transformer.rb
349 def parameters_entry(parameters)
350   PN::Map.new(parameters.map do |p|
351     entries = []
352     entries << transform(p.type_expr).with_name('type') unless p.type_expr.nil?
353     entries << PN::Literal(true).with_name('splat') if p.captures_rest
354     entries << transform(p.value).with_name('value') unless p.value.nil?
355     PN::Map.new(entries).with_name(p.name)
356   end).with_name('params')
357 end

    # File lib/puppet/pops/model/pn_transformer.rb
367 def pn_array(a)
368   a.map { |e| transform(e) }
369 end

   # File lib/puppet/pops/model/pn_transformer.rb
19 def transform(ast)
20   @visitor.visit_this_0(self, ast)
21 end

   # File lib/puppet/pops/model/pn_transformer.rb
23 def transform_AccessExpression(e)
24   PN::List.new([transform(e.left_expr)] + pn_array(e.keys)).as_call('access')
25 end

   # File lib/puppet/pops/model/pn_transformer.rb
27 def transform_AndExpression(e)
28   binary_op(e, 'and')
29 end

   # File lib/puppet/pops/model/pn_transformer.rb
31 def transform_ArithmeticExpression(e)
32   binary_op(e, e.operator)
33 end

   # File lib/puppet/pops/model/pn_transformer.rb
35 def transform_Array(a)
36   PN::List.new(pn_array(a))
37 end

   # File lib/puppet/pops/model/pn_transformer.rb
39 def transform_AssignmentExpression(e)
40   binary_op(e, e.operator)
41 end

   # File lib/puppet/pops/model/pn_transformer.rb
43 def transform_AttributeOperation(e)
44   PN::Call.new(e.operator, PN::Literal.new(e.attribute_name), transform(e.value_expr))
45 end

   # File lib/puppet/pops/model/pn_transformer.rb
47 def transform_AttributesOperation(e)
48   PN::Call.new('splat-hash', transform(e.expr))
49 end

   # File lib/puppet/pops/model/pn_transformer.rb
51 def transform_BlockExpression(e)
52   transform(e.statements).as_call('block')
53 end

   # File lib/puppet/pops/model/pn_transformer.rb
55 def transform_CallFunctionExpression(e)
56   call_to_pn(e, 'call-lambda', 'invoke-lambda')
57 end

   # File lib/puppet/pops/model/pn_transformer.rb
59 def transform_CallMethodExpression(e)
60   call_to_pn(e, 'call-method', 'invoke-method')
61 end

   # File lib/puppet/pops/model/pn_transformer.rb
63 def transform_CallNamedFunctionExpression(e)
64   call_to_pn(e, 'call', 'invoke')
65 end

   # File lib/puppet/pops/model/pn_transformer.rb
67 def transform_CaseExpression(e)
68   PN::Call.new('case', transform(e.test), transform(e.options))
69 end

   # File lib/puppet/pops/model/pn_transformer.rb
71 def transform_CaseOption(e)
72   PN::Map.new([transform(e.values).with_name('when'), block_as_entry('then', e.then_expr)])
73 end

   # File lib/puppet/pops/model/pn_transformer.rb
75 def transform_CollectExpression(e)
76   entries = [transform(e.type_expr).with_name('type'), transform(e.query).with_name('query')]
77   entries << transform(e.operations).with_name('ops') unless e.operations.empty?
78   PN::Map.new(entries).as_call('collect')
79 end

   # File lib/puppet/pops/model/pn_transformer.rb
81 def transform_ComparisonExpression(e)
82   binary_op(e, e.operator)
83 end

   # File lib/puppet/pops/model/pn_transformer.rb
85 def transform_ConcatenatedString(e)
86   transform(e.segments).as_call('concat')
87 end

   # File lib/puppet/pops/model/pn_transformer.rb
89 def transform_EppExpression(e)
90   e.body.nil? ? PN::Call.new('epp') : transform(e.body).as_call('epp')
91 end

   # File lib/puppet/pops/model/pn_transformer.rb
93 def transform_ExportedQuery(e)
94   is_nop?(e.expr) ? PN::Call.new('exported-query') : PN::Call.new('exported-query', transform(e.expr))
95 end

   # File lib/puppet/pops/model/pn_transformer.rb
97 def transform_Factory(e)
98   transform(e.model)
99 end

    # File lib/puppet/pops/model/pn_transformer.rb
101 def transform_FunctionDefinition(e)
102   definition_to_pn(e, 'function', nil, e.return_type)
103 end

    # File lib/puppet/pops/model/pn_transformer.rb
105 def transform_HeredocExpression(e)
106   entries = []
107   entries << PN::Literal.new(e.syntax).with_name('syntax') unless e.syntax == ''
108   entries << transform(e.text_expr).with_name('text')
109   PN::Map.new(entries).as_call('heredoc')
110 end

    # File lib/puppet/pops/model/pn_transformer.rb
112 def transform_HostClassDefinition(e)
113   definition_to_pn(e, 'class', e.parent_class)
114 end

    # File lib/puppet/pops/model/pn_transformer.rb
116 def transform_IfExpression(e)
117   if_to_pn(e, 'if')
118 end

    # File lib/puppet/pops/model/pn_transformer.rb
120 def transform_InExpression(e)
121   binary_op(e, 'in')
122 end

    # File lib/puppet/pops/model/pn_transformer.rb
124 def transform_KeyedEntry(e)
125   PN::Call.new('=>', transform(e.key), transform(e.value))
126 end

    # File lib/puppet/pops/model/pn_transformer.rb
128 def transform_LambdaExpression(e)
129   entries = []
130   entries << parameters_entry(e.parameters) unless e.parameters.empty?
131   entries << transform(e.return_type).with_name('returns') unless e.return_type.nil?
132   entries << block_as_entry('body', e.body) unless e.body.nil?
133   PN::Map.new(entries).as_call('lambda')
134 end

    # File lib/puppet/pops/model/pn_transformer.rb
136 def transform_LiteralBoolean(e)
137   PN::Literal.new(e.value)
138 end

    # File lib/puppet/pops/model/pn_transformer.rb
140 def transform_LiteralDefault(_)
141   PN::Call.new('default')
142 end

    # File lib/puppet/pops/model/pn_transformer.rb
144 def transform_LiteralFloat(e)
145   PN::Literal.new(e.value)
146 end

    # File lib/puppet/pops/model/pn_transformer.rb
148 def transform_LiteralHash(e)
149   transform(e.entries).as_call('hash')
150 end

    # File lib/puppet/pops/model/pn_transformer.rb
152 def transform_LiteralInteger(e)
153   vl = PN::Literal.new(e.value)
154   e.radix == 10 ? vl : PN::Map.new([PN::Literal.new(e.radix).with_name('radix'), vl.with_name('value')]).as_call('int')
155 end

    # File lib/puppet/pops/model/pn_transformer.rb
157 def transform_LiteralList(e)
158   transform(e.values).as_call('array')
159 end

    # File lib/puppet/pops/model/pn_transformer.rb
161 def transform_LiteralRegularExpression(e)
162   PN::Literal.new(Types::PRegexpType.regexp_to_s(e.value)).as_call('regexp')
163 end

    # File lib/puppet/pops/model/pn_transformer.rb
165 def transform_LiteralString(e)
166   PN::Literal.new(e.value)
167 end

    # File lib/puppet/pops/model/pn_transformer.rb
169 def transform_LiteralUndef(_)
170   PN::Literal.new(nil)
171 end

    # File lib/puppet/pops/model/pn_transformer.rb
173 def transform_MatchExpression(e)
174   binary_op(e, e.operator)
175 end

    # File lib/puppet/pops/model/pn_transformer.rb
177 def transform_NamedAccessExpression(e)
178   binary_op(e, '.')
179 end

    # File lib/puppet/pops/model/pn_transformer.rb
193 def transform_NilClass(e)
194   PN::Call.new('nop')
195 end

    # File lib/puppet/pops/model/pn_transformer.rb
181 def transform_NodeDefinition(e)
182   entries = [transform(e.host_matches).with_name('matches')]
183   entries << transform(e.parent).with_name('parent') unless e.parent.nil?
184   entries << block_as_entry('body', e.body) unless e.body.nil?
185   PN::Map.new(entries).as_call('node')
186 end

    # File lib/puppet/pops/model/pn_transformer.rb
188 def transform_Nop(_)
189   PN::Call.new('nop')
190 end

    # File lib/puppet/pops/model/pn_transformer.rb
197 def transform_NotExpression(e)
198   PN::Call.new('!', transform(e.expr))
199 end

    # File lib/puppet/pops/model/pn_transformer.rb
201 def transform_OrExpression(e)
202   binary_op(e, 'or')
203 end

    # File lib/puppet/pops/model/pn_transformer.rb
205 def transform_Parameter(e)
206   entries = [PN::Literal.new(e.name).with_name('name')]
207   entries << transform(e.type_expr).with_name('type') unless e.type_expr.nil?
208   entries << PN::Literal.new(true).with_name('splat') if e.captures_rest
209   entries << transform(e.value).with_name('value') unless e.value.nil?
210   PN::Map.new(entries).with_name('param')
211 end

    # File lib/puppet/pops/model/pn_transformer.rb
213 def transform_ParenthesizedExpression(e)
214   PN::Call.new('paren', transform(e.expr))
215 end

    # File lib/puppet/pops/model/pn_transformer.rb
217 def transform_PlanDefinition(e)
218   definition_to_pn(e, 'plan', nil, e.return_type)
219 end

    # File lib/puppet/pops/model/pn_transformer.rb
221 def transform_Program(e)
222   transform(e.body)
223 end

    # File lib/puppet/pops/model/pn_transformer.rb
225 def transform_QualifiedName(e)
226   PN::Call.new('qn', PN::Literal.new(e.value))
227 end

    # File lib/puppet/pops/model/pn_transformer.rb
229 def transform_QualifiedReference(e)
230   PN::Call.new('qr', PN::Literal.new(e.cased_value))
231 end

    # File lib/puppet/pops/model/pn_transformer.rb
233 def transform_RelationshipExpression(e)
234   binary_op(e, e.operator)
235 end

    # File lib/puppet/pops/model/pn_transformer.rb
237 def transform_RenderExpression(e)
238   PN::Call.new('render', transform(e.expr))
239 end

    # File lib/puppet/pops/model/pn_transformer.rb
241 def transform_RenderStringExpression(e)
242   PN::Literal.new(e.value).as_call('render-s')
243 end

    # File lib/puppet/pops/model/pn_transformer.rb
245 def transform_ReservedWord(e)
246   PN::Literal.new(e.word).as_call('reserved')
247 end

    # File lib/puppet/pops/model/pn_transformer.rb
249 def transform_ResourceBody(e)
250   PN::Map.new([
251     transform(e.title).with_name('title'),
252     transform(e.operations).with_name('ops')
253   ]).as_call('resource_body')
254 end

    # File lib/puppet/pops/model/pn_transformer.rb
256 def transform_ResourceDefaultsExpression(e)
257   entries = [transform(e.type_ref).with_name('type'), transform(e.operations).with_name('ops')]
258   entries << PN::Literal.new(e.form).with_name('form') unless e.form == 'regular'
259   PN::Map.new(entries).as_call('resource-defaults')
260 end

    # File lib/puppet/pops/model/pn_transformer.rb
262 def transform_ResourceExpression(e)
263   entries = [
264     transform(e.type_name).with_name('type'),
265     PN::List.new(pn_array(e.bodies).map { |body| body[0] }).with_name('bodies')
266   ]
267   entries << PN::Literal.new(e.form).with_name('form') unless e.form == 'regular'
268   PN::Map.new(entries).as_call('resource')
269 end

    # File lib/puppet/pops/model/pn_transformer.rb
271 def transform_ResourceOverrideExpression(e)
272   entries = [transform(e.resources).with_name('resources'), transform(e.operations).with_name('ops')]
273   entries << PN::Literal.new(e.form).with_name('form') unless e.form == 'regular'
274   PN::Map.new(entries).as_call('resource-override')
275 end

    # File lib/puppet/pops/model/pn_transformer.rb
277 def transform_ResourceTypeDefinition(e)
278   definition_to_pn(e, 'define')
279 end

    # File lib/puppet/pops/model/pn_transformer.rb
281 def transform_SelectorEntry(e)
282   PN::Call.new('=>', transform(e.matching_expr), transform(e.value_expr))
283 end

    # File lib/puppet/pops/model/pn_transformer.rb
285 def transform_SelectorExpression(e)
286   PN::Call.new('?', transform(e.left_expr), transform(e.selectors))
287 end

    # File lib/puppet/pops/model/pn_transformer.rb
289 def transform_TextExpression(e)
290   PN::Call.new('str', transform(e.expr))
291 end

    # File lib/puppet/pops/model/pn_transformer.rb
293 def transform_TypeAlias(e)
294   PN::Call.new('type-alias', PN::Literal.new(e.name), transform(e.type_expr))
295 end

    # File lib/puppet/pops/model/pn_transformer.rb
297 def transform_TypeDefinition(e)
298   PN::Call.new('type-definition', PN::Literal.new(e.name), PN::Literal.new(e.parent), transform(e.body))
299 end

    # File lib/puppet/pops/model/pn_transformer.rb
301 def transform_TypeMapping(e)
302   PN::Call.new('type-mapping', transform(e.type_expr), transform(e.mapping_expr))
303 end

    # File lib/puppet/pops/model/pn_transformer.rb
305 def transform_UnaryMinusExpression(e)
306   if e.expr.is_a?(LiteralValue)
307     v = e.expr.value
308     if v.is_a?(Numeric)
309       return PN::Literal.new(-v)
310     end
311   end
312   PN::Call.new('-', transform(e.expr))
313 end

    # File lib/puppet/pops/model/pn_transformer.rb
315 def transform_UnfoldExpression(e)
316   PN::Call.new('unfold', transform(e.expr))
317 end

    # File lib/puppet/pops/model/pn_transformer.rb
319 def transform_UnlessExpression(e)
320   if_to_pn(e, 'unless')
321 end

    # File lib/puppet/pops/model/pn_transformer.rb
323 def transform_VariableExpression(e)
324   ne = e.expr
325   PN::Call.new('var', ne.is_a?(Model::QualifiedName) ? PN::Literal.new(ne.value) : transform(ne))
326 end

    # File lib/puppet/pops/model/pn_transformer.rb
328 def transform_VirtualQuery(e)
329   is_nop?(e.expr) ? PN::Call.new('virtual-query') : PN::Call.new('virtual-query', transform(e.expr))
330 end