puppet 5.0.0 → 6.0.0

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', PType::DEFAULT, puppet_type_or_pattern)
-        register_implementation(puppet_type_or_pattern, expr, loader)
+        TypeAsserter.assert_instance_of('Second argument of type mapping', PTypeType::DEFAULT, puppet_type_or_pattern)
+        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/iterable.rb

@@ -1,4 +1,12 @@
 module Puppet::Pops::Types
+
+  # Implemented by classes that can produce an iterator to iterate over their contents
+  module IteratorProducer
+    def iterator
+      raise ArgumentError, 'iterator() is not implemented'
+    end
+  end
+
   # The runtime Iterable type for an Iterable
   module Iterable
     # Produces an `Iterable` for one of the following types with the following characterstics:
@@ -25,7 +33,7 @@ module Puppet::Pops::Types
       iter
     end
 
-    # Produces an `Iterable` for one of the following types with the following characterstics:
+    # Produces an `Iterable` for one of the following types with the following characteristics:
     #
     # `String`       - yields each character in the string
     # `Array`        - yields each element in the array
@@ -40,11 +48,14 @@ module Puppet::Pops::Types
     # The value `nil` is returned for all other objects.
     #
     # @param o [Object] The object to produce an `Iterable` for
+    # @param element_type [PAnyType] the element type for the iterator. Optional (inferred if not provided)
     # @return [Iterable,nil] The produced `Iterable` or `nil` if it couldn't be produced
     #
     # @api public
-    def self.on(o)
+    def self.on(o, element_type = nil)
       case o
+      when IteratorProducer
+        o.iterator
       when Iterable
         o
       when String
@@ -53,18 +64,24 @@ module Puppet::Pops::Types
         if o.empty?
           Iterator.new(PUnitType::DEFAULT, o.each)
         else
-          tc = TypeCalculator.singleton
-          Iterator.new(PVariantType.maybe_create(o.map {|e| tc.infer_set(e) }), o.each)
+          if element_type.nil?
+            tc = TypeCalculator.singleton
+            element_type = PVariantType.maybe_create(o.map {|e| tc.infer_set(e) })
+          end
+          Iterator.new(element_type, o.each)
         end
       when Hash
         # Each element is a two element [key, value] tuple.
         if o.empty?
-          Iterator.new(PHashType::DEFAULT_KEY_PAIR_TUPLE, o.each)
+          HashIterator.new(PHashType::DEFAULT_KEY_PAIR_TUPLE, o.each)
         else
-          tc = TypeCalculator.singleton
-          Iterator.new(PTupleType.new([
-            PVariantType.maybe_create(o.keys.map {|e| tc.infer_set(e) }),
-            PVariantType.maybe_create(o.values.map {|e| tc.infer_set(e) })], PHashType::KEY_PAIR_TUPLE_SIZE), o.each_pair)
+          if element_type.nil?
+            tc = TypeCalculator.singleton
+            element_type = PTupleType.new([
+              PVariantType.maybe_create(o.keys.map {|e| tc.infer_set(e) }),
+              PVariantType.maybe_create(o.values.map {|e| tc.infer_set(e) })], PHashType::KEY_PAIR_TUPLE_SIZE)
+          end
+          HashIterator.new(element_type, o.each_pair)
         end
       when Integer
         if o == 0
@@ -79,6 +96,8 @@ module Puppet::Pops::Types
         o.finite_range? ? IntegerRangeIterator.new(o) : nil
       when PEnumType
         Iterator.new(o, o.values.each)
+      when PTypeAliasType
+        on(o.resolved_type)
       when Range
         min = o.min
         max = o.max
@@ -132,13 +151,13 @@ module Puppet::Pops::Types
     def reverse_each(&block)
       # Default implementation cannot propagate reverse_each to a new enumerator so chained
       # calls must put reverse_each last.
-      raise ArgumentError 'reverse_each() is not implemented'
+      raise ArgumentError, 'reverse_each() is not implemented'
     end
 
     def step(step, &block)
       # Default implementation cannot propagate step to a new enumerator so chained
       # calls must put stepping last.
-      raise ArgumentError 'step() is not implemented'
+      raise ArgumentError, 'step() is not implemented'
     end
 
     def to_a
@@ -146,6 +165,10 @@ module Puppet::Pops::Types
       super
     end
 
