puppet 3.7.0-x64-mingw32

data/lib/puppet/pops/binder/injector_entry.rb

@@ -0,0 +1,57 @@
+# Represents an entry in the injectors internal data.
+#
+# @api public
+#
+class Puppet::Pops::Binder::InjectorEntry
+  # @return [Object] An opaque (comparable) object representing the precedence
+  # @api public
+  attr_reader :precedence
+
+  # @return [Puppet::Pops::Binder::Bindings::Binding] The binding for this entry
+  # @api public
+  attr_reader :binding
+
+  # @api private
+  attr_accessor :resolved
+
+  # @api private
+  attr_accessor :cached_producer
+
+  # @api private
+  def initialize(binding, precedence = 0)
+    @precedence = precedence.freeze
+    @binding = binding
+    @cached_producer = nil
+  end
+
+  # Marks an overriding entry as resolved (if not an overriding entry, the marking has no effect).
+  # @api private
+  #
+  def mark_override_resolved()
+    @resolved = true
+  end
+
+  # The binding is resolved if it is non-override, or if the override has been resolved
+  # @api private
+  #
+  def is_resolved?()
+    !binding.override || resolved
+  end
+
+  def is_abstract?
+    binding.abstract
+  end
+
+  def is_final?
+    binding.final
+  end
+
+  # Compares against another InjectorEntry by comparing precedence.
+  # @param injector_entry [InjectorEntry] entry to compare against.
+  # @return [Integer] 1, if this entry has higher precedence, 0 if equal, and -1 if given entry has higher precedence.
+  # @api public
+  #
+  def <=> (injector_entry)
+    precedence <=> injector_entry.precedence
+  end
+end

data/lib/puppet/pops/binder/key_factory.rb

@@ -0,0 +1,67 @@
+# The KeyFactory is responsible for creating keys used for lookup of bindings.
+# @api public
+#
+class Puppet::Pops::Binder::KeyFactory
+
+  attr_reader :type_calculator
+  # @api public
+  def initialize(type_calculator = Puppet::Pops::Types::TypeCalculator.new())
+    @type_calculator = type_calculator
+  end
+
+  # @api public
+  def binding_key(binding)
+    named_key(binding.type, binding.name)
+  end
+
+  # @api public
+  def named_key(type, name)
+    [(@type_calculator.assignable?(@type_calculator.data, type) ? @type_calculator.data : type), name]
+  end
+
+  # @api public
+  def data_key(name)
+    [@type_calculator.data, name]
+  end
+
+  # @api public
+  def is_contributions_key?(s)
+    return false unless s.is_a?(String)
+    s.start_with?('mc_')
+  end
+
+  # @api public
+  def multibind_contributions(multibind_id)
+    "mc_#{multibind_id}"
+  end
+
+  # @api public
+  def multibind_contribution_key_to_id(contributions_key)
+    # removes the leading "mc_" from the key to get the multibind_id
+    contributions_key[3..-1]
+  end
+
+  # @api public
+  def is_named?(key)
+    key.is_a?(Array) && key[1] && !key[1].empty?
+  end
+
+  # @api public
+  def is_data?(key)
+    return false unless key.is_a?(Array) && key[0].is_a?(Puppet::Pops::Types::PAnyType)
+    type_calculator.assignable?(type_calculator.data(), key[0])
+  end
+
+  # @api public
+  def is_ruby?(key)
+    key.is_a?(Array) && key[0].is_a?(Puppet::Pops::Types::PRuntimeType) && key[0].runtime == :ruby
+  end
+
+  # Returns the type of the key
+  # @api public
+  #
+  def get_type(key)
+    return nil unless key.is_a?(Array)
+    key[0]
+  end
+end

data/lib/puppet/pops/binder/lookup.rb

