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

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

@@ -1,45 +0,0 @@
-# A provider of labels for bindings model object, producing a human name for the model object.
-# @api private
-#
-class Puppet::Pops::Binder::BindingsLabelProvider
-  include Puppet::Pops::LabelProvider
-
-  def initialize
-    @@label_visitor ||= Puppet::Pops::Visitor.new(self,"label",0,0)
-  end
-
-  # Produces a label for the given object without article.
-  # @return [String] a human readable label
-  #
-  def label o
-   @@label_visitor.visit_this_0(self, o)
-  end
-
-  def label_PAnyType o                          ; "#{Puppet::Pops::Types::TypeFactory.label(o)}" end
-  def label_ProducerDescriptor o                ; "Producer"                                     end
-  def label_NonCachingProducerDescriptor o      ; "Non Caching Producer"                         end
-  def label_ConstantProducerDescriptor o        ; "Producer['#{o.value}']"                       end
-  def label_EvaluatingProducerDescriptor o      ; "Evaluating Producer"                          end
-  def label_InstanceProducerDescriptor o        ; "Producer[#{o.class_name}]"                    end
-  def label_LookupProducerDescriptor o          ; "Lookup Producer[#{o.name}]"                   end
-  def label_HashLookupProducerDescriptor o      ; "Hash Lookup Producer[#{o.name}][#{o.key}]"    end
-  def label_FirstFoundProducerDescriptor o      ; "First Found Producer"                         end
-  def label_ProducerProducerDescriptor o        ; "Producer[Producer]"                           end
-  def label_MultibindProducerDescriptor o       ; "Multibind Producer"                           end
-  def label_ArrayMultibindProducerDescriptor o  ; "Array Multibind Producer"                     end
-  def label_HashMultibindProducerDescriptor o   ; "Hash Multibind Producer"                      end
-  def label_Bindings o                          ; "Bindings"                                     end
-  def label_NamedBindings o                     ; "Named Bindings"                               end
-  def label_LayeredBindings o                   ; "Layered Bindings"                             end
-  def label_NamedLayer o                        ; "Layer '#{o.name}'"                            end
-  def label_ContributedBindings o               ; "Contributed Bindings"                         end
-  def label_NamedArgument o                     ; "Named Argument"                               end
-
-  def label_Binding(o)
-    'Binding' + (o.multibind_id.nil? ? '' : ' In Multibind')
-  end
-  def label_Multibinding(o)
-    'Multibinding' + (o.multibind_id.nil? ? '' : ' In Multibind')
-  end
-
-end

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

@@ -1,87 +0,0 @@
-require 'rgen/metamodel_builder'
-
-# The ClassLoader provides a Class instance given a class name or a meta-type.
-# If the class is not already loaded, it is loaded using the Puppet Autoloader.
-# This means it can load a class from a gem, or from puppet modules.
-#
-class Puppet::Pops::Binder::BindingsLoader
-  @confdir = Puppet.settings[:confdir]
-
-  # Returns a XXXXX given a fully qualified class name.
-  # Lookup of class is never relative to the calling namespace.
-  # @param name [String, Array<String>, Array<Symbol>, Puppet::Pops::Types::PAnyType] A fully qualified
-  #   class name String (e.g. '::Foo::Bar', 'Foo::Bar'), a PAnyType, or a fully qualified name in Array form where each part
-  #   is either a String or a Symbol, e.g. `%w{Puppetx Puppetlabs SomeExtension}`.
-  # @return [Class, nil] the looked up class or nil if no such class is loaded
-  # @raise ArgumentError If the given argument has the wrong type
-  # @api public
-  #
-  def self.provide(scope, name)
-    case name
-    when String
-      provide_from_string(scope, name)
-
-    when Array
-      provide_from_name_path(scope, name.join('::'), name)
-
-    else
-      raise ArgumentError, "Cannot provide a bindings from a '#{name.class.name}'"
-    end
-  end
-
-  # If loadable name exists relative to a a basedir or not. Returns the loadable path as a side effect.
-  # @return [String, nil] a loadable path for the given name, or nil
-  #
-  def self.loadable?(basedir, name)
-    # note, "lib" is added by the autoloader
-    #
-    paths_for_name(name).find {|p| Puppet::FileSystem.exist?(File.join(basedir, "lib/puppet/bindings", p)+'.rb') }
-  end
-
-  def self.loader()
-    @autoloader ||= Puppet::Util::Autoload.new("BindingsLoader", "puppet/bindings")
-  end
-  private_class_method :loader
-
-  def self.provide_from_string(scope, name)
-    name_path = name.split('::')
-    # always from the root, so remove an empty first segment
-    if name_path[0].empty?
-      name_path = name_path[1..-1]
-    end
-    provide_from_name_path(scope, name, name_path)
-  end
-  private_class_method :provide_from_string
-
-  def self.provide_from_name_path(scope, name, name_path)
-    # If bindings is already loaded, try this first
-    result = Puppet::Bindings.resolve(scope, name)
-
-    unless result
-      # Attempt to load it using the auto loader
-      paths_for_name(name).find {|path| loader.load(path, Puppet.lookup(:current_environment)) }
-      result = Puppet::Bindings.resolve(scope, name)
-    end
-    result
-  end
-  private_class_method :provide_from_name_path
-
-  def self.paths_for_name(fq_name)
-    [de_camel(fq_name), downcased_path(fq_name)].uniq
-  end
-  private_class_method :paths_for_name
-
-  def self.downcased_path(fq_name)
-    fq_name.to_s.gsub(/::/, '/').downcase
-  end
-  private_class_method :downcased_path
-
-  def self.de_camel(fq_name)
-    fq_name.to_s.gsub(/::/, '/').
-    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-    gsub(/([a-z\d])([A-Z])/,'\1_\2').
-    tr("-", "_").
-    downcase
-  end
-  private_class_method :de_camel
-end

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

