puppet 3.8.7-x64-mingw32 → 4.0.0.rc1-x64-mingw32

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

@@ -202,7 +202,7 @@ class Puppet::Pops::Binder::Binder
     # @api private
     #
     def bind(binding)
-      @@bind_visitor.visit_this(self, binding)
+      @@bind_visitor.visit_this_0(self, binding)
     end
 
     # @return [Puppet::Pops::Binder::InjectorEntry] the entry with the highest precedence
@@ -312,7 +312,7 @@ class Puppet::Pops::Binder::Binder
     def bind_LayeredBindings(o)
       o.layers.each do |layer|
         processor = LayerProcessor.new(binder, key_factory)
-        # All except abstract (==error) are transfered to injector_entries
+        # All except abstract (==error) are transferred to injector_entries
 
         processor.bind(layer).each do |k, v|
           entry = binder.injector_entries[k]
@@ -325,7 +325,8 @@ class Puppet::Pops::Binder::Binder
             raise ArgumentError, "Internal Error - redefinition of key: #{k}, (should never happen)" if entry
             binder.injector_entries[k] = v
           else
-            entry ? entry << v : binder.injector_entries[k] = v
+            # add contributions to existing contributions, else set them
+            binder.injector_entries[k] = entry ? entry + v : v
           end
         end
       end
@@ -380,7 +381,7 @@ class Puppet::Pops::Binder::Binder
           bkey = key(b.binding)
           this_layer[bkey] = b
           bkey
-        end
+        end.flatten
         contributions_key = key_factory.multibind_contributions(k)
         unless this_layer[contributions_key]
           this_layer[contributions_key] = []

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

@@ -9,6 +9,8 @@
 # TODO: If same config is loaded in a higher layer, skip it in the lower (since it is meaningless to load it again with lower
 #       precedence. (Optimization, or possibly an error, should produce a warning).
 #
+require 'puppet/plugins/binding_schemes'
+
 class Puppet::Pops::Binder::BindingsComposer
 
   # The BindingsConfig instance holding the read and parsed, but not evaluated configuration
@@ -70,8 +72,8 @@ class Puppet::Pops::Binder::BindingsComposer
         # do this in category 'extensions' to allow them to override the 'default'
         bind do
           name(scheme)
-          instance_of(::Puppetx::BINDINGS_SCHEMES_TYPE)
-          in_multibind(::Puppetx::BINDINGS_SCHEMES)
+          instance_of(Puppet::Plugins::BindingSchemes::BINDINGS_SCHEMES_TYPE)
+          in_multibind(Puppet::Plugins::BindingSchemes::BINDINGS_SCHEMES_KEY)
           to_instance(class_name)
           end
       end
@@ -157,7 +159,7 @@ class Puppet::Pops::Binder::BindingsComposer
 
   class SchemeHandlerHelper
     T = Puppet::Pops::Types::TypeFactory
-    HASH_OF_HANDLER = T.hash_of(T.type_of('Puppetx::Puppet::BindingsSchemeHandler'))
+    HASH_OF_HANDLER = T.hash_of(T.type_of(Puppet::Plugins::BindingSchemes::BINDINGS_SCHEMES_TYPE))
     def initialize(scope)
       @scope = scope
       @cache = nil
@@ -168,7 +170,7 @@ class Puppet::Pops::Binder::BindingsComposer
     end
 
     def load_schemes
-      @cache = @scope.compiler.boot_injector.lookup(@scope, HASH_OF_HANDLER, Puppetx::BINDINGS_SCHEMES) || {}
+      @cache = @scope.compiler.boot_injector.lookup(@scope, HASH_OF_HANDLER, Puppet::Plugins::BindingSchemes::BINDINGS_SCHEMES_KEY) || {}
     end
   end
 

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

@@ -389,6 +389,10 @@ module Puppet::Pops::Binder::BindingsFactory
       else
         raise ArgumentError, "to_instance accepts String (a class name), or a Class.*args got: #{type.class}."
       end