+    def hash_style?
+      false
+    end
+
     def unbounded?
       true
     end
@@ -218,6 +241,14 @@ module Puppet::Pops::Types
     end
   end
 
+  # Special iterator used when iterating over hashes. Returns `true` for `#hash_style?` so that
+  # it is possible to differentiate between two element arrays and key => value associations
+  class HashIterator < Iterator
+    def hash_style?
+      true
+    end
+  end
+
   # @api private
   class StepIterator < Iterator
     include Enumerable

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

@@ -2,8 +2,15 @@ require 'base64'
 module Puppet::Pops
 module Types
 
-# A Puppet Language Type that exposes the {{SemanticPuppet::Version}} and {{SemanticPuppet::VersionRange}}.
-# The version type is parameterized with version ranges.
+# A Puppet Language Type that represents binary data content (a sequence of 8-bit bytes).
+# Instances of this data type can be created from `String` and `Array[Integer[0,255]]`
+# values. Also see the `binary_file` function for reading binary content from a file.
+#
+# A `Binary` can be converted to `String` and `Array` form - see function `new` for
+# the respective target data type for more information.
+#
+# Instances of this data type serialize as base 64 encoded strings when the serialization
+# format is textual, and as binary content when a serialization format supports this.
 #
 # @api public
 class PBinaryType < PAnyType
@@ -84,8 +91,7 @@ class PBinaryType < PAnyType
     # @api private
     #
     def initialize(bin)
-      # TODO: When Ruby 1.9.3 support is dropped change this to `bin.b` for binary encoding instead of force_encoding
-      @binary_buffer = (bin.encoding.name == "ASCII-8BIT" ? bin : bin.dup.force_encoding("ASCII-8BIT")).freeze
+      @binary_buffer = (bin.encoding.name == "ASCII-8BIT" ? bin : bin.b).freeze
     end
 
     # Presents the binary content as a string base64 encoded string (without line breaks).
@@ -144,8 +150,8 @@ class PBinaryType < PAnyType
   end
 
   # @api private
-  def self.new_function(_, loader)
-    @new_function ||= Puppet::Functions.create_loaded_function(:new_Binary, loader) do
+  def self.new_function(type)
+    @new_function ||= Puppet::Functions.create_loaded_function(:new_Binary, type.loader) do
       local_types do
         type 'ByteInteger = Integer[0,255]'
         type 'Base64Format = Enum["%b", "%u", "%B", "%s", "%r"]'

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

