Class: Puppet::Pops::Validation::Checker3_1

Inherits:
Object
  • Object
show all
Defined in:
lib/puppet/pops/validation/checker3_1.rb

Overview

A Validator validates a model.

Validation is performed on each model element in isolation. Each method should validate the model element’s state but not validate its referenced/contained elements except to check their validity in their respective role. The intent is to drive the validation with a tree iterator that visits all elements in a model.

TODO: Add validation of multiplicities - this is a general validation that can be checked for all

Model objects via their metamodel. (I.e an extra call to multiplicity check in polymorph check).
This is however mostly valuable when validating model to model transformations, and is therefore T.B.D

Constant Summary collapse

Issues = 
Puppet::Pops::Issues
Model = 
Puppet::Pops::Model

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(diagnostics_producer) ⇒ Checker3_1

Initializes the validator with a diagnostics producer. This object must respond to :will_accept? and :accept.



20
21
22
23
24
25
26
27
28
29
30
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 20

def initialize(diagnostics_producer)
  @@check_visitor       ||= Puppet::Pops::Visitor.new(nil, "check", 0, 0)
  @@rvalue_visitor      ||= Puppet::Pops::Visitor.new(nil, "rvalue", 0, 0)
  @@hostname_visitor    ||= Puppet::Pops::Visitor.new(nil, "hostname", 1, 2)
  @@assignment_visitor  ||= Puppet::Pops::Visitor.new(nil, "assign", 0, 1)
  @@query_visitor       ||= Puppet::Pops::Visitor.new(nil, "query", 0, 0)
  @@top_visitor         ||= Puppet::Pops::Visitor.new(nil, "top", 1, 1)
  @@relation_visitor    ||= Puppet::Pops::Visitor.new(nil, "relation", 1, 1)

  @acceptor = diagnostics_producer
end

Instance Attribute Details

#acceptor ⇒ Object (readonly) 



16
17
18
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 16

def acceptor
  @acceptor
end

Instance Method Details

#assign(o, via_index = false) ⇒ Object

Checks the LHS of an assignment (is it assignable?). If args is true, assignment via index is checked.



76
77
78
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 76

def assign(o, via_index = false)
  @@assignment_visitor.visit_this_1(self, o, via_index)
end

#assign_AccessExpression(o, via_index) ⇒ Object 



98
99
100
101
102
103
104
105
106
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 98

def assign_AccessExpression(o, via_index)
  # Are indexed assignments allowed at all ? $x[x] = '...'
  if acceptor.will_accept? Issues::ILLEGAL_INDEXED_ASSIGNMENT
    acceptor.accept(Issues::ILLEGAL_INDEXED_ASSIGNMENT, o)
  else
    # Then the left expression must be assignable-via-index
    assign(o.left_expr, true)
  end
end

#assign_Object(o, via_index) ⇒ Object 



108
109
110
111
112
113
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 108

def assign_Object(o, via_index)
  # Can not assign to anything else (differentiate if this is via index or not)
  # i.e. 10 = 'hello' vs. 10['x'] = 'hello' (the root is reported as being in error in both cases)
  #
  acceptor.accept(via_index ? Issues::ILLEGAL_ASSIGNMENT_VIA_INDEX : Issues::ILLEGAL_ASSIGNMENT, o)
end

#assign_VariableExpression(o, via_index) ⇒ Object

—ASSIGNMENT CHECKS



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

def assign_VariableExpression(o, via_index)
  varname_string = varname_to_s(o.expr)
  if varname_string =~ /^[0-9]+$/
    acceptor.accept(Issues::ILLEGAL_NUMERIC_ASSIGNMENT, o, :varname => varname_string)
  end
  # Can not assign to something in another namespace (i.e. a '::' in the name is not legal)
  if acceptor.will_accept? Issues::CROSS_SCOPE_ASSIGNMENT
    if varname_string =~ /::/
      acceptor.accept(Issues::CROSS_SCOPE_ASSIGNMENT, o, :name => varname_string)
    end
  end
  # TODO: Could scan for reassignment of the same variable if done earlier in the same container
  #       Or if assigning to a parameter (more work).
  # TODO: Investigate if there are invalid cases for += assignment
