puppet 5.3.7 → 5.4.0

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

@@ -0,0 +1,218 @@
+module Puppet::Pops
+module Types
+
+# Base class for Parameterized Object implementations. The wrapper impersonates the base
+# object and extends it with methods to filter assignable types and instances based on parameter
+# values.
+#
+# @api public
+class PObjectTypeExtension < PAnyType
+  include TypeWithMembers
+
+  def self.register_ptype(loader, ir)
+    create_ptype(loader, ir, 'AnyType',
+      'base_type' => {
+        KEY_TYPE => PTypeType::DEFAULT
+      },
+      'init_parameters' => {
+        KEY_TYPE => PArrayType::DEFAULT
+      }
+    )
+  end
+
+  attr_reader :base_type, :parameters
+
+  # @api private
+  def self.create(base_type, init_parameters)
+    impl_class = Loaders.implementation_registry.module_for_type("#{base_type.name}TypeExtension") || self
+    impl_class.new(base_type, init_parameters)
+  end
+
+  # Creates an array of type parameters from the attributes of the given instance that matches the
+  # type parameters by name. Type parameters for which there is no matching attribute
+  # will have `nil` in their corresponding position on the array. The array is then passed
+  # as the `init_parameters` argument in a call to `create`
+  #
+  # @return [PObjectTypeExtension] the created extension
+  # @api private
+  def self.create_from_instance(base_type, instance)
+    type_parameters = base_type.type_parameters(true)
+    attrs = base_type.attributes(true)
+    params = type_parameters.keys.map do |pn|
+      attr = attrs[pn]
+      attr.nil? ? nil : instance.send(pn)
+    end
+    create(base_type, params)
+  end
+
+  def [](name)
+    @base_type[name]
+  end
+
+  # @api private
+  def initialize(base_type, init_parameters)
+    pts = base_type.type_parameters(true)
+    raise Puppet::ParseError, _('The %{label}-Type cannot be parameterized using []') % { label: base_type.label } if pts.empty?
+    @base_type = base_type
+
+    named_args = init_parameters.size == 1 && init_parameters[0].is_a?(Hash)
+    if named_args
+      # Catch case when first parameter is an assignable Hash
+      named_args = pts.size >= 1 && !pts.values[0].type.instance?(init_parameters[0])
+    end
+
+    by_name = {}
+    if named_args
+      hash = init_parameters[0]
+      hash.each_pair do |pn, pv|
+        tp = pts[pn]
+        if tp.nil?
+          raise Puppet::ParseError, _("'%{pn}' is not a known type parameter for %{label}-Type") % { pn: pn, label: base_type.label }
+        end
+        by_name[pn] = check_param(tp, pv) unless pv == :default
+      end
+    else
+      pts.values.each_with_index do |tp, idx|
+        if idx < init_parameters.size
+          pv = init_parameters[idx]
+          by_name[tp.name] = check_param(tp, pv) unless pv == :default
+        end
+      end
+    end
+    if by_name.empty?
+      raise Puppet::ParseError, _('The %{label}-Type cannot be parameterized using an empty parameter list') % { label: base_type.label }
+    end
+    @parameters = by_name
+  end
+
+  def check_param(type_param, v)
+    TypeAsserter.assert_instance_of(nil, type_param.type, v) { type_param.label }
+  end
+
+  # Return the parameter values as positional arguments with unset values as :default. The
+  # array is stripped from trailing :default values
+  # @return [Array] the parameter values
+  # @api private
+  def init_parameters
+    pts = @base_type.type_parameters(true)
+    if pts.size > 2
+      @parameters
+    else
+      result = pts.values.map do |tp|
+        pn = tp.name
+        @parameters.include?(pn) ? @parameters[pn] : :default
+      end
+      # Remove trailing defaults
+      result.pop while result.last == :default
+      result
+    end
+  end
+
+  # @api private
+  def eql?(o)
+    super(o) && @base_type.eql?(o.base_type) && @parameters.eql?(o.parameters)
+  end
+
+  # @api private
+  def generalize
+    @base_type
+  end
+
+  # @api private
+  def hash
+    @base_type.hash ^ @parameters.hash
+  end
+
+  # @api private
+  def loader
+    @base_type.loader
+  end
+
+  # @api private
+  def check_self_recursion(originator)
+    @base_type.check_self_recursion(originator)
+  end
+
+  # @api private
+  def create(*args)
+    @base_type.create(*args)
+  end
+
+  # @api private
+  def instance?(o, guard = nil)
+    @base_type.instance?(o, guard) && test_instance?(o, guard)
+  end
+
+  # @api private
+  def new_function
+    @base_type.new_function
+  end
+
+  # @api private
+  def simple_name
+    @base_type.simple_name
+  end
+
+  protected
+
+  # Checks that the given `param_values` hash contains all keys present in the `parameters` of
+  # this instance and that each keyed value is a match for the given parameter. The match is done
+  # using case expression semantics.
+  #
+  # This method is only called when a given type is found to be assignable to the base type of
+  # this extension.
+  #
+  # @param param_values[Hash] the parameter values of the assignable type
+  # @param guard[RecursionGuard] guard against endless recursion
+  # @return [Boolean] true or false to indicate assignability
+  # @api public
+  def test_assignable?(param_values, guard)
+    # Default implementation performs case expression style matching of all parameter values
+    # provided that the value exist (this should always be the case, since all defaults have
+    # been assigned at this point)
+    eval = Parser::EvaluatingParser.singleton.evaluator
+    @parameters.keys.all? do |pn|
+      if param_values.include?(pn)
+        a = param_values[pn]
+        b = @parameters[pn]
+        eval.match?(a, b) || a.is_a?(PAnyType) && b.is_a?(PAnyType) && b.assignable?(a)
+      else
+        false
+      end
+    end
+  end
+
+  # Checks that the given instance `o` has one attribute for each key present in the `parameters` of
+  # this instance and that each attribute value is a match for the given parameter. The match is done
+  # using case expression semantics.
+  #
+  # This method is only called when the given value is found to be an instance of the base type of
+  # this extension.
+  #
+  # @param o [Object] the instance to test
+  # @param guard[RecursionGuard] guard against endless recursion
+  # @return [Boolean] true or false to indicate if the value is an instance or not
+  # @api public
+  def test_instance?(o, guard)
+    eval = Parser::EvaluatingParser.singleton.evaluator
+    @parameters.keys.all? do |pn|
+      begin
+        m = o.public_method(pn)
+        m.arity == 0 ? eval.match?(m.call, @parameters[pn]) : false
+      rescue NameError
+        false
+      end
+    end
+  end
+
+  # @api private
+  def _assignable?(o, guard = nil)
+    if o.is_a?(PObjectTypeExtension)
+      @base_type.assignable?(o.base_type, guard) && test_assignable?(o.parameters, guard)
+    else
+      @base_type.assignable?(o, guard) && test_assignable?(EMPTY_HASH, guard)
+    end
+  end
+end
+end
+end

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

