Class: Puppet::Pops::Model::AstTransformer

Inherits:
Object
  • Object
show all
Defined in:
lib/puppet/pops/model/ast_transformer.rb

Overview

The receiver of ‘import(file)` calls; once per imported file, or nil if imports are ignored

Transforms a Pops::Model to classic Puppet AST. TODO: Documentation is currently skipped completely (it is only used for Rdoc)

Constant Summary collapse

AST = 
Puppet::Parser::AST
Model = 
Puppet::Pops::Model

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(source_file = "unknown-file", importer = nil) ⇒ AstTransformer

Returns a new instance of AstTransformer.



13
14
15
16
17
18
19
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 13

def initialize(source_file = "unknown-file", importer=nil)
  @@transform_visitor ||= Puppet::Pops::Visitor.new(nil,"transform",0,0)
  @@query_transform_visitor ||= Puppet::Pops::Visitor.new(nil,"query",0,0)
  @@hostname_transform_visitor ||= Puppet::Pops::Visitor.new(nil,"hostname",0,0)
  @importer = importer
  @source_file = source_file
end

Instance Attribute Details

#importer ⇒ Object (readonly) 



12
13
14
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 12

def importer
  @importer
end

Instance Method Details

#ast(o, klass, hash = {}) ⇒ Object

Initialize klass from o (location) and hash (options to created instance). The object o is used to compute a source location. It may be nil. Source position is merged into the given options (non surgically). If o is non-nil, the first found source position going up the containment hierarchy is set. I.e. callers should pass nil if a source position is not wanted or known to be unobtainable for the object.

Parameters:

  • o (Object, nil) —

    object from which source position / location is obtained, may be nil

  • klass (Class<Puppet::Parser::AST>) —

    the ast class to create an instance of

  • hash (Hash) (defaults to: {}) —

    hash with options for the class to create



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

def ast(o, klass, hash={})
  # create and pass hash with file and line information
  klass.new(merge_location(hash, o))
end

#hostname(o) ⇒ Object

Transforms pops expressions into AST 3.1 hostnames



74
75
76
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 74

def hostname(o)
  @@hostname_transform_visitor.visit_this(self, o)
end

#hostname_Array(o) ⇒ Object

Transforms Array of host matching expressions into a (Ruby) array of AST::HostName



460
461
462
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 460

def hostname_Array(o)
  o.collect {|x| ast x, AST::HostName, :value => hostname(x) }
end

#hostname_LiteralDefault(o) ⇒ Object 



476
477
478
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 476

def hostname_LiteralDefault(o)
  return 'default'
end

#hostname_LiteralNumber(o) ⇒ Object 



472
473
474
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 472

def hostname_LiteralNumber(o)
  transform(o) # Number to string with correct radix
end

#hostname_LiteralRegularExpression(o) ⇒ Object 



480
481
482
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 480

def hostname_LiteralRegularExpression(o)
  ast o, AST::Regex, :value => o.value
end

#hostname_LiteralValue(o) ⇒ Object 



464
465
466
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 464

def hostname_LiteralValue(o)
  return o.value
end

#hostname_Object(o) ⇒ Object 



484
485
486
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 484

def hostname_Object(o)
  raise "Illegal expression - unacceptable as a node name"
end

#hostname_QualifiedName(o) ⇒ Object 



468
469
470
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 468

def hostname_QualifiedName(o)
  return o.value
end

#is_nop?(o) ⇒ Boolean

Nil, nop Bee bopp a luh-lah, a bop bop boom.

Returns:

  • (Boolean) 


640
641
642
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 640

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

#merge_location(hash, o) ⇒ Object

THIS IS AN EXPENSIVE OPERATION The 3x AST requires line, pos etc. to be recorded directly in the AST nodes and this information must be computed. (Newer implementation only computes the information that is actually needed; typically when raising an exception).



42
43
44
45
46
47
48
49
50
51
52
53
54
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 42

def merge_location(hash, o)
  if o
    pos = {}
    source_pos = Puppet::Pops::Utils.find_closest_positioned(o)
    if source_pos
      pos[:line] = source_pos.line
      pos[:pos]  = source_pos.pos
    end
    pos[:file] = @source_file if @source_file
    hash = hash.merge(pos)
  end
  hash
end

#query(o) ⇒ Object

Transforms pops expressions into AST 3.1 query expressions



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

def query(o)
  @@query_transform_visitor.visit_this(self, o)
end

#query_AndExpression(o) ⇒ Object 



222
223
224
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 222

def query_AndExpression(o)
  ast o, AST::CollExpr, :test1 => query(o.left_expr), :oper => 'and', :test2 => query(o.right_expr)
end

#query_ComparisonExpression(o) ⇒ Object

Puppet AST only allows == and !=, and left expr is restricted, but right value is an expression



214
215
216
217
218
219
220
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 214

def query_ComparisonExpression(o)
  if [:'==', :'!='].include? o.operator
    ast o, AST::CollExpr, :test1 => query(o.left_expr), :oper => o.operator.to_s, :test2 => transform(o.right_expr)
  else
    raise "Not a valid comparison operator in a collection query: " + o.operator.to_s
  end
end

#query_LiteralBoolean(o) ⇒ Object 



252
253
254
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 252

def query_LiteralBoolean(o)
  transform(o)
end

#query_LiteralNumber(o) ⇒ Object 



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

def query_LiteralNumber(o)
  transform(o) # number to string in correct radix
end

#query_LiteralString(o) ⇒ Object 



248
249
250
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 248

def query_LiteralString(o)
  transform(o)
end

#query_Object(o) ⇒ Object

Ensures transformation fails if a 3.1 non supported object is encountered in a query expression



208
209
210
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 208

def query_Object(o)
  raise "Not a valid expression in a collection query: "+o.class.name
end

#query_OrExpression(o) ⇒ Object 



226
227
228
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 226

def query_OrExpression(o)
  ast o, AST::CollExpr, :test1 => query(o.left_expr), :oper => 'or', :test2 => query(o.right_expr)
end

#query_ParenthesizedExpression(o) ⇒ Object 



230
231
232
233
234
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 230

def query_ParenthesizedExpression(o)
  result = query(o.expr) # produces CollExpr
  result.parens = true
  result
end

#query_QualifiedName(o) ⇒ Object 



240
241
242
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 240

def query_QualifiedName(o)
  transform(o)
end

#query_VariableExpression(o) ⇒ Object 



236
237
238
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 236

def query_VariableExpression(o)
  transform(o)
end

#transform(o) ⇒ Object

Transforms pops expressions into AST 3.1 statements/expressions



57
58
59
60
61
62
63
64
65
66
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 57

def transform(o)
  begin
  @@transform_visitor.visit_this(self,o)
  rescue StandardError => e
    loc_data = {}
    merge_location(loc_data, o)
    raise Puppet::ParseError.new("Error while transforming to Puppet 3 AST: #{e.message}", 
      loc_data[:file], loc_data[:line], loc_data[:pos], e)
  end
end

#transform_AccessExpression(o) ⇒ Object

Puppet AST only allows:

  • variable => Hasharray Access

  • NAME [expressions] => Resource Reference(s)

  • type [epxressions] => Resource Reference(s)

  • HashArrayAccesses => HasharrayAccesses

i.e. it is not possible to do ‘func()`, `[1,2,3]`, `foo=>10, bar=>20` etc. since LHS is not an expression

