Module: Puppet::Pops::Evaluator::Runtime3Support Private

Included in:
AccessOperator, CompareOperator, EvaluatorImpl, RelationshipOperator
Defined in:
lib/puppet/pops/evaluator/runtime3_support.rb

Overview

This module is part of a private API. You should avoid using this module if possible, as it may be removed or be changed in the future.

A module with bindings between the new evaluator and the 3x runtime. The intention is to separate all calls into scope, compiler, resource, etc. in this module to make it easier to later refactor the evaluator for better implementations of the 3x classes.

Defined Under Namespace

Classes: EvaluationError, ExceptionRaisingAcceptor, SeverityProducer

Constant Summary collapse

NAME_SPACE_SEPARATOR =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

'::'.freeze
CLASS_STRING =

This constant is part of a private API. You should avoid using this constant if possible, as it may be removed or be changed in the future. 

'class'.freeze

Instance Method Summary collapse

Instance Method Details

#add_relationship(source, target, relationship_type, scope) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Adds a relationship between the given ‘source` and `target` of the given `relationship_type`

Parameters:

  • source (Puppet:Pops::Types::PCatalogEntryType) —

    the source end of the relationship (from)

  • target (Puppet:Pops::Types::PCatalogEntryType) —

    the target end of the relationship (to)

  • relationship_type (:relationship, :subscription) —

    the type of the relationship



148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 148

def add_relationship(source, target, relationship_type, scope)
  # The 3x way is to record a Puppet::Parser::Relationship that is evaluated at the end of the compilation.
  # This means it is not possible to detect any duplicates at this point (and signal where an attempt is made to
  # add a duplicate. There is also no location information to signal the original place in the logic. The user will have
  # to go fish.
  # The 3.x implementation is based on Strings :-o, so the source and target must be transformed. The resolution is
  # done by Catalog#resource(type, title). To do that, it creates a Puppet::Resource since it is responsible for
  # translating the name/type/title and create index-keys used by the catalog. The Puppet::Resource has bizarre parsing of
  # the type and title (scan for [] that is interpreted as type/title (but it gets it wrong).
  # Moreover if the type is "" or "component", the type is Class, and if the type is :main, it is :main, all other cases
  # undergo capitalization of name-segments (foo::bar becomes Foo::Bar). (This was earlier done in the reverse by the parser).
  # Further, the title undergoes the same munging !!!
  #
  # That bug infested nest of messy logic needs serious Exorcism!
  #
  # Unfortunately it is not easy to simply call more intelligent methods at a lower level as the compiler evaluates the recorded
  # Relationship object at a much later point, and it is responsible for invoking all the messy logic.
  #
  # TODO: Revisit the below logic when there is a sane implementation of the catalog, compiler and resource. For now
  # concentrate on transforming the type references to what is expected by the wacky logic.
  #
  # HOWEVER, the Compiler only records the Relationships, and the only method it calls is @relationships.each{|x| x.evaluate(catalog) }
  # Which means a smarter Relationship class could do this right. Instead of obtaining the resource from the catalog using
  # the borked resource(type, title) which creates a resource for the purpose of looking it up, it needs to instead
  # scan the catalog's resources
  #
  # GAAAH, it is even worse!
  # It starts in the parser, which parses "File['foo']" into an AST::ResourceReference with type = File, and title = foo
  # This AST is evaluated by looking up the type/title in the scope - causing it to be loaded if it exists, and if not, the given
  # type name/title is used. It does not search for resource instances, only classes and types. It returns symbolic information
  # [type, [title, title]]. From this, instances of Puppet::Resource are created and returned. These only have type/title information
  # filled out. One or an array of resources are returned.
  # This set of evaluated (empty reference) Resource instances are then passed to the relationship operator. It creates a
  # Puppet::Parser::Relationship giving it a source and a target that are (empty reference) Resource instances. These are then remembered
  # until the relationship is evaluated by the compiler (at the end). When evaluation takes place, the (empty reference) Resource instances
  # are converted to String (!?! WTF) on the simple format "#{type}[#{title}]", and the catalog is told to find a resource, by giving
  # it this string. If it cannot find the resource it fails, else the before/notify parameter is appended with the target.
  # The search for the resource begin with (you guessed it) again creating an (empty reference) resource from type and title (WTF?!?!).
  # The catalog now uses the reference resource to compute a key [r.type, r.title.to_s] and also gets a uniqueness key from the
  # resource (This is only a reference type created from title and type). If it cannot find it with the first key, it uses the
  # uniqueness key to lookup.
  #
  # This is probably done to allow a resource type to munge/translate the title in some way (but it is quite unclear from the long
  # and convoluted path of evaluation.
  # In order to do this in a way that is similar to 3.x two resources are created to be used as keys.
  #
  # And if that is not enough, a source/target may be a Collector (a baked query that will be evaluated by the
  # compiler - it is simply passed through here for processing by the compiler at the right time).
  #
  if source.is_a?(Puppet::Parser::Collector) || source.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
    # use verbatim - behavior defined by 3x
    source_resource = source
  else
    # transform into the wonderful String representation in 3x
    type, title = catalog_type_to_split_type_title(source)
    source_resource = Puppet::Resource.new(type, title)
  end
  if target.is_a?(Puppet::Parser::Collector) || target.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
    # use verbatim - behavior defined by 3x
    target_resource = target
  else
    # transform into the wonderful String representation in 3x
    type, title = catalog_type_to_split_type_title(target)
    target_resource = Puppet::Resource.new(type, title)
  end
  # Add the relationship to the compiler for later evaluation.
  scope.compiler.add_relationship(Puppet::Parser::Relationship.new(source_resource, target_resource, relationship_type))