@@ -1,70 +0,0 @@
-require 'rgen/metamodel_builder'
-
-module Puppet::Pops
-module Binder
-# The Bindings model is a model of Key to Producer mappings (bindings).
-# It is composed of a meta-model part (bindings_model_meta.rb), and
-# and implementation part (this file).
-#
-# @see BindingsFactory The BindingsFactory for more details on how to create model instances.
-# @api public
-require 'puppet/pops/binder/bindings_model_meta'
-
-# TODO: See PUP-2978 for possible performance optimization
-
-# Mix in implementation into the generated code
-module Bindings
-  class BindingsModelObject
-    include Visitable
-    include Adaptable
-    include Containment
-  end
-
-  class ConstantProducerDescriptor
-    module ClassModule
-      def setValue(v)
-        @value = v
-      end
-      def getValue()
-        @value
-      end
-      def value=(v)
-        @value = v
-      end
-    end
-  end
-
-  class NamedArgument
-    module ClassModule
-      def setValue(v)
-        @value = v
-      end
-      def getValue()
-        @value
-      end
-      def value=(v)
-        @value = v
-      end
-    end
-  end
-
-  class InstanceProducerDescriptor
-    module ClassModule
-      def addArguments(val, index =-1)
-        @arguments ||= []
-        @arguments.insert(index, val)
-      end
-      def removeArguments(val)
-        raise "unsupported operation"
-      end
-      def setArguments(values)
-        @arguments = []
-        values.each {|v| addArguments(v) }
-      end
-    end
-  end
-
-end
-end
-end
-

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

