puppet 4.10.12-universal-darwin → 5.0.0-universal-darwin

data/lib/puppet/plugins/data_providers/registry.rb

@@ -1,51 +0,0 @@
-# TODO: API 5.0, remove this module
-# @api private
-# @deprecated
-module Puppet::Plugins::DataProviders
-  class Registry
-    def self.register_extensions(extensions)
-      extensions.multibind(PER_MODULE_DATA_PROVIDER_KEY).name(PER_MODULE_DATA_PROVIDER_KEY).hash_of(PER_MODULE_DATA_PROVIDER_TYPE)
-      extensions.multibind(ENV_DATA_PROVIDERS_KEY).name(ENV_DATA_PROVIDERS_KEY).hash_of(ENV_DATA_PROVIDERS_TYPE)
-      extensions.multibind(MODULE_DATA_PROVIDERS_KEY).name(MODULE_DATA_PROVIDERS_KEY).hash_of(MODULE_DATA_PROVIDERS_TYPE)
-      extensions.multibind(PATH_BASED_DATA_PROVIDER_FACTORIES_KEY).name(PATH_BASED_DATA_PROVIDER_FACTORIES_KEY).hash_of(PATH_BASED_DATA_PROVIDER_FACTORIES_TYPE)
-    end
-
-    def self.hash_of_per_module_data_provider
-      @@HASH_OF_PER_MODULE_DATA_PROVIDERS ||= Puppet::Pops::Types::TypeFactory.hash_of(PER_MODULE_DATA_PROVIDER_TYPE)
-    end
-
-    def self.hash_of_module_data_providers
-      @@HASH_OF_MODULE_DATA_PROVIDERS ||= Puppet::Pops::Types::TypeFactory.hash_of(
-        Puppet::Pops::Types::TypeFactory.type_of(MODULE_DATA_PROVIDERS_TYPE))
-    end
-
-    def self.hash_of_environment_data_providers
-      @@HASH_OF_ENV_DATA_PROVIDERS ||= Puppet::Pops::Types::TypeFactory.hash_of(
-        Puppet::Pops::Types::TypeFactory.type_of(ENV_DATA_PROVIDERS_TYPE))
-    end
-
-    def self.hash_of_path_based_data_provider_factories
-      @@HASH_OF_PATH_BASED_DATA_PROVIDER_FACTORIES ||= Puppet::Pops::Types::TypeFactory.hash_of(
-        Puppet::Pops::Types::TypeFactory.type_of(PATH_BASED_DATA_PROVIDER_FACTORIES_TYPE))
-    end
-
-    # Registers a 'none' environment data provider, and a 'none' module data provider as the defaults.
-    # This is only done to allow that something binds to 'none' rather than removing the entire binding (which
-    # has the same effect).
-    #
-    def self.register_defaults(default_bindings)
-      default_bindings.bind do
-        name('none')
-        in_multibind(ENV_DATA_PROVIDERS_KEY)
-        to_instance(ENV_DATA_PROVIDERS_TYPE)
-      end
-
-      default_bindings.bind do
-        name('none')
-        in_multibind(MODULE_DATA_PROVIDERS_KEY)
-        to_instance(MODULE_DATA_PROVIDERS_TYPE)
-      end
-    end
-  end
-end
-

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