end

#call_function(name, args, o, scope) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 232

def call_function(name, args, o, scope)
  # Call via 4x API if the function exists there
  loaders = scope.compiler.loaders
  # find the loader that loaded the code, or use the private_environment_loader (sees env + all modules)
  adapter = Puppet::Pops::Utils.find_adapter(o, Puppet::Pops::Adapters::LoaderAdapter)
  loader = adapter.nil? ? loaders.private_environment_loader : adapter.loader
  if loader && func = loader.load(:function, name)
    return func.call(scope, *args)
  end

  # Call via 3x API if function exists there
  fail(Puppet::Pops::Issues::UNKNOWN_FUNCTION, o, {:name => name}) unless Puppet::Parser::Functions.function(name)

  # Arguments must be mapped since functions are unaware of the new and magical creatures in 4x.
  # NOTE: Passing an empty string last converts nil/:undef to empty string
  mapped_args = args.map {|a| convert(a, scope, '') }
  result = scope.send("function_#{name}", mapped_args)
  # Prevent non r-value functions from leaking their result (they are not written to care about this)
  Puppet::Parser::Functions.rvalue?(name) ? result : nil
end

#capitalize_qualified_name(name) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Capitalizes each segment of a qualified name



320
321
322
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 320

def capitalize_qualified_name(name)
  name.split(/::/).map(&:capitalize).join(NAME_SPACE_SEPARATOR)
end

#coerce_numeric(v, o, scope) ⇒ Numeric

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Coerce value ‘v` to numeric or fails. The given value `v` is coerced to Numeric, and if that fails the operation calls #fail.

Parameters:

  • v (Object) —

    the value to convert

  • o (Object) —

    originating instruction

  • scope (Object) —

    the (runtime specific) scope where evaluation of o takes place

Returns:

  • (Numeric) —

    value ‘v` converted to Numeric.



225
226
227
228
229
230
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 225

def coerce_numeric(v, o, scope)
  unless n = Puppet::Pops::Utils.to_n(v)
    fail(Puppet::Pops::Issues::NOT_NUMERIC, o, {:value => v})
  end
  n
end

#convert(o, scope, undef_value) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Converts 4x supported values to 3x values. This is required because resources and other objects do not know about the new type system, and does not support regular expressions. Unfortunately this has to be done for array and hash as well. A complication is that catalog types needs to be resolved against the scope.



436
437
438
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 436

def convert(o, scope, undef_value)
  @@convert_visitor.visit_this_2(self, o, scope, undef_value)
end

#convert2(o, scope, undef_value) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Converts nested 4x supported values to 3x values. This is required because resources and other objects do not know about the new type system, and does not support regular expressions. Unfortunately this has to be done for array and hash as well. A complication is that catalog types needs to be resolved against the scope.



445
446
447
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 445

def convert2(o, scope, undef_value)
  @@convert2_visitor.visit_this_2(self, o, scope, undef_value)