end

#check(o) ⇒ Object

Performs regular validity check



43
44
45
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 43

def check(o)
  @@check_visitor.visit_this_0(self, o)
end

#check_AccessExpression(o) ⇒ Object 



124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 124

def check_AccessExpression(o)
  # Check multiplicity of keys
  case o.left_expr
  when Model::QualifiedName
    # allows many keys, but the name should really be a QualifiedReference
    acceptor.accept(Issues::DEPRECATED_NAME_AS_TYPE, o, :name => o.left_expr.value)
  when Model::QualifiedReference
    # ok, allows many - this is a resource reference

  else
    # i.e. for any other expression that may produce an array or hash
    if o.keys.size > 1
      acceptor.accept(Issues::UNSUPPORTED_RANGE, o, :count => o.keys.size)
    end
    if o.keys.size < 1
      acceptor.accept(Issues::MISSING_INDEX, o)
    end
  end
end

#check_AssignmentExpression(o) ⇒ Object 



144
145
146
147
148
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 144

def check_AssignmentExpression(o)
  acceptor.accept(Issues::UNSUPPORTED_OPERATOR, o, {:operator => o.operator}) unless [:'=', :'+='].include? o.operator
  assign(o.left_expr)
  rvalue(o.right_expr)
end

#check_AttributeOperation(o) ⇒ Object

Checks that operation with :+> is contained in a ResourceOverride or Collector.

Parent of an AttributeOperation can be one of:

  • CollectExpression

  • ResourceOverride

  • ResourceBody (ILLEGAL this is a regular resource expression)

  • ResourceDefaults (ILLEGAL)



158
159
160
161
162
163
164
165
166
167
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 158

def check_AttributeOperation(o)
  if o.operator == :'+>'
    # Append operator use is constrained
    parent = o.eContainer
    unless parent.is_a?(Model::CollectExpression) || parent.is_a?(Model::ResourceOverrideExpression)
      acceptor.accept(Issues::ILLEGAL_ATTRIBUTE_APPEND, o, {:name=>o.attribute_name, :parent=>parent})
    end
  end
  rvalue(o.value_expr)
end

#check_BinaryExpression(o) ⇒ Object 



169
170
171
172
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 169

def check_BinaryExpression(o)
  rvalue(o.left_expr)
  rvalue(o.right_expr)
end

#check_CallNamedFunctionExpression(o) ⇒ Object 



174
175
176
177
178
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 174

def check_CallNamedFunctionExpression(o)
  unless o.functor_expr.is_a? Model::QualifiedName
    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.functor_expr, :feature => 'function name', :container => o)
  end
end

#check_CaseExpression(o) ⇒ Object 



186
187
188
189
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 186

def check_CaseExpression(o)
  # There should only be one LiteralDefault case option value
  # TODO: Implement this check
end

#check_CollectExpression(o) ⇒ Object 



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

def check_CollectExpression(o)
  unless o.type_expr.is_a? Model::QualifiedReference
    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.type_expr, :feature=> 'type name', :container => o)
  end

  # If a collect expression tries to collect exported resources and storeconfigs is not on
  # then it will not work... This was checked in the parser previously. This is a runtime checking
  # thing as opposed to a language thing.
  if acceptor.will_accept?(Issues::RT_NO_STORECONFIGS) && o.query.is_a?(Model::ExportedQuery)
    acceptor.accept(Issues::RT_NO_STORECONFIGS, o)
  end
end

#check_Factory(o) ⇒ Object 



120
121
122
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 120

def check_Factory(o)
  check(o.current)
end

#check_ImportExpression(o) ⇒ Object 



221
222
223
224
225
226
227
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 221