@@ -0,0 +1,238 @@
+module Puppet::Pops
+module Types
+
+# @api public
+class PInitType < PTypeWithContainedType
+  def self.register_ptype(loader, ir)
+    create_ptype(loader, ir, 'AnyType',
+      'type' => {
+        KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
+        KEY_VALUE => nil
+      },
+      'init_args' => {
+        KEY_TYPE => PArrayType::DEFAULT,
+        KEY_VALUE => EMPTY_ARRAY
+      }
+    )
+  end
+
+  attr_reader :init_args
+
+  def initialize(type, init_args)
+    super(type)
+    @init_args = init_args.nil? ? EMPTY_ARRAY : init_args
+
+    if type.nil?
+      raise ArgumentError, _('Init cannot be parameterized with an undefined type and additional arguments') unless @init_args.empty?
+      @initialized = true
+    else
+      @initialized = false
+    end
+  end
+
+  def instance?(o, guard = nil)
+    really_instance?(o, guard) == 1
+  end
+
+  # @api private
+  def really_instance?(o, guard = nil)
+    if @type.nil?
+      TypeFactory.rich_data.really_instance?(o)
+    else
+      assert_initialized
+      guarded_recursion(guard, 0) do |g|
+        v = @type.really_instance?(o, g)
+        if v < 1
+          if @single_type
+            s = @single_type.really_instance?(o, g)
+            v = s if s > v
+          end
+        end
+        if v < 1
+          if @other_type
+            s = @other_type.really_instance?(o, g)
+            s = @other_type.really_instance?([o], g) if s < 0 && @has_optional_single
+            v = s if s > v
+          end
+        end
+        v
+      end
+    end
+  end
+
+  def eql?(o)
+    super && @init_args == o.init_args
+  end
+
+  def hash
+    super ^ @init_args.hash
+  end
+
+  def new_function
+    return super if type.nil?
+    assert_initialized
+
+    target_type = type
+    single_type = @single_type
+    if @init_args.empty?
+      @new_function ||= Puppet::Functions.create_function(:new_Init, Puppet::Functions::InternalFunction) do
+        @target_type = target_type
+        @single_type = single_type
+
+        dispatch :from_array do
+          scope_param
+          param 'Array', :value
+        end
+
+        dispatch :create do
+          scope_param
+          param 'Any', :value
+        end
+
+        def self.create(scope, value, func)
+          func.call(scope, @target_type, value)
+        end
+
+        def self.from_array(scope, value, func)
+          # If there is a single argument that matches the array, then that gets priority over
+          # expanding the array into all arguments
+          if @single_type.instance?(value) || (@other_type && !@other_type.instance?(value) && @has_optional_single && @other_type.instance?([value]))
+            func.call(scope, @target_type, value)
+          else
+            func.call(scope, @target_type, *value)
+          end
+        end
+
+        def from_array(scope, value)
+          self.class.from_array(scope, value, loader.load(:function, 'new'))
+        end
+
+        def create(scope, value)
+          self.class.create(scope, value, loader.load(:function, 'new'))
+        end
+      end
+    else
+      init_args = @init_args
+      @new_function ||= Puppet::Functions.create_function(:new_Init, Puppet::Functions::InternalFunction) do
+        @target_type = target_type
+        @init_args = init_args
+
+        dispatch :create do
+          scope_param
+          param 'Any', :value
+        end
+
+        def self.create(scope, value, func)
+          func.call(scope, @target_type, value, *@init_args)
+        end
+
+        def create(scope, value)
+          self.class.create(scope, value, loader.load(:function, 'new'))
+        end
+      end
+    end
+  end
+
+  DEFAULT = PInitType.new(nil, EMPTY_ARRAY)
+
+  EXACTLY_ONE = [1, 1].freeze
+
+  def assert_initialized
+    return self if @initialized
+
+    @initialized = true
+    @self_recursion = true
+
+    begin
+      # Filter out types that will provide a new_function but are unsuitable to be contained in Init
+      #
+      # Calling Init#new would cause endless recursion
+      # The Optional is the same as Variant[T,Undef].
+      # The NotUndef is not meaningful to create instances of
+      if @type.instance_of?(PInitType) || @type.instance_of?(POptionalType) || @type.instance_of?(PNotUndefType)
+        raise ArgumentError.new
+      end
+      new_func = @type.new_function
+    rescue ArgumentError
+      raise ArgumentError, _("Creation of new instance of type '%{type_name}' is not supported") % { type_name: @type.to_s }
+    end
+    param_tuples = new_func.dispatcher.signatures.map { |closure| closure.type.param_types }
+
+    # An instance of the contained type is always a match to this type.
+    single_types = [@type]
+
+    if @init_args.empty?
+      # A value that is assignable to the type of a single parameter is also a match
+      single_tuples, other_tuples = param_tuples.partition { |tuple| EXACTLY_ONE == tuple.size_range }
+      single_types.concat(single_tuples.map { |tuple| tuple.types[0] })
+    else
+      tc = TypeCalculator.singleton
+      init_arg_types = @init_args.map { |arg| tc.infer_set(arg) }
+      arg_count = 1 + init_arg_types.size
+
+      # disqualify all parameter tuples that doesn't allow one value (type unknown at ths stage) + init args.
+      param_tuples = param_tuples.select do |tuple|
+        min, max = tuple.size_range
+        if arg_count >= min && arg_count <= max
+          # Aside from the first parameter, does the other parameters match?
+          tuple.assignable?(PTupleType.new(tuple.types[0..0].concat(init_arg_types)))
+        else
+          false
+        end
+      end
+      if param_tuples.empty?
+        raise ArgumentError, _("The type '%{type}' does not represent a valid set of parameters for %{subject}.new()") %
+          { type: to_s, subject: @type.generalize.name }
+      end
+      single_types.concat(param_tuples.map { |tuple| tuple.types[0] })
+      other_tuples = EMPTY_ARRAY
+    end
+    @single_type = PVariantType.maybe_create(single_types)
+    unless other_tuples.empty?
+      @other_type = PVariantType.maybe_create(other_tuples)
+      @has_optional_single = other_tuples.any? { |tuple| tuple.size_range.min == 1 }
+    end
+
+    guard = RecursionGuard.new
+    accept(NoopTypeAcceptor::INSTANCE, guard)
+    @self_recursion = guard.recursive_this?(self)
+  end
+
+  def accept(visitor, guard)
+    guarded_recursion(guard, nil) do |g|
+      super(visitor, g)
+      @single_type.accept(visitor, guard) if @single_type
+      @other_type.accept(visitor, guard) if @other_type
+    end
+  end
+
+  protected
+
+  def _assignable?(o, guard)
+    guarded_recursion(guard, false) do |g|
+      assert_initialized
+      if o.is_a?(PInitType)
+        @type.nil? || @type.assignable?(o.type, g)
+      elsif @type.nil?
+        TypeFactory.rich_data.assignable?(o, g)
+      else
+        @type.assignable?(o, g) ||
+          @single_type && @single_type.assignable?(o, g) ||
+          @other_type && (@other_type.assignable?(o, g) || @has_optional_single && @other_type.assignable?(PTupleType.new([o])))
+      end
+    end
+  end
+
+  private
+
+  def guarded_recursion(guard, dflt)
+    if @self_recursion
+      guard ||= RecursionGuard.new
+      guard.with_this(self) { |state| (state & RecursionGuard::SELF_RECURSION_IN_THIS) == 0 ? yield(guard) : dflt }
+    else
+      yield(guard)
+    end
+  end
+end
+end
+end

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