@@ -1,215 +0,0 @@
-
-# Dumps a Pops::Binder::Bindings model in reverse polish notation; i.e. LISP style
-# The intention is to use this for debugging output
-# TODO: BAD NAME - A DUMP is a Ruby Serialization
-# NOTE: use :break, :indent, :dedent in lists to do just that
-#
-class Puppet::Pops::Binder::BindingsModelDumper < Puppet::Pops::Model::TreeDumper
-  Bindings = Puppet::Pops::Binder::Bindings
-
-  attr_reader :type_calculator
-  attr_reader :expression_dumper
-
-  def initialize
-    super
-    @type_calculator = Puppet::Pops::Types::TypeCalculator.new()
-    @expression_dumper = Puppet::Pops::Model::ModelTreeDumper.new()
-  end
-
-  def dump_BindingsFactory o
-    do_dump(o.model)
-  end
-
-  def dump_BindingsBuilder o
-    do_dump(o.model)
-  end
-
-  def dump_BindingsContainerBuilder o
-    do_dump(o.model)
-  end
-
-  def dump_NamedLayer o
-    result = ['named-layer', (o.name.nil? ? '<no-name>': o.name), :indent]
-    if o.bindings
-      o.bindings.each do |b|
-        result << :break
-        result << do_dump(b)
-      end
-    end
-    result << :dedent
-    result
-  end
-
-  def dump_Injector o
-    result = ['injector', :indent,
-      :break,
-      ['entries', do_dump(o.instance_variable_get('@impl').instance_variable_get('@entries'))],
-      :dedent
-    ]
-    result
-  end
-
-  def dump_InjectorEntry o
-    result = ['entry', :indent]
-    result << :break
-    result << ['precedence', o.precedence]
-    result << :break
-    result << ['binding', do_dump(o.binding)]
-    result << :break
-    result << ['producer', do_dump(o.cached_producer)]
-    result << :dedent
-    result
-  end
-
-  def dump_Array o
-    o.collect {|e| do_dump(e) }
-  end
-
-  def dump_Hash o
-    result = ["hash", :indent]
-    o.each do |elem|
-      result << :break
-      result << ["=>", :indent, do_dump(elem[0]), :break, do_dump(elem[1]), :dedent]
-    end
-    result << :dedent
-    result
-  end
-
-  def dump_Integer o
-    o.to_s
-  end
-
-  # Dump a Ruby String in single quotes unless it is a number.
-  def dump_String o
-    "'#{o}'"
-  end
-
-  def dump_NilClass o
-    "()"
-  end
-
-  def dump_Object o
-    ['dev-error-no-polymorph-dump-for:', o.class.to_s, o.to_s]
-  end
-
-  def is_nop? o
-    o.nil? || o.is_a?(Model::Nop) || o.is_a?(AST::Nop)
-  end
-
-  def dump_ProducerDescriptor o
-     result = [o.class.name]
-     result << expression_dumper.dump(o.transformer) if o.transformer
-     result
-  end
-
-  def dump_NonCachingProducerDescriptor o
-    dump_ProducerDescriptor(o) + do_dump(o.producer)
-  end
-
-  def dump_ConstantProducerDescriptor o
-    ['constant', do_dump(o.value)]
-  end
-
-  def dump_EvaluatingProducerDescriptor o
-    result = dump_ProducerDescriptor(o)
-    result << expression_dumper.dump(o.expression)
-  end
-
-  def dump_InstanceProducerDescriptor o
-    # TODO: o.arguments, o. transformer
-    ['instance', o.class_name]
-  end
-
-  def dump_ProducerProducerDescriptor o
-    # skip the transformer lambda...
-    result = ['producer-producer', do_dump(o.producer)]
-    result << expression_dumper.dump(o.transformer) if o.transformer
-    result
-  end
-
-  def dump_LookupProducerDescriptor o
-    ['lookup', do_dump(o.type), o.name]
-  end
-
-  def dump_PAnyType o
-    type_calculator.string(o)
-  end
-
-  def dump_HashLookupProducerDescriptor o
-    # TODO: transformer lambda
-    result = ['hash-lookup', do_dump(o.type), o.name, "[#{do_dump(o.key)}]"]
-    result << expression_dumper.dump(o.transformer) if o.transformer
-    result
-  end
-
-  def dump_FirstFoundProducerDescriptor o
-    # TODO: transformer lambda
-    ['first-found', do_dump(o.producers)]
-  end
-
-  def dump_ArrayMultibindProducerDescriptor o
-    ['multibind-array']
-  end
-
-  def dump_HashMultibindProducerDescriptor o
-    ['multibind-hash']
-  end
-
-  def dump_NamedArgument o
-    "#{o.name} => #{do_dump(o.value)}"
-  end
-
-  def dump_Binding o
-    result = ['bind', :indent]
-    result << 'override' if o.override
-    result << 'abstract' if o.abstract
-    result.concat([do_dump(o.type), o.name])
-    result << :break
-    result << "(in #{o.multibind_id})" if o.multibind_id
-    result << :break
-    result << ['to', do_dump(o.producer)] + do_dump(o.producer_args)
-    result << :dedent
-    result
-  end
-
-  def dump_Multibinding o
-    result = ['multibind', o.id, :indent]
-    result << 'override' if o.override
-    result << 'abstract' if o.abstract
-    result.concat([do_dump(o.type), o.name])
-    result << :break
-    result << "(in #{o.multibind_id})" if o.multibind_id
-    result << :break
-    result << ['to', do_dump(o.producer)] + do_dump(o.producer_args)
-    result << :dedent
-    result
-  end
-
-  def dump_Bindings o
-    do_dump(o.bindings)
-  end
-
-  def dump_NamedBindings o
-    result = ['named-bindings', o.name, :indent]
-    o.bindings.each do |b|
-      result << :break
-      result << do_dump(b)
-    end
-    result << :dedent
-    result
-  end
-
-  def dump_LayeredBindings o
-    result = ['layers', :indent]
-      o.layers.each do |layer|
-        result << :break
-        result << do_dump(layer)
-      end
-    result << :dedent
-    result
-  end
-
-  def dump_ContributedBindings o
-    ['contributed', o.name, do_dump(o.bindings)]
-  end
-end

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

