puppet 5.0.1 → 5.1.0

data/lib/puppet/pops/pcore.rb

@@ -96,8 +96,7 @@ module Pcore
     aliases.each do |name, type_string|
       add_type(Types::PTypeAliasType.new(name, Types::TypeFactory.type_reference(type_string), nil), loader, name_authority)
     end
-    parser = Types::TypeParser.singleton
-    aliases.each_key.map { |name| loader.load(:type, name).resolve(parser, loader) }
+    aliases.each_key.map { |name| loader.load(:type, name).resolve(loader) }
   end
 end
 end

data/lib/puppet/pops/resource/param.rb

@@ -21,7 +21,7 @@ class Param
   def self.register_ptype(loader, ir)
     @ptype = Pcore::create_object_type(loader, ir, self, 'Puppet::Resource::Param', nil,
       {
-        Types::KEY_TYPE => Types::PType::DEFAULT,
+        Types::KEY_TYPE => Types::PTypeType::DEFAULT,
         Types::KEY_NAME => Types::PStringType::NON_EMPTY,
         'name_var' => {
           Types::KEY_TYPE => Types::PBooleanType::DEFAULT,

data/lib/puppet/pops/resource/resource_type_impl.rb

@@ -7,7 +7,7 @@ def self.register_ptypes(loader, ir)
   types = [Param, ResourceTypeImpl].map do |c|
     c.register_ptype(loader, ir)
   end
-  types.each {|t| t.resolve(Types::TypeParser.singleton, loader) }
+  types.each {|t| t.resolve(loader) }
 end
 
 class ResourceTypeImpl

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

@@ -164,18 +164,6 @@ module Serialization
             { :type_name => pcore_type.name, :arg_class => value.class.name }
       end
     end
-
-    def data_to_pcore_type(pcore_type)
-      if pcore_type.is_a?(Hash)
-        without_value { convert(pcore_type) }
-      else
-        type = Types::TypeParser.singleton.parse(pcore_type, @loader)
-        if type.is_a?(Types::PTypeReferenceType)
-          raise SerializationError, _('No implementation mapping found for Puppet Type %{type_name}') % { type_name: pcore_type }
-        end
-        type
-      end
-    end
   end
 end
 end

data/lib/puppet/pops/time/timestamp.rb

@@ -71,31 +71,43 @@ class Timestamp < TimeData
     parsed = nil
     if format.is_a?(Array)
       format.each do |fmt|
-        assert_no_tz_extractor(fmt) if has_timezone
-        begin
-          parsed = DateTime.strptime(str, fmt)
-          break
-        rescue ArgumentError
+        parsed = DateTime._strptime(str, fmt)
+        next if parsed.nil?
+        if parsed.include?(:leftover) || (has_timezone && parsed.include?(:zone))
+          parsed = nil
+          next
         end
+        break
+      end
+      if parsed.nil?
+        raise ArgumentError, _(
+          "Unable to parse '%{str}' using any of the formats %{formats}") % { str: str, formats: format.join(', ') }
       end
-      raise ArgumentError, _("Unable to parse '%{str}' using any of the formats %{formats}") % { str: str, formats: format.join(', ') } if parsed.nil?
     else
-      assert_no_tz_extractor(format) if has_timezone
-      begin
-        parsed = DateTime.strptime(str, format)
-      rescue ArgumentError
+      parsed = DateTime._strptime(str, format)
+      if parsed.nil? || parsed.include?(:leftover)
         raise ArgumentError, _("Unable to parse '%{str}' using format '%{format}'") % { str: str, format: format }
       end
+      if has_timezone && parsed.include?(:zone)
+        raise ArgumentError, _(
+          'Using a Timezone designator in format specification is mutually exclusive to providing an explicit timezone argument')
+      end
+    end
+    unless has_timezone
+      timezone = parsed[:zone]
+      has_timezone = !timezone.nil?
     end
-    parsed_time = parsed.to_time
+    fraction = parsed[:sec_fraction]
+
+    # Convert msec rational found in _strptime hash to usec
+    fraction = fraction * 1000000 unless fraction.nil?
+
+    # Create the Time instance and adjust for timezone
+    parsed_time = ::Time.utc(parsed[:year], parsed[:mon], parsed[:mday], parsed[:hour], parsed[:min], parsed[:sec], fraction)
     parsed_time -= utc_offset(timezone) if has_timezone
-    from_time(parsed_time)
-  end
 
-  def self.assert_no_tz_extractor(format)
-    if format =~ /[^%]%[zZ]/
-      raise ArgumentError, _('Using a Timezone designator in format specification is mutually exclusive to providing an explicit timezone argument')
-    end
+    # Convert to Timestamp
+    from_time(parsed_time)
   end
 
   undef_method :-@, :+@, :div, :fdiv, :abs, :abs2, :magnitude # does not make sense on a Timestamp

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

@@ -7,9 +7,9 @@ KEY_ANNOTATIONS = 'annotations'.freeze
 #
 # @api public
 module Annotatable
-  TYPE_ANNOTATIONS = PHashType.new(PType.new(PTypeReferenceType.new('Annotation')), PHashType::DEFAULT)
+  TYPE_ANNOTATIONS = PHashType.new(PTypeType.new(PTypeReferenceType.new('Annotation')), PHashType::DEFAULT)
 
-  # @return [{PType => PStructType}] the map of annotations
+  # @return [{PTypeType => PStructType}] the map of annotations
   # @api public
   def annotations
     @annotations.nil? ? EMPTY_HASH : @annotations

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

@@ -21,29 +21,29 @@ module Types
     # If no annotation was found and no block is given, this method returns `nil`
     #
     # @param o [Object] object to annotate
-    # @param block [Proc] optional, evaluated when a new annotation must be created. Should return the i12n hash
+    # @param block [Proc] optional, evaluated when a new annotation must be created. Should return the init hash
     # @return [Annotation<self>] an annotation of the same class as the receiver of the call
     #
     def self.annotate(o)
       adapter = get(o)
       if adapter.nil?
         if o.is_a?(Annotatable)
-          i12n = o.annotations[_pcore_type]
-          i12n = yield if i12n.nil? && block_given?
+          init_hash = o.annotations[_pcore_type]
+          init_hash = yield if init_hash.nil? && block_given?
         else
-          i12n = yield if block_given?
+          init_hash = yield if block_given?
         end
-        adapter = associate_adapter(_pcore_type.from_hash(i12n), o) unless i12n.nil?
+        adapter = associate_adapter(_pcore_type.from_hash(init_hash), o) unless init_hash.nil?
       end
       adapter
     end
 
     # Forces the creation or removal of an annotation of this type.
-    # If `i21n` is a hash, a new annotation is created and returned
-    # If `i12n` is `nil`, then the annotation is cleared and the previous annotation is returned.
+    # If `init_hash` is a hash, a new annotation is created and returned
+    # If `init_hash` is `nil`, then the annotation is cleared and the previous annotation is returned.
     #
     # @param o [Object] object to annotate
-    # @param i12n [Hash{String,Object},nil] the initializer for the annotation or `nil` to clear the annotation
+    # @param init_hash [Hash{String,Object},nil] the initializer for the annotation or `nil` to clear the annotation
     # @return [Annotation<self>] an annotation of the same class as the receiver of the call
     #
     def self.annotate_new(o, init_hash)

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

@@ -24,7 +24,7 @@ class ClassLoader
     when Array
       provide_from_name_path(name.join('::'), name)
 
-    when PAnyType, PType
+    when PAnyType, PTypeType
       provide_from_type(name)
 
     else
@@ -44,8 +44,8 @@ class ClassLoader
       # There is no other thing to load except this Enum meta type
       RGen::MetamodelBuilder::MMBase::Boolean
 
-    when PType
-      # TODO: PType should has a type argument (a PAnyType) so the Class' class could be returned
+    when PTypeType
+      # TODO: PTypeType should have a type argument (a PAnyType) so the Class' class could be returned
       #       (but this only matters in special circumstances when meta programming has been used).
       Class
 

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

@@ -41,7 +41,7 @@ module Types
         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)
       else
-        TypeAsserter.assert_instance_of('Second argument of type mapping', PType::DEFAULT, puppet_type_or_pattern)
+        TypeAsserter.assert_instance_of('Second argument of type mapping', PTypeType::DEFAULT, puppet_type_or_pattern)
         register_implementation(puppet_type_or_pattern, expr, loader)
       end
     end

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

@@ -132,13 +132,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

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

@@ -144,8 +144,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.dispatchers.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