@@ -107,7 +107,6 @@ class PSemVerRangeType < PAnyType
   end
 
   def self.new_function(type)
-    range_expr = "\\A#{range_pattern}\\Z"
     @new_function ||= Puppet::Functions.create_loaded_function(:new_VersionRange, type.loader) do
       local_types do
         type 'SemVerRangeString = String[1]'

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

@@ -60,14 +60,14 @@ class PSemVerType < PScalarType
       local_types do
         type 'PositiveInteger = Integer[0,default]'
         type 'SemVerQualifier = Pattern[/\A(?<part>[0-9A-Za-z-]+)(?:\.\g<part>)*\Z/]'
-        type 'SemVerString = String[1]'
+        type "SemVerPattern = Pattern[/\\A#{SemanticPuppet::Version::REGEX_FULL}\\Z/]"
         type 'SemVerHash = Struct[{major=>PositiveInteger,minor=>PositiveInteger,patch=>PositiveInteger,Optional[prerelease]=>SemVerQualifier,Optional[build]=>SemVerQualifier}]'
       end
 
       # Creates a SemVer from a string as specified by http://semver.org/
       #
       dispatch :from_string do
-        param 'SemVerString', :str
+        param 'SemVerPattern', :str
       end
 
       # Creates a SemVer from integers, prerelease, and build arguments
@@ -86,6 +86,10 @@ class PSemVerType < PScalarType
         param 'SemVerHash', :hash_args
       end
 