end

#convert2_NilClass(o, scope, undef_value) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



454
455
456
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 454

def convert2_NilClass(o, scope, undef_value)
  :undef
end

#convert2_Symbol(o, scope, undef_value) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

The :undef symbol should not be converted when nested in arrays or hashes



499
500
501
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 499

def convert2_Symbol(o, scope, undef_value)
  o
end

#convert_Array(o, scope, undef_value) ⇒ Object Also known as: convert2_Array

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



469
470
471
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 469

def convert_Array(o, scope, undef_value)
  o.map {|x| convert2(x, scope, undef_value) }
end

#convert_Hash(o, scope, undef_value) ⇒ Object Also known as: convert2_Hash

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



474
475
476
477
478
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 474

def convert_Hash(o, scope, undef_value)
  result = {}
  o.each {|k,v| result[convert2(k, scope, undef_value)] = convert2(v, scope, undef_value) }
  result
end

#convert_NilClass(o, scope, undef_value) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



450
451
452
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 450

def convert_NilClass(o, scope, undef_value)
  undef_value
end

#convert_Object(o, scope, undef_value) ⇒ Object Also known as: convert2_Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



464
465
466
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 464

def convert_Object(o, scope, undef_value)
  o
end

#convert_PAnyType(o, scope, undef_value) ⇒ Object Also known as: convert2_PAnyType

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



503
504
505
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 503

def convert_PAnyType(o, scope, undef_value)
  o
end

#convert_PCatalogEntryType(o, scope, undef_value) ⇒ Object Also known as: convert2_PCatalogEntryType

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



508
509
510
511
512
513
514
515
516
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 508

def convert_PCatalogEntryType(o, scope, undef_value)
  # Since 4x does not support dynamic scoping, all names are absolute and can be
  # used as is (with some check/transformation/mangling between absolute/relative form
  # due to Puppet::Resource's idiosyncratic behavior where some references must be
  # absolute and others cannot be.
  # Thus there is no need to call scope.resolve_type_and_titles to do dynamic lookup.

  Puppet::Resource.new(*catalog_type_to_split_type_title(o))
end

#convert_Regexp(o, scope, undef_value) ⇒ Object Also known as: convert2_Regexp

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



481
482
483
484
485
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 481

def convert_Regexp(o, scope, undef_value)
  # Puppet 3x cannot handle parameter values that are reqular expressions. Turn into regexp string in
  # source form
  o.inspect
end

#convert_String(o, scope, undef_value) ⇒ Object Also known as: convert2_String

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



458
459
460
461
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 458

def convert_String(o, scope, undef_value)
  # although wasteful, needed because user code may mutate these strings in Resources
  o.frozen? ? o.dup : o
end

#convert_Symbol(o, scope, undef_value) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



488
489
490
491
492
493
494
495
496
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 488

def convert_Symbol(o, scope, undef_value)
  case o
  # Support :undef since it may come from a 3x structure
  when :undef
    undef_value  # 3x wants undef as either empty string or :undef
  else
    o   # :default, and all others are verbatim since they are new in future evaluator
  end
end

#create_local_scope_from(hash, scope) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Creates a local scope with vairalbes set from a hash of variable name to value

Raises:

  • (ArgumentError) 


117
118
119
120
121
122
123
124
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 117

def create_local_scope_from(hash, scope)
  # two dummy values are needed since the scope tries to give an error message (can not happen in this
  # case - it is just wrong, the error should be reported by the caller who knows in more detail where it
  # is in the source.
  #
  raise ArgumentError, "Internal error - attempt to create a local scope without a hash" unless hash.is_a?(Hash)
  scope.ephemeral_from(hash)
end

#create_match_scope_from(scope) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Creates a nested match scope



127
128
129
130
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 127

def create_match_scope_from(scope)
  # Create a transparent match scope (for future matches)
  scope.new_match_scope(nil)
end

#create_resource_defaults(o, scope, type_name, evaluated_parameters) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Defines default parameters for a type with the given name.



309
310
311
312
313
314
315
316
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 309

def create_resource_defaults(o, scope, type_name, evaluated_parameters)
  # Note that name must be capitalized in this 3x call
  # The 3x impl creates a Resource instance with a bogus title and then asks the created resource
  # for the type of the name.
  # Note, locations are available per parameter.
  #
  scope.define_settings(capitalize_qualified_name(type_name), evaluated_parameters)