def check_ImportExpression(o)
  o.files.each do |f|
    unless f.is_a? Model::LiteralString
      acceptor.accept(Issues::ILLEGAL_EXPRESSION, f, :feature => 'file name', :container => o)
    end
  end
end

#check_InstanceReference(o) ⇒ Object 



229
230
231
232
233
234
235
236
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 229

def check_InstanceReference(o)
  # TODO: Original warning is :
  #       Puppet.warning addcontext("Deprecation notice:  Resource references should now be capitalized")
  #       This model element is not used in the egrammar.
  #       Either implement checks or deprecate the use of InstanceReference (the same is acheived by
  #       transformation of AccessExpression when used where an Instance/Resource reference is allowed.
  #
end

#check_LambdaExpression(o) ⇒ Object

A Lambda is a Definition, but it may appear in other scopes that top scope (Which check_Definition asserts).



254
255
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 254

def check_LambdaExpression(o)
end

#check_MethodCallExpression(o) ⇒ Object 



180
181
182
183
184
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 180

def check_MethodCallExpression(o)
  unless o.functor_expr.is_a? Model::QualifiedName
    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.functor_expr, :feature => 'function name', :container => o)
  end
end

#check_NamedAccessExpression(o) ⇒ Object

Only used for function names, grammar should not be able to produce something faulty, but check anyway if model is created programatically (it will fail in transformation to AST for sure).



206
207
208
209
210
211
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 206

def check_NamedAccessExpression(o)
  name = o.right_expr
  unless name.is_a? Model::QualifiedName
    acceptor.accept(Issues::ILLEGAL_EXPRESSION, name, :feature=> 'function name', :container => o.eContainer)
  end
end

#check_NamedDefinition(o) ⇒ Object

for ‘class’ and ‘define’



214
215
216
217
218
219
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 214

def check_NamedDefinition(o)
  top(o.eContainer, o)
  if (acceptor.will_accept? Issues::NAME_WITH_HYPHEN) && o.name.include?('-')
    acceptor.accept(Issues::NAME_WITH_HYPHEN, o, {:name => o.name})
  end
end

#check_NodeDefinition(o) ⇒ Object 



257
258
259
260
261
262
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 257

def check_NodeDefinition(o)
  # Check that hostnames are valid hostnames (or regular expressons)
  hostname(o.host_matches, o)
  hostname(o.parent, o, 'parent') unless o.parent.nil?
  top(o.eContainer, o)
end

#check_Object(o) ⇒ Object

—CHECKS



117
118
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 117

def check_Object(o)
end

#check_Parameter(o) ⇒ Object 



309
310
311
312
313
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 309

def check_Parameter(o)
  if o.name =~ /^[0-9]+$/
    acceptor.accept(Issues::ILLEGAL_NUMERIC_PARAMETER, o, :name => o.name)
  end
end

#check_QualifiedName(o) ⇒ Object

No checking takes place - all expressions using a QualifiedName need to check. This because the rules are slightly different depending on the container (A variable allows a numeric start, but not other names). This means that (if the lexer/parser so chooses) a QualifiedName can be anything when it represents a Bare Word and evaluates to a String.



269
270
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 269

def check_QualifiedName(o)
end

#check_QualifiedReference(o) ⇒ Object

Checks that the value is a valid UpperCaseWord (a CLASSREF), and optionally if it contains a hypen. DOH: QualifiedReferences are created with LOWER CASE NAMES at parse time



274
275
276
277
278
279
280
281
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 274

def check_QualifiedReference(o)
  # Is this a valid qualified name?
  if o.value !~ Puppet::Pops::Patterns::CLASSREF
    acceptor.accept(Issues::ILLEGAL_CLASSREF, o, {:name=>o.value})
  elsif (acceptor.will_accept? Issues::NAME_WITH_HYPHEN) && o.value.include?('-')
    acceptor.accept(Issues::NAME_WITH_HYPHEN, o, {:name => o.value})
  end
end

#check_QueryExpression(o) ⇒ Object 



