puppet 5.4.0-x86-mingw32 → 5.5.0-x86-mingw32

data/lib/puppet/pops/serialization/json.rb

@@ -1,4 +1,4 @@
-require 'json'
+require 'puppet/util/json'
 
 module Puppet::Pops
 module Serialization
@@ -146,12 +146,12 @@ module JSON
     end
 
     def to_a
-      ::JSON.parse(io_string)
+      ::Puppet::Util::Json.load(io_string)
     end
 
     def to_json
       if @indent > 0
-        ::JSON.pretty_unparse(to_a, { :indent => ' ' * @indent })
+        ::Puppet::Util::Json.dump(to_a, { :pretty => true, :indent => ' ' * @indent })
       else
         io_string
       end
@@ -159,7 +159,7 @@ module JSON
 
     # Write a payload object. Not subject to extensions
     def write_pl(obj)
-      @io << obj.to_json << ','
+      @io << Puppet::Util::Json.dump(obj) << ','
     end
 
     def io_string
@@ -198,7 +198,7 @@ module JSON
       if ext.nil?
         case obj
         when Numeric, String, true, false, nil
-          @io << obj.to_json
+          @io << Puppet::Util::Json.dump(obj)
           write_delim
         else
           raise SerializationError, _("Unable to serialize a %{obj}") % { obj: obj.class.name }
@@ -284,9 +284,9 @@ module JSON
     def parse_io(io)
       case io
       when IO, StringIO
-        ::JSON.parse(io.read)
+        ::Puppet::Util::Json.load(io.read)
       when String
-        ::JSON.parse(io)
+        ::Puppet::Util::Json.load(io)
       else
         io
       end

data/lib/puppet/pops/types/class_loader.rb

@@ -32,8 +32,6 @@ class ClassLoader
     end
   end
 
-  private
-
   def self.provide_from_type(type)
     case type
     when PRuntimeType
@@ -66,12 +64,13 @@ class ClassLoader
     when PPatternType  ; String
     when PEnumType     ; String
     when PFloatType    ; Float
-    when PUndefType      ; NilClass
+    when PUndefType    ; NilClass
     when PCallableType ; Proc
     else
       nil
     end
   end
+  private_class_method :provide_from_type
 
   def self.provide_from_string(name)
     name_path = name.split(TypeFormatter::NAME_SEGMENT_SEPARATOR)
@@ -97,6 +96,7 @@ class ClassLoader
     return nil unless result.is_a?(Module)
     result
   end
+  private_class_method :provide_from_string
 
   def self.find_class(name_path)
     name_path.reduce(Object) do |ns, name|
@@ -107,6 +107,7 @@ class ClassLoader
       end
     end
   end
+  private_class_method :find_class
 
   def self.paths_for_name(fq_named_parts)
     # search two entries, one where all parts are decamelized, and one with names just downcased
@@ -115,6 +116,7 @@ class ClassLoader
     #
     [fq_named_parts.map {|part| de_camel(part)}.join('/'), fq_named_parts.join('/').downcase ]
   end
+  private_class_method :paths_for_name
 
   def self.de_camel(fq_name)
     fq_name.to_s.gsub(/::/, '/').
@@ -123,6 +125,7 @@ class ClassLoader
     tr("-", "_").
     downcase
   end
+  private_class_method :de_camel
 
 end
 end

data/lib/puppet/pops/types/implementation_registry.rb

@@ -8,20 +8,15 @@ module Types
   class ImplementationRegistry
     TYPE_REGEXP_SUBST = TypeFactory.tuple([PRegexpType::DEFAULT, PStringType::NON_EMPTY])
 
-    def self.singleton
-      @singleton ||= new(Loaders.static_loader)
-    end
-
     # Create a new instance. This method is normally only called once
     #
-    # The initializer will create mappings for well known types that can be loaded using the static loader
-    #
-    def initialize(static_loader)
+    # @param parent [ImplementationRegistry, nil] the parent of this registry
+    def initialize(parent = nil)
+      @parent = parent
       @type_names_per_implementation = {}
       @implementations_per_type_name = {}
       @type_name_substitutions = []
       @impl_name_substitutions = []