end

#create_resource_overrides(o, scope, evaluated_resources, evaluated_parameters) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Creates resource overrides for all resource type objects in evaluated_resources. The same set of evaluated parameters are applied to all.



327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 327

def create_resource_overrides(o, scope, evaluated_resources, evaluated_parameters)
  # Not 100% accurate as this is the resource expression location and each title is processed separately
  # The titles are however the result of evaluation and they have no location at this point (an array
  # of positions for the source expressions are required for this to work.
  # TODO: Revisit and possible improve the accuracy.
  #
  file, line = extract_file_line(o)

  evaluated_resources.each do |r|
    unless r.is_a?(Puppet::Pops::Types::PResourceType) && r.type_name != 'class'
      fail(Puppet::Pops::Issues::ILLEGAL_OVERRIDEN_TYPE, o, {:actual => r} )
    end
    resource = Puppet::Parser::Resource.new(
    r.type_name, r.title,
      :parameters => evaluated_parameters,
      :file => file,
      :line => line,
      # WTF is this? Which source is this? The file? The name of the context ?
      :source => scope.source,
      :scope => scope
    )

    scope.compiler.add_override(resource)
  end
end

#create_resource_parameter(o, scope, name, value, operator) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

The o is used for source reference



254
255
256
257
258
259
260
261
262
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 254

def create_resource_parameter(o, scope, name, value, operator)
  file, line = extract_file_line(o)
  Puppet::Parser::Resource::Param.new(
    :name   => name,
    :value  => convert(value, scope, nil), # converted to 3x since 4x supports additional objects / types
    :source => scope.source, :line => line, :file => file,
    :add    => operator == :'+>'
  )
end

#create_resources(o, scope, virtual, exported, type_name, resource_titles, evaluated_parameters) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 266

def create_resources(o, scope, virtual, exported, type_name, resource_titles, evaluated_parameters)

  # TODO: Unknown resource causes creation of Resource to fail with ArgumentError, should give
  # a proper Issue. Now the result is "Error while evaluating a Resource Statement" with the message
  # from the raised exception. (It may be good enough).

  # resolve in scope.
  fully_qualified_type, resource_titles = scope.resolve_type_and_titles(type_name, resource_titles)

  # Not 100% accurate as this is the resource expression location and each title is processed separately
  # The titles are however the result of evaluation and they have no location at this point (an array
  # of positions for the source expressions are required for this to work).
  # TODO: Revisit and possible improve the accuracy.
  #
  file, line = extract_file_line(o)
  # Build a resource for each title
  resource_titles.map do |resource_title|
      resource = Puppet::Parser::Resource.new(
        fully_qualified_type, resource_title,
        :parameters => evaluated_parameters,
        :file => file,
        :line => line,
        :exported => exported,
        :virtual => virtual,
        # WTF is this? Which source is this? The file? The name of the context ?
        :source => scope.source,
        :scope => scope,
        :strict => true
      )

      if resource.resource_type.is_a? Puppet::Resource::Type
        resource.resource_type.instantiate_resource(scope, resource)
      end
      scope.compiler.add_resource(scope, resource)
      scope.compiler.evaluate_classes([resource_title], scope, false, true) if fully_qualified_type == CLASS_STRING
      # Turn the resource into a PType (a reference to a resource type)
      # weed out nil's
      resource_to_ptype(resource)
  end
end

#fail(issue, semantic, options = {}, except = nil) ⇒ !

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Fails the evaluation of semantic with a given issue.

Parameters:

  • issue (Puppet::Pops::Issue) —

    the issue to report

  • semantic (Puppet::Pops::ModelPopsObject) —

    the object for which evaluation failed in some way. Used to determine origin.

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

    hash of optional named data elements for the given issue

Returns:

  • (!) —

    this method does not return

Raises:

  • (Puppet::ParseError) —

    an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)



18
19
20
21
22
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 18

def fail(issue, semantic, options={}, except=nil)
  optionally_fail(issue, semantic, options, except)
  # an error should have been raised since fail always fails
  raise ArgumentError, "Internal Error: Configuration of runtime error handling wrong: should have raised exception"
end

#find_resource(scope, type_name, title) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Finds a resource given a type and a title.



355
356
357
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 355