283
284
285
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 283

def check_QueryExpression(o)
  query(o.expr) if o.expr  # is optional
end

#check_RelationshipExpression(o) ⇒ Object

relationship_side: resource

| resourceref
| collection
| variable
| quotedtext
| selector
| casestatement
| hasharrayaccesses



324
325
326
327
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 324

def check_RelationshipExpression(o)
  relation(o.left_expr, o)
  relation(o.right_expr, o)
end

#check_ResourceDefaultsExpression(o) ⇒ Object 



342
343
344
345
346
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 342

def check_ResourceDefaultsExpression(o)
  if o.form && o.form != :regular
    acceptor.accept(Issues::NOT_VIRTUALIZEABLE, o)
  end
end

#check_ResourceExpression(o) ⇒ Object 



329
330
331
332
333
334
335
336
337
338
339
340
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 329

def check_ResourceExpression(o)
  # A resource expression must have a lower case NAME as its type e.g. 'file { ... }'
  unless o.type_name.is_a? Model::QualifiedName
    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.type_name, :feature => 'resource type', :container => o)
  end

  # This is a runtime check - the model is valid, but will have runtime issues when evaluated
  # and storeconfigs is not set.
  if acceptor.will_accept?(Issues::RT_NO_STORECONFIGS) && o.exported
    acceptor.accept(Issues::RT_NO_STORECONFIGS_EXPORT, o)
  end
end

#check_UnaryExpression(o) ⇒ Object 



361
362
363
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 361

def check_UnaryExpression(o)
  rvalue(o.expr)
end

#check_UnlessExpression(o) ⇒ Object 



365
366
367
368
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 365

def check_UnlessExpression(o)
  # TODO: Unless may not have an elsif
  # TODO: 3.x unless may not have an else
end

#check_VariableExpression(o) ⇒ Object 



370
371
372
373
374
375
376
377
378
379
380
381
382
383
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 370

def check_VariableExpression(o)
  # The expression must be a qualified name
  if !o.expr.is_a? Model::QualifiedName
    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, :feature => 'name', :container => o)
  else
    # Note, that if it later becomes illegal with hyphen in any name, this special check
    # can be skipped in favor of the check in QualifiedName, which is now not done if contained in
    # a VariableExpression
    name = o.expr.value
    if (acceptor.will_accept? Issues::VAR_WITH_HYPHEN) && name.include?('-')
      acceptor.accept(Issues::VAR_WITH_HYPHEN, o, {:name => name})
    end
  end
end

#hostname(o, semantic, single_feature_name = nil) ⇒ Object

Performs check if this is a vaid hostname expression

Parameters:

  • single_feature_name (String, nil) (defaults to: nil) —

    the name of a single valued hostname feature of the value’s container. e.g. ‘parent’



49
50
51
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 49

def hostname(o, semantic, single_feature_name = nil)
  @@hostname_visitor.visit_this_2(self, o, semantic, single_feature_name)
end

#hostname_Array(o, semantic, single_feature_name) ⇒ Object

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



388
389
390
391
392
393
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 388

def hostname_Array(o, semantic, single_feature_name)
  if single_feature_name
    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature=>single_feature_name, :container=>semantic})
  end
  o.each {|x| hostname(x, semantic, false) }
end

#hostname_ConcatenatedString(o, semantic, single_feature_name) ⇒ Object 



409
410
411
412
413
414
415
416
417
418
419
420
421
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 409

def hostname_ConcatenatedString(o, semantic, single_feature_name)
  # Puppet 3.1. only accepts a concatenated string without interpolated expressions
  if the_expr = o.segments.index {|s| s.is_a?(Model::TextExpression) }
    acceptor.accept(Issues::ILLEGAL_HOSTNAME_INTERPOLATION, o.segments[the_expr].expr)
  elsif o.segments.size() != 1
    # corner case, bad model, concatenation of several plain strings
    acceptor.accept(Issues::ILLEGAL_HOSTNAME_INTERPOLATION, o)
  else
    # corner case, may be ok, but lexer may have replaced with plain string, this is
    # here if it does not
    hostname_String(o.segments[0], o.segments[0], false)
  end