@@ -0,0 +1,199 @@
+# This class is the backing implementation of the Puppet function 'lookup'.
+# See puppet/parser/functions/lookup.rb for documentation.
+#
+class Puppet::Pops::Binder::Lookup
+
+  def self.parse_lookup_args(args)
+    options = {}
+    pblock = if args[-1].respond_to?(:puppet_lambda)
+      args.pop
+    end
+
+    case args.size
+    when 1
+      # name, or all options
+      if args[ 0 ].is_a?(Hash)
+        options = to_symbolic_hash(args[ 0 ])
+      else
+        options[ :name ] = args[ 0 ]
+      end
+
+    when 2
+      # name and type, or name and options
+      if args[ 1 ].is_a?(Hash)
+        options = to_symbolic_hash(args[ 1 ])
+        options[:name] = args[ 0 ] # silently overwrite option with given name
+      else
+        options[:name] = args[ 0 ]
+        options[:type] = args[ 1 ]
+      end
+
+    when 3
+      # name, type, default (no options)
+      options[ :name ] = args[ 0 ]
+      options[ :type ] = args[ 1 ]
+      options[ :default ] = args[ 2 ]
+    else
+      raise Puppet::ParseError, "The lookup function accepts 1-3 arguments, got #{args.size}"
+    end
+    options[:pblock] = pblock
+    options
+  end
+
+  def self.to_symbolic_hash(input)
+    names = [:name, :type, :default, :accept_undef, :extra, :override]
+    options = {}
+    names.each {|n| options[n] = undef_as_nil(input[n.to_s] || input[n]) }
+    options
+  end
+
+  def self.type_mismatch(type_calculator, expected, got)
+    "has wrong type, expected #{type_calculator.string(expected)}, got #{type_calculator.string(got)}"
+  end
+
+  def self.fail(msg)
+    raise Puppet::ParseError, "Function lookup() " + msg
+  end
+
+  def self.fail_lookup(names)
+    name_part = if names.size == 1
+      "the name '#{names[0]}'"
+    else
+      "any of the names ['" + names.join(', ') + "']"
+    end
+    fail("did not find a value for #{name_part}")
+  end
+
+  def self.validate_options(options, type_calculator)
+    type_parser = Puppet::Pops::Types::TypeParser.new
+    name_type = type_parser.parse('Variant[Array[String], String]')
+
+    if is_nil_or_undef?(options[:name]) || options[:name].is_a?(Array) && options[:name].empty?
+      fail ("requires a name, or array of names. Got nothing to lookup.")
+    end
+
+    t = type_calculator.infer(options[:name])
+    if ! type_calculator.assignable?(name_type, t)
+      fail("given 'name' argument, #{type_mismatch(type_calculator, options[:name], t)}")
+    end
+
+    # unless a type is already given (future case), parse the type (or default 'Data'), fails if invalid type is given
+    unless options[:type].is_a?(Puppet::Pops::Types::PAnyType)
+      options[:type] = type_parser.parse(options[:type] || 'Data')
+    end
+
+    # default value must comply with the given type
+    if options[:default]
+      t = type_calculator.infer(options[:default])
+      if ! type_calculator.assignable?(options[:type], t)
+        fail("'default' value #{type_mismatch(type_calculator, options[:type], t)}")
+      end
+    end
+
+    if options[:extra] && !options[:extra].is_a?(Hash)
+      # do not perform inference here, it is enough to know that it is not a hash
+      fail("'extra' value must be a Hash, got #{options[:extra].class}")
+    end
+    options[:extra] = {} unless options[:extra]
+
+    if options[:override] && !options[:override].is_a?(Hash)
+      # do not perform inference here, it is enough to know that it is not a hash
+      fail("'override' value must be a Hash, got #{options[:extra].class}")
+    end
+    options[:override] = {} unless options[:override]
+
+  end
+
+  def self.nil_as_undef(x)
+    x.nil? ? :undef : x
+  end
+
+  def self.undef_as_nil(x)
+    is_nil_or_undef?(x) ? nil : x
+  end
+
+  def self.is_nil_or_undef?(x)
+    x.nil? || x == :undef
+  end
+
+  # This is used as a marker - a value that cannot (at least not easily) by mistake be found in
+  # hiera data.
+  #
+  class PrivateNotFoundMarker; end
+
+  def self.search_for(scope, type, name, options)
+    # search in order, override, injector, hiera, then extra
+    if !(result = options[:override][name]).nil?
+      result
+    elsif !(result = scope.compiler.injector.lookup(scope, type, name)).nil?
+      result
+   else
+     result = scope.function_hiera([name, PrivateNotFoundMarker])
+     if !result.nil? && result != PrivateNotFoundMarker
+       result
+     else
+       options[:extra][name]
+     end
+   end
+  end
+
+  # This is the method called from the puppet/parser/functions/lookup.rb
+  # @param args [Array] array following the puppet function call conventions
+  def self.lookup(scope, args)
+    type_calculator = Puppet::Pops::Types::TypeCalculator.new
+    options = parse_lookup_args(args)
+    validate_options(options, type_calculator)
+    names = [options[:name]].flatten
+    type = options[:type]
+
+    result_with_name = names.reduce([]) do |memo, name|
+      break memo if !memo[1].nil?
+      [name, search_for(scope, type, name, options)]
+    end
+
+    result = if result_with_name[1].nil?
+      # not found, use default (which may be nil), the default is already type checked
+      options[:default]
+    else
+      # injector.lookup is type-safe already do no need to type check the result
+      result_with_name[1]
+    end
+
+    # If a block is given it is called with :undef passed as 'nil' since the lookup function
+    # is available from 3x with --binder turned on, and the evaluation is always 4x.
+    # TODO PUPPET4: Simply pass the value
+    #
+    result = if pblock = options[:pblock]
+      result2 = case pblock.parameter_count
+      when 1
+        pblock.call(scope, undef_as_nil(result))
+      when 2
+        pblock.call(scope, result_with_name[ 0 ], undef_as_nil(result))
+      else
+        pblock.call(scope, result_with_name[ 0 ], undef_as_nil(result), undef_as_nil(options[ :default ]))
+      end
+
+      # if the given result was returned, there is no need to type-check it again
+      if !result2.equal?(result)
+        t = type_calculator.infer(undef_as_nil(result2))
+        if !type_calculator.assignable?(type, t)
+          fail "the value produced by the given code block #{type_mismatch(type_calculator, type, t)}"
+        end
+      end
+      result2
+    else
+      result
+    end
+
+    # Finally, the result if nil must be acceptable or an error is raised
+    if is_nil_or_undef?(result) && !options[:accept_undef]
+      fail_lookup(names)
+    else
+      # Since the function may be used without future parser being in effect, nil is not handled in a good
+      # way, and should instead be turned into :undef.
+      # TODO PUPPET4: Simply return the result
+      #
+      Puppet[:parser] == 'future' ? result : nil_as_undef(result)
+    end
+  end
+end