Validation for 3.x semantics should validate the illegal cases. This transformation may fail, or ignore excess information if the expressions are not correct. This means that the transformation does not have to evaluate the lhs to detect the target expression.

Hm, this seems to have changed, the LHS (variable) is evaluated if evaluateable, else it is used as is.



137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 137

def transform_AccessExpression(o)
  case o.left_expr
  when Model::QualifiedName
    ast o, AST::ResourceReference, :type => o.left_expr.value, :title => transform(o.keys)

  when Model::QualifiedReference
    ast o, AST::ResourceReference, :type => o.left_expr.value, :title => transform(o.keys)

  when Model::VariableExpression
    ast o, AST::HashOrArrayAccess, :variable => transform(o.left_expr), :key => transform(o.keys()[0])

  else
    ast o, AST::HashOrArrayAccess, :variable => transform(o.left_expr), :key => transform(o.keys()[0])
  end
end

#transform_AndExpression(o) ⇒ Object 



268
269
270
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 268

def transform_AndExpression(o)
  ast o, AST::BooleanOperator, :operator => 'and', :lval => transform(o.left_expr), :rval => transform(o.right_expr)
end

#transform_ArithmeticExpression(o) ⇒ Object 



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

def transform_ArithmeticExpression(o)
  ast o, AST::ArithmeticOperator2, :lval => transform(o.left_expr), :rval=>transform(o.right_expr),
  :operator => o.operator.to_s