end

#hostname_LiteralDefault(o, semantic, single_feature_name) ⇒ Object 



435
436
437
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 435

def hostname_LiteralDefault(o, semantic, single_feature_name)
  # always ok
end

#hostname_LiteralNumber(o, semantic, single_feature_name) ⇒ Object 



431
432
433
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 431

def hostname_LiteralNumber(o, semantic, single_feature_name)
  # always ok
end

#hostname_LiteralRegularExpression(o, semantic, single_feature_name) ⇒ Object 



439
440
441
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 439

def hostname_LiteralRegularExpression(o, semantic, single_feature_name)
  # always ok
end

#hostname_LiteralValue(o, semantic, single_feature_name) ⇒ Object 



405
406
407
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 405

def hostname_LiteralValue(o, semantic, single_feature_name)
  hostname_String(o.value.to_s, o, single_feature_name)
end

#hostname_Object(o, semantic, single_feature_name) ⇒ Object 



443
444
445
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 443

def hostname_Object(o, semantic, single_feature_name)
  acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature=> single_feature_name || 'hostname', :container=>semantic})
end

#hostname_QualifiedName(o, semantic, single_feature_name) ⇒ Object 



423
424
425
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 423

def hostname_QualifiedName(o, semantic, single_feature_name)
  hostname_String(o.value.to_s, o, single_feature_name)
end

#hostname_QualifiedReference(o, semantic, single_feature_name) ⇒ Object 



427
428
429
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 427

def hostname_QualifiedReference(o, semantic, single_feature_name)
  hostname_String(o.value.to_s, o, single_feature_name)
end

#hostname_String(o, semantic, single_feature_name) ⇒ Object 



395
396
397
398
399
400
401
402
403
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 395

def hostname_String(o, semantic, single_feature_name)
  # The 3.x checker only checks for illegal characters - if matching /[^-\w.]/ the name is invalid,
  # but this allows pathological names like "a..b......c", "----"
  # TODO: Investigate if more illegal hostnames should be flagged.
  #
  if o =~ Puppet::Pops::Patterns::ILLEGAL_HOSTNAME_CHARS
    acceptor.accept(Issues::ILLEGAL_HOSTNAME_CHARS, semantic, :hostname => o)
  end
end

#query(o) ⇒ Object

Performs check if this is valid as a query



54
55
56
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 54

def query(o)
  @@query_visitor.visit_this_0(self, o)
end

#query_BooleanExpression(o) ⇒ Object

Allows AND, OR, and checks if left/right are allowed in query.



461
462
463
464
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 461

def query_BooleanExpression(o)
  query o.left_expr
  query o.right_expr
end

#query_ComparisonExpression(o) ⇒ Object

Puppet AST only allows == and !=



456
457
458
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 456

def query_ComparisonExpression(o)
  acceptor.accept(Issues::ILLEGAL_QUERY_EXPRESSION, o) unless [:'==', :'!='].include? o.operator
end

#query_LiteralBoolean(o) ⇒ Object 



478
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 478

def query_LiteralBoolean(o); end

#query_LiteralNumber(o) ⇒ Object 



474
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 474

def query_LiteralNumber(o); end

#query_LiteralString(o) ⇒ Object 



476
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 476

def query_LiteralString(o); end

#query_Object(o) ⇒ Object

Anything not explicitly allowed is flagged as error.



450
451
452
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 450

def query_Object(o)
  acceptor.accept(Issues::ILLEGAL_QUERY_EXPRESSION, o)
end

#query_ParenthesizedExpression(o) ⇒ Object 



466
467
468
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 466

def query_ParenthesizedExpression(o)
  query(o.expr)
end

#query_QualifiedName(o) ⇒ Object 



472
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 472