@@ -1,398 +0,0 @@
-# The Binder is responsible for processing layered bindings that can be used to setup an Injector.
-#
-# An instance should be created and a call to {#define_layers} should be made which will process the layered bindings
-# (handle overrides, abstract entries etc.).
-# The constructed hash with `key => InjectorEntry` mappings is obtained as {#injector_entries}, and is used to initialize an
-# {Injector Injector}.
-#
-# @api public
-#
-module Puppet::Pops
-module Binder
-class Binder
-
-  # @api private
-  attr_reader :injector_entries
-
-  # @api private
-  attr :id_index
-
-  # @api private
-  attr_reader :key_factory
-
-  # A parent Binder or nil
-  # @api private
-  attr_reader :parent
-
-  # The next anonymous key to use
-  # @api private
-  attr_reader :anonymous_key
-
-  # This binder's precedence
-  # @api private
-  attr_reader :binder_precedence
-
-  # @api public
-  def initialize(layered_bindings, parent_binder=nil)
-    @parent = parent_binder
-    @id_index = Hash.new() { |k, v| [] }
-
-    @key_factory = KeyFactory.new()
-
-    # Resulting hash of all key -> binding
-    @injector_entries = {}
-
-    if @parent.nil?
-      @anonymous_key = 0
-      @binder_precedence = 0
-    else
-      # First anonymous key is the parent's next (non incremented key). (The parent can not change, it is
-      # the final, free key).
-      @anonymous_key = @parent.anonymous_key
-      @binder_precedence = @parent.binder_precedence + 1
-    end
-    define_layers(layered_bindings)
-  end
-
-  # Binds layers from highest to lowest as defined by the given LayeredBindings.
-  # @note
-  #   The model should have been
-  #   validated to get better error messages if the model is invalid. This implementation expects the model
-  #   to be valid, and any errors raised will be more technical runtime errors.
-  #
-  # @param layered_bindings [Bindings::LayeredBindings] the named and ordered layers
-  # @raise ArgumentError if this binder is already configured
-  # @raise ArgumentError if bindings with unresolved 'override' surfaces as an effective binding
-  # @raise ArgumentError if the given argument has the wrong type, or if model is invalid in some way
-  # @return [Binder] self
-  # @api public
-  #
-  def define_layers(layered_bindings)
-
-    LayerProcessor.new(self, key_factory).bind(layered_bindings)
-    contribution_keys = []
-    # make one pass over entries to collect contributions, and check overrides
-    injector_entries.each do |k,v|
-      if key_factory.is_contributions_key?(k)
-        contribution_keys << [k,v]
-      elsif !v.is_resolved?()
-        raise ArgumentError, "Binding with unresolved 'override' detected: #{self.class.format_binding(v.binding)}}"
-      else
-        # if binding has an id, add it to the index
-        add_id_to_index(v.binding)
-      end
-    end
-
-    # If a lower level binder has contributions for a key also contributed to in this binder
-    # they must included in the higher shadowing contribution.
-    # If a contribution is made to an id that is defined in a parent
-    # contribute to an id that is defined in a lower binder, it must be promoted to this binder (copied) or
-    # there is risk of making the lower level injector dirty.
-    #
-    contribution_keys.each do |kv|
-      parent_contribution = lookup_in_parent(kv[0])
-      next unless parent_contribution
-      injector_entries[kv[0]] = kv[1] + parent_contributions
-
-      # key the multibind_id from the contribution key
-      multibind_id = key_factory.multibind_contribution_key_to_id(kv[0])
-      promote_matching_bindings(self, @parent, multibind_id)
-    end
-  end
-  private :define_layers
-
-  # @api private
-  def next_anonymous_key
-    tmp = @anonymous_key
-    @anonymous_key += 1
-    tmp
-  end
-
-  def add_id_to_index(binding)
-    return unless binding.is_a?(Bindings::Multibinding) && !(id = binding.id).nil?
-    @id_index[id] = @id_index[id] << binding
-  end
-
-  def promote_matching_bindings(to_binder, from_binder, multibind_id)
-    return if from_binder.nil?
-    from_binder.id_index[ multibind_id ].each do |binding|
-      key = key_factory.binding_key(binding)
-      entry = lookup(key)
-      unless entry.precedence == @binder_precedence
-        # it is from a lower layer it must be promoted
-        injector_entries[ key ] = InjectorEntry.new(binding, binder_precedence)
-      end
-    end
-    # recursive "up the parent chain" to promote all
-    promote_matching_bindings(to_binder, from_binder.parent, multibind_id)
-  end
-
-  def lookup_in_parent(key)
-    @parent.nil? ? nil : @parent.lookup(key)
-  end
-
-  def lookup(key)
-    if x = injector_entries[key]
-      return x
-    end
-    @parent ?  @parent.lookup(key) :  nil
-  end
-
-  # @api private
-  def self.format_binding(b)
-    type_name = b.type.to_s
-    layer_name, bindings_name = get_named_binding_layer_and_name(b)
-    "binding: '#{type_name}/#{b.name}' in: '#{bindings_name}' in layer: '#{layer_name}'"
-  end
-
-  # @api private
-  def self.format_contribution_source(b) 
-    layer_name, bindings_name = get_named_binding_layer_and_name(b)
-    "(layer: #{layer_name}, bindings: #{bindings_name})"
-  end
-
-  # @api private
-  def self.get_named_binding_layer_and_name(b)
-    return ['<unknown>', '<unknown>'] if b.nil?
-    return [get_named_layer(b), b.name] if b.is_a?(Bindings::NamedBindings)
-    get_named_binding_layer_and_name(b.eContainer)
-  end
-
-  # @api private
-  def self.get_named_layer(b)
-    return '<unknown>' if b.nil?
-    return b.name if b.is_a?(Bindings::NamedLayer)
-    get_named_layer(b.eContainer)
-  end
-
-  # Processes the information in a layer, aggregating it to the injector_entries hash in its parent binder.
-  # A LayerProcessor holds the intermediate state required while processing one layer.
-  #
-  # @api private
-  #
-  class LayerProcessor
-    attr :bindings
-    attr :binder
-    attr :key_factory
-    attr :contributions
-    attr :binder_precedence
-
-    def initialize(binder, key_factory)
-      @binder = binder
-      @binder_precedence = binder.binder_precedence
-      @key_factory = key_factory
-      @bindings = []
-      @contributions = []
-      @@bind_visitor ||= Visitor.new(nil,"bind",0,0)
-    end
-
-    # Add the binding to the list of potentially effective bindings from this layer
-    # @api private
-    #
-    def add(b)
-      bindings << InjectorEntry.new(b, binder_precedence)
-    end
-
-    # Add a multibind contribution
-    # @api private
-    #
-    def add_contribution(b)
-      contributions << InjectorEntry.new(b, binder_precedence)
-    end
-
-    # Bind given abstract binding
-    # @api private
-    #
-    def bind(binding)
-      @@bind_visitor.visit_this_0(self, binding)
-    end
-
-    # @return [InjectorEntry] the entry with the highest precedence
-    # @api private
-    def highest(b1, b2)
-      if b1.is_abstract? != b2.is_abstract?
-        # if one is abstract and the other is not, the non abstract wins
-        b1.is_abstract? ? b2 : b1
-      else
-        case b1.precedence <=> b2.precedence
-        when 1
-          b1
-        when -1
-          b2
-        when 0
-          raise_conflicting_binding(b1, b2)
-        end
-      end
-    end
-
-    # Raises a conflicting bindings error given two InjectorEntry's with same precedence in the same layer
-    # (if they are in different layers, something is seriously wrong)
-    def raise_conflicting_binding(b1, b2)
-      b1_layer_name, b1_bindings_name = binder.class.get_named_binding_layer_and_name(b1.binding)
-      b2_layer_name, b2_bindings_name = binder.class.get_named_binding_layer_and_name(b2.binding)
-
-      finality_msg = (b1.is_final? || b2.is_final?) ? ". Override of final binding not allowed" : ''
-
-      # TODO: Use of layer_name is not very good, it is not guaranteed to be unique
-      unless b1_layer_name == b2_layer_name
-        raise ArgumentError, [
-          'Conflicting binding for',
-          "'#{b1.binding.name}'",
-          'being resolved across layers',
-          "'#{b1_layer_name}' and",
-          "'#{b2_layer_name}'"
-          ].join(' ')+finality_msg
-      end
-
-      # Conflicting bindings made from the same source
-      if b1_bindings_name == b2_bindings_name
-        raise ArgumentError, [
-          'Conflicting binding for name:',
-          "'#{b1.binding.name}'",
-          'in layer:',
-          "'#{b1_layer_name}', ",
-          'both from:',
-          "'#{b1_bindings_name}'"
-          ].join(' ')+finality_msg
-      end
-
-      # Conflicting bindings from different sources
-      raise ArgumentError, [
-        'Conflicting binding for name:',
-        "'#{b1.binding.name}'",
-        'in layer:',
-        "'#{b1_layer_name}',",
-        'from:',
-        "'#{b1_bindings_name}', and",
-        "'#{b2_bindings_name}'"
-        ].join(' ')+finality_msg
-    end
-
-
-    # Produces the key for the given Binding.
-    # @param binding [Bindings::Binding] the binding to get a key for
-    # @return [Object] an opaque key
-    # @api private
-    #
-    def key(binding)
-      k = if is_contribution?(binding)
-        # contributions get a unique (sequential) key
-        binder.next_anonymous_key()
-      else
-        key_factory.binding_key(binding)
-      end
-    end
-
-    # @api private
-    def is_contribution?(binding)
-      ! binding.multibind_id.nil?
-    end
-
-    # @api private
-    def bind_Binding(o)
-      if is_contribution?(o)
-        add_contribution(o)
-      else
-        add(o)
-      end
-    end
-
-    # @api private
-    def bind_Bindings(o)
-      o.bindings.each {|b| bind(b) }
-    end
-
-    # @api private
-    def bind_NamedBindings(o)
-      # Name is ignored here, it should be introspected when needed (in case of errors)
-      o.bindings.each {|b| bind(b) }
-    end
-
-    # Process layered bindings from highest to lowest layer
-    # @api private
-    #
-    def bind_LayeredBindings(o)
-      o.layers.each do |layer|
-        processor = LayerProcessor.new(binder, key_factory)
-        # All except abstract (==error) are transferred to injector_entries
-
-        processor.bind(layer).each do |k, v|
-          entry = binder.injector_entries[k]
-          unless key_factory.is_contributions_key?(k)
-            if v.is_abstract?()
-              layer_name, bindings_name = Binder.get_named_binding_layer_and_name(v.binding)
-              type_name = v.binding.type.to_s
-              raise ArgumentError, "The abstract binding '#{type_name}/#{v.binding.name}' in '#{bindings_name}' in layer '#{layer_name}' was not overridden"
-            end
-            raise ArgumentError, "Internal Error - redefinition of key: #{k}, (should never happen)" if entry
-            binder.injector_entries[k] = v
-          else
-            # add contributions to existing contributions, else set them
-            binder.injector_entries[k] = entry ? entry + v : v
-          end
-        end
-      end
-    end
-
-    # Processes one named ("top level") layer consisting of a list of NamedBindings
-    # @api private
-    #
-    def bind_NamedLayer(o)
-      o.bindings.each {|b| bind(b) }
-      this_layer = {}
-
-      # process regular bindings
-      bindings.each do |b|
-        bkey = key(b.binding)
-
-        # ignore if a higher layer defined it (unless the lower is final), but ensure override gets resolved
-        # (override is not resolved across binders)
-        if x = binder.injector_entries[bkey]
-          if b.is_final?
-            raise_conflicting_binding(x, b)
-          end
-          x.mark_override_resolved()
-          next
-        end
-
-        # If a lower (parent) binder exposes a final binding it may not be overridden
-        #
-        if (x = binder.lookup_in_parent(bkey)) && x.is_final?
-          raise_conflicting_binding(x, b)
-        end
-
-        # if already found in this layer, one wins (and resolves override), or it is an error
-        existing = this_layer[bkey]
-        winner = existing ? highest(existing, b) : b
-        this_layer[bkey] = winner
-        if existing
-          winner.mark_override_resolved()
-        end
-      end
-
-      # Process contributions
-      # - organize map multibind_id to bindings with this id
-      # - for each id, create an array with the unique anonymous keys to the contributed bindings
-      # - bind the index to a special multibind contributions key (these are aggregated)
-      #
-      c_hash = Hash.new {|hash, key| hash[ key ] = [] }
-      contributions.each {|b| c_hash[ b.binding.multibind_id ] << b }
-      # - for each id
-      c_hash.each do |k, v|
-        index = v.collect do |b|
-          bkey = key(b.binding)
-          this_layer[bkey] = b
-          bkey
-        end.flatten
-        contributions_key = key_factory.multibind_contributions(k)
-        unless this_layer[contributions_key]
-          this_layer[contributions_key] = []
-        end
-        this_layer[contributions_key] += index
-      end
-      this_layer
-    end
-  end
-end
-end
-end

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