end

#transform_Array(o) ⇒ Object 



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

def transform_Array(o)
  ast nil, AST::ASTArray, :children => o.collect {|x| transform(x) }
end

#transform_AssignmentExpression(o) ⇒ Object

Assignment in AST 3.1 is to variable or hasharray accesses !!! See Bug #16116



281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 281

def transform_AssignmentExpression(o)
  args = {:value => transform(o.right_expr) }
  case o.operator
  when :'+='
    args[:append] = true
  when :'='
  else
    raise "The operator #{o.operator} is not supported by Puppet 3."
  end

  args[:name] = case o.left_expr
  when Model::VariableExpression
    ast o, AST::Name, {:value => o.left_expr.expr.value }
  when Model::AccessExpression
    transform(o.left_expr)
  else
    raise "LHS is not an expression that can be assigned to"
  end
  ast o, AST::VarDef, args
end

#transform_AttributeOperation(o) ⇒ Object

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



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

def transform_AttributeOperation(o)
  args = { :value => transform(o.value_expr) }
  args[:add] = true if o.operator == :'+>'
  args[:param] = o.attribute_name
  ast o, AST::ResourceParam, args
end

#transform_BlockExpression(o) ⇒ Object

Puppet 3.1 representation of a BlockExpression is an AST::Array - this makes it impossible to differentiate between a LiteralArray and a Sequence. (Should it return the collected array, or the last expression?) (A BlockExpression has now been introduced in the AST to solve this).



417
418
419
420
421
422
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 417

def transform_BlockExpression(o)
  children = []
  # remove nops resulting from import
  o.statements.each {|s| r = transform(s); children << r unless is_nop?(r) }
  ast o, AST::BlockExpression, :children => children  # o.statements.collect {|s| transform(s) }
end

#transform_CallMethodExpression(o) ⇒ Object

Transformation of CallMethodExpression handles a NamedAccessExpression functor and turns this into a 3.1 AST::MethodCall.



581
582
583
584
585
586
587
588
589
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 581

def transform_CallMethodExpression(o)
  name = o.functor_expr
  raise "Unacceptable expression for name of function" unless name.is_a? Model::NamedAccessExpression
  # transform of NamedAccess produces a hash, add arguments to it
  astargs = transform(name).merge(:arguments => transform(o.arguments))
  astargs.merge!(:lambda => transform(o.lambda)) if o.lambda # do not want a Nop as the lambda
  ast o, AST::MethodCall, astargs

end

#transform_CallNamedFunctionExpression(o) ⇒ Object

Puppet 3.1 AST only supports calling a function by name (it is not possible to produce a function that is then called). rval_required (for an expression) functor_expr (lhs - the “name” expression) arguments - list of arguments



566
567
568
569
570
571
572
573
574
575
576
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 566