def find_resource(scope, type_name, title)
  scope.compiler.findresource(type_name, title)
end

#get_resource_parameter_value(scope, resource, parameter_name) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns the value of a resource’s parameter by first looking up the parameter in the resource and then in the defaults for the resource. Since the resource exists (it must in order to look up its parameters, any overrides have already been applied). Defaults are not applied to a resource until it has been finished (which typically has not taken place when this is evaluated; hence the dual lookup).



364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 364

def get_resource_parameter_value(scope, resource, parameter_name)
  # This gets the parameter value, or nil (for both valid parameters and parameters that do not exist).
  val = resource[parameter_name]

  # Sometimes the resource is a Puppet::Parser::Resource and sometimes it is
  # a Puppet::Resource. The Puppet::Resource case occurs when puppet language
  # is evaluated against an already completed catalog (where all instances of
  # Puppet::Parser::Resource are converted to Puppet::Resource instances).
  # Evaluating against an already completed catalog is really only found in
  # the language specification tests, where the puppet language is used to
  # test itself.
  if resource.is_a?(Puppet::Parser::Resource)
    # The defaults must be looked up in the scope where the resource was created (not in the given
    # scope where the lookup takes place.
    resource_scope = resource.scope
    if val.nil? && resource_scope && defaults = resource_scope.lookupdefaults(resource.type)
      # NOTE: 3x resource keeps defaults as hash using symbol for name as key to Parameter which (again) holds
      # name and value.
      # NOTE: meta parameters that are unset ends up here, and there are no defaults for those encoded
      # in the defaults, they may receive hardcoded defaults later (e.g. 'tag').
      param = defaults[parameter_name.to_sym]
      # Some parameters (meta parameters like 'tag') does not return a param from which the value can be obtained
      # at all times. Instead, they return a nil param until a value has been set.
      val = param.nil? ? nil : param.value
    end
  end
  val
end

#get_scope_nesting_level(scope) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



132
133
134
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 132

def get_scope_nesting_level(scope)
  scope.ephemeral_level
end

#get_variable_value(name, o, scope) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns the value of the variable (nil is returned if variable has no value, or if variable does not exist)



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 72

def get_variable_value(name, o, scope)
  # Puppet 3x stores all variables as strings (then converts them back to numeric with a regexp... to see if it is a match variable)
  # Not ideal, scope should support numeric lookup directly instead.
  # TODO: consider fixing scope
  catch(:undefined_variable) {
    x = scope.lookupvar(name.to_s)
    # Must convert :undef back to nil - this can happen when an undefined variable is used in a
    # parameter's default value expression - there nil must be :undef to work with the rest of 3x.
    # Now that the value comes back to 4x it is changed to nil.
    return (x == :undef) ? nil : x
  }
  # It is always ok to reference numeric variables even if they are not assigned. They are always undef
  # if not set by a match expression.
  #
  unless name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME
    fail(Puppet::Pops::Issues::UNKNOWN_VARIABLE, o, {:name => name})
  end
end

#initialize ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



426
427
428
429
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 426

def initialize
  @@convert_visitor   ||= Puppet::Pops::Visitor.new(self, "convert", 2, 2)
  @@convert2_visitor   ||= Puppet::Pops::Visitor.new(self, "convert2", 2, 2)
end

#is_boolean?(x) ⇒ Boolean

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Utility method for TrueClass || FalseClass

Parameters:

  • x (Object) —

    the object to test if it is instance of TrueClass or FalseClass

Returns:

  • (Boolean) 


422
423
424
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 422

def is_boolean? x
  x.is_a?(TrueClass) || x.is_a?(FalseClass)
end

#is_parameter_of_resource?(scope, resource, name) ⇒ Boolean

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns true, if the given name is the name of a resource parameter.

Returns:

  • (Boolean) 


395
396
397
398
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 395

def is_parameter_of_resource?(scope, resource, name)
  return false unless name.is_a?(String)
  resource.valid_parameter?(name)
end

#is_true?(o) ⇒ Boolean

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

This is the same type of “truth” as used in the current Puppet DSL.

Returns:

  • (Boolean) 


408
409
410
411
412
413
414
415
416
417
418
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 408

def is_true? o
  # Is the value true?  This allows us to control the definition of truth
  # in one place.
  case o
  # Support :undef since it may come from a 3x structure
  when :undef
    false
  else
    !!o
  end