-      TypeParser.type_map.values.each { |type| register_implementation(type.simple_name, type.class.name, static_loader) }
     end
 
     # Register a bidirectional type mapping.
@@ -29,20 +24,18 @@ module Types
     # @overload register_type_mapping(runtime_type, puppet_type)
     #   @param runtime_type [PRuntimeType] type that represents the runtime module or class to map to a puppet type
     #   @param puppet_type [PAnyType] type that will be mapped to the runtime module or class
-    #   @param loader [Loader::Loader] the loader to use when resolving names
     # @overload register_type_mapping(runtime_type, pattern_replacement)
     #   @param runtime_type [PRuntimeType] type containing the pattern and replacement to map the runtime type to a puppet type
     #   @param puppet_type [Array(Regexp,String)] the pattern and replacement to map a puppet type to a runtime type
-    #   @param loader [Loader::Loader] the loader to use when resolving names
-    def register_type_mapping(runtime_type, puppet_type_or_pattern, loader)
+    def register_type_mapping(runtime_type, puppet_type_or_pattern, _ = nil)
       TypeAsserter.assert_assignable('First argument of type mapping', PRuntimeType::RUBY, runtime_type)
       expr = runtime_type.name_or_pattern
       if expr.is_a?(Array)
         TypeAsserter.assert_instance_of('Second argument of type mapping', TYPE_REGEXP_SUBST, puppet_type_or_pattern)
-        register_implementation_regexp(puppet_type_or_pattern, expr, loader)
+        register_implementation_regexp(puppet_type_or_pattern, expr)
       else
         TypeAsserter.assert_instance_of('Second argument of type mapping', PTypeType::DEFAULT, puppet_type_or_pattern)
-        register_implementation(puppet_type_or_pattern, expr, loader)
+        register_implementation(puppet_type_or_pattern, expr)
       end
     end
 
@@ -50,23 +43,20 @@ module Types
     #
     # @param type_namespace [String] the namespace for the puppet types
     # @param impl_namespace [String] the namespace for the implementations