@@ -1,215 +0,0 @@
-require 'rgen/metamodel_builder'
-
-# The Bindings model is a model of Key to Producer mappings (bindings).
-# The central concept is that a Bindings is a nested structure of bindings.
-# A top level Bindings should be a NamedBindings (the name is used primarily
-# in error messages). A Key is a Type/Name combination.
-#
-# TODO: In this version, references to "any object" uses the class Object,
-#       but this is only temporary. The intent is to use specific Puppet Objects
-#       that are typed using the Puppet Type System (to enable serialization).
-#
-# @see Puppet::Pops::Binder::BindingsFactory The BindingsFactory for more details on how to create model instances.
-# @api public
-module Puppet::Pops::Binder::Bindings
-  extend RGen::MetamodelBuilder::ModuleExtension
-
-  # This declaration is used to overcome bugs in RGen. What is really wanted is an Opaque Object
-  # type that does not serialize its values, but such an type does not work when recreating the
-  # meta model from a dump.
-  # Instead, after loading the model, the generated code for type validation must be patched
-  #
-  FakeObject = String
-
-  # @abstract
-  # @api public
-  class BindingsModelObject < RGen::MetamodelBuilder::MMBase
-    abstract
-  end
-
-  # @abstract
-  # @api public
-  #
-  class AbstractBinding < BindingsModelObject
-    abstract
-  end
-
-  # An abstract producer
-  # @abstract
-  # @api public
-  #
-  class ProducerDescriptor < BindingsModelObject
-    abstract
-    contains_one_uni 'transformer', Puppet::Pops::Model::LambdaExpression
-  end
-  # All producers are singleton producers unless wrapped in a non caching producer
-  # where each lookup produces a new instance. It is an error to have a nesting level > 1
-  # and to nest a NonCachingProducerDescriptor.
-  #
-  # @api public
-  #
-  class NonCachingProducerDescriptor < ProducerDescriptor
-    contains_one_uni 'producer', ProducerDescriptor
-  end
-
-  # Produces a constant value (i.e. something of {Puppet::Pops::Types::PDataType PDataType})
-  # @api public
-  #
-  class ConstantProducerDescriptor < ProducerDescriptor
-    # TODO: This should be a typed Puppet Object
-    has_attr 'value', FakeObject
-  end
-
-  # Produces a value by evaluating a Puppet DSL expression.
-  # Note that the expression is not contained as it is part of a Puppet::Pops::Model::Program.
-  # To include the expression in the serialization, the Program it is contained in must be
-  # contained in the same serialization. This can be achieved by containing it in the
-  # ContributedBindings that is the top of a BindingsModel produced and given to the Injector.
-  #
-  # @api public
-  #
-  class EvaluatingProducerDescriptor < ProducerDescriptor
-    has_one 'expression', Puppet::Pops::Model::Expression
-  end
-
-  # An InstanceProducer creates an instance of the given class
-  # Arguments are passed to the class' `new` operator in the order they are given.
-  # @api public
-  #
-  class InstanceProducerDescriptor < ProducerDescriptor
-    # TODO: This should be a typed Puppet Object ??
-    has_many_attr 'arguments', FakeObject, :upperBound => -1
-    has_attr 'class_name', String
-  end
-
-  # A ProducerProducerDescriptor, describes that the produced instance is itself a Producer
-  # that should be used to produce the value.
-  # @api public
-  #
-  class ProducerProducerDescriptor < ProducerDescriptor
-    contains_one_uni 'producer', ProducerDescriptor, :lowerBound => 1
-  end
-
-  # Produces a value by looking up another key (type/name)
-  # @api public
-  #
-  class LookupProducerDescriptor < ProducerDescriptor
-    has_attr 'type', Object
-    has_attr 'name', String
-  end
-
-  # Produces a value by looking up another multibound key, and then looking up
-  # the detail using a detail_key.
-  # This is used to produce a specific service of a given type (such as a SyntaxChecker for the syntax "json").
-  # @api public
-  #
-  class HashLookupProducerDescriptor < LookupProducerDescriptor
-    has_attr 'key', String
-  end
-
-  # Produces a value by looking up each producer in turn. The first existing producer wins.
-  # @api public
-  #
-  class FirstFoundProducerDescriptor < ProducerDescriptor
-    contains_many_uni 'producers', LookupProducerDescriptor
-  end
-
-  # @api public
-  # @abstract
-  class MultibindProducerDescriptor < ProducerDescriptor
-    abstract
-  end
-
-  # Used in a Multibind of Array type unless it has a producer. May explicitly be used as well.
-  # @api public
-  #
-  class ArrayMultibindProducerDescriptor < MultibindProducerDescriptor
-  end
-
-  # Used in a Multibind of Hash type unless it has a producer. May explicitly be used as well.
-  # @api public
-  #
-  class HashMultibindProducerDescriptor < MultibindProducerDescriptor
-  end
-
-  # Plays the role of "Hash[String, Object] entry" but with keys in defined order.
-  #
-  # @api public
-  #
-  class NamedArgument < BindingsModelObject
-    has_attr 'name', String, :lowerBound => 1
-    has_attr 'value', FakeObject
-  end
-
-  # Binds a type/name combination to a producer. Optionally marking the bindidng as being abstract, or being an
-  # override of another binding. Optionally, the binding defines producer arguments passed to the producer when
-  # it is created.
-  #
-  # @api public
-  class Binding < AbstractBinding
-    has_attr 'type', Object
-    has_attr 'name', String
-    has_attr 'override', Boolean
-    has_attr 'abstract', Boolean
-    has_attr 'final', Boolean
-    # If set is a contribution in a multibind
-    has_attr 'multibind_id', String, :lowerBound => 0
-    # Invariant: Only multibinds may have lowerBound 0, all regular Binding must have a producer.
-    contains_one_uni 'producer', ProducerDescriptor, :lowerBound => 0
-    contains_many_uni 'producer_args', NamedArgument, :lowerBound => 0
-  end
-
-
-  # A multibinding is a binding other bindings can contribute to.
-  #
-  # @api public
-  class Multibinding < Binding
-    has_attr 'id', String
-  end
-
-  # A container of Binding instances
-  # @api public
-  #
-  class Bindings < AbstractBinding
-    contains_many_uni 'bindings', AbstractBinding
-  end
-
-  # The top level container of bindings can have a name (for error messages, logging, tracing).
-  # May be nested.
-  # @api public
-  #
-  class NamedBindings < Bindings
-    has_attr 'name', String
-  end
-
-  # A named layer of bindings having the same priority.
-  # @api public
-  class NamedLayer < BindingsModelObject
-    has_attr 'name', String, :lowerBound => 1
-    contains_many_uni 'bindings', NamedBindings
-  end
-
-  # A list of layers with bindings in descending priority order.
-  # @api public
-  #
-  class LayeredBindings < BindingsModelObject
-    contains_many_uni 'layers', NamedLayer
-  end
-
-  # ContributedBindings is a named container of one or more NamedBindings.
-  # The intent is that a bindings producer returns a ContributedBindings that identifies the contributor
-  # as opposed to the names of the different set of bindings. The ContributorBindings name is typically
-  # a technical name that indicates their source (a service).
-  #
-  # When EvaluatingProducerDescriptor is used, it holds a reference to an Expression. That expression
-  # should be contained in the programs referenced in the ContributedBindings that contains that producer.
-  # While the bindings model will still work if this is not the case, it will not serialize and deserialize
-  # correctly.
-  #
-  # @api public
-  #
-  class ContributedBindings < NamedLayer
-    contains_many_uni 'programs', Puppet::Pops::Model::Program
-  end
-
-end