bolt 0.24.0 → 0.25.0

data/vendored/puppet/lib/puppet/parser/functions/tag.rb

@@ -1,12 +0,0 @@
-# Tag the current scope with each passed name
-Puppet::Parser::Functions::newfunction(:tag, :arity => -2, :doc => "Add the specified tags to the containing class
-  or definition.  All contained objects will then acquire that tag, also.
-  ") do |vals|
-    if Puppet[:tasks]
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
-        {:operation => 'tag'})
-    end
-
-    self.resource.tag(*vals)
-end

data/vendored/puppet/lib/puppet/parser/functions/tagged.rb

@@ -1,21 +0,0 @@
-# Test whether a given tag is set.  This functions as a big OR -- if any of the specified tags are unset, we return false.
-Puppet::Parser::Functions::newfunction(:tagged, :type => :rvalue, :arity => -2, :doc => "A boolean function that
-  tells you whether the current container is tagged with the specified tags.
-  The tags are ANDed, so that all of the specified tags must be included for
-  the function to return true.") do |vals|
-    if Puppet[:tasks]
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::CATALOG_OPERATION_NOT_SUPPORTED_WHEN_SCRIPTING,
-        {:operation => 'tagged'})
-    end
-
-    retval = true
-    vals.each do |val|
-      unless compiler.catalog.tagged?(val) or resource.tagged?(val)
-        retval = false
-        break
-      end
-    end
-
-    return retval
-end

data/vendored/puppet/lib/puppet/parser/functions/template.rb

