class Puppet::Pops::Model::PNTransformer

Public Class Methods

new() click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
14 def initialize
15   @visitor = Visitor.new(nil, 'transform', 0, 0)
16 end
transform(ast) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
10 def self.transform(ast)
11   singleton.transform(ast)
12 end

Public Instance Methods

binary_op(e, op) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
335 def binary_op(e, op)
336   PN::Call.new(op, transform(e.left_expr), transform(e.right_expr))
337 end
block_as_entry(name, expr) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
358 def block_as_entry(name, expr)
359   if expr.is_a?(BlockExpression)
360     transform(expr.statements).with_name(name)
361   else
362     transform([expr]).with_name(name)
363   end
364 end
call_to_pn(e, r, nr) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
370 def call_to_pn(e, r, nr)
371   entries = [transform(e.functor_expr).with_name('functor'), transform(e.arguments).with_name('args')]
372   entries << transform(e.lambda).with_name('block') unless e.lambda.nil?
373   PN::Map.new(entries).as_call(e.rval_required ? r : nr)
374 end
definition_to_pn(e, type_name, parent = nil, return_type = nil) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
339 def definition_to_pn(e, type_name, parent = nil, return_type = nil)
340   entries = [PN::Literal.new(e.name).with_name('name')]
341   entries << PN::Literal.new(parent).with_name('parent') unless parent.nil?
342   entries << parameters_entry(e.parameters) unless e.parameters.empty?
343   entries << block_as_entry('body', e.body) unless e.body.nil?
344   entries << transform(return_type).with_name('returns') unless return_type.nil?
345   PN::Map.new(entries).as_call(type_name)
346 end
if_to_pn(e, name) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
376 def if_to_pn(e, name)
377   entries = [transform(e.test).with_name('test')]
378   entries << block_as_entry('then', e.then_expr) unless is_nop?(e.then_expr)
379   entries << block_as_entry('else', e.else_expr) unless is_nop?(e.else_expr)
380   PN::Map.new(entries).as_call(name)
381 end
is_nop?(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
331 def is_nop?(e)
332   e.nil? || e.is_a?(Nop)
333 end
parameters_entry(parameters) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
348 def parameters_entry(parameters)
349   PN::Map.new(parameters.map do |p|
350     entries = []
351     entries << transform(p.type_expr).with_name('type') unless p.type_expr.nil?
352     entries << PN::Literal(true).with_name('splat') if p.captures_rest
353     entries << transform(p.value).with_name('value') unless p.value.nil?
354     PN::Map.new(entries).with_name(p.name)
355   end).with_name('params')
356 end
pn_array(a) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
366 def pn_array(a)
367   a.map { |e| transform(e) }
368 end
transform(ast) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
18 def transform(ast)
19   @visitor.visit_this_0(self, ast)
20 end
transform_AccessExpression(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
22 def transform_AccessExpression(e)
23   PN::List.new([transform(e.left_expr)] + pn_array(e.keys)).as_call('access')
24 end
transform_AndExpression(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
26 def transform_AndExpression(e)
27   binary_op(e, 'and')
28 end
transform_ArithmeticExpression(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
30 def transform_ArithmeticExpression(e)
31   binary_op(e, e.operator)
32 end
transform_Array(a) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
34 def transform_Array(a)
35   PN::List.new(pn_array(a))
36 end
transform_AssignmentExpression(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
38 def transform_AssignmentExpression(e)
39   binary_op(e, e.operator)
40 end
transform_AttributeOperation(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
42 def transform_AttributeOperation(e)
43   PN::Call.new(e.operator, PN::Literal.new(e.attribute_name), transform(e.value_expr))
44 end
transform_AttributesOperation(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
46 def transform_AttributesOperation(e)
47   PN::Call.new('splat-hash', transform(e.expr))
48 end
transform_BlockExpression(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
50 def transform_BlockExpression(e)
51   transform(e.statements).as_call('block')
52 end
transform_CallFunctionExpression(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
54 def transform_CallFunctionExpression(e)
55   call_to_pn(e, 'call-lambda', 'invoke-lambda')
56 end
transform_CallMethodExpression(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
58 def transform_CallMethodExpression(e)
59   call_to_pn(e, 'call-method', 'invoke-method')
60 end
transform_CallNamedFunctionExpression(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
62 def transform_CallNamedFunctionExpression(e)
63   call_to_pn(e, 'call', 'invoke')
64 end
transform_CaseExpression(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
66 def transform_CaseExpression(e)
67   PN::Call.new('case', transform(e.test), transform(e.options))
68 end
transform_CaseOption(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
70 def transform_CaseOption(e)
71   PN::Map.new([transform(e.values).with_name('when'), block_as_entry('then', e.then_expr)])
72 end
transform_CollectExpression(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
74 def transform_CollectExpression(e)
75   entries = [transform(e.type_expr).with_name('type'), transform(e.query).with_name('query')]
76   entries << transform(e.operations).with_name('ops') unless e.operations.empty?
77   PN::Map.new(entries).as_call('collect')
78 end
transform_ComparisonExpression(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
80 def transform_ComparisonExpression(e)
81   binary_op(e, e.operator)
82 end
transform_ConcatenatedString(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
84 def transform_ConcatenatedString(e)
85   transform(e.segments).as_call('concat')
86 end
transform_EppExpression(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
88 def transform_EppExpression(e)
89   e.body.nil? ? PN::Call.new('epp') : transform(e.body).as_call('epp')
90 end
transform_ExportedQuery(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
92 def transform_ExportedQuery(e)
93   is_nop?(e.expr) ? PN::Call.new('exported-query') : PN::Call.new('exported-query', transform(e.expr))
94 end
transform_Factory(e) click to toggle source
   # File lib/puppet/pops/model/pn_transformer.rb
96 def transform_Factory(e)
97   transform(e.model)
98 end
transform_FunctionDefinition(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
100 def transform_FunctionDefinition(e)
101   definition_to_pn(e, 'function', nil, e.return_type)
102 end
transform_HeredocExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
104 def transform_HeredocExpression(e)
105   entries = []
106   entries << PN::Literal.new(e.syntax).with_name('syntax') unless e.syntax == ''
107   entries << transform(e.text_expr).with_name('text')
108   PN::Map.new(entries).as_call('heredoc')
109 end
transform_HostClassDefinition(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
111 def transform_HostClassDefinition(e)
112   definition_to_pn(e, 'class', e.parent_class)
113 end
transform_IfExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
115 def transform_IfExpression(e)
116   if_to_pn(e, 'if')
117 end
transform_InExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
119 def transform_InExpression(e)
120   binary_op(e, 'in')
121 end
transform_KeyedEntry(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
123 def transform_KeyedEntry(e)
124   PN::Call.new('=>', transform(e.key), transform(e.value))
125 end
transform_LambdaExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
127 def transform_LambdaExpression(e)
128   entries = []
129   entries << parameters_entry(e.parameters) unless e.parameters.empty?
130   entries << transform(e.return_type).with_name('returns') unless e.return_type.nil?
131   entries << block_as_entry('body', e.body) unless e.body.nil?
132   PN::Map.new(entries).as_call('lambda')
133 end
transform_LiteralBoolean(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
135 def transform_LiteralBoolean(e)
136   PN::Literal.new(e.value)
137 end
transform_LiteralDefault(_) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
139 def transform_LiteralDefault(_)
140   PN::Call.new('default')
141 end
transform_LiteralFloat(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
143 def transform_LiteralFloat(e)
144   PN::Literal.new(e.value)
145 end
transform_LiteralHash(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
147 def transform_LiteralHash(e)
148   transform(e.entries).as_call('hash')
149 end
transform_LiteralInteger(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
151 def transform_LiteralInteger(e)
152   vl = PN::Literal.new(e.value)
153   e.radix == 10 ? vl : PN::Map.new([PN::Literal.new(e.radix).with_name('radix'), vl.with_name('value')]).as_call('int')
154 end
transform_LiteralList(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
156 def transform_LiteralList(e)
157   transform(e.values).as_call('array')
158 end
transform_LiteralRegularExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
160 def transform_LiteralRegularExpression(e)
161   PN::Literal.new(Types::PRegexpType.regexp_to_s(e.value)).as_call('regexp')
162 end
transform_LiteralString(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
164 def transform_LiteralString(e)
165   PN::Literal.new(e.value)
166 end
transform_LiteralUndef(_) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
168 def transform_LiteralUndef(_)
169   PN::Literal.new(nil)
170 end
transform_MatchExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
172 def transform_MatchExpression(e)
173   binary_op(e, e.operator)
174 end
transform_NamedAccessExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
176 def transform_NamedAccessExpression(e)
177   binary_op(e, '.')
178 end
transform_NilClass(e) click to toggle source

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

    # File lib/puppet/pops/model/pn_transformer.rb
192 def transform_NilClass(e)
193   PN::Call.new('nop')
194 end
transform_NodeDefinition(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
180 def transform_NodeDefinition(e)
181   entries = [transform(e.host_matches).with_name('matches')]
182   entries << transform(e.parent).with_name('parent') unless e.parent.nil?
183   entries << block_as_entry('body', e.body) unless e.body.nil?
184   PN::Map.new(entries).as_call('node')
185 end
transform_Nop(_) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
187 def transform_Nop(_)
188   PN::Call.new('nop')
189 end
transform_NotExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
196 def transform_NotExpression(e)
197   PN::Call.new('!', transform(e.expr))
198 end
transform_OrExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
200 def transform_OrExpression(e)
201   binary_op(e, 'or')
202 end
transform_Parameter(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
204 def transform_Parameter(e)
205   entries = [PN::Literal.new(e.name).with_name('name')]
206   entries << transform(e.type_expr).with_name('type') unless e.type_expr.nil?
207   entries << PN::Literal.new(true).with_name('splat') if e.captures_rest
208   entries << transform(e.value).with_name('value') unless e.value.nil?
209   PN::Map.new(entries).with_name('param')
210 end
transform_ParenthesizedExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
212 def transform_ParenthesizedExpression(e)
213   PN::Call.new('paren', transform(e.expr))
214 end
transform_PlanDefinition(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
216 def transform_PlanDefinition(e)
217   definition_to_pn(e, 'plan', nil, e.return_type)
218 end
transform_Program(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
220 def transform_Program(e)
221   transform(e.body)
222 end
transform_QualifiedName(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
224 def transform_QualifiedName(e)
225   PN::Call.new('qn', PN::Literal.new(e.value))
226 end
transform_QualifiedReference(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
228 def transform_QualifiedReference(e)
229   PN::Call.new('qr', PN::Literal.new(e.cased_value))
230 end
transform_RelationshipExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
232 def transform_RelationshipExpression(e)
233   binary_op(e, e.operator)
234 end
transform_RenderExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
236 def transform_RenderExpression(e)
237   PN::Call.new('render', transform(e.expr))
238 end
transform_RenderStringExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
240 def transform_RenderStringExpression(e)
241   PN::Literal.new(e.value).as_call('render-s')
242 end
transform_ReservedWord(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
244 def transform_ReservedWord(e)
245   PN::Literal.new(e.word).as_call('reserved')
246 end
transform_ResourceBody(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
248 def transform_ResourceBody(e)
249   PN::Map.new([
250     transform(e.title).with_name('title'),
251     transform(e.operations).with_name('ops')
252   ]).as_call('resource_body')
253 end
transform_ResourceDefaultsExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
255 def transform_ResourceDefaultsExpression(e)
256   entries = [transform(e.type_ref).with_name('type'), transform(e.operations).with_name('ops')]
257   entries << PN::Literal.new(e.form).with_name('form') unless e.form == 'regular'
258   PN::Map.new(entries).as_call('resource-defaults')
259 end
transform_ResourceExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
261 def transform_ResourceExpression(e)
262   entries = [
263     transform(e.type_name).with_name('type'),
264     PN::List.new(pn_array(e.bodies).map { |body| body[0] }).with_name('bodies')
265   ]
266   entries << PN::Literal.new(e.form).with_name('form') unless e.form == 'regular'
267   PN::Map.new(entries).as_call('resource')
268 end
transform_ResourceOverrideExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
270 def transform_ResourceOverrideExpression(e)
271   entries = [transform(e.resources).with_name('resources'), transform(e.operations).with_name('ops')]
272   entries << PN::Literal.new(e.form).with_name('form') unless e.form == 'regular'
273   PN::Map.new(entries).as_call('resource-override')
274 end
transform_ResourceTypeDefinition(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
276 def transform_ResourceTypeDefinition(e)
277   definition_to_pn(e, 'define')
278 end
transform_SelectorEntry(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
280 def transform_SelectorEntry(e)
281   PN::Call.new('=>', transform(e.matching_expr), transform(e.value_expr))
282 end
transform_SelectorExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
284 def transform_SelectorExpression(e)
285   PN::Call.new('?', transform(e.left_expr), transform(e.selectors))
286 end
transform_TextExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
288 def transform_TextExpression(e)
289   PN::Call.new('str', transform(e.expr))
290 end
transform_TypeAlias(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
292 def transform_TypeAlias(e)
293   PN::Call.new('type-alias', PN::Literal.new(e.name), transform(e.type_expr))
294 end
transform_TypeDefinition(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
296 def transform_TypeDefinition(e)
297   PN::Call.new('type-definition', PN::Literal.new(e.name), PN::Literal.new(e.parent), transform(e.body))
298 end
transform_TypeMapping(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
300 def transform_TypeMapping(e)
301   PN::Call.new('type-mapping', transform(e.type_expr), transform(e.mapping_expr))
302 end
transform_UnaryMinusExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
304 def transform_UnaryMinusExpression(e)
305   if e.expr.is_a?(LiteralValue)
306     v = e.expr.value
307     if v.is_a?(Numeric)
308       return PN::Literal.new(-v)
309     end
310   end
311   PN::Call.new('-', transform(e.expr))
312 end
transform_UnfoldExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
314 def transform_UnfoldExpression(e)
315   PN::Call.new('unfold', transform(e.expr))
316 end
transform_UnlessExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
318 def transform_UnlessExpression(e)
319   if_to_pn(e, 'unless')
320 end
transform_VariableExpression(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
322 def transform_VariableExpression(e)
323   ne = e.expr
324   PN::Call.new('var', ne.is_a?(Model::QualifiedName) ? PN::Literal.new(ne.value) : transform(ne))
325 end
transform_VirtualQuery(e) click to toggle source
    # File lib/puppet/pops/model/pn_transformer.rb
327 def transform_VirtualQuery(e)
328   is_nop?(e.expr) ? PN::Call.new('virtual-query') : PN::Call.new('virtual-query', transform(e.expr))
329 end