data/lib/puppet/pops/binder/producers.rb

@@ -0,0 +1,826 @@
+# This module contains the various producers used by Puppet Bindings.
+# The main (abstract) class is {Puppet::Pops::Binder::Producers::Producer} which documents the
+# Producer API and serves as a base class for all other producers.
+# It is required that custom producers inherit from this producer (directly or indirectly).
+#
+# The selection of a Producer is typically performed by the Innjector when it configures itself
+# from a Bindings model where a {Puppet::Pops::Binder::Bindings::ProducerDescriptor} describes
+# which producer to use. The configuration uses this to create the concrete producer.
+# It is possible to describe that a particular producer class is to be used, and also to describe that
+# a custom producer (derived from Producer) should be used. This is available for both regular
+# bindings as well as multi-bindings.
+#
+#
+# @api public
+#
+module Puppet::Pops::Binder::Producers
+  # Producer is an abstract base class representing the base contract for a bound producer.
+  # Typically, when a lookup is performed it is the value that is returned (via a producer), but
+  # it is also possible to lookup the producer, and ask it to produce the value (the producer may
+  # return a series of values, which makes this especially useful).
+  #
+  # When looking up a producer, it is of importance to only use the API of the Producer class
+  # unless it is known that a particular custom producer class has been bound.
+  #
+  # Custom Producers
+  # ----------------
+  # The intent is that this class is derived for custom producers that require additional
+  # options/arguments when producing an instance. Such a custom producer may raise an error if called
+  # with too few arguments, or may implement specific `produce` methods and always raise an
+  # error on #produce indicating that this producer requires custom calls and that it can not
+  # be used as an implicit producer.
+  #
+  # Features of Producer
+  # --------------------
+  # The Producer class is abstract, but offers the ability to transform the produced result
+  # by passing the option `:transformer` which should be a Puppet Lambda Expression taking one argument
+  # and producing the transformed (wanted) result.
+  #
+  # @abstract
+  # @api public
+  #
+  class Producer
+    # A Puppet 3 AST Lambda Expression
+    # @api public
+    #
+    attr_reader :transformer
+
+    # Creates a Producer.
+    # Derived classes should call this constructor to get support for transformer lambda.
+    #
+    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
+    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
+    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @api public
+    #
+    def initialize(injector, binding, scope, options)
+      if transformer_lambda = options[:transformer]
+        if transformer_lambda.is_a?(Proc)
+          raise ArgumentError, "Transformer Proc must take two arguments; scope, value." unless transformer_lambda.arity == 2
+          @transformer = transformer_lambda
+        else
+          raise ArgumentError, "Transformer must be a LambdaExpression" unless transformer_lambda.is_a?(Puppet::Pops::Model::LambdaExpression)
+          raise ArgumentError, "Transformer lambda must take one argument; value." unless transformer_lambda.parameters.size() == 1
+          @transformer = Puppet::Pops::Parser::EvaluatingParser.new.closure(transformer_lambda, scope)
+        end
+      end
+    end
+
+    # Produces an instance.
+    # @param scope [Puppet::Parser:Scope] the scope to use for evaluation
+    # @param args [Object] arguments to custom producers, always empty for implicit productions
+    # @return [Object] the produced instance (should never be nil).
+    # @api public
+    #
+    def produce(scope, *args)
+      do_transformation(scope, internal_produce(scope))
+    end
+
+    # Returns the producer after possibly having recreated an internal/wrapped producer.
+    # This implementation returns `self`. A derived class may want to override this method
+    # to perform initialization/refresh of its internal state. This method is called when
+    # a producer is requested.
+    # @see Puppet::Pops::Binder::ProducerProducer for an example of implementation.
+    # @param scope [Puppet::Parser:Scope] the scope to use for evaluation
+    # @return [Puppet::Pops::Binder::Producer] the producer to use
+    # @api public
+    #
+    def producer(scope)
+      self
+    end
+
+    protected
+
+    # Derived classes should implement this method to do the production of a value
+    # @param scope [Puppet::Parser::Scope] the scope to use when performing lookup and evaluation
+    # @raise [NotImplementedError] this implementation always raises an error
+    # @abstract
+    # @api private
+    #
+    def internal_produce(scope)
+      raise NotImplementedError, "Producer-class '#{self.class.name}' should implement #internal_produce(scope)"
+    end
+
+    # Transforms the produced value if a transformer has been defined.
+    # @param scope [Puppet::Parser::Scope] the scope used for evaluation
+    # @param produced_value [Object, nil] the produced value (possibly nil)
+    # @return [Object] the transformed value if a transformer is defined, else the given `produced_value`
+    # @api private
+    #
+    def do_transformation(scope, produced_value)
+      return produced_value unless transformer
+      transformer.call(scope, produced_value)
+    end
+  end
+
+  # Abstract Producer holding a value
+  # @abstract
+  # @api public
+  #
+  class AbstractValueProducer < Producer
+
+    # @api public
+    attr_reader :value
+
+    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
+    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
+    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Puppet::Pops::Model::LambdaExpression, nil] :value (nil) the value to produce
+    # @api public
+    #
+   def initialize(injector, binding, scope, options)
+      super
+      # nil is ok here, as an abstract value producer may be used to signal "not found"
+      @value = options[:value]
+    end
+  end
+
+  # Produces the same/singleton value on each production
+  # @api public
+  #
+  class SingletonProducer < AbstractValueProducer
+    protected
+
+    # @api private
+    def internal_produce(scope)
+      value()
+    end
+  end
+
+  # Produces a deep clone of its value on each production.
+  # @api public
+  #
+  class DeepCloningProducer < AbstractValueProducer
+    protected
+
+    # @api private
+    def internal_produce(scope)
+      case value
+      when Integer, Float, TrueClass, FalseClass, Symbol
+        # These are immutable
+        return value
+      when String
+        # ok if frozen, else fall through to default
+        return value() if value.frozen?
+      end
+      # The default: serialize/deserialize to get a deep copy
+      Marshal.load(Marshal.dump(value()))
+    end
+  end
+
+  # This abstract producer class remembers the injector and binding.
+  # @abstract
+  # @api public
+  #
+  class AbstractArgumentedProducer < Producer
+
+    # @api public
+    attr_reader :injector
+
+    # @api public
+    attr_reader :binding
+
+    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
+    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
+    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @api public
+    #
+    def initialize(injector, binding, scope, options)
+      super
+      @injector = injector
+      @binding = binding
+    end
+  end
+
+  # @api public
+  class InstantiatingProducer < AbstractArgumentedProducer
+
+    # @api public
+    attr_reader :the_class
+
+    # @api public
+    attr_reader :init_args
+
+    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
+    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
+    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [String] :class_name The name of the class to create instance of
+    # @option options [Array<Object>] :init_args ([]) Optional arguments to class constructor
+    # @api public
+    #
+    def initialize(injector, binding, scope, options)
+      # Better do this, even if a transformation of a created instance is kind of an odd thing to do, one can imagine
+      # sending it to a function for further detailing.
+      #
+      super
+      class_name = options[:class_name]
+      raise ArgumentError, "Option 'class_name' must be given for an InstantiatingProducer" unless class_name
+      # get class by name
+      @the_class = Puppet::Pops::Types::ClassLoader.provide(class_name)
+      @init_args = options[:init_args] || []
+      raise ArgumentError, "Can not load the class #{class_name} specified in binding named: '#{binding.name}'" unless @the_class
+    end
+
+    protected
+
+    # Performs initialization the same way as Assisted Inject does (but handle arguments to
+    # constructor)
+    # @api private
+    #
+    def internal_produce(scope)
+      result = nil
+      # A class :inject method wins over an instance :initialize if it is present, unless a more specific
+      # constructor exists. (i.e do not pick :inject from superclass if class has a constructor).
+      #
+      if the_class.respond_to?(:inject)
+        inject_method = the_class.method(:inject)
+        initialize_method = the_class.instance_method(:initialize)
+        if inject_method.owner <= initialize_method.owner
+          result = the_class.inject(injector, scope, binding, *init_args)
+        end
+      end
+      if result.nil?
+        result = the_class.new(*init_args)
+      end
+      result
+    end
+  end
+
+  # @api public
+  class FirstFoundProducer < Producer
+    # @api public
+    attr_reader :producers
+
+    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
+    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
+    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Array<Puppet::Pops::Binder::Producers::Producer>] :producers list of producers to consult. Required.
+    # @api public
+    #
+    def initialize(injector, binding, scope, options)
+      super
+      @producers = options[:producers]
+      raise ArgumentError, "Option :producers' must be set to a list of producers." if @producers.nil?
+      raise ArgumentError, "Given 'producers' option is not an Array" unless @producers.is_a?(Array)
+    end
+
+    protected
+
+    # @api private
+    def internal_produce(scope)
+      # return the first produced value that is non-nil (unfortunately there is no such enumerable method)
+      producers.reduce(nil) {|memo, p| break memo unless memo.nil?; p.produce(scope)}
+    end
+  end
+
+  # Evaluates a Puppet Expression and returns the result.
+  # This is typically used for strings with interpolated expressions.
+  # @api public
+  #
+  class EvaluatingProducer < Producer
+    # A Puppet 3 AST Expression
+    # @api public
+    #
+    attr_reader :expression
+
+    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
+    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
+    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Array<Puppet::Pops::Model::Expression>] :expression The expression to evaluate
+    # @api public
+    #
+    def initialize(injector, binding, scope, options)
+      super
+      @expression = options[:expression]
+      raise ArgumentError, "Option 'expression' must be given to an EvaluatingProducer." unless @expression
+    end
+
+    # @api private
+    def internal_produce(scope)
+      Puppet::Pops::Parser::EvaluatingParser.new.evaluate(scope, expression)
+    end
+  end
+
+  # @api public
+  class LookupProducer < AbstractArgumentedProducer
+
+    # @api public
+    attr_reader :type
+
+    # @api public
+    attr_reader :name
+
+    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
+    # @param binder [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
+    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Puppet::Pops::Types::PAnyType] :type The type to lookup
+    # @option options [String] :name ('') The name to lookup
+    # @api public
+    #
+    def initialize(injector, binder, scope, options)
+      super
+      @type = options[:type]
+      @name = options[:name] || ''
+      raise ArgumentError, "Option 'type' must be given in a LookupProducer." unless @type
+    end
+
+    protected
+
+    # @api private
+    def internal_produce(scope)
+      injector.lookup_type(scope, type, name)
+    end
+  end
+
+  # @api public
+  class LookupKeyProducer < LookupProducer
+
+    # @api public
+    attr_reader :key
+
+    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
+    # @param binder [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
+    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Puppet::Pops::Types::PAnyType] :type The type to lookup
+    # @option options [String] :name ('') The name to lookup
+    # @option options [Puppet::Pops::Types::PAnyType] :key The key to lookup in the hash
+    # @api public
+    #
+    def initialize(injector, binder, scope, options)
+      super
+      @key = options[:key]
+      raise ArgumentError, "Option 'key' must be given in a LookupKeyProducer." if key.nil?
+    end
+
+    protected
+
+    # @api private
+    def internal_produce(scope)
+
+      result = super
+      result.is_a?(Hash) ? result[key] : nil
+    end
+  end
+
+  # Produces the given producer, then uses that producer.
+  # @see ProducerProducer for the non singleton version
+  # @api public
+  #
+  class SingletonProducerProducer < Producer
+
+    # @api public
+    attr_reader :value_producer
+
+    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
+    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
+    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Puppet::Pops::Model::LambdaExpression] :producer_producer a producer of a value producer (required)
+    # @api public
+    #
+    def initialize(injector, binding, scope, options)
+      super
+      p = options[:producer_producer]
+      raise ArgumentError, "Option :producer_producer must be given in a SingletonProducerProducer" unless p
+      @value_producer = p.produce(scope)
+    end
+
+    protected
+
+    # @api private
+    def internal_produce(scope)
+      value_producer.produce(scope)
+    end
+  end
+
+  # A ProducerProducer creates a producer via another producer, and then uses this created producer
+  # to produce values. This is useful for custom production of series of values.
+  # On each request for a producer, this producer will reset its internal producer (i.e. restarting
+  # the series).
+  #
+  # @param producer_producer [#produce(scope)] the producer of the producer
+  #
+  # @api public
+  #
+  class ProducerProducer < Producer
+
+    # @api public
+    attr_reader :producer_producer
+
+    # @api public
+    attr_reader :value_producer
+
+    # Creates  new ProducerProducer given a producer.
+    #
+    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
+    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
+    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Puppet::Pops::Binder::Producer] :producer_producer a producer of a value producer (required)
+    #
+    # @api public
+    #
+    def initialize(injector, binding, scope, options)
+      super
+      unless producer_producer = options[:producer_producer]
+        raise ArgumentError, "The option :producer_producer must be set in a ProducerProducer"
+      end
+      raise ArgumentError, "Argument must be a Producer" unless producer_producer.is_a?(Producer)
+
+      @producer_producer = producer_producer
+      @value_producer = nil
+    end
+
+    # Updates the internal state to use a new instance of the wrapped producer.
+    # @api public
+    #
+    def producer(scope)
+      @value_producer = @producer_producer.produce(scope)
+      self
+    end
+
+    protected
+
+    # Produces a value after having created an instance of the wrapped producer (if not already created).
+    # @api private
+    #
+    def internal_produce(scope, *args)
+      producer() unless value_producer
+      value_producer.produce(scope)
+    end
+  end
+
+  # This type of producer should only be created by the Injector.
+  #
+  # @api private
+  #
+  class AssistedInjectProducer < Producer
+    # An Assisted Inject Producer is created when a lookup is made of a type that is
+    # not bound. It does not support a transformer lambda.
+    # @note This initializer has a different signature than all others. Do not use in regular logic.
+    # @api private
+    #
+    def initialize(injector, clazz)
+      raise ArgumentError, "class must be given" unless clazz.is_a?(Class)
+
+      @injector = injector
+      @clazz = clazz
+      @inst = nil
+    end
+
+    def produce(scope, *args)
+      producer(scope, *args) unless @inst
+      @inst
+    end
+
+    # @api private
+    def producer(scope, *args)
+      @inst = nil
+      # A class :inject method wins over an instance :initialize if it is present, unless a more specific zero args
+      # constructor exists. (i.e do not pick :inject from superclass if class has a zero args constructor).
+      #
+      if @clazz.respond_to?(:inject)
+        inject_method = @clazz.method(:inject)
+        initialize_method = @clazz.instance_method(:initialize)
+        if inject_method.owner <= initialize_method.owner || initialize_method.arity != 0
+          @inst = @clazz.inject(@injector, scope, nil, *args)
+        end
+      end
+      if @inst.nil?
+        unless args.empty?
+          raise ArgumentError, "Assisted Inject can not pass arguments to no-args constructor when there is no class inject method."
+        end
+        @inst = @clazz.new()
+      end
+      self
+    end
+  end
+
+  # Abstract base class for multibind producers.
+  # Is suitable as base class for custom implementations of multibind producers.
+  # @abstract
+  # @api public
+  #
+  class MultibindProducer < AbstractArgumentedProducer
+    attr_reader :contributions_key
+
+    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
+    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
+    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    #
+    # @api public
+    #
+    def initialize(injector, binding, scope, options)
+      super
+      @contributions_key = injector.key_factory.multibind_contributions(binding.id)
+    end
+
+    # @param expected [Array<Puppet::Pops::Types::PAnyType>, Puppet::Pops::Types::PAnyType] expected type or types
+    # @param actual [Object, Puppet::Pops::Types::PAnyType> the actual value (or its type)
+    # @return [String] a formatted string for inclusion as detail in an error message
+    # @api private
+    #
+    def type_error_detail(expected, actual)
+      tc = injector.type_calculator
+      expected = [expected] unless expected.is_a?(Array)
+      actual_t = tc.is_ptype?(actual) ? actual : tc.infer(actual)
+      expstrs = expected.collect {|t| tc.string(t) }
+      "expected: #{expstrs.join(', or ')}, got: #{tc.string(actual_t)}"
+    end
+  end
+
+  # A configurable multibind producer for Array type multibindings.
+  #
+  # This implementation collects all contributions to the multibind and then combines them using the following rules:
+  #
+  # - all *unnamed* entries are added unless the option `:priority_on_unnamed` is set to true, in which case the unnamed
+  #   contribution with the highest priority is added, and the rest are ignored (unless they have the same priority in which
+  #   case an error is raised).
+  # - all *named* entries are handled the same way as *unnamed* but the option `:priority_on_named` controls their handling.
+  # - the option `:uniq` post processes the result to only contain unique entries
+  # - the option `:flatten` post processes the result by flattening all nested arrays.
+  # - If both `:flatten` and `:uniq` are true, flattening is done first.
+  #
+  # @note
+  #   Collection accepts elements that comply with the array's element type, or the entire type (i.e. Array[element_type]).
+  #   If the type is restrictive - e.g. Array[String] and an Array[String] is contributed, the result will not be type
+  #   compliant without also using the `:flatten` option, and a type error will be raised. For an array with relaxed typing
+  #   i.e. Array[Data], it is valid to produce a result such as `['a', ['b', 'c'], 'd']` and no flattening is required
+  #   and no error is raised (but using the array needs to be aware of potential array, non-array entries.
+  #   The use of the option `:flatten` controls how the result is flattened.
+  #
+  # @api public
+  #
+  class ArrayMultibindProducer < MultibindProducer
+
+    # @return [Boolean] whether the result should be made contain unique (non-equal) entries or not
+    # @api public
+    attr_reader :uniq
+
+    # @return [Boolean, Integer] If result should be flattened (true), or not (false), or flattened to given level (0 = none, -1 = all)
+    # @api public
+    attr_reader :flatten
+
+    # @return [Boolean] whether priority should be considered for named contributions
+    # @api public
+    attr_reader :priority_on_named
+
+    # @return [Boolean] whether priority should be considered for unnamed contributions
+    # @api public
+    attr_reader :priority_on_unnamed
+
+    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
+    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
+    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Boolean] :uniq (false) if collected result should be post-processed to contain only unique entries
+    # @option options [Boolean, Integer] :flatten (false) if collected result should be post-processed so all contained arrays
+    #   are flattened. May be set to an Integer value to indicate the level of recursion (-1 is endless, 0 is none).
+    # @option options [Boolean] :priority_on_named (true) if highest precedented named element should win or if all should be included
+    # @option options [Boolean] :priority_on_unnamed (false) if highest precedented unnamed element should win or if all should be included
+    # @api public
+    #
+    def initialize(injector, binding, scope, options)
+      super
+      @uniq = !!options[:uniq]
+      @flatten = options[:flatten]
+      @priority_on_named = options[:priority_on_named].nil? ? true : options[:priority_on_name]
+      @priority_on_unnamed = !!options[:priority_on_unnamed]
+
+      case @flatten
+      when Integer
+      when true
+        @flatten = -1
+      when false
+        @flatten = nil
+      when NilClass
+        @flatten = nil
+      else
+        raise ArgumentError, "Option :flatten must be nil, Boolean, or an integer value" unless @flatten.is_a?(Integer)
+      end
+    end
+
+    protected
+
+    # @api private
+    def internal_produce(scope)
+      seen = {}
+      included_keys = []
+
+      injector.get_contributions(scope, contributions_key).each do |element|
+        key = element[0]
+        entry = element[1]
+
+        name = entry.binding.name
+        existing = seen[name]
+        empty_name = name.nil? || name.empty?
+        if existing
+          if empty_name && priority_on_unnamed
+            if (seen[name] <=> entry) >= 0
+              raise ArgumentError, "Duplicate key (same priority) contributed to Array Multibinding '#{binding.name}' with unnamed entry."
+            end
+            next
+          elsif !empty_name && priority_on_named
+            if (seen[name] <=> entry) >= 0
+              raise ArgumentError, "Duplicate key (same priority) contributed to Array Multibinding '#{binding.name}', key: '#{name}'."
+            end
+            next
+          end
+        else
+          seen[name] = entry
+        end
+        included_keys << key
+      end
+      result = included_keys.collect do |k|
+        x = injector.lookup_key(scope, k)
+        assert_type(binding(), injector.type_calculator(), x)
+        x
+      end
+
+      result.flatten!(flatten) if flatten
+      result.uniq! if uniq
+      result
+    end
+
+    # @api private
+    def assert_type(binding, tc, value)
+      infered = tc.infer(value)
+      unless tc.assignable?(binding.type.element_type, infered) || tc.assignable?(binding.type, infered)
+        raise ArgumentError, ["Type Error: contribution to '#{binding.name}' does not match type of multibind, ",
+          "#{type_error_detail([binding.type.element_type, binding.type], value)}"].join()
+      end
+    end
+  end
+
+  # @api public
+  class HashMultibindProducer < MultibindProducer
+
+    # @return [Symbol] One of `:error`, `:merge`, `:append`, `:priority`, `:ignore`
+    # @api public
+    attr_reader :conflict_resolution
+
+    # @return [Boolean]
+    # @api public
+    attr_reader :uniq
+
+    # @return [Boolean, Integer] Flatten all if true, or none if false, or to given level (0 = none, -1 = all)
+    # @api public
+    attr_reader :flatten
+
+    # The hash multibind producer provides options to control conflict resolution.
+    # By default, the hash is produced using `:priority` resolution - the highest entry is selected, the rest are
+    # ignored unless they have the same priority which is an error.
+    #
+    # @param injector [Puppet::Pops::Binder::Injector] The injector where the lookup originates
+    # @param binding [Puppet::Pops::Binder::Bindings::Binding, nil] The binding using this producer
+    # @param scope [Puppet::Parser::Scope] The scope to use for evaluation
+    # @option options [Puppet::Pops::Model::LambdaExpression] :transformer (nil) a transformer of produced value
+    # @option options [Symbol, String] :conflict_resolution (:priority) One of `:error`, `:merge`, `:append`, `:priority`, `:ignore`
+    #   <ul><li> `ignore` the first found highest priority contribution is used, the rest are ignored</li>
+    #   <li>`error` any duplicate key is an error</li>
+    #   <li>`append` element type must be compatible with Array, makes elements be arrays and appends all found</li>
+    #   <li>`merge` element type must be compatible with hash, merges hashes with retention of highest priority hash content</li>
+    #   <li>`priority` the first found highest priority contribution is used, duplicates with same priority raises and error, the rest are
+    #     ignored.</li></ul>
+    # @option options [Boolean, Integer] :flatten (false) If appended should be flattened. Also see {#flatten}.
+    # @option options [Boolean] :uniq (false) If appended result should be made unique.
+    #
+    # @api public
+    #
+  def initialize(injector, binding, scope, options)
+      super
+      @conflict_resolution = options[:conflict_resolution].nil? ? :priority : options[:conflict_resolution]
+      @uniq = !!options[:uniq]
+      @flatten = options[:flatten]
+
+      unless [:error, :merge, :append, :priority, :ignore].include?(@conflict_resolution)
+        raise ArgumentError, "Unknown conflict_resolution for Multibind Hash: '#{@conflict_resolution}."
+      end
+
+      case @flatten
+      when Integer
+      when true
+        @flatten = -1
+      when false
+        @flatten = nil
+      when NilClass
+        @flatten = nil
+      else
+        raise ArgumentError, "Option :flatten must be nil, Boolean, or an integer value" unless @flatten.is_a?(Integer)
+      end
+
+      if uniq || flatten || conflict_resolution.to_s == 'append'
+        etype = binding.type.element_type
+        unless etype.class == Puppet::Pops::Types::PDataType || etype.is_a?(Puppet::Pops::Types::PArrayType)
+          detail = []
+          detail << ":uniq" if uniq
+          detail << ":flatten" if flatten
+          detail << ":conflict_resolution => :append" if conflict_resolution.to_s == 'append'
+          raise ArgumentError, ["Options #{detail.join(', and ')} cannot be used with a Multibind ",
+            "of type #{injector.type_calculator.string(binding.type)}"].join()
+        end
+      end
+    end
+
+    protected
+
+    # @api private
+    def internal_produce(scope)
+      seen = {}
+      included_entries = []
+
+      injector.get_contributions(scope, contributions_key).each do |element|
+        key = element[0]
+        entry = element[1]
+
+        name = entry.binding.name
+        raise ArgumentError, "A Hash Multibind contribution to '#{binding.name}' must have a name." if name.nil? || name.empty?
+
+        existing = seen[name]
+        if existing
+          case conflict_resolution.to_s
+          when 'priority'
+            # skip if duplicate has lower prio
+            if (comparison = (seen[name] <=> entry)) <= 0
+              raise ArgumentError, "Internal Error: contributions not given in decreasing precedence order" unless comparison == 0
+              raise ArgumentError, "Duplicate key (same priority) contributed to Hash Multibinding '#{binding.name}', key: '#{name}'."
+            end
+            next
+
+          when 'ignore'
+            # skip, ignore conflict if prio is the same
+            next
+
+          when 'error'
+            raise ArgumentError, "Duplicate key contributed to Hash Multibinding '#{binding.name}', key: '#{name}'."
+
+          end
+        else
+          seen[name] = entry
+        end
+        included_entries << [key, entry]
+      end
+      result = {}
+      included_entries.each do |element|
+        k = element[ 0 ]
+        entry = element[ 1 ]
+        x = injector.lookup_key(scope, k)
+        name = entry.binding.name
+        assert_type(binding(), injector.type_calculator(), name, x)
+        if result[ name ]
+          merge(result, name, result[ name ], x)
+        else
+          result[ name ] = conflict_resolution().to_s == 'append' ? [x] : x
+        end
+      end
+      result
+    end
+
+    # @api private
+    def merge(result, name, higher, lower)
+      case conflict_resolution.to_s
+      when 'append'
+        unless higher.is_a?(Array)
+          higher = [higher]
+        end
+        tmp = higher + [lower]
+        tmp.flatten!(flatten) if flatten
+        tmp.uniq! if uniq
+        result[name] = tmp
+
+      when 'merge'
+        result[name] = lower.merge(higher)
+
+      end
+    end
+
+    # @api private
+    def assert_type(binding, tc, key, value)
+      unless tc.instance?(binding.type.key_type, key)
+        raise ArgumentError, ["Type Error: key contribution to #{binding.name}['#{key}'] ",
+          "is incompatible with key type: #{tc.label(binding.type)}, ",
+          type_error_detail(binding.type.key_type, key)].join()
+      end
+
+      if key.nil? || !key.is_a?(String) || key.empty?
+        raise ArgumentError, "Entry contributing to multibind hash with id '#{binding.id}' must have a name."
+      end
+
+      unless tc.instance?(binding.type.element_type, value)
+        raise ArgumentError, ["Type Error: value contribution to #{binding.name}['#{key}'] ",
+          "is incompatible, ",
+          type_error_detail(binding.type.element_type, value)].join()
+      end
+    end
+  end
+
+end