def transform_CallNamedFunctionExpression(o)
  name = o.functor_expr
  raise "Unacceptable expression for name of function" unless name.is_a? Model::QualifiedName
  args = {
    :name => name.value,
    :arguments => transform(o.arguments),
    :ftype => o.rval_required ? :rvalue : :statement
  }
  args[:pblock] = transform(o.lambda) if o.lambda
  ast o, AST::Function, args
end

#transform_CaseExpression(o) ⇒ Object 



591
592
593
594
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 591

def transform_CaseExpression(o)
  # Expects expression, AST::ASTArray of AST
  ast o, AST::CaseStatement, :test => transform(o.test), :options => transform(o.options)
end

#transform_CaseOption(o) ⇒ Object 



596
597
598
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 596

def transform_CaseOption(o)
  ast o, AST::CaseOpt, :value => transform(o.values), :statements => transform(o.then_expr)
end

#transform_CollectExpression(o) ⇒ Object

Puppet AST has a complicated structure LHS can not be an expression, it must be a type (which is downcased). type = a downcased QualifiedName



157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 157

def transform_CollectExpression(o)
  raise "LHS is not a type" unless o.type_expr.is_a? Model::QualifiedReference
  type = o.type_expr.value().downcase()
  args = { :type => type }

  # This somewhat peculiar encoding is used by the 3.1 AST.
  query = transform(o.query)
  if query.is_a? Symbol
    args[:form] =  query
  else
    args[:form] = query.form
    args[:query] = query
    query.type = type
  end

  if o.operations.size > 0
    args[:override] = transform(o.operations)
  end
  ast o, AST::Collection, args
end

#transform_ComparisonExpression(o) ⇒ Object 



264
265
266
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 264

def transform_ComparisonExpression(o)
  ast o, AST::ComparisonOperator, :operator => o.operator.to_s, :lval => transform(o.left_expr), :rval => transform(o.right_expr)
end

#transform_ConcatenatedString(o) ⇒ Object

Interpolated strings are kept in an array of AST (string or other expression).



425
426
427
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 425

def transform_ConcatenatedString(o)
  ast o, AST::Concat, :value => o.segments.collect {|x| transform(x)}
end

#transform_EppExpression(o) ⇒ Object 



178
179
180
181
182
183
184
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 178

def transform_EppExpression(o)
  # TODO: Not supported in 3x TODO_EPP
  parameters = o.parameters.collect {|p| transform(p) }
  args = { :parameters => parameters }
  args[:children] = transform(o.body) unless is_nop?(o.body)
  Puppet::Parser::AST::Epp.new(merge_location(args, o))
end

#transform_ExportedQuery(o) ⇒ Object 



186
187
188
189
190
191
192
193
194
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 186

def transform_ExportedQuery(o)
  if is_nop?(o.expr)
    result = :exported
  else
    result = query(o.expr)
    result.form = :exported
  end
  result
end

#transform_Factory(o) ⇒ Object 



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

def transform_Factory(o)
  transform(o.current)
end

#transform_HeredocExpression(o) ⇒ Object 



439
440
441
442
443
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 439

def transform_HeredocExpression(o)
  # TODO_HEREDOC Not supported in 3x
  args = {:syntax=> o.syntax(), :expr => transform(o.text_expr()) }
  Puppet::Parser::AST::Heredoc.new(merge_location(args, o))
end

#transform_HostClassDefinition(o) ⇒ Object 



429
430
431
432
433
434
435
436
437
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 429

def transform_HostClassDefinition(o)
  parameters = o.parameters.collect {|p| transform(p) }
  args = {
    :arguments => parameters,
    :parent => o.parent_class,
  }
  args[:code] = transform(o.body) unless is_nop?(o.body)
  Puppet::Parser::AST::Hostclass.new(o.name, merge_location(args, o))
end

#transform_IfExpression(o) ⇒ Object 



544
545
546
547
548
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 544

def transform_IfExpression(o)
  args = { :test => transform(o.test), :statements => transform(o.then_expr) }
  args[:else] = transform(o.else_expr) # Tests say Nop should be there (unless is_nop? o.else_expr), probably not needed
  ast o, AST::IfStatement, args