+
+      # Help by setting the type - since if an to_instance is bound, the type is know. This avoids having
+      # to specify the same thing twice.
+      self.instance_of(type)
       model.producer = Puppet::Pops::Binder::BindingsFactory.instance_producer(class_name, *args)
     end
 

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

@@ -10,7 +10,7 @@ class Puppet::Pops::Binder::BindingsLabelProvider < Puppet::Pops::LabelProvider
   # @return [String] a human readable label
   #
   def label o
-   @@label_visitor.visit(o)
+   @@label_visitor.visit_this_0(self, o)
   end
 
   def label_PAnyType o                          ; "#{Puppet::Pops::Types::TypeFactory.label(o)}" end

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

@@ -6,7 +6,6 @@ require 'rgen/metamodel_builder'
 #
 class Puppet::Pops::Binder::BindingsLoader
   @confdir = Puppet.settings[:confdir]
-#  @autoloader = Puppet::Util::Autoload.new("BindingsLoader", "puppet/bindings", :wrap => false)
 
   # Returns a XXXXX given a fully qualified class name.
   # Lookup of class is never relative to the calling namespace.
@@ -42,11 +41,7 @@ class Puppet::Pops::Binder::BindingsLoader
   private
 
   def self.loader()
-    unless Puppet.settings[:confdir] == @confdir
-      @confdir = Puppet.settings[:confdir] == @confdir
-      @autoloader = Puppet::Util::Autoload.new("BindingsLoader", "puppet/bindings", :wrap => false)
-    end
-    @autoloader
+    @autoloader ||= Puppet::Util::Autoload.new("BindingsLoader", "puppet/bindings")
   end
 
   def self.provide_from_string(scope, name)
@@ -64,14 +59,14 @@ class Puppet::Pops::Binder::BindingsLoader
 
     unless result
       # Attempt to load it using the auto loader
-      paths_for_name(name).find {|path| loader.load(path) }
+      paths_for_name(name).find {|path| loader.load(path, Puppet.lookup(:current_environment)) }
       result = Puppet::Bindings.resolve(scope, name)
     end
     result
   end
 
   def self.paths_for_name(fq_name)
-    [de_camel(fq_name), downcased_path(fq_name)]
+    [de_camel(fq_name), downcased_path(fq_name)].uniq
   end
 
   def self.downcased_path(fq_name)

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

@@ -40,17 +40,39 @@ class Puppet::Pops::Binder::BindingsModelDumper < Puppet::Pops::Model::TreeDumpe
     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_Array o
-    o.collect {|e| do_dump(e) }
+  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_ASTArray o
-    ["[]"] + o.children.collect {|x| do_dump(x)}
+  def dump_Array o
+    o.collect {|e| do_dump(e) }
   end
 
-  def dump_ASTHash o
-    ["{}"] + o.value.sort_by{|k,v| k.to_s}.collect {|x| [do_dump(x[0]), do_dump(x[1])]}
+  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
@@ -138,22 +160,28 @@ class Puppet::Pops::Binder::BindingsModelDumper < Puppet::Pops::Model::TreeDumpe
   end
 
   def dump_Binding o
-    result = ['bind']
+    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]
+    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
 

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

@@ -84,8 +84,8 @@ module Puppet::Pops::Binder::Config
       end
 
       unless diagnostics.errors?
-        @layering_config   = data['layers'] or default_layers
-        @scheme_extensions = (data['extensions'] and data['extensions']['scheme_handlers'] or default_scheme_extensions)
+        @layering_config   = data['layers'] || default_layers
+        @scheme_extensions = (data['extensions'] && data['extensions']['scheme_handlers'] || default_scheme_extensions)
       else
         @layering_config = []
         @scheme_extensions = {}

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

@@ -42,7 +42,7 @@ module Puppet::Pops::Binder::Config
         accept(Issues::CONFIG_LAYERS_MISSING, config_file)
       end
 