@@ -10,6 +10,8 @@ KEY_VALUE = 'value'.freeze
 class PMetaType < PAnyType
   include Annotatable
 
+  attr_reader :loader
+
   def self.register_ptype(loader, ir)
     # Abstract type. It doesn't register anything
   end
@@ -31,16 +33,17 @@ class PMetaType < PAnyType
   # @param loader [Loader::Loader] loader to use when loading type aliases
   # @return [PTypeAliasType] the receiver of the call, i.e. `self`
   # @api private
-  def resolve(type_parser, loader)
+  def resolve(loader)
     unless @init_hash_expression.nil?
+      @loader = loader
       @self_recursion = true # assumed while it being found out below
 
       init_hash_expression = @init_hash_expression
       @init_hash_expression = nil
       if init_hash_expression.is_a?(Model::LiteralHash)
-        init_hash = resolve_literal_hash(type_parser, loader, init_hash_expression)
+        init_hash = resolve_literal_hash(loader, init_hash_expression)
       else
-        init_hash = resolve_hash(type_parser, loader, init_hash_expression)
+        init_hash = resolve_hash(loader, init_hash_expression)
       end
       _pcore_init_from_hash(init_hash)
 
@@ -54,27 +57,31 @@ class PMetaType < PAnyType
     self
   end
 
-  def resolve_literal_hash(type_parser, loader, init_hash_expression)
-    type_parser.interpret_LiteralHash(init_hash_expression, loader)
+  def resolve_literal_hash(loader, init_hash_expression)
+    TypeParser.singleton.interpret_LiteralHash(init_hash_expression, loader)
   end
 
-  def resolve_hash(type_parser, loader, init_hash)
-    resolve_type_refs(type_parser, loader, init_hash)
+  def resolve_hash(loader, init_hash)
+    resolve_type_refs(loader, init_hash)
   end
 
-  def resolve_type_refs(type_parser, loader, o)
+  def resolve_type_refs(loader, o)
     case o
     when Hash
-      Hash[o.map { |k, v| [resolve_type_refs(type_parser, loader, k), resolve_type_refs(type_parser, loader, v)] }]
+      Hash[o.map { |k, v| [resolve_type_refs(loader, k), resolve_type_refs(loader, v)] }]
     when Array
-      o.map { |e| resolve_type_refs(type_parser, loader, e) }
+      o.map { |e| resolve_type_refs(loader, e) }
     when PAnyType
-      o.resolve(type_parser, loader)
+      o.resolve(loader)
     else
       o
     end
   end
 
+  def resolved?
+    @init_hash_expression.nil?
+  end
+
   # Returns the expanded string the form of the alias, e.g. <alias name> = <resolved type>
   #
   # @return [String] the expanded form of this alias