end

#transform_InExpression(o) ⇒ Object 



276
277
278
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 276

def transform_InExpression(o)
  ast o, AST::InOperator, :lval => transform(o.left_expr), :rval => transform(o.right_expr)
end

#transform_KeyedEntry(o) ⇒ Object

Transforms entry into a hash (they are later merged with strange effects: Bug #19426). Puppet 3.x only allows:

  • NAME

  • quotedtext

As keys (quoted text can be an interpolated string which is compared as a key in a less than satisfactory way).



333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 333

def transform_KeyedEntry(o)
  value = transform(o.value)
  key = case o.key
  when Model::QualifiedName
    o.key.value
  when Model::LiteralString
    transform o.key
  when Model::LiteralNumber
    transform o.key
  when Model::ConcatenatedString
    transform o.key
  else
    raise "Illegal hash key expression of type (#{o.key.class})"
  end
  {key => value}
end

#transform_LambdaExpression(o) ⇒ Object 



358
359
360
361
362
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 358

def transform_LambdaExpression(o)
  astargs = { :parameters => o.parameters.collect {|p| transform(p) } }
  astargs.merge!({ :children => transform(o.body) }) if o.body         # do not want children if it is nil/nop
  ast o, AST::Lambda, astargs
end

#transform_LiteralBoolean(o) ⇒ Object 



105
106
107
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 105

def transform_LiteralBoolean(o)
  ast o, AST::Boolean, :value => o.value
end

#transform_LiteralDefault(o) ⇒ Object 



364
365
366
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 364

def transform_LiteralDefault(o)
  ast o, AST::Default, :value => :default
end

#transform_LiteralFloat(o) ⇒ Object 



78
79
80
81
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 78

def transform_LiteralFloat(o)
  # Numbers are Names in the AST !! (Name a.k.a BareWord)
  ast o, AST::Name, :value => o.value.to_s
end

#transform_LiteralHash(o) ⇒ Object

Literal hash has strange behavior in Puppet 3.1. See Bug #19426, and this implementation is bug compatible



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

def transform_LiteralHash(o)
  if o.entries.size == 0
    ast o, AST::ASTHash, {:value=> {}}
  else
    value = {}
    o.entries.each {|x| value.merge! transform(x) }
    ast o, AST::ASTHash, {:value=> value}
  end
end

#transform_LiteralInteger(o) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 83

def transform_LiteralInteger(o)
  s = 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

  # Numbers are Names in the AST !! (Name a.k.a BareWord)
  ast o, AST::Name, :value => s
end

#transform_LiteralList(o) ⇒ Object 



310
311
312
313
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 310

def transform_LiteralList(o)
  # Uses default transform of Ruby Array to ASTArray
  transform(o.values)
end

#transform_LiteralRegularExpression(o) ⇒ Object 



372
373
374
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 372

def transform_LiteralRegularExpression(o)
  ast o, AST::Regex, :value => o.value
end

#transform_LiteralString(o) ⇒ Object 



354
355
356
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 354

def transform_LiteralString(o)
  ast o, AST::String, :value => o.value
end

#transform_LiteralUndef(o) ⇒ Object 



368
369
370
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 368

def transform_LiteralUndef(o)
  ast o, AST::Undef, :value => :undef
end

#transform_LiteralValue(o) ⇒ Object

Transforms all literal values to string (override for those that should not be AST::String)



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

def transform_LiteralValue(o)
  ast o, AST::String, :value => o.value.to_s
end

#transform_MatchExpression(o) ⇒ Object 



350
351
352
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 350

def transform_MatchExpression(o)
  ast o, AST::MatchOperator, :operator => o.operator.to_s, :lval => transform(o.left_expr), :rval => transform(o.right_expr)
end

#transform_NamedAccessExpression(o) ⇒ Object

In the 3.1. grammar this is a hash that is merged with other elements to form a method call Also in 3.1. grammar there are restrictions on the LHS (that are only there for grammar issues).



383
384
385
386
387
388
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 383

def transform_NamedAccessExpression(o)
  receiver = transform(o.left_expr)
  name = o.right_expr
  raise "Unacceptable function/method name" unless name.is_a? Model::QualifiedName
  {:receiver => receiver, :name => name.value}
end

#transform_NilClass(o) ⇒ Object 



390
391
392
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 390

def transform_NilClass(o)
  ast o, AST::Nop, {}
end

#transform_NodeDefinition(o) ⇒ Object 



445
446
447
448
449
450
451
452
453
454
455
456
457
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 445

def transform_NodeDefinition(o)
  # o.host_matches are expressions, and 3.1 AST requires special object AST::HostName
  # where a HostName is one of NAME, STRING, DEFAULT or Regexp - all of these are strings except regexp
  #
  args = {
    :code => transform(o.body)
  }
  args[:parent] = hostname(o.parent) unless is_nop?(o.parent)
  if(args[:parent].is_a?(Array))
    raise "Illegal expression - unacceptable as a node parent"
  end
  Puppet::Parser::AST::Node.new(hostname(o.host_matches), merge_location(args, o))
end

#transform_Nop(o) ⇒ Object 



376
377
378
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 376

def transform_Nop(o)
  ast o, AST::Nop
end

#transform_NotExpression(o) ⇒ Object 



394
395
396
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 394

def transform_NotExpression(o)
  ast o, AST::Not, :value => transform(o.expr)
end

#transform_Object(o) ⇒ Object 



633
634
635
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 633

def transform_Object(o)
  raise "Unacceptable transform - found an Object without a rule: #{o.class}"
end

#transform_OrExpression(o) ⇒ Object 



272
273
274
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 272

def transform_OrExpression(o)
  ast o, AST::BooleanOperator, :operator => 'or', :lval => transform(o.left_expr), :rval => transform(o.right_expr)
end

#transform_Parameter(o) ⇒ Object

Parameter is a parameter in a definition of some kind. It is transformed to an array on the form ‘[name]´, or `[name, value]´.



527
528
529
530
531
532
533
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 527

def transform_Parameter(o)
  if o.value
    [o.name, transform(o.value)]
  else
    [o.name]
  end
end

#transform_ParenthesizedExpression(o) ⇒ Object

For non query expressions, parentheses can be dropped in the resulting AST.



536
537
538
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 536

def transform_ParenthesizedExpression(o)
  transform(o.expr)
end

#transform_Program(o) ⇒ Object 



540
541
542
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 540

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

#transform_QualifiedName(o) ⇒ Object 



256
257
258
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 256

def transform_QualifiedName(o)
  ast o, AST::Name, :value => o.value
end

#transform_QualifiedReference(o) ⇒ Object 



260
261
262
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 260

def transform_QualifiedReference(o)
  ast o, AST::Type, :value => o.value
end

#transform_RelationshipExpression(o) ⇒ Object 



488
489
490
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 488

def transform_RelationshipExpression(o)
  Puppet::Parser::AST::Relationship.new(transform(o.left_expr), transform(o.right_expr), o.operator.to_s, merge_location({}, o))
end

#transform_RenderExpression(o) ⇒ Object 



497
498
499
500
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 497

def transform_RenderExpression(o)
  # TODO_EPP Not supported in 3x
  ast o, AST::RenderExpression, :value => transform(o.expr)
end

#transform_RenderStringExpression(o) ⇒ Object 



492
493
494
495
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 492

def transform_RenderStringExpression(o)
  # TODO_EPP Not supported in 3x
  ast o, AST::RenderString, :value => o.value
end

#transform_ResourceBody(o) ⇒ Object 



600
601
602
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 600

def transform_ResourceBody(o)
  raise "Unsupported transformation - use the new evaluator"
end

#transform_ResourceDefaultsExpression(o) ⇒ Object 



604
605
606
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 604

def transform_ResourceDefaultsExpression(o)
  raise "Unsupported transformation - use the new evaluator"
end

#transform_ResourceExpression(o) ⇒ Object

Transformation of ResourceExpression requires calling a method on the resulting AST::Resource if it is virtual or exported



611
612
613
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 611

def transform_ResourceExpression(o)
  raise "Unsupported transformation - use the new evaluator"
end

#transform_ResourceOverrideExpression(o) ⇒ Object

Transformation of ResourceOverrideExpression is slightly more involved than a straight forward transformation. A ResourceOverrideExppression has “resources” which should be an AccessExpression on the form QualifiedName, or QualifiedReference to be valid. It also has a set of attribute operations.

The AST equivalence is an AST::ResourceOverride with a ResourceReference as its LHS, and a set of Parameters. ResourceReference has type as a string, and the expressions representing the “titles” to be an ASTArray.



521
522
523
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 521

def transform_ResourceOverrideExpression(o)
  raise "Unsupported transformation - use the new evaluator"
end

#transform_ResourceTypeDefinition(o) ⇒ Object 



502
503
504
505
506
507
508
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 502

def transform_ResourceTypeDefinition(o)
  parameters = o.parameters.collect {|p| transform(p) }
  args = { :arguments => parameters }
  args[:code] = transform(o.body) unless is_nop?(o.body)

  Puppet::Parser::AST::Definition.new(o.name, merge_location(args, o))
end

#transform_SelectorEntry(o) ⇒ Object 



629
630
631
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 629

def transform_SelectorEntry(o)
  ast o, AST::ResourceParam, :param => transform(o.matching_expr), :value => transform(o.value_expr)
end

#transform_SelectorExpression(o) ⇒ Object

Transformation of SelectorExpression is limited to certain types of expressions. This is probably due to constraints in the old grammar rather than any real concerns.



617
618
619
620
621
622
623
624
625
626
627
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 617

def transform_SelectorExpression(o)
  case o.left_expr
  when Model::CallNamedFunctionExpression
  when Model::AccessExpression
  when Model::VariableExpression
  when Model::ConcatenatedString
  else
    raise "Unacceptable select expression" unless o.left_expr.kind_of? Model::Literal
  end
  ast o, AST::Selector, :param => transform(o.left_expr), :values => transform(o.selectors)
end

#transform_TextExpression(o) ⇒ Object

In Puppet 3.1, the ConcatenatedString is responsible for the evaluation and stringification of expression segments. Expressions and Strings are kept in an array.



405
406
407
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 405

def transform_TextExpression(o)
  transform(o.expr)
end

#transform_UnaryMinusExpression(o) ⇒ Object 



409
410
411
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 409

def transform_UnaryMinusExpression(o)
  ast o, AST::Minus, :value => transform(o.expr)
end

#transform_UnlessExpression(o) ⇒ Object

Unless is not an AST object, instead an AST::IfStatement is used with an AST::Not around the test



552
553
554
555
556
557
558
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 552

def transform_UnlessExpression(o)
  args = { :test => ast(o, AST::Not, :value => transform(o.test)),
    :statements => transform(o.then_expr) }
  # AST 3.1 does not allow else on unless in the grammar, but it is ok since unless is encoded as an if !x
  args.merge!({:else => transform(o.else_expr)}) unless is_nop?(o.else_expr)
  ast o, AST::IfStatement, args
end

#transform_VariableExpression(o) ⇒ Object 



398
399
400
401
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 398

def transform_VariableExpression(o)
  # assumes the expression is a QualifiedName
  ast o, AST::Variable, :value => o.expr.value
end

#transform_VirtualQuery(o) ⇒ Object 



196
197
198
199
200
201
202
203
204
 
# File 'lib/puppet/pops/model/ast_transformer.rb', line 196

def transform_VirtualQuery(o)
  if is_nop?(o.expr)
    result = :virtual
  else
    result = query(o.expr)
    result.form = :virtual
  end
  result
end