@@ -1,124 +0,0 @@
-module Puppet::Pops
-# @api public
-module Binder::BinderIssues
-
-  # NOTE: The methods #issue and #hard_issue are done in a somewhat funny way
-  # since the Issues is a module with these methods defined on the module-class
-  # This makes it hard to inherit them in this module. (Likewise if Issues was a class, and they
-  # need to be defined for the class, and such methods are also not inherited, it becomes more
-  # difficult to reuse these. It did not seem as a good idea to refactor Issues at this point
-  # in time - they should both probably be refactored once bindings support is finished.
-  # Meanwhile, they delegate to Issues.
-
-
-  # (see Issues#issue)
-  def self.issue (issue_code, *args, &block)
-    Issues.issue(issue_code, *args, &block)
-  end
-
-  # (see Issues#hard_issue)
-  def self.hard_issue(issue_code, *args, &block)
-    Issues.hard_issue(issue_code, *args, &block)
-  end
-
-  # Producer issues (binding identified using :binding argument)
-
-  # @api public
-  MISSING_NAME = issue :MISSING_NAME, :binding do
-    "#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no name"
-  end
-
-  # @api public
-  MISSING_KEY = issue :MISSING_KEY, :binding do
-    "#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no key"
-  end
-
-  # @api public
-  MISSING_VALUE = issue :MISSING_VALUE, :binding do
-    "#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no value"
-  end
-
-  # @api public
-  MISSING_EXPRESSION = issue :MISSING_EXPRESSION, :binding do
-    "#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no expression"
-  end
-
-  # @api public
-  MISSING_CLASS_NAME = issue :MISSING_CLASS_NAME, :binding do
-    "#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no class name"
-  end
-
-  # @api public
-  CACHED_PRODUCER_MISSING_PRODUCER = issue :PRODUCER_MISSING_PRODUCER, :binding do
-    "#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has no producer"
-  end
-
-  # @api public
-  INCOMPATIBLE_TYPE = issue :INCOMPATIBLE_TYPE, :binding, :expected_type, :actual_type do
-    "#{label.a_an_uc(binding)} with #{label.a_an(semantic)} has an incompatible type: expected #{label.a_an(expected_type)}, but got #{label.a_an(actual_type)}."
-  end
-
-  # @api public
-  MULTIBIND_INCOMPATIBLE_TYPE = issue :MULTIBIND_INCOMPATIBLE_TYPE, :binding, :actual_type do
-    "#{label.a_an_uc(binding)} with #{label.a_an(semantic)} cannot bind #{label.a_an(actual_type)} value"
-  end
-
-  # @api public
-  MODEL_OBJECT_IS_UNBOUND = issue :MODEL_OBJECT_IS_UNBOUND do
-    "#{label.a_an_uc(semantic)} is not contained in a binding"
-  end
-
-  # Binding issues (binding identified using semantic)
-
-  # @api public
-  MISSING_PRODUCER = issue :MISSING_PRODUCER do
-    "#{label.a_an_uc(semantic)} has no producer"
-  end
-
-  # @api public
-  MISSING_TYPE = issue :MISSING_TYPE do
-    "#{label.a_an_uc(semantic)} has no type"
-  end
-
-  # @api public
-  MULTIBIND_NOT_COLLECTION_PRODUCER = issue :MULTIBIND_NOT_COLLECTION_PRODUCER, :actual_producer do
-    "#{label.a_an_uc(semantic)} must have a MultibindProducerDescriptor, but got: #{label.a_an(actual_producer)}"
-  end
-
-  # @api public
-  MULTIBIND_TYPE_ERROR = issue :MULTIBIND_TYPE_ERROR, :actual_type do
-    "#{label.a_an_uc(semantic)} is expected to bind a collection type, but got: #{label.a_an(actual_type)}."
-  end
-
-  # @api public
-  MISSING_BINDINGS = issue :MISSING_BINDINGS do
-    "#{label.a_an_uc(semantic)} has zero bindings"
-  end
-
-  # @api public
-  MISSING_BINDINGS_NAME = issue :MISSING_BINDINGS_NAME do
-    "#{label.a_an_uc(semantic)} has no name"
-  end
-
-  # @api public
-  MISSING_PREDICATES = issue :MISSING_PREDICATES do
-    "#{label.a_an_uc(semantic)} has zero predicates"
-  end
-
-  # @api public
-  MISSING_LAYERS = issue :MISSING_LAYERS do
-    "#{label.a_an_uc(semantic)} has zero layers"
-  end
-
-  # @api public
-  MISSING_LAYER_NAME = issue :MISSING_LAYER_NAME do
-    "#{label.a_an_uc(semantic)} has a layer without name"
-  end
-
-  # @api public
-  MISSING_BINDINGS_IN_LAYER = issue :MISSING_BINDINGS_IN_LAYER, :layer do
-    "#{label.a_an_uc(semantic)} has zero bindings in #{label.label(layer)}"
-  end
-
-end
-end