Class: Puppet::Parser::Scope
- Extended by:
- Forwardable
- Includes:
- Util::Errors, Util::MethodHelper
- Defined in:
- lib/puppet/parser/scope.rb
Overview
This class is part of the internal parser/evaluator/compiler functionality of Puppet. It is passed between the various classes that participate in evaluation. None of its methods are API except those that are clearly marked as such.
Defined Under Namespace
Classes: Ephemeral, LocalScope, MatchScope, ParameterScope
Constant Summary collapse
- BUILT_IN_VARS =
Variables that always exist with nil value even if not set
['module_name'.freeze, 'caller_module_name'.freeze].freeze
- EMPTY_HASH =
{}.freeze
- UNDEFINED_VARIABLES_KIND =
'undefined_variables'.freeze
- UNCAUGHT_THROW_EXCEPTION =
The exception raised when a throw is uncaught is different in different versions of ruby. In >=2.2.0 it is UncaughtThrowError (which did not exist prior to this)
defined?(UncaughtThrowError) ? UncaughtThrowError : ArgumentError
- VARNAME_TRUSTED =
'trusted'.freeze
- VARNAME_FACTS =
'facts'.freeze
- VARNAME_SERVER_FACTS =
'server_facts'.freeze
- RESERVED_VARIABLE_NAMES =
[VARNAME_TRUSTED, VARNAME_FACTS].freeze
- TYPENAME_CLASS =
'Class'.freeze
- TYPENAME_NODE =
'Node'.freeze
Instance Attribute Summary collapse
- #compiler ⇒ Object readonly
-
#defaults ⇒ Object
readonly
Hash of hashes of default values per type name.
- #parent ⇒ Object
- #resource ⇒ Object
- #source ⇒ Object
Class Method Summary collapse
-
.number?(value) ⇒ Boolean
Coerce value to a number, or return ‘nil` if it isn’t one.
-
.true?(value) ⇒ Boolean
Is the value true? This allows us to control the definition of truth in one place.
Instance Method Summary collapse
-
#[](varname, options = EMPTY_HASH) ⇒ Object
Retrieves the variable value assigned to the name given as an argument.
-
#[]=(varname, value, _ = nil) ⇒ Object
Sets the variable value of the name given as an argument to the given value.
-
#bound?(name) ⇒ Boolean
Returns true if the given name is bound in the current (most nested) scope for assignments.
-
#call_function(func_name, args, &block) ⇒ Object
Calls a 3.x or 4.x function by name with arguments given in an array using the 4.x calling convention and returns the result.
-
#catalog ⇒ Object
Alias for ‘compiler.catalog`.
-
#class_scope(klass) ⇒ Object
Return the scope associated with a class.
-
#class_set(name, scope) ⇒ Object
Store the fact that we’ve evaluated a class, and store a reference to the scope in which it was evaluated, so that we can look it up later.
-
#define_settings(type, params) ⇒ Object
Set defaults for a type.
-
#effective_symtable(use_ephemeral) ⇒ Object
Return the effective “table” for setting variables.
-
#enclosing_scope ⇒ Puppet::Parser::Scope
The enclosing scope (topscope or nodescope) of this scope.
-
#environment ⇒ Object
Alias for ‘compiler.environment`.
- #ephemeral_from(match, file = nil, line = nil) ⇒ Object
- #ephemeral_level ⇒ Object
-
#exist?(name) ⇒ Boolean
Returns true if the variable of the given name is set to any value (including nil).
- #find_builtin_resource_type(type) ⇒ Object private
- #find_defined_resource_type(type) ⇒ Object private
- #find_definition(name) ⇒ Object
- #find_global_scope ⇒ Object
- #find_hostclass(name) ⇒ Object
- #find_resource_type(type) ⇒ Object private
- #findresource(type, title = nil) ⇒ Object
- #handle_not_found(class_name, variable_name, position, reason = nil) ⇒ Object
-
#include?(name) ⇒ Boolean
Returns true if the variable of the given name has a non nil value.
-
#inherited_scope ⇒ Puppet::Parser::Scope
The class scope of the inherited thing of this scope’s resource.
-
#initialize(compiler, options = EMPTY_HASH) ⇒ Scope
constructor
Initialize our new scope.
- #is_classscope? ⇒ Boolean
-
#is_default?(type, key, value) ⇒ Boolean
Check if the given value is a known default for the given type.
- #is_nodescope? ⇒ Boolean
- #is_topscope? ⇒ Boolean
- #lookup_qualified_variable(fqn, options) ⇒ Object private
-
#lookupdefaults(type) ⇒ Object
Collect all of the defaults set at any higher scopes.
-
#lookuptype(name) ⇒ Object
Look up a defined type.
-
#lookupvar(name, options = EMPTY_HASH) ⇒ Object
Lookup a variable within this scope using the Puppet language’s scoping rules.
-
#merge_settings(env_name) ⇒ Object
Merge all settings for the given env_name into this scope.
- #method_missing(method, *args, &block) ⇒ Object
-
#new_ephemeral(local_scope = false) ⇒ Object
TODO: Who calls this?.
-
#new_match_scope(match_data) ⇒ Object
Nests a match data scope.
-
#newscope(options = {}) ⇒ Object
Create a new scope and set these options.
- #parent_module_name ⇒ Object
-
#pop_ephemerals(level) ⇒ Array
private
Pop ephemeral scopes up to level and return them.
-
#push_ephemerals(ephemeral_scopes) ⇒ Object
private
Push ephemeral scopes onto the ephemeral scope stack.
-
#resolve_type_and_titles(type, titles) ⇒ Object
private
To be removed when enough time has passed after puppet 5.0.0.
- #set_facts(hash) ⇒ Object
-
#set_match_data(match_data) ⇒ Object
Sets match data in the most nested scope (which always is a MatchScope), it clobbers match data already set there.
- #set_server_facts(hash) ⇒ Object
- #set_trusted(hash) ⇒ Object
-
#setvar(name, value, options = EMPTY_HASH) ⇒ Object
Set a variable in the current scope.
-
#to_hash(recursive = true) ⇒ Object
Returns a Hash containing all variables and their values, optionally (and by default) including the values defined in parent.
-
#to_s ⇒ Object
(also: #inspect)
Used mainly for logging.
-
#transform_and_assert_classnames(names) ⇒ Array<String>
Transforms references to classes to the form suitable for lookup in the compiler.
- #undef_as(x, v) ⇒ Object
- #variable_not_found(name, reason = nil) ⇒ Object
-
#with_global_scope {|global_scope| ... } ⇒ Object
private
Execute given block in global scope with no ephemerals present.
-
#with_guarded_scope ⇒ Object
private
Execute given block and ensure that ephemeral level is restored.
-
#with_local_scope(scope_variables) ⇒ Object
private
Execute given block with a ephemeral scope containing the given variables.
-
#with_parameter_scope(callee_name, param_names) {|param_scope| ... } ⇒ Object
private
Nests a parameter scope.
-
#without_ephemeral_scopes ⇒ Object
private
Execute given block with all ephemeral popped from the ephemeral stack.
Methods included from Util::Errors
#adderrorcontext, #devfail, #error_context, #exceptwrap, #fail
Methods included from Util::MethodHelper
#requiredopts, #set_options, #symbolize_options
Constructor Details
#initialize(compiler, options = EMPTY_HASH) ⇒ Scope
Initialize our new scope. Defaults to having no parent.
377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 |
# File 'lib/puppet/parser/scope.rb', line 377 def initialize(compiler, = EMPTY_HASH) if compiler.is_a? Puppet::Parser::Compiler @compiler = compiler else raise Puppet::DevError, "you must pass a compiler instance to a new scope object" end () extend_with_functions_module # The symbol table for this scope. This is where we store variables. # @symtable = Ephemeral.new(nil, true) @symtable = LocalScope.new(nil) @ephemeral = [ MatchScope.new(@symtable, nil) ] # All of the defaults set for types. It's a hash of hashes, # with the first key being the type, then the second key being # the parameter. @defaults = Hash.new { |dhash,type| dhash[type] = {} } # The table for storing class singletons. This will only actually # be used by top scopes and node scopes. @class_scopes = {} end |
Dynamic Method Handling
This class handles dynamic methods through the method_missing method
#method_missing(method, *args, &block) ⇒ Object
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 |
# File 'lib/puppet/parser/scope.rb', line 1003 def method_missing(method, *args, &block) method.to_s =~ /^function_(.*)$/ name = $1 super unless name super unless Puppet::Parser::Functions.function(name) # In odd circumstances, this might not end up defined by the previous # method, so we might as well be certain. if respond_to? method send(method, *args) else raise Puppet::DevError, "Function #{name} not defined despite being loaded!" end end |
Instance Attribute Details
#compiler ⇒ Object (readonly)
29 30 31 |
# File 'lib/puppet/parser/scope.rb', line 29 def compiler @compiler end |
#defaults ⇒ Object (readonly)
Hash of hashes of default values per type name
33 34 35 |
# File 'lib/puppet/parser/scope.rb', line 33 def defaults @defaults end |
Class Method Details
.number?(value) ⇒ Boolean
Coerce value to a number, or return ‘nil` if it isn’t one.
331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 |
# File 'lib/puppet/parser/scope.rb', line 331 def self.number?(value) case value when Numeric value when /^-?\d+(:?\.\d+|(:?\.\d+)?e\d+)$/ value.to_f when /^0x[0-9a-f]+$/i value.to_i(16) when /^0[0-7]+$/ value.to_i(8) when /^-?\d+$/ value.to_i else nil end end |
.true?(value) ⇒ Boolean
Is the value true? This allows us to control the definition of truth in one place.
319 320 321 322 323 324 325 326 327 328 |
# File 'lib/puppet/parser/scope.rb', line 319 def self.true?(value) case value when '' false when :undef false else !!value end end |
Instance Method Details
#[](varname, options = EMPTY_HASH) ⇒ Object
Retrieves the variable value assigned to the name given as an argument. The name must be a String, and namespace can be qualified with ‘::’. The value is looked up in this scope, its parent scopes, or in a specific visible named scope.
556 557 558 |
# File 'lib/puppet/parser/scope.rb', line 556 def [](varname, = EMPTY_HASH) lookupvar(varname, ) end |
#[]=(varname, value, _ = nil) ⇒ Object
Sets the variable value of the name given as an argument to the given value. The value is set in the current scope and may shadow a variable with the same name in a visible outer scope. It is illegal to re-assign a variable in the same scope. It is illegal to set a variable in some other scope/namespace than the scope passed to a method.
856 857 858 |
# File 'lib/puppet/parser/scope.rb', line 856 def []=(varname, value, _ = nil) setvar(varname, value) end |
#bound?(name) ⇒ Boolean
Returns true if the given name is bound in the current (most nested) scope for assignments.
312 313 314 315 |
# File 'lib/puppet/parser/scope.rb', line 312 def bound?(name) # Do not look in ephemeral (match scope), the semantics is to answer if an assignable variable is bound effective_symtable(false).bound?(name) end |
#call_function(func_name, args, &block) ⇒ Object
Calls a 3.x or 4.x function by name with arguments given in an array using the 4.x calling convention and returns the result. Note that it is the caller’s responsibility to rescue the given ArgumentError and provide location information to aid the user find the problem. The problem is otherwise reported against the source location that invoked the function that ultimately called this method.
1066 1067 1068 |
# File 'lib/puppet/parser/scope.rb', line 1066 def call_function(func_name, args, &block) Puppet::Pops::Parser::EvaluatingParser.new.evaluator.external_call_function(func_name, args, self, &block) end |
#catalog ⇒ Object
Alias for ‘compiler.catalog`
41 42 43 |
# File 'lib/puppet/parser/scope.rb', line 41 def catalog @compiler.catalog end |
#class_scope(klass) ⇒ Object
Return the scope associated with a class. This is just here so that subclasses can set their parent scopes to be the scope of their parent class, and it’s also used when looking up qualified variables.
420 421 422 423 424 |
# File 'lib/puppet/parser/scope.rb', line 420 def class_scope(klass) # They might pass in either the class or class name k = klass.respond_to?(:name) ? klass.name : klass @class_scopes[k] || (parent && parent.class_scope(k)) end |
#class_set(name, scope) ⇒ Object
Store the fact that we’ve evaluated a class, and store a reference to the scope in which it was evaluated, so that we can look it up later.
408 409 410 411 412 413 414 |
# File 'lib/puppet/parser/scope.rb', line 408 def class_set(name, scope) if parent parent.class_set(name, scope) else @class_scopes[name] = scope end end |
#define_settings(type, params) ⇒ Object
Set defaults for a type. The typename should already be downcased, so that the syntax is isolated. We don’t do any kind of type-checking here; instead we let the resource do it when the defaults are used.
686 687 688 689 690 691 692 693 694 695 696 697 698 |
# File 'lib/puppet/parser/scope.rb', line 686 def define_settings(type, params) table = @defaults[type] # if we got a single param, it'll be in its own array params = [params] unless params.is_a?(Array) params.each { |param| if table.include?(param.name) raise Puppet::ParseError.new(_("Default already defined for %{type} { %{param} }; cannot redefine") % { type: type, param: param.name }, param.file, param.line) end table[param.name] = param } end |
#effective_symtable(use_ephemeral) ⇒ Object
Return the effective “table” for setting variables. This method returns the first ephemeral “table” that acts as a local scope, or this scope’s symtable. If the parameter ‘use_ephemeral` is true, the “top most” ephemeral “table” will be returned (irrespective of it being a match scope or a local scope).
835 836 837 838 839 840 841 842 843 |
# File 'lib/puppet/parser/scope.rb', line 835 def effective_symtable(use_ephemeral) s = @ephemeral[-1] return s || @symtable if use_ephemeral while s && !s.is_local_scope?() s = s.parent end s || @symtable end |
#enclosing_scope ⇒ Puppet::Parser::Scope
The enclosing scope (topscope or nodescope) of this scope. The enclosing scopes are produced when a class or define is included at some point. The parent scope of the included class or define becomes the scope in which it was included. The chain of parent scopes is followed until a node scope or the topscope is found
578 579 580 581 582 583 584 585 586 |
# File 'lib/puppet/parser/scope.rb', line 578 def enclosing_scope if has_enclosing_scope? if parent.is_topscope? || parent.is_nodescope? parent else parent.enclosing_scope end end end |
#environment ⇒ Object
Alias for ‘compiler.environment`
36 37 38 |
# File 'lib/puppet/parser/scope.rb', line 36 def environment @compiler.environment end |
#ephemeral_from(match, file = nil, line = nil) ⇒ Object
970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 |
# File 'lib/puppet/parser/scope.rb', line 970 def ephemeral_from(match, file = nil, line = nil) case match when Hash # Create local scope ephemeral and set all values from hash new_ephemeral(true) match.each {|k,v| setvar(k, v, :file => file, :line => line, :ephemeral => true) } # Must always have an inner match data scope (that starts out as transparent) # In 3x slightly wasteful, since a new nested scope is created for a match # (TODO: Fix that problem) new_ephemeral(false) else raise(ArgumentError,_("Invalid regex match data. Got a %{klass}") % { klass: match.class }) unless match.is_a?(MatchData) # Create a match ephemeral and set values from match data new_match_scope(match) end end |
#ephemeral_level ⇒ Object
883 884 885 |
# File 'lib/puppet/parser/scope.rb', line 883 def ephemeral_level @ephemeral.size end |
#exist?(name) ⇒ Boolean
Returns true if the variable of the given name is set to any value (including nil)
287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 |
# File 'lib/puppet/parser/scope.rb', line 287 def exist?(name) # Note !! ensure the answer is boolean !! if name =~ /^(.*)::(.+)$/ class_name = $1 variable_name = $2 return true if class_name == '' && BUILT_IN_VARS.include?(variable_name) # lookup class, but do not care if it is not evaluated since that will result # in it not existing anyway. (Tests may run with just scopes and no evaluated classes which # will result in class_scope for "" not returning topscope). klass = find_hostclass(class_name) other_scope = klass.nil? ? nil : class_scope(klass) if other_scope.nil? class_name == '' ? compiler.topscope.exist?(variable_name) : false else other_scope.exist?(variable_name) end else next_scope = inherited_scope || enclosing_scope effective_symtable(true).include?(name) || next_scope && next_scope.exist?(name) || BUILT_IN_VARS.include?(name) end end |
#find_builtin_resource_type(type) ⇒ 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.
993 994 995 |
# File 'lib/puppet/parser/scope.rb', line 993 def find_builtin_resource_type(type) raise Puppet::DevError, "Scope#find_builtin_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead" end |
#find_defined_resource_type(type) ⇒ 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.
998 999 1000 |
# File 'lib/puppet/parser/scope.rb', line 998 def find_defined_resource_type(type) raise Puppet::DevError, "Scope#find_defined_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead" end |
#find_definition(name) ⇒ Object
352 353 354 |
# File 'lib/puppet/parser/scope.rb', line 352 def find_definition(name) environment.known_resource_types.find_definition(name) end |
#find_global_scope ⇒ Object
356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 |
# File 'lib/puppet/parser/scope.rb', line 356 def find_global_scope() # walk upwards until first found node_scope or top_scope if is_nodescope? || is_topscope? self else next_scope = inherited_scope || enclosing_scope if next_scope.nil? # this happens when testing, and there is only a single test scope and no link to any # other scopes self else next_scope.find_global_scope() end end end |
#find_hostclass(name) ⇒ Object
348 349 350 |
# File 'lib/puppet/parser/scope.rb', line 348 def find_hostclass(name) environment.known_resource_types.find_hostclass(name) end |
#find_resource_type(type) ⇒ 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.
988 989 990 |
# File 'lib/puppet/parser/scope.rb', line 988 def find_resource_type(type) raise Puppet::DevError, "Scope#find_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead" end |
#findresource(type, title = nil) ⇒ Object
372 373 374 |
# File 'lib/puppet/parser/scope.rb', line 372 def findresource(type, title = nil) @compiler.catalog.resource(type, title) end |
#handle_not_found(class_name, variable_name, position, reason = nil) ⇒ Object
626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 |
# File 'lib/puppet/parser/scope.rb', line 626 def handle_not_found(class_name, variable_name, position, reason = nil) unless Puppet[:strict_variables] # Do not issue warning if strict variables are on, as an error will be raised by variable_not_found location = if position[:lineproc] " at #{position[:lineproc].call}" elsif position[:file] && position[:line] " at #{position[:file]}:#{position[:line]}" else "" end variable_not_found("#{class_name}::#{variable_name}", "#{reason}#{location}") return nil end variable_not_found("#{class_name}::#{variable_name}", reason) end |
#include?(name) ⇒ Boolean
Returns true if the variable of the given name has a non nil value. TODO: This has vague semantics - does the variable exist or not?
use ['name'] to get nil or value, and if nil check with exist?('name')
this include? is only useful because of checking against the boolean value false.
276 277 278 279 280 281 |
# File 'lib/puppet/parser/scope.rb', line 276 def include?(name) catch(:undefined_variable) { return ! self[name].nil? } false end |
#inherited_scope ⇒ Puppet::Parser::Scope
The class scope of the inherited thing of this scope’s resource.
563 564 565 566 567 568 569 |
# File 'lib/puppet/parser/scope.rb', line 563 def inherited_scope if resource && resource.type == TYPENAME_CLASS && !resource.resource_type.parent.nil? qualified_scope(resource.resource_type.parent) else nil end end |
#is_classscope? ⇒ Boolean
588 589 590 |
# File 'lib/puppet/parser/scope.rb', line 588 def is_classscope? resource && resource.type == TYPENAME_CLASS end |
#is_default?(type, key, value) ⇒ Boolean
Check if the given value is a known default for the given type
460 461 462 463 464 465 466 467 |
# File 'lib/puppet/parser/scope.rb', line 460 def is_default?(type, key, value) defaults_for_type = @defaults[type] unless defaults_for_type.nil? default_param = defaults_for_type[key] return true if !default_param.nil? && value == default_param.value end !parent.nil? && parent.is_default?(type, key, value) end |
#is_nodescope? ⇒ Boolean
592 593 594 |
# File 'lib/puppet/parser/scope.rb', line 592 def is_nodescope? resource && resource.type == TYPENAME_NODE end |
#is_topscope? ⇒ Boolean
596 597 598 |
# File 'lib/puppet/parser/scope.rb', line 596 def is_topscope? equal?(@compiler.topscope) end |
#lookup_qualified_variable(fqn, options) ⇒ 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.
601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 |
# File 'lib/puppet/parser/scope.rb', line 601 def lookup_qualified_variable(fqn, ) table = @compiler.qualified_variables val = table[fqn] return val if !val.nil? || table.include?(fqn) # not found - search inherited scope for class leaf_index = fqn.rindex('::') unless leaf_index.nil? leaf_name = fqn[ (leaf_index+2)..-1 ] class_name = fqn[ 0, leaf_index ] begin qs = qualified_scope(class_name) unless qs.nil? iscope = qs.inherited_scope return lookup_qualified_variable("#{iscope.source.name}::#{leaf_name}", ) unless iscope.nil? end rescue RuntimeError => e # because a failure to find the class, or inherited should be reported against given name return handle_not_found(class_name, leaf_name, , e.) end end # report with leading '::' by using empty class_name return handle_not_found('', fqn, ) end |
#lookupdefaults(type) ⇒ Object
Collect all of the defaults set at any higher scopes. This is a different type of lookup because it’s additive – it collects all of the defaults, with defaults in closer scopes overriding those in later scopes.
The lookupdefaults searches in the the order:
* inherited
* contained (recursive)
* self
437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 |
# File 'lib/puppet/parser/scope.rb', line 437 def lookupdefaults(type) values = {} # first collect the values from the parents if parent parent.lookupdefaults(type).each { |var,value| values[var] = value } end # then override them with any current values # this should probably be done differently if @defaults.include?(type) @defaults[type].each { |var,value| values[var] = value } end values end |
#lookuptype(name) ⇒ Object
Look up a defined type.
470 471 472 473 474 |
# File 'lib/puppet/parser/scope.rb', line 470 def lookuptype(name) # This happens a lot, avoid making a call to make a call krt = environment.known_resource_types krt.find_definition(name) || krt.find_hostclass(name) end |
#lookupvar(name, options = EMPTY_HASH) ⇒ Object
Lookup a variable within this scope using the Puppet language’s scoping rules. Variables can be qualified using just as in a manifest.
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 |
# File 'lib/puppet/parser/scope.rb', line 494 def lookupvar(name, = EMPTY_HASH) unless name.is_a? String raise Puppet::ParseError, _("Scope variable name %{name} is a %{klass}, not a string") % { name: name.inspect, klass: name.class } end # If name has '::' in it, it is resolved as a qualified variable unless (idx = name.index('::')).nil? # Always drop leading '::' if present as that is how the values are keyed. return lookup_qualified_variable(idx == 0 ? name[2..-1] : name, ) end # At this point, search is for a non qualified (simple) name table = @ephemeral.last val = table[name] return val unless val.nil? && !table.include?(name) next_scope = inherited_scope || enclosing_scope if next_scope next_scope.lookupvar(name, ) else variable_not_found(name) end end |
#merge_settings(env_name) ⇒ Object
Merge all settings for the given env_name into this scope
702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 |
# File 'lib/puppet/parser/scope.rb', line 702 def merge_settings(env_name) settings = Puppet.settings table = effective_symtable(false) global_table = compiler.qualified_variables all_local = {} settings.each_key do |name| next if :name == name key = name.to_s value = transform_setting(settings.value_sym(name, env_name)) table[key] = value all_local[key] = value # also write the fqn into global table for direct lookup global_table["settings::#{key}"] = value end # set the 'all_local' - a hash of all settings global_table["settings::all_local"] = all_local nil end |
#new_ephemeral(local_scope = false) ⇒ Object
TODO: Who calls this?
888 889 890 891 892 893 894 |
# File 'lib/puppet/parser/scope.rb', line 888 def new_ephemeral(local_scope = false) if local_scope @ephemeral.push(LocalScope.new(@ephemeral.last)) else @ephemeral.push(MatchScope.new(@ephemeral.last, nil)) end end |
#new_match_scope(match_data) ⇒ Object
Nests a match data scope
966 967 968 |
# File 'lib/puppet/parser/scope.rb', line 966 def new_match_scope(match_data) @ephemeral.push(MatchScope.new(@ephemeral.last, match_data)) end |
#newscope(options = {}) ⇒ Object
Create a new scope and set these options.
674 675 676 |
# File 'lib/puppet/parser/scope.rb', line 674 def newscope( = {}) compiler.newscope(self, ) end |
#parent_module_name ⇒ Object
678 679 680 681 |
# File 'lib/puppet/parser/scope.rb', line 678 def parent_module_name return nil unless @parent && @parent.source @parent.source.module_name end |
#pop_ephemerals(level) ⇒ 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.
Pop ephemeral scopes up to level and return them
872 873 874 |
# File 'lib/puppet/parser/scope.rb', line 872 def pop_ephemerals(level) @ephemeral.pop(@ephemeral.size - level) end |
#push_ephemerals(ephemeral_scopes) ⇒ 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.
Push ephemeral scopes onto the ephemeral scope stack
879 880 881 |
# File 'lib/puppet/parser/scope.rb', line 879 def push_ephemerals(ephemeral_scopes) ephemeral_scopes.each { |ephemeral_scope| @ephemeral.push(ephemeral_scope) } unless ephemeral_scopes.nil? end |
#resolve_type_and_titles(type, titles) ⇒ 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.
To be removed when enough time has passed after puppet 5.0.0
1019 1020 1021 |
# File 'lib/puppet/parser/scope.rb', line 1019 def resolve_type_and_titles(type, titles) raise Puppet::DevError, "Scope#resolve_type_and_title() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead" end |
#set_facts(hash) ⇒ Object
798 799 800 |
# File 'lib/puppet/parser/scope.rb', line 798 def set_facts(hash) setvar('facts', deep_freeze(hash), :privileged => true) end |
#set_match_data(match_data) ⇒ Object
Sets match data in the most nested scope (which always is a MatchScope), it clobbers match data already set there
961 962 963 |
# File 'lib/puppet/parser/scope.rb', line 961 def set_match_data(match_data) @ephemeral.last.match_data = match_data end |
#set_server_facts(hash) ⇒ Object
802 803 804 |
# File 'lib/puppet/parser/scope.rb', line 802 def set_server_facts(hash) setvar('server_facts', deep_freeze(hash), :privileged => true) end |
#set_trusted(hash) ⇒ Object
794 795 796 |
# File 'lib/puppet/parser/scope.rb', line 794 def set_trusted(hash) setvar('trusted', deep_freeze(hash), :privileged => true) end |
#setvar(name, value, options = EMPTY_HASH) ⇒ Object
Set a variable in the current scope. This will override settings in scopes above, but will not allow variables in the current scope to be reassigned.
It's preferred that you use self[]= instead of this; only use this
when you need to set options.
749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 |
# File 'lib/puppet/parser/scope.rb', line 749 def setvar(name, value, = EMPTY_HASH) if name =~ /^[0-9]+$/ raise Puppet::ParseError.new(_("Cannot assign to a numeric match result variable '$%{name}'") % { name: name }) # unless options[:ephemeral] end unless name.is_a? String raise Puppet::ParseError, _("Scope variable name %{value0} is a %{value1}, not a string") % { value0: name.inspect, value1: name.class } end # Check for reserved variable names if (name == VARNAME_TRUSTED || name == VARNAME_FACTS) && ![:privileged] raise Puppet::ParseError, _("Attempt to assign to a reserved variable name: '%{name}'") % { name: name } end # Check for server_facts reserved variable name if the trusted_sever_facts setting is true if name == VARNAME_SERVER_FACTS && ![:privileged] && Puppet[:trusted_server_facts] raise Puppet::ParseError, _("Attempt to assign to a reserved variable name: '%{name}'") % { name: name } end table = effective_symtable([:ephemeral]) if table.bound?(name) error = Puppet::ParseError.new(_("Cannot reassign variable '$%{name}'") % { name: name }) error.file = [:file] if [:file] error.line = [:line] if [:line] raise error end table[name] = value # Assign the qualified name in the environment # Note that Settings scope has a source set to Boolean true. # # Only meaningful to set a fqn globally if table to assign to is the top of the scope's ephemeral stack if @symtable.equal?(table) if is_topscope? # the scope name is '::' compiler.qualified_variables[name] = value elsif source.is_a?(Puppet::Resource::Type) && source.type == :hostclass # the name is the name of the class sourcename = source.name compiler.qualified_variables["#{sourcename}::#{name}"] = value end end value end |
#to_hash(recursive = true) ⇒ Object
Returns a Hash containing all variables and their values, optionally (and by default) including the values defined in parent. Local values shadow parent values. Ephemeral scopes for match results ($0 - $n) are not included.
658 659 660 661 662 663 664 665 666 667 668 669 670 671 |
# File 'lib/puppet/parser/scope.rb', line 658 def to_hash(recursive = true) if recursive and has_enclosing_scope? target = enclosing_scope.to_hash(recursive) if !(inherited = inherited_scope).nil? target.merge!(inherited.to_hash(recursive)) end else target = Hash.new end # add all local scopes @ephemeral.last.add_entries_to(target) target end |
#to_s ⇒ Object Also known as: inspect
Used mainly for logging
861 862 863 |
# File 'lib/puppet/parser/scope.rb', line 861 def to_s "Scope(#{@resource})" end |
#transform_and_assert_classnames(names) ⇒ Array<String>
Transforms references to classes to the form suitable for lookup in the compiler.
Makes names passed in the names array absolute if they are relative.
Transforms Class[] and Resource[] type references to class name or raises an error if a Class[] is unspecific, if a Resource is not a ‘class’ resource, or if unspecific (no title).
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 |
# File 'lib/puppet/parser/scope.rb', line 1036 def transform_and_assert_classnames(names) names.map do |name| case name when String name.sub(/^([^:]{1,2})/, '::\1') when Puppet::Resource assert_class_and_title(name.type, name.title) name.title.sub(/^([^:]{1,2})/, '::\1') when Puppet::Pops::Types::PClassType #TRANSLATORS "Class" and "Type" are Puppet keywords and should not be translated raise ArgumentError, _("Cannot use an unspecific Class[] Type") unless name.class_name name.class_name.sub(/^([^:]{1,2})/, '::\1') when Puppet::Pops::Types::PResourceType assert_class_and_title(name.type_name, name.title) name.title.sub(/^([^:]{1,2})/, '::\1') end.downcase end end |
#undef_as(x, v) ⇒ Object
476 477 478 479 480 481 482 |
# File 'lib/puppet/parser/scope.rb', line 476 def undef_as(x,v) if v.nil? or v == :undef x else v end end |
#variable_not_found(name, reason = nil) ⇒ Object
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 |
# File 'lib/puppet/parser/scope.rb', line 525 def variable_not_found(name, reason=nil) # Built in variables and numeric variables always exist if BUILT_IN_VARS.include?(name) || name =~ Puppet::Pops::Patterns::NUMERIC_VAR_NAME return nil end begin throw(:undefined_variable, reason) rescue UNCAUGHT_THROW_EXCEPTION case Puppet[:strict] when :off # do nothing when :warning Puppet.warn_once(UNDEFINED_VARIABLES_KIND, _("Variable: %{name}") % { name: name }, _("Undefined variable '%{name}'; %{reason}") % { name: name, reason: reason } ) when :error raise ArgumentError, _("Undefined variable '%{name}'; %{reason}") % { name: name, reason: reason } end end nil end |
#with_global_scope {|global_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.
Execute given block in global scope with no ephemerals present
902 903 904 |
# File 'lib/puppet/parser/scope.rb', line 902 def with_global_scope(&block) find_global_scope.without_ephemeral_scopes(&block) end |
#with_guarded_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.
Execute given block and ensure that ephemeral level is restored
950 951 952 953 954 955 956 957 |
# File 'lib/puppet/parser/scope.rb', line 950 def with_guarded_scope elevel = ephemeral_level begin yield ensure pop_ephemerals(elevel) end end |
#with_local_scope(scope_variables) ⇒ 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.
Execute given block with a ephemeral scope containing the given variables
908 909 910 911 912 913 914 915 916 917 |
# File 'lib/puppet/parser/scope.rb', line 908 def with_local_scope(scope_variables) local = LocalScope.new(@ephemeral.last) scope_variables.each_pair { |k, v| local[k] = v } @ephemeral.push(local) begin yield(self) ensure @ephemeral.pop end end |
#with_parameter_scope(callee_name, param_names) {|param_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.
Nests a parameter scope
937 938 939 940 941 942 943 |
# File 'lib/puppet/parser/scope.rb', line 937 def with_parameter_scope(callee_name, param_names) param_scope = ParameterScope.new(@ephemeral.last, callee_name, param_names) with_guarded_scope do @ephemeral.push(param_scope) yield(param_scope) end end |
#without_ephemeral_scopes ⇒ 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.
Execute given block with all ephemeral popped from the ephemeral stack
922 923 924 925 926 927 928 929 930 |
# File 'lib/puppet/parser/scope.rb', line 922 def without_ephemeral_scopes save_ephemeral = @ephemeral begin @ephemeral = [ @symtable ] yield(self) ensure @ephemeral = save_ephemeral end end |