-      if version = (data['version'] or data[:version])
+      if version = (data['version'] || data[:version])
         accept(Issues::CONFIG_WRONG_VERSION, config_file, {:expected => 1, :actual => version}) unless version == 1
       else
         accept(Issues::CONFIG_VERSION_MISSING, config_file)

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

@@ -20,6 +20,10 @@ module Puppet::Pops::Binder::Config::Issues
     "The configuration file '#{semantic}' has no 'layers' entry in the top level hash"
   end
 
+  CONFIG_CATEGORIES_MISSING = issue :CONFIG_CATEGORIES_MISSING do
+    "The configuration file '#{semantic}' has no 'categories' entry in the top level hash"
+  end
+
   CONFIG_VERSION_MISSING = issue :CONFIG_VERSION_MISSING do
     "The configuration file '#{semantic}' has no 'version' entry in the top level hash"
   end

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

@@ -554,7 +554,6 @@ module Private
       return [] unless contributions = lookup_key(scope, contributions_key)
       contributions.each { |k| result[k] = get_entry(k) }
       result.sort {|a, b| a[0] <=> b[0] }
-      #result.sort_by {|key, entry| entry }
     end
 
     # Produces an injectable class given a key, or nil if key does not represent an injectable class

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

@@ -6,7 +6,7 @@
 # @abstract
 # @api public
 #
-class Puppet::Pops::Binder::SchemeHandler::SymbolicScheme < Puppetx::Puppet::BindingsSchemeHandler
+class Puppet::Pops::Binder::SchemeHandler::SymbolicScheme < Puppet::Plugins::BindingSchemes::BindingsSchemeHandler
 
   # Shared implementation for module: and confdir: since the distinction is only in checks if a symbolic name
   # exists as a loadable file or not. Once this method is called it is assumed that the name is relative

data/lib/puppet/pops/evaluator/access_operator.rb