+      argument_mismatch :on_error do
+        param 'String', :str
+      end
+
       def from_string(str)
         SemanticPuppet::Version.parse(str)
       end
@@ -97,6 +101,10 @@ class PSemVerType < PScalarType
       def from_hash(hash)
         SemanticPuppet::Version.new(hash['major'], hash['minor'], hash['patch'], hash['prerelease'], hash['build'])
       end
+
+      def on_error(str)
+        _("The string '%{str}' cannot be converted to a SemVer") % { str: str }
+      end
     end
   end
 

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

@@ -227,7 +227,6 @@ class PTypeSetType < PMetaType
   def name_for(t, default_name)
     key = @types.key(t)
     if key.nil?
-      qname = t.name
       if @references.empty?
         default_name
       else

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

@@ -0,0 +1,190 @@
+module Puppet::Pops
+module Types
+class PURIType < PAnyType
+
+  # Tell evaluator that an members of instances of this type can be invoked using dot notation
+  include TypeWithMembers
+
+  SCHEME = 'scheme'.freeze
+  USERINFO = 'userinfo'.freeze
+  HOST = 'host'.freeze
+  PORT = 'port'.freeze
+  PATH = 'path'.freeze
+  QUERY = 'query'.freeze
+  FRAGMENT = 'fragment'.freeze
+  OPAQUE = 'opaque'.freeze
+
+  URI_MEMBERS = {
+    SCHEME => AttrReader.new(SCHEME),
+    USERINFO => AttrReader.new(USERINFO),
+    HOST => AttrReader.new(HOST),
+    PORT => AttrReader.new(PORT),
+    PATH => AttrReader.new(PATH),
+    QUERY => AttrReader.new(QUERY),
+    FRAGMENT => AttrReader.new(FRAGMENT),
+    OPAQUE => AttrReader.new(OPAQUE),
+  }
+
+  TYPE_URI_INIT_HASH = TypeFactory.struct(
+    TypeFactory.optional(SCHEME) => PStringType::NON_EMPTY,
+    TypeFactory.optional(USERINFO) => PStringType::NON_EMPTY,
+    TypeFactory.optional(HOST) => PStringType::NON_EMPTY,
+    TypeFactory.optional(PORT) => PIntegerType.new(0),
+    TypeFactory.optional(PATH) => PStringType::NON_EMPTY,
+    TypeFactory.optional(QUERY) => PStringType::NON_EMPTY,
+    TypeFactory.optional(FRAGMENT) => PStringType::NON_EMPTY,
+    TypeFactory.optional(OPAQUE) => PStringType::NON_EMPTY,
+  )
+
+  TYPE_STRING_PARAM = TypeFactory.optional(PVariantType.new([
+    PStringType::NON_EMPTY,
+    PRegexpType::DEFAULT,
+    TypeFactory.type_type(PPatternType::DEFAULT),
+    TypeFactory.type_type(PEnumType::DEFAULT),
+    TypeFactory.type_type(PNotUndefType::DEFAULT),
+    TypeFactory.type_type(PUndefType::DEFAULT),
+  ]))
+
+  TYPE_INTEGER_PARAM = TypeFactory.optional(PVariantType.new([
+    PIntegerType.new(0),
+    TypeFactory.type_type(PNotUndefType::DEFAULT),
+    TypeFactory.type_type(PUndefType::DEFAULT),
+  ]))
+
+  TYPE_URI_PARAM_HASH_TYPE = TypeFactory.struct(
+    TypeFactory.optional(SCHEME) => TYPE_STRING_PARAM,
+    TypeFactory.optional(USERINFO) => TYPE_STRING_PARAM,
+    TypeFactory.optional(HOST) => TYPE_STRING_PARAM,
+    TypeFactory.optional(PORT) => TYPE_INTEGER_PARAM,
+    TypeFactory.optional(PATH) => TYPE_STRING_PARAM,
+    TypeFactory.optional(QUERY) => TYPE_STRING_PARAM,
+    TypeFactory.optional(FRAGMENT) => TYPE_STRING_PARAM,
+    TypeFactory.optional(OPAQUE) => TYPE_STRING_PARAM,
+  )
+
+  TYPE_URI_PARAM_TYPE = PVariantType.new([PStringType::NON_EMPTY, TYPE_URI_PARAM_HASH_TYPE])
+
+  def self.register_ptype(loader, ir)
+    create_ptype(loader, ir, 'AnyType',
+      {
+        'parameters' => { KEY_TYPE => TypeFactory.optional(TYPE_URI_PARAM_TYPE), KEY_VALUE => nil }
+      }
+    )
+  end
+
+  def self.new_function(type)
+    @new_function ||= Puppet::Functions.create_loaded_function(:new_error, type.loader) do
+      dispatch :create do
+        param 'String[1]', :uri
+      end
+
+      dispatch :from_hash do
+        param TYPE_URI_INIT_HASH, :hash
+      end
+
+      def create(uri)
+        URI.parse(uri)
+      end
+
+      def from_hash(init_hash)
+        sym_hash = {}
+        init_hash.each_pair { |k, v| sym_hash[k.to_sym] = v }
+        scheme = sym_hash[:scheme]
+        scheme_class = scheme.nil? ? URI::Generic : (URI.scheme_list[scheme.upcase] || URI::Generic)
+        scheme_class.build(sym_hash)
+      end
+    end
+  end
+
+  attr_reader :parameters
+
+  def initialize(parameters = nil)
+    if parameters.is_a?(String)
+      parameters = TypeAsserter.assert_instance_of('URI-Type parameter', Pcore::TYPE_URI, parameters, true)
+      @parameters = uri_to_hash(URI.parse(parameters))
+    elsif parameters.is_a?(URI)
+      @parameters = uri_to_hash(parameters)
+    elsif parameters.is_a?(Hash)
+      params = TypeAsserter.assert_instance_of('URI-Type parameter', TYPE_URI_PARAM_TYPE, parameters, true)
+      @parameters = params.empty? ? nil : params
+    end
+  end
+
+  def eql?(o)
+    self.class == o.class && @parameters == o.parameters
+  end
+
+  def ==(o)
+    eql?(o)
+  end
+
+  def [](key)
+    URI_MEMBERS[key]
+  end
+
+  def generalize
+    DEFAULT
+  end
+
+  def hash
+    self.class.hash ^ @parameters.hash
+  end
+
+  def instance?(o, guard = nil)
+    return false unless o.is_a?(URI)
+    return true if @parameters.nil?
+
+    eval = Parser::EvaluatingParser.singleton.evaluator
+    @parameters.keys.all? { |pn| eval.match?(o.send(pn), @parameters[pn]) }
+  end
+
+  def roundtrip_with_string?
+    true
+  end
+
+  def _pcore_init_hash
+    @parameters == nil? ? EMPTY_HASH : { 'parameters' => @parameters }
+  end
+
+  protected
+
+  def _assignable?(o, guard = nil)
+    return false unless o.class == self.class
+    return true if @parameters.nil?
+    o_params = o.parameters || EMPTY_HASH
+
+    eval = Parser::EvaluatingParser.singleton.evaluator
+    @parameters.keys.all? do |pn|
+      if o_params.include?(pn)
+        a = o_params[pn]
+        b = @parameters[pn]
+        eval.match?(a, b) || a.is_a?(PAnyType) && b.is_a?(PAnyType) && b.assignable?(a)
+      else
+        false
+      end
+    end
+  end
+
+  private
+
+  def uri_to_hash(uri)
+    result = {}
+    scheme = uri.scheme
+    unless scheme.nil?
+      scheme = scheme.downcase
+      result[SCHEME] = scheme
+    end
+    result[USERINFO] = uri.userinfo unless uri.userinfo.nil?
+    result[HOST] = uri.host.downcase unless uri.host.nil?
+    result[PORT] = uri.port.to_s unless uri.port.nil? || uri.port == 80 && 'http' == scheme || uri.port == 443 && 'https' == scheme
+    result[PATH] = uri.path unless uri.path.nil? || uri.path.empty?
+    result[QUERY] = uri.query unless uri.query.nil?
+    result[FRAGMENT] = uri.fragment unless uri.fragment.nil?
+    result[OPAQUE] = uri.opaque unless uri.opaque.nil?
+    result.empty? ? nil : result
+  end
+
+  DEFAULT = PURIType.new(nil)
+end
+end
+end