@@ -1,39 +0,0 @@
-Puppet::Parser::Functions::newfunction(:template, :type => :rvalue, :arity => -2, :doc =>
-  "Loads an ERB template from a module, evaluates it, and returns the resulting
-  value as a string.
-
-  The argument to this function should be a `<MODULE NAME>/<TEMPLATE FILE>`
-  reference, which will load `<TEMPLATE FILE>` from a module's `templates`
-  directory. (For example, the reference `apache/vhost.conf.erb` will load the
-  file `<MODULES DIRECTORY>/apache/templates/vhost.conf.erb`.)
-
-  This function can also accept:
-
-  * An absolute path, which can load a template file from anywhere on disk.
-  * Multiple arguments, which will evaluate all of the specified templates and
-  return their outputs concatenated into a single string.") do |vals|
-    if Puppet[:tasks]
-      raise Puppet::ParseErrorWithIssue.from_issue_and_stack(
-        Puppet::Pops::Issues::FEATURE_NOT_SUPPORTED_WHEN_SCRIPTING,
-        {:feature => 'ERB template'})
-    end
-    vals.collect do |file|
-      # Use a wrapper, so the template can't get access to the full
-      # Scope object.
-      debug "Retrieving template #{file}"
-
-      wrapper = Puppet::Parser::TemplateWrapper.new(self)
-      wrapper.file = file
-      begin
-        wrapper.result
-      rescue => detail
-        info = detail.backtrace.first.split(':')
-        message = []
-        message << _("Failed to parse template %{file}:") % { file: file }
-        message << _("  Filepath: %{file_path}") % { file_path: info[0] }
-        message << _("  Line: %{line}") % { line: info[1] }
-        message << _("  Detail: %{detail}") % { detail: detail }
-        raise Puppet::ParseError, message.join("\n") + "\n"
-      end
-    end.join("")
-end

data/vendored/puppet/lib/puppet/parser/functions/then.rb

@@ -1,73 +0,0 @@
-Puppet::Parser::Functions::newfunction(
-  :then,
-  :type => :rvalue,
-  :arity => -2,
-  :doc => <<-DOC
-Call a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
-with the given argument unless the argument is undef. Return `undef` if argument is
-`undef`, and otherwise the result of giving the argument to the lambda.
-
-This is useful to process a sequence of operations where an intermediate
-result may be `undef` (which makes the entire sequence `undef`).
-The `then` function is especially useful with the function `dig` which
-performs in a similar way "digging out" a value in a complex structure.
-
-**Example:** Using `dig` and `then`
-
-```puppet
-$data = {a => { b => [{x => 10, y => 20}, {x => 100, y => 200}]}}
-notice $data.dig(a, b, 1, x).then |$x| { $x * 2 }
-```
-
-Would notice the value 200
-
-Contrast this with:
-
-```puppet
-$data = {a => { b => [{x => 10, y => 20}, {ex => 100, why => 200}]}}
-notice $data.dig(a, b, 1, x).then |$x| { $x * 2 }
-```
-
-Which would notice `undef` since the last lookup of 'x' results in `undef` which
-is returned (without calling the lambda given to the `then` function).
-
-As a result there is no need for conditional logic or a temporary (non local)
-variable as the result is now either the wanted value (`x`) multiplied
-by 2 or `undef`.
-
-Calls to `then` can be chained. In the next example, a structure is using an offset based on
-using 1 as the index to the first element (instead of 0 which is used in the language).
-We are not sure if user input actually contains an index at all, or if it is
-outside the range of available names.args.
-
-**Example:** Chaining calls to the `then` function
-
-```puppet
-# Names to choose from
-$names = ['Ringo', 'Paul', 'George', 'John']
-
-# Structure where 'beatle 2' is wanted (but where the number refers
-# to 'Paul' because input comes from a source using 1 for the first
-# element).
-
-$data = ['singer', { beatle => 2 }]
-$picked = assert_type(String,
-  # the data we are interested in is the second in the array,
-  # a hash, where we want the value of the key 'beatle'
-  $data.dig(1, 'beatle')
-    # and we want the index in $names before the given index
-    .then |$x| { $names[$x-1] }
-    # so we can construct a string with that beatle's name
-    .then |$x| { "Picked Beatle '${x}'" }
-)
-```
-
-Would notice "Picked Beatle 'Paul'", and would raise an error if the result
-was not a String.
-
-* Since 4.5.0
-
-DOC
-) do |args|
-  Puppet::Parser::Functions::Error.is4x('then')
-end

data/vendored/puppet/lib/puppet/parser/functions/type.rb

@@ -1,53 +0,0 @@
-Puppet::Parser::Functions::newfunction(
-  :type,
-  :type => :rvalue,
-  :arity => -1,
-  :doc => <<-DOC
-Returns the data type of a given value with a given degree of generality.
-
-```puppet
-type InferenceFidelity = Enum[generalized, reduced, detailed]
-
-function type(Any $value, InferenceFidelity $fidelity = 'detailed') # returns Type
-```
-
- **Example:** Using `type`
-
- ``` puppet
- notice type(42) =~ Type[Integer]
- ```
-
- Would notice `true`.
-
- By default, the best possible inference is made where all details are retained.
- This is good when the type is used for further type calculations but is overwhelmingly
- rich in information if it is used in a error message.
-
- The optional argument `$fidelity` may be given as (from lowest to highest fidelity):
-
- * `generalized` - reduces to common type and drops size constraints
- * `reduced` - reduces to common type in collections
- * `detailed` - (default) all details about inferred types is retained
-
- **Example:** Using `type()` with different inference fidelity:
-
- ``` puppet
- notice type([3.14, 42], 'generalized')
- notice type([3.14, 42], 'reduced'')
- notice type([3.14, 42], 'detailed')
- notice type([3.14, 42])
- ```
-
- Would notice the four values:
-
- 1. 'Array[Numeric]'
- 2. 'Array[Numeric, 2, 2]'
- 3. 'Tuple[Float[3.14], Integer[42,42]]]'
- 4. 'Tuple[Float[3.14], Integer[42,42]]]'
-
- * Since 4.4.0
-
-DOC
-) do |args|
-  Puppet::Parser::Functions::Error.is4x('type')
-end

data/vendored/puppet/lib/puppet/parser/functions/versioncmp.rb

@@ -1,30 +0,0 @@
-require 'puppet/util/package'
-
-Puppet::Parser::Functions::newfunction( :versioncmp, :type => :rvalue, :arity => 2, :doc =>
-"Compares two version numbers.
-
-Prototype:
-
-    \$result = versioncmp(a, b)
-
-Where a and b are arbitrary version strings.
-
-This function returns:
-
-* `1` if version a is greater than version b
-* `0` if the versions are equal
-* `-1` if version a is less than version b
-
-Example:
-
-    if versioncmp('2.6-1', '2.4.5') > 0 {
-        notice('2.6-1 is > than 2.4.5')
-    }
-
-This function uses the same version comparison algorithm used by Puppet's
-`package` type.
-
-") do |args|
-
-  return Puppet::Util::Package.versioncmp(args[0], args[1])
-end

data/vendored/puppet/lib/puppet/parser/functions/with.rb

@@ -1,28 +0,0 @@
-Puppet::Parser::Functions::newfunction(
-  :with,
-  :type => :rvalue,
-  :arity => -1,
-  :doc => <<-DOC
-Call a [lambda](https://puppet.com/docs/puppet/latest/lang_lambdas.html)
-with the given arguments and return the result. Since a lambda's scope is
-local 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/vendored/puppet/lib/puppet/parser/parser_factory.rb

@@ -1,30 +0,0 @@
-module Puppet; end
-
-module Puppet::Parser
-  # The ParserFactory makes selection of parser possible.
-  # Currently, it is possible to switch between two different parsers:
-  # * classic_parser, the parser in 3.1
-  # * eparser, the Expression Based Parser
-  #
-  class ParserFactory
-    # Produces a parser instance for the given environment
-    def self.parser
-      evaluating_parser
-    end
-
-    # Creates an instance of an E4ParserAdapter that adapts an
-    # EvaluatingParser to the 3x way of parsing.
-    #
-    def self.evaluating_parser
-      unless defined?(Puppet::Parser::E4ParserAdapter)
-        require 'puppet/parser/e4_parser_adapter'
-        require 'puppet/pops/parser/code_merger'
-      end
-      E4ParserAdapter.new
-    end
-
-    def self.code_merger
-      Puppet::Pops::Parser::CodeMerger.new
-    end
-  end
-end

data/vendored/puppet/lib/puppet/parser/relationship.rb

@@ -1,83 +0,0 @@
-class Puppet::Parser::Relationship
-  attr_accessor :source, :target, :type
-
-  PARAM_MAP = {:relationship => :before, :subscription => :notify}
-
-  def arrayify(resources, left)
-    case resources
-    when Puppet::Pops::Evaluator::Collectors::AbstractCollector
-      # on the LHS, go as far left as possible, else whatever the collected result is
-      left ? leftmost_alternative(resources) : resources.collected.values
-    when Array
-      resources
-    else
-      [resources]
-    end
-  end
-
-  def evaluate(catalog)
-    arrayify(source, true).each do |s|
-      arrayify(target, false).each do |t|
-        mk_relationship(s, t, catalog)
-      end
-    end
-  end
-
-  def initialize(source, target, type)
-    @source, @target, @type = source, target, type
-  end
-
-  def param_name
-    PARAM_MAP[type] || raise(ArgumentError, _("Invalid relationship type %{relationship_type}") % { relationship_type: type })
-  end
-
-  def mk_relationship(source, target, catalog)
-    source_ref = canonical_ref(source)
-    target_ref = canonical_ref(target)
-    rel_param = param_name
-
-    unless source_resource = catalog.resource(*source_ref)
-      raise ArgumentError, _("Could not find resource '%{source}' for relationship on '%{target}'") % { source: source.to_s, target: target.to_s }
-    end
-    unless catalog.resource(*target_ref)
-      raise ArgumentError, _("Could not find resource '%{target}' for relationship from '%{source}'") % { target: target.to_s, source: source.to_s }
-    end
-    Puppet.debug {"Adding relationship from #{source} to #{target} with '#{param_name}'"}
-    if source_resource[rel_param].class != Array
-      source_resource[rel_param] = [source_resource[rel_param]].compact
-    end
-    source_resource[rel_param] << (target_ref[1].nil? ? target_ref[0] : "#{target_ref[0]}[#{target_ref[1]}]")
-  end
-
-  private
-
-  # Finds the leftmost alternative for a collector (if it is empty, try its empty alternative recursively until there is
-  # either nothing left, or a non empty set is found.
-  #
-  def leftmost_alternative(x)
-    if x.is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
-      collected = x.collected
-      return collected.values unless collected.empty?
-      adapter = Puppet::Pops::Adapters::EmptyAlternativeAdapter.get(x)
-      adapter.nil? ? [] : leftmost_alternative(adapter.empty_alternative)
-    elsif x.is_a?(Array) && x.size == 1 && x[0].is_a?(Puppet::Pops::Evaluator::Collectors::AbstractCollector)
-      leftmost_alternative(x[0])
-    else
-      x
-    end
-  end
-
-  # Turns a PResourceType or PClassType into an array [type, title] and all other references to [ref, nil]
-  # This is needed since it is not possible to find resources in the catalog based on the type system types :-(
-  # (note, the catalog is also used on the agent side)
-  def canonical_ref(ref)
-    case ref
-    when Puppet::Pops::Types::PResourceType
-      [ref.type_name, ref.title]
-    when Puppet::Pops::Types::PClassType
-      ['class', ref.class_name]
-    else
-      [ref.to_s, nil]
-    end
-  end
-end

data/vendored/puppet/lib/puppet/parser/resource.rb

@@ -1,416 +0,0 @@
-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'
-
-  include Puppet::Util
-  include Puppet::Util::Errors
-  include Puppet::Util::Logging
-
-  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 %{stage} specified by %{resource}") % { stage: self[:stage] || :main, resource: 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 %{res}") % { res: 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_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, with_defaults = true)
-    raise ArgumentError, _('Resources require a hash as last argument') unless attributes.is_a? Hash
-    raise ArgumentError, _('Resources require a scope') unless attributes[:scope]
-    super(type, title, attributes)
-
-    @source ||= scope.source
-
-    if with_defaults
-      scope.lookupdefaults(self.type).each_pair do |name, param|
-        unless @parameters.include?(name)
-          self.debug "Adding default for #{name}"
-
-          param = param.dup
-          @parameters[name] = param
-          tag(*param.value) if param.name == :tag
-        end
-      end
-    end
-  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
-
-    if evaluated?
-      error_location_str = Puppet::Util::Errors.error_location(file, line)
-      msg = if error_location_str.empty?
-              _('Attempt to override an already evaluated resource with new values')
-            else
-              _('Attempt to override an already evaluated resource, defined at %{error_location}, with new values') % { error_location: error_location_str }
-            end
-      strict = Puppet[:strict]
-      unless strict == :off
-        if strict == :error
-          raise Puppet::ParseError.new(msg, resource.file, resource.line)
-        else
-          msg += Puppet::Util::Errors.error_location_with_space(resource.file, resource.line)
-          Puppet.warning(msg)
-        end
-      end
-    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
-    parse_title.merge(@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 %{value0}: %{ref} is not a resource") % { value0: self.ref, ref: ref } 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 Puppet::Error, _("Resource %{ref} could not be found; it might not have been produced yet") % { ref: ref }
-      end
-
-      # Ensure that the found resource is a capability resource
-      raise Puppet::Error, _("Invalid consume in %{ref}: %{cap} is not a capability resource") % { ref: ref, cap: cap } 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 %{res} tries to consume %{cns} but no 'consumes' mapping exists for %{resource_type} and %{cns_type}") % { res: self, cns: cns, resource_type: self.resource_type, cns_type: 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 '%{resource}' caused by multiple consumed mappings to the same attribute") % { name: name, resource: self } 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
-
-  def add_scope_tags
-    scope_resource = scope.resource
-    unless scope_resource.nil? || scope_resource.equal?(self)
-      merge_tags_from(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]
-
-    # Parameter is already set - if overriding with a default - simply ignore the setting of the default value
-    return if scope.is_default?(type, param.name, param.value)
-
-    # The parameter is already set.  Fail if they're not allowed to override it.
-    unless param.source.child_of?(current.source) || param.source.equal?(current.source) && scope.is_default?(type, param.name, current.value)
-      error_location_str = Puppet::Util::Errors.error_location(current.file, current.line)
-      msg = if current.source.to_s == ''
-              if error_location_str.empty?
-                _("Parameter '%{name}' is already set on %{resource}; cannot redefine") %
-                    { name: param.name, resource: ref }
-              else
-                _("Parameter '%{name}' is already set on %{resource} at %{error_location}; cannot redefine") %
-                    { name: param.name, resource: ref, error_location: error_location_str }
-              end
-            else
-              if error_location_str.empty?
-                _("Parameter '%{name}' is already set on %{resource} by %{source}; cannot redefine") %
-                    { name: param.name, resource: ref, source: current.source.to_s }
-              else
-                _("Parameter '%{name}' is already set on %{resource} by %{source} at %{error_location}; cannot redefine") %
-                    { name: param.name, resource: ref, source: current.source.to_s, error_location: error_location_str }
-              end
-            end
-      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}' for on %{resource}") % { param: param.name, resource: self } if @parameters[param.name]
-
-      set_parameter(param)
-    end
-  end
-end