@@ -39,7 +39,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       fail(Puppet::Pops::Issues::BAD_STRING_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
       # Note that Ruby 1.8.7 requires a length of 1 to produce a String
-      k1 = coerce_numeric(keys[0], @semantic.keys[0], scope)
+      k1 = coerce_numeric(keys[0], @semantic.keys, scope)
       bad_access_key_type(o, 0, k1, Integer) unless k1.is_a?(Integer)
       k2 = 1
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos
@@ -50,8 +50,8 @@ class Puppet::Pops::Evaluator::AccessOperator
         o[ k1, k2 ]
       end
     when 2
-      k1 = coerce_numeric(keys[0], @semantic.keys[0], scope)
-      k2 = coerce_numeric(keys[1], @semantic.keys[1], scope)
+      k1 = coerce_numeric(keys[0], @semantic.keys, scope)
+      k2 = coerce_numeric(keys[1], @semantic.keys, scope)
       [k1, k2].each_with_index { |k,i| bad_access_key_type(o, i, k, Integer) unless k.is_a?(Integer) }
 
       k1 = k1 < 0 ? o.length + k1 : k1           # abs pos (negative is count from end)
@@ -89,11 +89,11 @@ class Puppet::Pops::Evaluator::AccessOperator
     when 0
       fail(Puppet::Pops::Issues::BAD_ARRAY_SLICE_ARITY, @semantic.left_expr, {:actual => keys.size})
     when 1
-      k = coerce_numeric(keys[0], @semantic.keys[0], scope)
-      unless k.is_a?(Integer)
-        bad_access_key_type(o, 0, k, Integer)
+      key = coerce_numeric(keys[0], @semantic.keys[0], scope)
+      unless key.is_a?(Integer)
+        bad_access_key_type(o, 0, key, Integer)
       end
-      o[k]
+      o[key]
     when 2
       # A slice [from, to] with support for -1 to mean start, or end respectively.
       k1 = coerce_numeric(keys[0], @semantic.keys[0], scope)
@@ -142,18 +142,15 @@ class Puppet::Pops::Evaluator::AccessOperator
     end
   end
 
-  # Ruby does not have an infinity constant.  TODO: Consider having one constant in Puppet. Now it is in several places.
-  INFINITY = 1.0 / 0.0
-
   def access_PEnumType(o, scope, keys)
     keys.flatten!
-    assert_keys(keys, o, 1, INFINITY, String)
+    assert_keys(keys, o, 1, Float::INFINITY, String)
     Puppet::Pops::Types::TypeFactory.enum(*keys)
   end
 
   def access_PVariantType(o, scope, keys)
     keys.flatten!
-    assert_keys(keys, o, 1, INFINITY, Puppet::Pops::Types::PAnyType)
+    assert_keys(keys, o, 1, Float::INFINITY, Puppet::Pops::Types::PAnyType)
     Puppet::Pops::Types::TypeFactory.variant(*keys)
   end
 
@@ -166,7 +163,7 @@ class Puppet::Pops::Evaluator::AccessOperator
       size_type = TYPEFACTORY.range(keys[-1], :default)
       keys = keys[0, keys.size - 1]
     end
-    assert_keys(keys, o, 1, INFINITY, Puppet::Pops::Types::PAnyType)
+    assert_keys(keys, o, 1, Float::INFINITY, Puppet::Pops::Types::PAnyType)
     t = Puppet::Pops::Types::TypeFactory.tuple(*keys)
     # set size type, or nil for default (exactly 1)
     t.size_type = size_type
@@ -201,13 +198,13 @@ class Puppet::Pops::Evaluator::AccessOperator
   # @param keys [Array<Object>] the evaluated keys
   # @param o [Object] evaluated LHS reported as :base_type
   # @param min [Integer] the minimum number of keys (typically 1)
-  # @param max [Numeric] the maximum number of keys (use same as min, specific number, or INFINITY)
+  # @param max [Numeric] the maximum number of keys (use same as min, specific number, or Float::INFINITY)
   # @param allowed_classes [Class] a variable number of classes that each key must be an instance of (any)
   # @api private
   #
   def assert_keys(keys, o, min, max, *allowed_classes)
     size = keys.size
-    unless size.between?(min, max || INFINITY)
+    unless size.between?(min, max || Float::INFINITY)
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, :base_type => o, :min=>1, :max => max, :actual => keys.size)
     end
     keys.each_with_index do |k, i|
@@ -247,44 +244,24 @@ class Puppet::Pops::Evaluator::AccessOperator
 
   def access_PPatternType(o, scope, keys)
     keys.flatten!
-    assert_keys(keys, o, 1, INFINITY, String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::Types::PRegexpType)
+    assert_keys(keys, o, 1, Float::INFINITY, String, Regexp, Puppet::Pops::Types::PPatternType, Puppet::Pops::Types::PRegexpType)
     Puppet::Pops::Types::TypeFactory.pattern(*keys)
   end
 
   def access_POptionalType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
-      type = keys[0]
-      unless type.is_a?(Puppet::Pops::Types::PAnyType) || type.is_a?(String)
-        fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Optional-Type', :actual => type.class})
+      unless keys[0].is_a?(Puppet::Pops::Types::PAnyType)
+        fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_TYPE, @semantic.keys[0], {:base_type => 'Optional-Type', :actual => keys[0].class})
       end
-      TYPEFACTORY.optional(type)
+      result = Puppet::Pops::Types::POptionalType.new()
+      result.optional_type = keys[0]
+      result
     else
       fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'Optional-Type', :min => 1, :actual => keys.size})
     end
   end
 
