puppet-retrospec 1.5.0 → 1.6.0

data/vendor/pup410/lib/puppet/parser/functions/with.rb

@@ -0,0 +1,28 @@
+Puppet::Parser::Functions::newfunction(
+  :with,
+  :type => :rvalue,
+  :arity => -1,
+  :doc => <<-DOC
+Call a [lambda](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html)
+with the given arguments and return the result. Since a lambda's scope is
+[local](https://docs.puppetlabs.com/puppet/latest/reference/lang_lambdas.html#lambda-scope)
+to the lambda, you can use the `with` function to create private blocks of code within a
+class using variables whose values cannot be accessed outside of the lambda.
+
+**Example**: Using `with`
+
+~~~ puppet
+# Concatenate three strings into a single string formatted as a list.
+$fruit = with("apples", "oranges", "bananas") |$x, $y, $z| {
+  "${x}, ${y}, and ${z}"
+}
+$check_var = $x
+# $fruit contains "apples, oranges, and bananas"
+# $check_var is undefined, as the value of $x is local to the lambda.
+~~~
+
+- Since 4.0.0
+DOC
+) do |args|
+  Puppet::Parser::Functions::Error.is4x('with')
+end

data/vendor/pup410/lib/puppet/parser/resource.rb

@@ -0,0 +1,388 @@
+require 'puppet/resource'
+
+# The primary difference between this class and its
+# parent is that this class has rules on who can set
+# parameters
+class Puppet::Parser::Resource < Puppet::Resource
+  require 'puppet/parser/resource/param'
+  require 'puppet/util/tagging'
+  require 'puppet/parser/yaml_trimmer'
+
+  include Puppet::Util
+  include Puppet::Util::MethodHelper
+  include Puppet::Util::Errors
+  include Puppet::Util::Logging
+  include Puppet::Parser::YamlTrimmer
+
+  attr_accessor :source, :scope, :collector_id
+  attr_accessor :virtual, :override, :translated, :catalog, :evaluated
+  attr_accessor :file, :line
+
+  attr_reader :exported, :parameters
+
+  # Determine whether the provided parameter name is a relationship parameter.
+  def self.relationship_parameter?(name)
+    @relationship_names ||= Puppet::Type.relationship_params.collect { |p| p.name }
+    @relationship_names.include?(name)
+  end
+
+  # Set up some boolean test methods
+  def translated?; !!@translated; end
+  def override?;   !!@override;   end
+  def evaluated?;  !!@evaluated;  end
+
+  def [](param)
+    param = param.intern
+    if param == :title
+      return self.title
+    end
+    if @parameters.has_key?(param)
+      @parameters[param].value
+    else
+      nil
+    end
+  end
+
+  def eachparam
+    @parameters.each do |name, param|
+      yield param
+    end
+  end
+
+  def environment
+    scope.environment
+  end
+
+  # Process the  stage metaparameter for a class.   A containment edge
+  # is drawn from  the class to the stage.   The stage for containment
+  # defaults to main, if none is specified.
+  def add_edge_to_stage
+    return unless self.class?
+
+    unless stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
+      raise ArgumentError, "Could not find stage #{self[:stage] || :main} specified by #{self}"
+    end
+
+    self[:stage] ||= stage.title unless stage.title == :main
+    catalog.add_edge(stage, self)
+  end
+
+  # Retrieve the associated definition and evaluate it.
+  def evaluate
+    return if evaluated?
+    Puppet::Util::Profiler.profile("Evaluated resource #{self}", [:compiler, :evaluate_resource, self]) do
+      @evaluated = true
+      if builtin_type?
+        devfail "Cannot evaluate a builtin type (#{type})"
+      elsif resource_type.nil?
+        self.fail "Cannot find definition #{type}"
+      else
+        finish_evaluation() # do not finish completely (as that destroys Sensitive data)
+        resource_type.evaluate_code(self)
+      end
+    end
+  end
+
+  # Mark this resource as both exported and virtual,
+  # or remove the exported mark.
+  def exported=(value)
+    if value
+      @virtual = true
+      @exported = value
+    else
+      @exported = value
+    end
+  end
+
+  # Finish the evaluation by assigning defaults and scope tags
+  # @api private
+  #
+  def finish_evaluation
+    return if @evaluation_finished
+    add_defaults
+    add_scope_tags
+    @evaluation_finished = true
+  end
+
+  # Do any finishing work on this object, called before
+  # storage/translation. The method does nothing the second time
+  # it is called on the same resource.
+  #
+  # @param do_validate [Boolean] true if validation should be performed
+  #
+  # @api private
+  def finish(do_validate = true)
+    return if finished?
+    @finished = true
+    finish_evaluation
+    replace_sensitive_data
+    validate if do_validate
+  end
+
+  # Has this resource already been finished?
+  def finished?
+    @finished
+  end
+
+  def initialize(type, title, attributes)
+    raise ArgumentError, 'Resources require a hash as last argument' unless attributes.is_a? Hash
+    raise ArgumentError, 'Resources require a scope' unless attributes[:scope]
+    super
+
+    @source ||= scope.source
+  end
+
+  # Is this resource modeling an isomorphic resource type?
+  def isomorphic?
+    if builtin_type?
+      return resource_type.isomorphic?
+    else
+      return true
+    end
+  end
+
+  def is_unevaluated_consumer?
+    # We don't declare a new variable here just to test. Saves memory
+    instance_variable_defined?(:@unevaluated_consumer)
+  end
+
+  def mark_unevaluated_consumer
+    @unevaluated_consumer = true
+  end
+
+  # Merge an override resource in.  This will throw exceptions if
+  # any overrides aren't allowed.
+  def merge(resource)
+    # Test the resource scope, to make sure the resource is even allowed
+    # to override.
+    unless self.source.object_id == resource.source.object_id || resource.source.child_of?(self.source)
+      raise Puppet::ParseError.new("Only subclasses can override parameters", resource.file, resource.line)
+    end
+    # Some of these might fail, but they'll fail in the way we want.
+    resource.parameters.each do |name, param|
+      override_parameter(param)
+    end
+  end
+
+  def name
+    self[:name] || self.title
+  end
+
+  # A temporary occasion, until I get paths in the scopes figured out.
+  alias path to_s
+
+  # Define a parameter in our resource.
+  # if we ever receive a parameter named 'tag', set
+  # the resource tags with its value.
+  def set_parameter(param, value = nil)
+    if ! param.is_a?(Puppet::Parser::Resource::Param)
+      param = param.name if param.is_a?(Puppet::Pops::Resource::Param)
+      param = Puppet::Parser::Resource::Param.new(
+        :name => param, :value => value, :source => self.source
+      )
+    end
+
+    tag(*param.value) if param.name == :tag
+
+    # And store it in our parameter hash.
+    @parameters[param.name] = param
+  end
+  alias []= set_parameter
+
+  def to_hash
+    @parameters.reduce({}) do |result, (_, param)|
+      value = param.value
+      value = (:undef == value) ? nil : value
+
+      unless value.nil?
+        case param.name
+        when :before, :subscribe, :notify, :require
+          if value.is_a?(Array)
+            value = value.flatten.reject {|v| v.nil? || :undef == v }
+          end
+          result[param.name] = value
+        else
+          result[param.name] = value
+        end
+      end
+      result
+    end
+  end
+
+  # Convert this resource to a RAL resource.
+  def to_ral
+    copy_as_resource.to_ral
+  end
+
+  # Answers if this resource is tagged with at least one of the tags given in downcased string form.
+  #
+  # The method is a faster variant of the tagged? method that does no conversion of its
+  # arguments.
+  #
+  # The match takes into account the tags that a resource will inherit from its container
+  # but have not been set yet.
+  # It does *not* take tags set via resource defaults as these will *never* be set on
+  # the resource itself since all resources always have tags that are automatically
+  # assigned.
+  #
+  # @param tag_array [Array[String]] list tags to look for
+  # @return [Boolean] true if this instance is tagged with at least one of the provided tags
+  #
+  def raw_tagged?(tag_array)
+    super || ((scope_resource = scope.resource) && !scope_resource.equal?(self) && scope_resource.raw_tagged?(tag_array))
+  end
+
+  # Fills resource params from a capability
+  #
+  # This backs 'consumes => Sql[one]'
+  # @api private
+  def add_parameters_from_consume
+    return if self[:consume].nil?
+
+    map = {}
+    [ self[:consume] ].flatten.map do |ref|
+      # Assert that the ref really is a resource reference
+      raise Puppet::Error, "Invalid consume in #{self.ref}: #{ref} is not a resource" unless ref.is_a?(Puppet::Resource)
+
+      # Resolve references
+      t = ref.type
+      t = Puppet::Pops::Evaluator::Runtime3ResourceSupport.find_resource_type(scope, t) unless t == 'class' || t == 'node'
+      cap = catalog.resource(t, ref.title)
+      if cap.nil?
+        raise "Resource #{ref} could not be found; it might not have been produced yet"
+      end
+
+      # Ensure that the found resource is a capability resource
+      raise Puppet::Error, "Invalid consume in #{ref}: #{cap} is not a capability resource" unless cap.resource_type.is_capability?
+      cap
+    end.each do |cns|
+      # Establish mappings
+      blueprint = resource_type.consumes.find do |bp|
+        bp[:capability] == cns.type
+      end
+      # @todo lutter 2015-08-03: catch this earlier, can we do this during
+      # static analysis ?
+      raise "Resource #{self} tries to consume #{cns} but no 'consumes' mapping exists for #{self.resource_type} and #{cns.type}" unless blueprint
+
+      # setup scope that has, for each attr of cns, a binding to cns[attr]
+      scope.with_global_scope do |global_scope|
+        cns_scope = global_scope.newscope(:source => self, :resource => self)
+        cns.to_hash.each { |name, value| cns_scope[name.to_s] = value }
+
+        # evaluate mappings in that scope
+        resource_type.arguments.keys.each do |name|
+          if expr = blueprint[:mappings][name]
+            # Explicit mapping
+            value = expr.safeevaluate(cns_scope)
+          else
+            value = cns[name]
+          end
+          unless value.nil?
+            # @todo lutter 2015-07-01: this should be caught by the checker
+            # much earlier. We consume several capres, at least two of which
+            # want to map to the same parameter (PUP-5080)
+            raise "Attempt to reassign attribute '#{name}' in '#{self}' caused by multiple consumed mappings to the same attribute" if map[name]
+            map[name] = value
+          end
+        end
+      end
+    end
+
+    map.each { |name, value| self[name] = value if self[name].nil? }
+  end
+
+  def offset
+    nil
+  end
+
+  def pos
+    nil
+  end
+
+  private
+
+  # Add default values from our definition.
+  def add_defaults
+    scope.lookupdefaults(self.type).each do |name, param|
+      unless @parameters.include?(name)
+        self.debug "Adding default for #{name}"
+
+        @parameters[name] = param.dup
+      end
+    end
+  end
+
+  def add_scope_tags
+    scope_resource = scope.resource
+    unless scope_resource.nil? || scope_resource.equal?(self)
+      merge_tags(scope_resource)
+    end
+  end
+
+  def replace_sensitive_data
+    parameters.each_pair do |name, param|
+      if param.value.is_a?(Puppet::Pops::Types::PSensitiveType::Sensitive)
+        @sensitive_parameters << name
+        param.value = param.value.unwrap
+      end
+    end
+  end
+
+  # Accept a parameter from an override.
+  def override_parameter(param)
+    # This can happen if the override is defining a new parameter, rather
+    # than replacing an existing one.
+    (set_parameter(param) and return) unless current = @parameters[param.name]
+
+    # The parameter is already set.  Fail if they're not allowed to override it.
+    unless param.source.child_of?(current.source)
+      msg = "Parameter '#{param.name}' is already set on #{self}"
+      msg += " by #{current.source}" if current.source.to_s != ""
+      if current.file or current.line
+        fields = []
+        fields << current.file if current.file
+        fields << current.line.to_s if current.line
+        msg += " at #{fields.join(":")}"
+      end
+      msg += "; cannot redefine"
+      raise Puppet::ParseError.new(msg, param.file, param.line)
+    end
+
+    # If we've gotten this far, we're allowed to override.
+
+    # Merge with previous value, if the parameter was generated with the +>
+    # syntax.  It's important that we use a copy of the new param instance
+    # here, not the old one, and not the original new one, so that the source
+    # is registered correctly for later overrides but the values aren't
+    # implicitly shared when multiple resources are overridden at once (see
+    # ticket #3556).
+    if param.add
+      param = param.dup
+      param.value = [current.value, param.value].flatten
+    end
+
+    set_parameter(param)
+  end
+
+  # Make sure the resource's parameters are all valid for the type.
+  def validate
+    if builtin_type?
+      begin
+        @parameters.each { |name, value| validate_parameter(name) }
+      rescue => detail
+        self.fail Puppet::ParseError, detail.to_s + " on #{self}", detail
+      end
+    else
+      resource_type.validate_resource(self)
+    end
+  end
+
+  def extract_parameters(params)
+    params.each do |param|
+      # Don't set the same parameter twice
+      self.fail Puppet::ParseError, "Duplicate parameter '#{param.name}' for on #{self}" if @parameters[param.name]
+
+      set_parameter(param)
+    end
+  end
+end

data/vendor/pup410/lib/puppet/parser/scope.rb

@@ -0,0 +1,1138 @@
+
+# The scope class, which handles storing and retrieving variables and types and
+# such.
+require 'forwardable'
+
+require 'puppet/parser'
+require 'puppet/parser/templatewrapper'
+
+require 'puppet/util/methodhelper'
+
+# 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.
+#
+# @api public
+class Puppet::Parser::Scope
+  extend Forwardable
+  include Puppet::Util::MethodHelper
+
+  require 'puppet/parser/resource'
+
+  AST = Puppet::Parser::AST
+
+  # Variables that always exist with nil value even if not set
+  BUILT_IN_VARS = ['module_name'.freeze, 'caller_module_name'.freeze].freeze
+  EMPTY_HASH = {}.freeze
+
+  Puppet::Util.logmethods(self)
+
+  include Puppet::Util::Errors
+  attr_accessor :source, :resource
+  attr_accessor :compiler
+  attr_accessor :parent
+  attr_reader :namespaces
+
+  # Hash of hashes of default values per type name
+  attr_reader :defaults
+
+  # Add some alias methods that forward to the compiler, since we reference
+  # them frequently enough to justify the extra method call.
+  def_delegators :compiler, :catalog, :environment
+
+
+  # Abstract base class for LocalScope and MatchScope
+  #
+  class Ephemeral
+
+    attr_reader :parent
+
+    def initialize(parent = nil)
+      @parent = parent
+    end
+
+    def is_local_scope?
+      false
+    end
+
+    def [](name)
+      if @parent
+        @parent[name]
+      end
+    end
+
+    def include?(name)
+      (@parent and @parent.include?(name))
+    end
+
+    def bound?(name)
+      false
+    end
+
+    def add_entries_to(target = {})
+      @parent.add_entries_to(target) unless @parent.nil?
+      # do not include match data ($0-$n)
+      target
+    end
+  end
+
+  class LocalScope < Ephemeral
+
+    def initialize(parent=nil)
+      super parent
+      @symbols = {}
+    end
+
+    def [](name)
+      val = @symbols[name]
+      val.nil? && !@symbols.include?(name) ? super : val
+    end
+
+    def is_local_scope?
+      true
+    end
+
+    def []=(name, value)
+      @symbols[name] = value
+    end
+
+    def include?(name)
+      bound?(name) || super
+    end
+
+    def delete(name)
+      @symbols.delete(name)
+    end
+
+    def bound?(name)
+      @symbols.include?(name)
+    end
+
+    def add_entries_to(target = {})
+      super
+      @symbols.each do |k, v|
+        if v == :undef || v.nil?
+          target.delete(k)
+        else
+          target[ k ] = v
+        end
+      end
+      target
+    end
+  end
+
+  class MatchScope < Ephemeral
+
+    attr_accessor :match_data
+
+    def initialize(parent = nil, match_data = nil)
+      super parent
+      @match_data = match_data
+    end
+
+    def is_local_scope?
+      false
+    end
+
+    def [](name)
+      if bound?(name)
+        @match_data[name.to_i]
+      else
+        super
+      end
+    end
+
+    def include?(name)
+      bound?(name) or super
+    end
+
+    def bound?(name)
+      # A "match variables" scope reports all numeric variables to be bound if the scope has
+      # match_data. Without match data the scope is transparent.
+      #
+      @match_data && name =~ /^\d+$/
+    end
+
+    def []=(name, value)
+      # TODO: Bad choice of exception
+      raise Puppet::ParseError, "Numerical variables cannot be changed. Attempt to set $#{name}"
+    end
+
+    def delete(name)
+      # TODO: Bad choice of exception
+      raise Puppet::ParseError, "Numerical variables cannot be deleted: Attempt to delete: $#{name}"
+    end
+
+    def add_entries_to(target = {})
+      # do not include match data ($0-$n)
+      super
+    end
+
+  end
+
+  # @api private
+  class ParameterScope < Ephemeral
+    class Access
+      attr_accessor :value
+
+      def assigned?
+        instance_variable_defined?(:@value)
+      end
+    end
+
+    # A parameter default must be evaluated using a special scope. The scope that is given to this method must
+    # have a `ParameterScope` as its last ephemeral scope. This method will then push a `MatchScope` while the
+    # given `expression` is evaluated. The method will catch any throw of `:unevaluated_parameter` and produce
+    # an error saying that the evaluated parameter X tries to access the unevaluated parameter Y.
+    #
+    # @param name [String] the name of the currently evaluated parameter
+    # @param expression [Puppet::Parser::AST] the expression to evaluate
+    # @param scope [Puppet::Parser::Scope] a scope where a `ParameterScope` has been pushed
+    # @return [Object] the result of the evaluation
+    #
+    # @api private
+    def evaluate3x(name, expression, scope)
+      scope.with_guarded_scope do
+        bad = catch(:unevaluated_parameter) do
+          scope.new_match_scope(nil)
+          return as_read_only { expression.safeevaluate(scope) }
+        end
+        parameter_reference_failure(name, bad)
+      end
+    end
+
+    def evaluate(name, expression, scope, evaluator)
+      scope.with_guarded_scope do
+        bad = catch(:unevaluated_parameter) do
+          scope.new_match_scope(nil)
+          return as_read_only { evaluator.evaluate(expression, scope) }
+        end
+        parameter_reference_failure(name, bad)
+      end
+    end
+
+    def parameter_reference_failure(from, to)
+      # Parameters are evaluated in the order they have in the @params hash.
+      keys = @params.keys
+      raise Puppet::Error, "#{@callee_name}: expects a value for parameter $#{to}" if keys.index(to) < keys.index(from)
+      raise Puppet::Error, "#{@callee_name}: default expression for $#{from} tries to illegally access not yet evaluated $#{to}"
+    end
+    private :parameter_reference_failure
+
+    def initialize(parent, callee_name, param_names)
+      super(parent)
+      @callee_name = callee_name
+      @params = {}
+      param_names.each { |name| @params[name] = Access.new }
+    end
+
+    def [](name)
+      access = @params[name]
+      return super if access.nil?
+      throw(:unevaluated_parameter, name) unless access.assigned?
+      access.value
+    end
+
+    def []=(name, value)
+      raise Puppet::Error, "Attempt to assign variable #{name} when evaluating parameters" if @read_only
+      @params[name] ||= Access.new
+      @params[name].value = value
+    end
+
+    def bound?(name)
+      @params.include?(name)
+    end
+
+    def include?(name)
+      @params.include?(name) || super
+    end
+
+    def is_local_scope?
+      true
+    end
+
+    def as_read_only
+      read_only = @read_only
+      @read_only = true
+      begin
+        yield
+      ensure
+        @read_only = read_only
+      end
+    end
+
+    def to_hash
+      Hash[@params.select {|_, access| access.assigned? }.map { |name, access| [name, access.value] }]
+    end
+  end
+
+
+  # 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.
+  #
+  def include?(name)
+    catch(:undefined_variable) {
+      return ! self[name].nil?
+    }
+    false
+  end
+
+  # Returns true if the variable of the given name is set to any value (including nil)
+  #
+  # @return [Boolean] if variable exists or not
+  #
+  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
+
+  # Returns true if the given name is bound in the current (most nested) scope for assignments.
+  #
+  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
+
+  # Is the value true?  This allows us to control the definition of truth
+  # in one place.
+  def self.true?(value)
+    case value
+    when ''
+      false
+    when :undef
+      false
+    else
+      !!value
+    end
+  end
+
+  # Coerce value to a number, or return `nil` if it isn't one.
+  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
+
+  def find_hostclass(name)
+    environment.known_resource_types.find_hostclass(name)
+  end
+
+  def find_definition(name)
+    environment.known_resource_types.find_definition(name)
+  end
+
+  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
+
+  # This just delegates directly.
+  def_delegator :compiler, :findresource
+
+  # Initialize our new scope.  Defaults to having no parent.
+  def initialize(compiler, options = {})
+    if compiler.is_a? Puppet::Parser::Compiler
+      self.compiler = compiler
+    else
+      raise Puppet::DevError, "you must pass a compiler instance to a new scope object"
+    end
+
+    if n = options.delete(:namespace)
+      @namespaces = [n.freeze].freeze
+    else
+      @namespaces = ["".freeze].freeze
+    end
+
+    raise Puppet::DevError, "compiler passed in options" if options.include? :compiler
+    set_options(options)
+
+    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
+
+  # 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.
+  def class_set(name, scope)
+    if parent
+      parent.class_set(name, scope)
+    else
+      @class_scopes[name] = scope
+    end
+  end
+
+  # 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.
+  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
+
+  # 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
+  #
+  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
+
+  # Look up a defined type.
+  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
+
+  def undef_as(x,v)
+    if v.nil? or v == :undef
+      x
+    else
+      v
+    end
+  end
+
+  # Lookup a variable within this scope using the Puppet language's
+  # scoping rules. Variables can be qualified using just as in a
+  # manifest.
+  #
+  # @param [String] name the variable name to lookup
+  #
+  # @return Object the value of the variable, or if not found; nil if `strict_variables` is false, and thrown :undefined_variable otherwise
+  #
+  # @api public
+  def lookupvar(name, options = EMPTY_HASH)
+    unless name.is_a? String
+      raise Puppet::ParseError, "Scope variable name #{name.inspect} is a #{name.class}, not a string"
+    end
+
+    if name =~ /^(.*)::(.+)$/
+      return lookup_qualified_variable($1, $2, options)
+    end
+
+    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, options)
+    else
+      variable_not_found(name)
+    end
+  end
+
+  UNDEFINED_VARIABLES_KIND = 'undefined_variables'.freeze
+  DEPRECATION_KIND = 'deprecation'.freeze
+
+  # 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)
+  #
+  UNCAUGHT_THROW_EXCEPTION = defined?(UncaughtThrowError) ? UncaughtThrowError : ArgumentError
+
+  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}",
+        "Undefined variable '#{name}'; #{reason}" )
+      when :error
+        raise ArgumentError, "Undefined variable '#{name}'; #{reason}"
+      end
+    end
+    nil
+  end
+
+  # 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.
+  #
+  # @param varname [String] the name of the variable (may be a qualified name using `(ns'::')*varname`
+  # @param options [Hash] Additional options, not part of api.
+  # @return [Object] the value assigned to the given varname
+  # @see #[]=
+  # @api public
+  #
+  def [](varname, options={})
+    lookupvar(varname, options)
+  end
+
+  # The scope of the inherited thing of this scope's resource. This could
+  # either be a node that was inherited or the class.
+  #
+  # @return [Puppet::Parser::Scope] The scope or nil if there is not an inherited scope
+  def inherited_scope
+    if has_inherited_class?
+      qualified_scope(resource.resource_type.parent)
+    else
+      nil
+    end
+  end
+
+  # 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
+  #
+  # @return [Puppet::Parser::Scope] The scope or nil if there is no enclosing scope
+  def enclosing_scope
+    if has_enclosing_scope?
+      if parent.is_topscope? or parent.is_nodescope?
+        parent
+      else
+        parent.enclosing_scope
+      end
+    else
+      nil
+    end
+  end
+
+  def is_classscope?
+    resource and resource.type == "Class"
+  end
+
+  def is_nodescope?
+    resource and resource.type == "Node"
+  end
+
+  def is_topscope?
+    @compiler && equal?(@compiler.topscope)
+  end
+
+  def lookup_qualified_variable(class_name, variable_name, position)
+    begin
+      if lookup_as_local_name?(class_name, variable_name)
+        if is_topscope?
+          # This is the case where $::x is looked up from within the topscope itself, or from a local scope
+          # parented at the top scope. In this case, the lookup must ignore local and ephemeral scopes.
+          #
+          handle_not_found(class_name, variable_name, position) unless @symtable.include?(variable_name)
+          @symtable[variable_name]
+        else
+          self[variable_name]
+        end
+      else
+        qualified_scope(class_name).lookupvar(variable_name, position)
+      end
+    rescue RuntimeError => e
+      handle_not_found(class_name, variable_name, position, e.message)
+    end
+  end
+
+  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
+
+  # Handles the special case of looking up fully qualified variable in not yet evaluated top scope
+  # This is ok if the lookup request originated in topscope (this happens when evaluating
+  # bindings; using the top scope to provide the values for facts.
+  # @param class_name [String] the classname part of a variable name, may be special ""
+  # @param variable_name [String] the variable name without the absolute leading '::'
+  # @return [Boolean] true if the given variable name should be looked up directly in this scope
+  #
+  def lookup_as_local_name?(class_name, variable_name)
+    # not a local if name has more than one segment
+    return nil if variable_name =~ /::/
+    # partial only if the class for "" cannot be found
+    return nil unless class_name == "" && klass = find_hostclass(class_name) && class_scope(klass).nil?
+    is_topscope?
+  end
+
+  def has_inherited_class?
+    is_classscope? and resource.resource_type.parent
+  end
+  private :has_inherited_class?
+
+  def has_enclosing_scope?
+    not parent.nil?
+  end
+  private :has_enclosing_scope?
+
+  def qualified_scope(classname)
+    raise "class #{classname} could not be found"     unless klass = find_hostclass(classname)
+    raise "class #{classname} has not been evaluated" unless kscope = class_scope(klass)
+    kscope
+  end
+  private :qualified_scope
+
+  # 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.
+  #
+  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
+
+  def namespaces
+    @namespaces
+  end
+
+  # Create a new scope and set these options.
+  def newscope(options = {})
+    compiler.newscope(self, options)
+  end
+
+  def parent_module_name
+    return nil unless @parent
+    return nil unless @parent.source
+    @parent.source.module_name
+  end
+
+  # 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.
+  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.name} }; cannot redefine", param.file, param.line)
+      end
+      table[param.name] = param
+    }
+  end
+
+  # Merge all settings for the given _env_name_ into this scope
+  # @param env_name [Symbol] the name of the environment
+  def merge_settings(env_name)
+    settings = Puppet.settings
+    table = effective_symtable(false)
+    settings.each_key do |name|
+      next if :name == name
+      table[name.to_s] = transform_setting(settings.value_sym(name, env_name))
+    end
+    nil
+  end
+
+  def transform_setting(val)
+    if val.is_a?(String) || val.is_a?(Numeric) || true == val || false == val || nil == val
+      val
+    elsif val.is_a?(Array)
+      val.map {|entry| transform_setting(entry) }
+    elsif val.is_a?(Hash)
+      result = {}
+      val.each {|k,v| result[transform_setting(k)] = transform_setting(v) }
+      result
+    else
+      # not ideal, but required as there are settings values that are special
+      :undef == val ? nil : val.to_s
+    end
+  end
+  private :transform_setting
+
+  VARNAME_TRUSTED = 'trusted'.freeze
+  VARNAME_FACTS = 'facts'.freeze
+  VARNAME_SERVER_FACTS = 'server_facts'.freeze
+  RESERVED_VARIABLE_NAMES = [VARNAME_TRUSTED, VARNAME_FACTS].freeze
+
+  # 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.
+  def setvar(name, value, options = EMPTY_HASH)
+    if name =~ /^[0-9]+$/
+      raise Puppet::ParseError.new("Cannot assign to a numeric match result variable '$#{name}'") # unless options[:ephemeral]
+    end
+    unless name.is_a? String
+      raise Puppet::ParseError, "Scope variable name #{name.inspect} is a #{name.class}, not a string"
+    end
+
+    # Check for reserved variable names
+    if (name == VARNAME_TRUSTED || name == VARNAME_FACTS) && !options[:privileged]
+      raise Puppet::ParseError, "Attempt to assign to a reserved variable name: '#{name}'"
+    end
+
+    # Check for server_facts reserved variable name if the trusted_sever_facts setting is true
+    if name == VARNAME_SERVER_FACTS && !options[:privileged] && Puppet[:trusted_server_facts]
+      raise Puppet::ParseError, "Attempt to assign to a reserved variable name: '#{name}'"
+    end
+
+    table = effective_symtable(options[:ephemeral])
+    if table.bound?(name)
+      if options[:append]
+        error = Puppet::ParseError.new("Cannot append, variable '$#{name}' is defined in this scope")
+      else
+        error = Puppet::ParseError.new("Cannot reassign variable '$#{name}'")
+      end
+      error.file = options[:file] if options[:file]
+      error.line = options[:line] if options[:line]
+      raise error
+    end
+
+    if options[:append]
+      # produced result (value) is the resulting appended value, note: the table[]= does not return the value
+      table[name] = (value = append_value(undef_as('', self[name]), value))
+    else
+      table[name] = value
+    end
+    value
+  end
+
+  def set_trusted(hash)
+    setvar('trusted', deep_freeze(hash), :privileged => true)
+  end
+
+  def set_facts(hash)
+    setvar('facts', deep_freeze(hash), :privileged => true)
+  end
+
+  def set_server_facts(hash)
+    setvar('server_facts', deep_freeze(hash), :privileged => true)
+  end
+
+  # Deeply freezes the given object. The object and its content must be of the types:
+  # Array, Hash, Numeric, Boolean, Symbol, Regexp, NilClass, or String. All other types raises an Error.
+  # (i.e. if they are assignable to Puppet::Pops::Types::Data type).
+  #
+  def deep_freeze(object)
+    case object
+    when Array
+      object.each {|v| deep_freeze(v) }
+      object.freeze
+    when Hash
+      object.each {|k, v| deep_freeze(k); deep_freeze(v) }
+      object.freeze
+    when NilClass, Numeric, TrueClass, FalseClass
+      # do nothing
+    when String
+      object.freeze
+    else
+      raise Puppet::Error, "Unsupported data type: '#{object.class}'"
+    end
+    object
+  end
+  private :deep_freeze
+
+  # 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).
+  #
+  # @param use_ephemeral [Boolean] whether the top most ephemeral (of any kind) should be used or not
+  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
+
+  # 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.
+  #
+  # @param varname [String] The variable name to which the value is assigned. Must not contain `::`
+  # @param value [String] The value to assign to the given variable name.
+  # @param options [Hash] Additional options, not part of api and no longer used.
+  #
+  # @api public
+  #
+  def []=(varname, value, _ = nil)
+    setvar(varname, value)
+  end
+
+  def append_value(bound_value, new_value)
+    case new_value
+    when Array
+      bound_value + new_value
+    when Hash
+      bound_value.merge(new_value)
+    else
+      if bound_value.is_a?(Hash)
+        raise ArgumentError, "Trying to append to a hash with something which is not a hash is unsupported"
+      end
+      bound_value + new_value
+    end
+  end
+  private :append_value
+
+  # Return the tags associated with this scope.
+  def_delegator :resource, :tags
+
+  # Used mainly for logging
+  def to_s
+    "Scope(#{@resource})"
+  end
+
+  alias_method :inspect, :to_s
+
+  # Pop ephemeral scopes up to level and return them
+  #
+  # @deprecated use #pop_epehemeral
+  # @api private
+  def unset_ephemeral_var(level=:all)
+    Puppet.deprecation_warning('Method Parser::Scope#unset_ephemeral_var() is deprecated')
+    if level == :all
+      @ephemeral = [ MatchScope.new(@symtable, nil)]
+    else
+      @ephemeral.pop(@ephemeral.size - level)
+    end
+  end
+
+  # Pop ephemeral scopes up to level and return them
+  #
+  # @param level [Fixnum] a positive integer
+  # @return [Array] the removed ephemeral scopes
+  # @api private
+  def pop_ephemerals(level)
+    @ephemeral.pop(@ephemeral.size - level)
+  end
+
+  # Push ephemeral scopes onto the ephemeral scope stack
+  # @param ephemeral_scopes [Array]
+  # @api private
+  def push_ephemerals(ephemeral_scopes)
+    ephemeral_scopes.each { |ephemeral_scope| @ephemeral.push(ephemeral_scope) } unless ephemeral_scopes.nil?
+  end
+
+  def ephemeral_level
+    @ephemeral.size
+  end
+
+  # TODO: Who calls this?
+  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
+
+  # Execute given block in global scope with no ephemerals present
+  #
+  # @yieldparam [Scope] global_scope the global and ephemeral less scope
+  # @return [Object] the return of the block
+  #
+  # @api private
+  def with_global_scope(&block)
+    find_global_scope.without_ephemeral_scopes(&block)
+  end
+
+  # Execute given block with a ephemeral scope containing the given variables
+  # @api private
+  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
+
+  # Execute given block with all ephemeral popped from the ephemeral stack
+  #
+  # @api private
+  def without_ephemeral_scopes
+    save_ephemeral = @ephemeral
+    begin
+      @ephemeral = [ @symtable ]
+      yield(self)
+    ensure
+      @ephemeral = save_ephemeral
+    end
+  end
+
+  # Nests a parameter scope
+  # @param [String] callee_name the name of the function, template, or resource that defines the parameters
+  # @param [Array<String>] param_names list of parameter names
+  # @yieldparam [ParameterScope] param_scope the nested scope
+  # @api private
+  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
+
+  # Execute given block and ensure that ephemeral level is restored
+  #
+  # @return [Object] the return of the block
+  #
+  # @api private
+  def with_guarded_scope
+    elevel = ephemeral_level
+    begin
+      yield
+    ensure
+      pop_ephemerals(elevel)
+    end
+  end
+
+  # Sets match data in the most nested scope (which always is a MatchScope), it clobbers match data already set there
+  #
+  def set_match_data(match_data)
+    @ephemeral.last.match_data = match_data
+  end
+
+  # Nests a match data scope
+  def new_match_scope(match_data)
+    @ephemeral.push(MatchScope.new(@ephemeral.last, match_data))
+  end
+
+  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 #{match.class}") unless match.is_a?(MatchData)
+      # Create a match ephemeral and set values from match data
+      new_match_scope(match)
+    end
+  end
+
+  # @api private
+  def find_resource_type(type)
+    raise Puppet::DevError, "Scope#find_resource_type() is no longer supported, use Puppet::Pops::Evaluator::Runtime3ResourceSupport instead"
+  end
+
+  # @api private
+  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
+
+  # @api private
+  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
+
+
+  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
+
+  # Called from two places:
+  # runtime3support when creating resources
+  # ast::resource - used by create resources ?
+  # @api private
+  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"
+
+#    Puppet.deprecation_warning('Scope#resolve_type_and_titles is deprecated.')
+#
+#    raise ArgumentError, "titles must be an array" unless titles.is_a?(Array)
+#
+#    case type.downcase
+#    when "class"
+#      # resolve the titles
+#      titles = titles.collect do |a_title|
+#        hostclass = find_hostclass(a_title)
+#        hostclass ?  hostclass.name : a_title
+#      end
+#    when "node"
+#      # no-op
+#    else
+#      # resolve the type
+#      resource_type = find_resource_type(type)
+#      type = resource_type.name if resource_type
+#    end
+#
+#    return [type, titles]
+  end
+
+  # 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).
+  #
+  #
+  # @param names [Array<String>] names to (optionally) make absolute
+  # @return [Array<String>] names after transformation
+  #
+  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::PHostClassType
+        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
+
+  # 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.
+  #
+  # @return [Object] the result of the called function
+  # @raise ArgumentError if the function does not exist
+  def call_function(func_name, args, &block)
+    Puppet::Pops::Parser::EvaluatingParser.new.evaluator.external_call_function(func_name, args, self, &block)
+  end
+
+  private
+
+  def assert_class_and_title(type_name, title)
+    if type_name.nil? || type_name == ''
+      raise ArgumentError, "Cannot use an unspecific Resource[] where a Resource['class', name] is expected"
+    end
+    unless type_name =~ /^[Cc]lass$/
+      raise ArgumentError, "Cannot use a Resource[#{type_name}] where a Resource['class', name] is expected"
+    end
+    if title.nil?
+      raise ArgumentError, "Cannot use an unspecific Resource['class'] where a Resource['class', name] is expected"
+    end
+  end
+
+  def extend_with_functions_module
+    root = Puppet.lookup(:root_environment)
+    extend Puppet::Parser::Functions.environment_module(root)
+    extend Puppet::Parser::Functions.environment_module(environment) if environment != root
+  end
+end