end

#optionally_fail(issue, semantic, options = {}, except = nil) ⇒ !

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Optionally (based on severity) Fails the evaluation of semantic with a given issue If the given issue is configured to be of severity < :error it is only reported, and the function returns.

Parameters:

  • issue (Puppet::Pops::Issue) —

    the issue to report

  • semantic (Puppet::Pops::ModelPopsObject) —

    the object for which evaluation failed in some way. Used to determine origin.

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

    hash of optional named data elements for the given issue

Returns:

  • (!) —

    this method does not return

Raises:

  • (Puppet::ParseError) —

    an evaluation error initialized from the arguments (TODO: Change to EvaluationError?)



33
34
35
36
37
38
39
40
41
42
43
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 33

def optionally_fail(issue, semantic, options={}, except=nil)
  if except.nil?
    # Want a stacktrace, and it must be passed as an exception
    begin
     raise EvaluationError.new()
    rescue EvaluationError => e
      except = e
    end
  end
  diagnostic_producer.accept(issue, semantic, options, except)
end

#resource_to_ptype(resource) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



400
401
402
403
404
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 400

def resource_to_ptype(resource)
  nil if resource.nil?
  # inference returns the meta type since the 3x Resource is an alternate way to describe a type
  type_calculator.infer(resource).type
end

#set_match_data(match_data, scope) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



104
105
106
107
108
109
110
111
112
113
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 104

def set_match_data(match_data, scope)
  # See set_variable for rationale for not passing file and line to ephemeral_from.
  # NOTE: The 3x scope adds one ephemeral(match) to its internal stack per match that succeeds ! It never
  # clears anything. Thus a context that performs many matches will get very deep (there simply is no way to
  # clear the match variables without rolling back the ephemeral stack.)
  # This implementation does not attempt to fix this, it behaves the same bad way.
  unless match_data.nil?
    scope.ephemeral_from(match_data)
  end
end

#set_scope_nesting_level(scope, level) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



136
137
138
139
140
141
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 136

def set_scope_nesting_level(scope, level)
  # Yup, 3x uses this method to reset the level, it also supports passing :all to destroy all 
  # ephemeral/local scopes - which is a sure way to create havoc.
  #
  scope.unset_ephemeral_var(level)
end

#set_variable(name, value, o, scope) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Binds the given variable name to the given value in the given scope. The reference object ‘o` is intended to be used for origin information - the 3x scope implementation only makes use of location when there is an error. This is now handled by other mechanisms; first a check is made if a variable exists and an error is raised if attempting to change an immutable value. Errors in name, numeric variable assignment etc. have also been validated prior to this call. In the event the scope.setvar still raises an error, the general exception handling for evaluation of the assignment expression knows about its location. Because of this, there is no need to extract the location for each setting (extraction is somewhat expensive since 3x requires line instead of offset).



54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 54

def set_variable(name, value, o, scope)
  # Scope also checks this but requires that location information are passed as options.
  # Those are expensive to calculate and a test is instead made here to enable failing with better information.
  # The error is not specific enough to allow catching it - need to check the actual message text.
  # TODO: Improve the messy implementation in Scope.
  #
  if scope.bound?(name)
    if Puppet::Parser::Scope::RESERVED_VARIABLE_NAMES.include?(name)
      fail(Puppet::Pops::Issues::ILLEGAL_RESERVED_ASSIGNMENT, o, {:name => name} )
    else
      fail(Puppet::Pops::Issues::ILLEGAL_REASSIGNMENT, o, {:name => name} )
    end
  end
  scope.setvar(name, value)
end

#variable_bound?(name, scope) ⇒ Boolean

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns true if the variable of the given name is set in the given most nested scope. True is returned even if variable is bound to nil.

Returns:

  • (Boolean) 


94
95
96
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 94

def variable_bound?(name, scope)
  scope.bound?(name.to_s)
end

#variable_exists?(name, scope) ⇒ Boolean

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns true if the variable is bound to a value or nil, in the scope or it’s parent scopes.

Returns:

  • (Boolean) 


100
101
102
 
# File 'lib/puppet/pops/evaluator/runtime3_support.rb', line 100

def variable_exists?(name, scope)
  scope.exist?(name.to_s)
end