-  def access_PNotUndefType(o, scope, keys)
-    keys.flatten!
-    case keys.size
-    when 0
-      TYPEFACTORY.not_undef
-    when 1
-      type = keys[0]
-      case type
-      when String
-        type = TYPEFACTORY.string(type)
-      when Puppet::Pops::Types::PAnyType
-        type = nil if type.class == Puppet::Pops::Types::PAnyType
-      else
-        fail(Puppet::Pops::Issues::BAD_NOT_UNDEF_SLICE_TYPE, @semantic.keys[0], {:base_type => 'NotUndef-Type', :actual => type.class})
-      end
-      TYPEFACTORY.not_undef(type)
-    else
-      fail(Puppet::Pops::Issues::BAD_TYPE_SLICE_ARITY, @semantic, {:base_type => 'NotUndef-Type', :min => 0, :max => 1, :actual => keys.size})
-    end
-  end
-
   def access_PType(o, scope, keys)
     keys.flatten!
     if keys.size == 1
@@ -317,9 +294,6 @@ class Puppet::Pops::Evaluator::AccessOperator
     end
     ranged_integer = Puppet::Pops::Types::PIntegerType.new()
     from, to = keys
-    # NOTE! Do not merge the following line to 4.x. It has the same check in the initialize method
-    raise ArgumentError, "'from' must be less or equal to 'to'. Got (#{from}, #{to}" if from.is_a?(Numeric) && to.is_a?(Numeric) && from > to
-
     ranged_integer.from = from == :default ? nil : from
     ranged_integer.to = to == :default ? nil : to
     ranged_integer
@@ -336,9 +310,6 @@ class Puppet::Pops::Evaluator::AccessOperator
     end
     ranged_float = Puppet::Pops::Types::PFloatType.new()
     from, to = keys
-    # NOTE! Do not merge the following line to 4.x. It has the same check in the initialize method
-    raise ArgumentError, "'from' must be less or equal to 'to'. Got (#{from}, #{to}" if from.is_a?(Numeric) && to.is_a?(Numeric) && from > to
-
     ranged_float.from = from == :default || from.nil? ? nil : Float(from)
     ranged_float.to = to == :default || to.nil? ? nil : Float(to)
     ranged_float
@@ -434,9 +405,6 @@ class Puppet::Pops::Evaluator::AccessOperator
       end
       ranged_integer = Puppet::Pops::Types::PIntegerType.new()
       from, to = keys
-      # NOTE! Do not merge the following line to 4.x. It has the same check in the initialize method
-      raise ArgumentError, "'from' must be less or equal to 'to'. Got (#{from}, #{to}" if from.is_a?(Numeric) && to.is_a?(Numeric) && from > to
-
       ranged_integer.from = from == :default ? nil : from
       ranged_integer.to = to == :default ? nil : to
       ranged_integer

data/lib/puppet/pops/evaluator/callable_mismatch_describer.rb

@@ -17,9 +17,9 @@ module Puppet::Pops::Evaluator::CallableMismatchDescriber
       result << "expected:\n  #{name}(#{signature_string(signature)}) - #{arg_count_string(signature.type)}"
     else
       result << "expected one of:\n"
-      result << supported_signatures.map do |signature|
-        params_type = signature.type.param_types
-        "  #{name}(#{signature_string(signature)}) - #{arg_count_string(signature.type)}"
+      result << supported_signatures.map do |sig|
+        params_type = sig.type.param_types
+        "  #{name}(#{signature_string(sig)}) - #{arg_count_string(sig.type)}"
       end.join("\n")
     end
 
@@ -157,14 +157,14 @@ module Puppet::Pops::Evaluator::CallableMismatchDescriber
   #   * from and to are equal => `{from}`
   #   * from and to are both and 1 and squelch_one == true => `''`
   #   * from is 0 and to is 1 => `'?'`
-  #   * to is INFINITY => `{from, }`
+  #   * to is Float::INFINITY => `{from, }`
   #
   # @api private
   def self.range_string(size_range, squelch_one = true)
     from, to = size_range
     if from == to
       (squelch_one && from == 1) ? '' : "{#{from}}"
-    elsif to == Puppet::Pops::Types::INFINITY
+    elsif to == Float::INFINITY
       "{#{from},}"
     elsif from == 0 && to == 1
       '?'