def query_QualifiedName(o); end

#query_VariableExpression(o) ⇒ Object 



470
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 470

def query_VariableExpression(o); end

#relation(o, container) ⇒ Object

Performs check if this is valid as a relationship side



59
60
61
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 59

def relation(o, container)
  @@relation_visitor.visit_this_1(self, o, container)
end

#relation_AccessExpression(o, rel_expr) ⇒ Object 



291
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 291

def relation_AccessExpression(o, rel_expr); end

#relation_CaseExpression(o, rel_expr) ⇒ Object 



303
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 303

def relation_CaseExpression(o, rel_expr); end

#relation_CollectExpression(o, rel_expr) ⇒ Object 



293
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 293

def relation_CollectExpression(o, rel_expr); end

#relation_ConcatenatedStringExpression(o, rel_expr) ⇒ Object 



299
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 299

def relation_ConcatenatedStringExpression(o, rel_expr); end

#relation_LiteralString(o, rel_expr) ⇒ Object 



297
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 297

def relation_LiteralString(o, rel_expr); end

#relation_Object(o, rel_expr) ⇒ Object 



287
288
289
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 287

def relation_Object(o, rel_expr)
  acceptor.accept(Issues::ILLEGAL_EXPRESSION, o, {:feature => o.eContainingFeature, :container => rel_expr})
end

#relation_RelationshipExpression(o, rel_expr) ⇒ Object 



307
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 307

def relation_RelationshipExpression(o, rel_expr); end

#relation_ResourceExpression(o, rel_expr) ⇒ Object 



305
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 305

def relation_ResourceExpression(o, rel_expr); end

#relation_SelectorExpression(o, rel_expr) ⇒ Object 



301
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 301

def relation_SelectorExpression(o, rel_expr); end

#relation_VariableExpression(o, rel_expr) ⇒ Object 



295
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 295

def relation_VariableExpression(o, rel_expr); end

#rvalue(o) ⇒ Object

Performs check if this is valid as a rvalue



64
65
66
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 64

def rvalue(o)
  @@rvalue_visitor.visit_this_0(self, o)
end

#rvalue_BlockExpression(o) ⇒ Object 



489
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 489

def rvalue_BlockExpression(o)           ; acceptor.accept(Issues::NOT_RVALUE, o) ; end

#rvalue_CaseExpression(o) ⇒ Object 



491
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 491

def rvalue_CaseExpression(o)            ; acceptor.accept(Issues::NOT_RVALUE, o) ; end

#rvalue_CollectExpression(o) ⇒ Object 



503
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 503

def rvalue_CollectExpression(o)         ; acceptor.accept(Issues::NOT_RVALUE, o) ; end

#rvalue_Definition(o) ⇒ Object 



505
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 505

def rvalue_Definition(o)                ; acceptor.accept(Issues::NOT_RVALUE, o) ; end

#rvalue_Expression(o) ⇒ Object

By default, all expressions are reported as being rvalues Implement specific rvalue checks for those that are not.



485
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 485

def rvalue_Expression(o); end

#rvalue_IfExpression(o) ⇒ Object 



493
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 493

def rvalue_IfExpression(o)              ; acceptor.accept(Issues::NOT_RVALUE, o) ; end

#rvalue_ImportExpression(o) ⇒ Object 



487
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 487

def rvalue_ImportExpression(o)          ; acceptor.accept(Issues::NOT_RVALUE, o) ; end

#rvalue_NodeDefinition(o) ⇒ Object 



507
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 507

def rvalue_NodeDefinition(o)            ; acceptor.accept(Issues::NOT_RVALUE, o) ; end

#rvalue_ResourceDefaultsExpression(o) ⇒ Object 



499
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 499

def rvalue_ResourceDefaultsExpression(o); acceptor.accept(Issues::NOT_RVALUE, o) ; end

#rvalue_ResourceExpression(o) ⇒ Object 



497
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 497