-    # @param loader [Loader::Loader] the loader to use when resolving names
-    def register_implementation_namespace(type_namespace, impl_namespace, loader)
+    def register_implementation_namespace(type_namespace, impl_namespace, _ = nil)
       ns = TypeFormatter::NAME_SEGMENT_SEPARATOR
       register_implementation_regexp(
         [/\A#{type_namespace}#{ns}(\w+)\z/, "#{impl_namespace}#{ns}\\1"],
-        [/\A#{impl_namespace}#{ns}(\w+)\z/, "#{type_namespace}#{ns}\\1"],
-        loader)
+        [/\A#{impl_namespace}#{ns}(\w+)\z/, "#{type_namespace}#{ns}\\1"])
     end
 
     # Register a bidirectional regexp mapping
     #
     # @param type_name_subst [Array(Regexp,String)] regexp and replacement mapping type names to runtime names
     # @param impl_name_subst [Array(Regexp,String)] regexp and replacement mapping runtime names to type names
-    # @param loader [Loader::Loader] the loader to use when resolving names
-    def register_implementation_regexp(type_name_subst, impl_name_subst, loader)
-      @type_name_substitutions << [type_name_subst, loader]
-      @impl_name_substitutions << [impl_name_subst, loader]
+    def register_implementation_regexp(type_name_subst, impl_name_subst, _ = nil)
+      @type_name_substitutions << type_name_subst
+      @impl_name_substitutions << impl_name_subst
       nil
     end
 
@@ -74,12 +64,11 @@ module Types
     #
     # @param type [PAnyType,String] the type or type name
     # @param impl_module[Module,String] the module or module name
-    # @param loader [Loader::Loader] the loader to use when resolving names
-    def register_implementation(type, impl_module, loader)
+    def register_implementation(type, impl_module, _ = nil)
       type = type.name if type.is_a?(PAnyType)
       impl_module = impl_module.name if impl_module.is_a?(Module)
-      @type_names_per_implementation[impl_module] = [type, loader]
-      @implementations_per_type_name[type] = [impl_module, loader]
+      @type_names_per_implementation[impl_module] = type
+      @implementations_per_type_name[type] = impl_module
       nil
     end
 
@@ -89,7 +78,8 @@ module Types
     # @return [String,nil] the name of the implementation module, or `nil` if no mapping was found
     def module_name_for_type(type)
       type = type.name if type.is_a?(PAnyType)
-      find_mapping(type, @implementations_per_type_name, @type_name_substitutions)
+      name = @parent.module_name_for_type(type) unless @parent.nil?
+      name.nil? ? find_mapping(type, @implementations_per_type_name, @type_name_substitutions) : name
     end
 
     # Find the module that corresponds to the given type or type name
@@ -97,18 +87,19 @@ module Types
     # @param type [PAnyType,String] the name of the type
     # @return [Module,nil] the name of the implementation module, or `nil` if no mapping was found
     def module_for_type(type)
-      name_and_loader = module_name_for_type(type)
+      name = module_name_for_type(type)
       # TODO Shouldn't ClassLoader be module specific?
-      name_and_loader.nil? ? nil : ClassLoader.provide(name_and_loader[0])
+      name.nil? ? nil : ClassLoader.provide(name)
     end
 
     # Find the type name and loader that corresponds to the given runtime module or module name
     #
     # @param impl_module [Module,String] the implementation class or class name
-    # @return [Array(String,Loader::Loader),nil] the name and loader of the type, or `nil` if no mapping was found
+    # @return [String,nil] the name of the type, or `nil` if no mapping was found
     def type_name_for_module(impl_module)
       impl_module = impl_module.name if impl_module.is_a?(Module)
-      find_mapping(impl_module, @type_names_per_implementation, @impl_name_substitutions)
+      name = @parent.type_name_for_module(impl_module) unless @parent.nil?
+      name.nil? ? find_mapping(impl_module, @type_names_per_implementation, @impl_name_substitutions) : name
     end
 
     # Find the name for, and then load, the type  that corresponds to the given runtime module or module name
@@ -118,20 +109,22 @@ module Types
     # @param impl_module [Module,String] the implementation class or class name
     # @return [PAnyType,nil] the type, or `nil` if no mapping was found
     def type_for_module(impl_module)
-      name_and_loader = type_name_for_module(impl_module)
-      if name_and_loader.nil?
+      name = type_name_for_module(impl_module)
+      if name.nil?
         nil
       else
-        TypeParser.singleton.parse(*name_and_loader)
+        TypeParser.singleton.parse(name)
       end
     end
 
+    private
+
     def find_mapping(name, names, substitutions)
       found = names[name]
       if found.nil?
         substitutions.each do |subst|
-          substituted = name.sub(*subst[0])
-          return [substituted, subst[1]] unless substituted == name
+          substituted = name.sub(*subst)
+          return substituted unless substituted == name
         end
       end
       found

data/lib/puppet/pops/types/p_object_type.rb

@@ -484,6 +484,7 @@ class PObjectType < PMetaType
     # @api private
   def create_new_function
     impl_class = implementation_class
+    return impl_class.create_new_function(self) if impl_class.respond_to?(:create_new_function)
 
     (param_names, param_types, required_param_count) = parameter_info(impl_class)
 
@@ -532,14 +533,13 @@ class PObjectType < PMetaType
   def implementation_class(create = true)
     if @implementation_class.nil? && create
       ir = Loaders.implementation_registry
-      impl_name = ir.nil? ? nil : ir.module_name_for_type(self)
-      if impl_name.nil?
+      class_name = ir.nil? ? nil : ir.module_name_for_type(self)
+      if class_name.nil?
         # Use generator to create a default implementation
         @implementation_class = RubyGenerator.new.create_class(self)
         @implementation_class.class_eval(&@implementation_override) if instance_variable_defined?(:@implementation_override)
       else
         # Can the mapping be loaded?
-        class_name = impl_name[0]
         @implementation_class = ClassLoader.provide(class_name)
 
         raise Puppet::Error, "Unable to load class #{class_name}" if @implementation_class.nil?

data/lib/puppet/pops/types/p_timespan_type.rb

@@ -3,7 +3,7 @@ module Types
   class PAbstractTimeDataType < PScalarType
     # @param from [AbstractTime] lower bound for this type. Nil or :default means unbounded
     # @param to [AbstractTime] upper bound for this type. Nil or :default means unbounded
-    def initialize(from, to)
+    def initialize(from, to = nil)
       @from = convert_arg(from, true)
       @to = convert_arg(to, false)
       raise ArgumentError, "'from' must be less or equal to 'to'. Got (#{@from}, #{@to}" unless @from <= @to
@@ -161,7 +161,7 @@ module Types
         end
 
         def from_fields(days, hours, minutes, seconds, milliseconds = 0, microseconds = 0, nanoseconds = 0)
-          Time::Timespan.from_fields(days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds)
+          Time::Timespan.from_fields(false, days, hours, minutes, seconds, milliseconds, microseconds, nanoseconds)
         end
 
         def from_string_hash(args_hash)

data/lib/puppet/pops/types/p_type_set_type.rb

@@ -23,6 +23,10 @@ class PTypeSetType < PMetaType
       @type_set.name_authority
     end
 
+    def model_loader
+      @type_set.loader
+    end
+
     def find(typed_name)
       if typed_name.type == :type && typed_name.name_authority == @type_set.name_authority
         type = @type_set[typed_name.name]
@@ -48,7 +52,7 @@ class PTypeSetType < PMetaType
     TypeFactory.optional(KEY_NAME_AUTHORITY) => Pcore::TYPE_URI,
     TypeFactory.optional(KEY_NAME) => Pcore::TYPE_QUALIFIED_REFERENCE,
     TypeFactory.optional(KEY_VERSION) => TYPE_STRING_OR_VERSION,
-    TypeFactory.optional(KEY_TYPES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, PTypeType::DEFAULT, PCollectionType::NOT_EMPTY_SIZE),
+    TypeFactory.optional(KEY_TYPES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, PVariantType.new([PTypeType::DEFAULT, PObjectType::TYPE_OBJECT_I12N]), PCollectionType::NOT_EMPTY_SIZE),
     TypeFactory.optional(KEY_REFERENCES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, TYPE_TYPE_REFERENCE_I12N, PCollectionType::NOT_EMPTY_SIZE),
     TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS,
   })
@@ -288,6 +292,25 @@ class PTypeSetType < PMetaType
       types.each do |type_name, value|
         full_name = "#{@name}::#{type_name}".freeze
         typed_name = Loader::TypedName.new(:type, full_name, name_auth)
+        if value.is_a?(Model::ResourceDefaultsExpression)
+          # This is actually a <Parent> { <key-value entries> } notation. Convert to a literal hash that contains the parent
+          n = value.type_ref
+          name = n.cased_value
+          entries = []
+          unless name == 'Object' or name == 'TypeSet'
+            if value.operations.any? { |op| op.attribute_name == KEY_PARENT }
+              case Puppet[:strict]
+              when :warning
+                IssueReporter.warning(value, Issues::DUPLICATE_KEY, :key => KEY_PARENT)
+              when :error
+                IssueReporter.error(Puppet::ParseErrorWithIssue, value, Issues::DUPLICATE_KEY, :key => KEY_PARENT)
+              end
+            end
+            entries << Model::KeyedEntry.new(n.locator, n.offset, n.length, KEY_PARENT, n)
+          end
+          value.operations.each { |op| entries << Model::KeyedEntry.new(op.locator, op.offset, op.length, op.attribute_name, op.value_expr) }
+          value = Model::LiteralHash.new(value.locator, value.offset, value.length, entries)
+        end
         type = Loader::TypeDefinitionInstantiator.create_type(full_name, value, name_auth)
         loader.set_entry(typed_name, type, value.locator.to_uri(value))
         types[type_name] = type

data/lib/puppet/pops/types/ruby_generator.rb

@@ -158,7 +158,7 @@ class RubyGenerator < TypeFormatter
       ir = Loaders.implementation_registry
       impl_name = ir.module_name_for_type(type)
       raise Puppet::Error, "Unable to create an instance of #{type.name}. No mapping exists to runtime object" if impl_name.nil?
-      impl_name[0]
+      impl_name
     end
   end
 
@@ -179,9 +179,8 @@ class RubyGenerator < TypeFormatter
     unless obj.parent.nil?
       if impl_subst.empty?
         ir = Loaders.implementation_registry
-        parent_impl = ir.module_name_for_type(obj.parent)
-        raise Puppet::Error, "Unable to create an instance of #{obj.parent.name}. No mapping exists to runtime object" if parent_impl.nil?
-        parent_name = parent_impl[0]
+        parent_name = ir.module_name_for_type(obj.parent)
+        raise Puppet::Error, "Unable to create an instance of #{obj.parent.name}. No mapping exists to runtime object" if parent_name.nil?
       else
         parent_name = obj.parent.name.gsub(*impl_subst)
       end

data/lib/puppet/pops/types/type_calculator.rb

@@ -159,7 +159,7 @@ class TypeCalculator
       t = type(t)
     end
     t.is_a?(PAnyType) ? t.assignable?(t2) : false
- end
+  end
 
   # Returns an iterable if the t represents something that can be iterated
   def enumerable(t)

data/lib/puppet/pops/types/type_factory.rb

@@ -210,8 +210,6 @@ module TypeFactory
     case args.size
     when 0
       PTimestampType::DEFAULT
-    when 1
-      PTimestampType.new(args[0], args[0])
     else
       PTimestampType.new(*args)
     end
@@ -221,8 +219,6 @@ module TypeFactory
     case args.size
     when 0
       PTimespanType::DEFAULT
-    when 1
-      PTimespanType.new(args[0], args[0])
     else
       PTimespanType.new(*args)
     end

data/lib/puppet/pops/types/type_mismatch_describer.rb

@@ -19,7 +19,7 @@ module Types
     def eql?(o)
       self == o
     end
-   end
+  end
 
   # @api private
   class SubjectPathElement < TypePathElement

data/lib/puppet/pops/types/type_parser.rb

@@ -290,7 +290,14 @@ class TypeParser
 
   # @api private
   def loader_from_context(ast, context)
-    Adapters::LoaderAdapter.loader_for_model_object(ast, nil, context)
+    model_loader = Adapters::LoaderAdapter.loader_for_model_object(ast, nil, context)
+    if context.is_a?(PTypeSetType::TypeSetLoader)
+      # Only swap a given TypeSetLoader for another loader when the other loader is different
+      # from the one associated with the TypeSet expression
+      context.model_loader.equal?(model_loader.parent) ? context : model_loader
+    else
+      model_loader
+    end
   end
 
   # @api private
@@ -489,9 +496,9 @@ class TypeParser
         end
       elsif parameters.size != 2
         raise_invalid_parameters_error('Integer', '1 or 2', parameters.size)
-     else
-       TypeFactory.range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
-     end
+      else
+        TypeFactory.range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
+      end
 
     when 'object'
       raise_invalid_parameters_error('Object', 1, parameters.size) unless parameters.size == 1
@@ -529,9 +536,9 @@ class TypeParser
         end
       elsif parameters.size != 2
         raise_invalid_parameters_error('Float', '1 or 2', parameters.size)
-     else
-       TypeFactory.float_range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
-     end
+      else
+        TypeFactory.float_range(parameters[0] == :default ? nil : parameters[0], parameters[1] == :default ? nil : parameters[1])
+      end
 
     when 'string'
       size_type =