def rvalue_ResourceExpression(o)        ; acceptor.accept(Issues::NOT_RVALUE, o) ; end

#rvalue_ResourceOverrideExpression(o) ⇒ Object 



501
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 501

def rvalue_ResourceOverrideExpression(o); acceptor.accept(Issues::NOT_RVALUE, o) ; end

#rvalue_UnaryExpression(o) ⇒ Object 



509
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 509

def rvalue_UnaryExpression(o)           ; rvalue o.expr                 ; end

#rvalue_UnlessExpression(o) ⇒ Object 



495
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 495

def rvalue_UnlessExpression(o)          ; acceptor.accept(Issues::NOT_RVALUE, o) ; end

#select_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.



350
351
352
353
354
355
356
357
358
359
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 350

def select_SelectorExpression(o)
  case o.left_expr
  when Model::CallNamedFunctionExpression
  when Model::AccessExpression
  when Model::VariableExpression
  when Model::ConcatenatedString
  else
    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.left_expr, :feature => 'left operand', :container => o)
  end
end

#top(o, definition) ⇒ Object

Performs check if this is valid as a container of a definition (class, define, node)



69
70
71
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 69

def top(o, definition)
  @@top_visitor.visit_this_1(self, o, definition)
end

#top_BlockExpression(o, definition) ⇒ Object 



522
523
524
525
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 522

def top_BlockExpression(o, definition)
  # ok, if this is a block representing the body of a class, or is top level
  top o.eContainer, definition
end

#top_HostClassDefinition(o, definition) ⇒ Object 



527
528
529
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 527

def top_HostClassDefinition(o, definition)
  # ok, stop scanning parents
end

#top_LambdaExpression(o, definition) ⇒ Object

A LambdaExpression is a BlockExpression, and this method is needed to prevent the polymorph method for BlockExpression to accept a lambda. A lambda can not iteratively create classes, nodes or defines as the lambda does not have a closure.



539
540
541
542
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 539

def top_LambdaExpression(o, definition)
  # fail, stop scanning parents
  acceptor.accept(Issues::NOT_TOP_LEVEL, definition)
end

#top_NilClass(o, definition) ⇒ Object

—TOP CHECK



513
514
515
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 513

def top_NilClass(o, definition)
  # ok, reached the top, no more parents
end

#top_Object(o, definition) ⇒ Object 



517
518
519
520
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 517

def top_Object(o, definition)
  # fail, reached a container that is not top level
  acceptor.accept(Issues::NOT_TOP_LEVEL, definition)
end

#top_Program(o, definition) ⇒ Object 



531
532
533
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 531

def top_Program(o, definition)
  # ok
end

#transform_KeyedEntry(o) ⇒ Object

Restrictions on hash key are because of the strange key comparisons/and merge rules in the AST evaluation (Even the allowed ones are handled in a strange way).



241
242
243
244
245
246
247
248
249
250
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 241

def transform_KeyedEntry(o)
  case o.key
  when Model::QualifiedName
  when Model::LiteralString
  when Model::LiteralNumber
  when Model::ConcatenatedString
  else
    acceptor.accept(Issues::ILLEGAL_EXPRESSION, o.key, :feature => 'hash key', :container => o.eContainer)
  end
end

#validate(model) ⇒ Object

Validates the entire model by visiting each model element and calling check. The result is collected (or acted on immediately) by the configured diagnostic provider/acceptor given when creating this Checker.



36
37
38
39
40
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 36

def validate(model)
  # tree iterate the model, and call check for each element
  check(model)
  model.eAllContents.each {|m| check(m) }
end

#varname_to_s(o) ⇒ Object

Produces string part of something named, or nil if not a QualifiedName or QualifiedReference



548
549
550
551
552
553
554
555
556
557
 
# File 'lib/puppet/pops/validation/checker3_1.rb', line 548

def varname_to_s(o)
  case o
  when Model::QualifiedName
    o.value
  when Model::QualifiedReference
    o.value
  else
    nil
  end
end