puppet 4.4.0 → 4.5.0

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

@@ -30,7 +30,7 @@ module TypeAsserter
   # @api public
   def self.assert_instance_of(subject, expected_type, value, nil_ok = false, &block)
     unless value.nil? && nil_ok
-      report_type_mismatch(subject, expected_type, TypeCalculator.singleton.infer_set(value).generalize, &block) unless expected_type.instance?(value)
+      report_type_mismatch(subject, expected_type, TypeCalculator.singleton.infer_set(value), &block) unless expected_type.instance?(value)
     end
     value
   end
@@ -39,7 +39,7 @@ module TypeAsserter
     subject = yield(subject) if block_given?
     subject = subject[0] % subject[1..-1] if subject.is_a?(Array)
     raise TypeAssertionError.new(
-      TypeMismatchDescriber.singleton.describe_mismatch("#{subject} has wrong type,", expected_type, actual_type), expected_type, actual_type)
+      TypeMismatchDescriber.singleton.describe_mismatch("#{subject} had wrong type,", expected_type, actual_type), expected_type, actual_type)
   end
   private_class_method :report_type_mismatch
 end

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

@@ -312,6 +312,8 @@ class TypeCalculator
         infer_set_Array(o)
       when Hash
         infer_set_Hash(o)
+      when Semantic::Version
+        infer_set_Version(o)
       else
         infer_set_Object(o)
     end
@@ -429,7 +431,7 @@ class TypeCalculator
 
     if t1.is_a?(PVariantType) && t2.is_a?(PVariantType)
       # The common type is one that complies with either set
-      return PVariantType.new(t1.types | t2.types)
+      return PVariantType.maybe_create(t1.types | t2.types)
     end
 
     if t1.is_a?(PRegexpType) && t2.is_a?(PRegexpType)
@@ -552,7 +554,14 @@ class TypeCalculator
 
   # @api private
   def infer_Object(o)
-    PRuntimeType.new(:ruby, o.class.name)
+    if o.is_a?(PuppetObject)
+      o._ptype
+    else
+      name = o.class.name
+      ir = Loaders.implementation_registry
+      type = ir.nil? ? nil : ir.type_for_module(name)
+      type.nil? ? PRuntimeType.new(:ruby, name) : type
+    end
   end
 
   # The type of all types is PType
@@ -652,7 +661,7 @@ class TypeCalculator
     # A mapping must be made to empty string. A nil value will result in an error later
     title = o.title
     title = '' if :undef == title
-    PType.new(PResourceType.new(o.type.to_s.downcase, title))
+    PType.new(PResourceType.new(o.type.to_s, title))
   end
 
   # @api private
@@ -664,6 +673,16 @@ class TypeCalculator
     end
   end
 
+  # @api private
+  def infer_Version(o)
+    PSemVerType::DEFAULT
+  end
+
+  # @api private
+  def infer_VersionRange(o)
+    PSemVerRangeType::DEFAULT
+  end
+
   # @api private
   def infer_Hash(o)
     if o.empty?
@@ -697,14 +716,19 @@ class TypeCalculator
     if o.empty?
       PHashType::EMPTY
     elsif o.keys.all? {|k| PStringType::NON_EMPTY.instance?(k) }
-      PStructType.new(o.each_pair.map { |k,v| PStructElement.new(PStringType.new(nil, [k]), infer_set(v)) })
+      PStructType.new(o.each_pair.map { |k,v| PStructElement.new(PStringType.new(size_as_type(k), [k]), infer_set(v)) })
     else
-      ktype = PVariantType.new(o.keys.map {|k| infer_set(k) })
-      etype = PVariantType.new(o.values.map {|e| infer_set(e) })
+      ktype = PVariantType.maybe_create(o.keys.map {|k| infer_set(k) })
+      etype = PVariantType.maybe_create(o.values.map {|e| infer_set(e) })
       PHashType.new(unwrap_single_variant(ktype), unwrap_single_variant(etype), size_as_type(o))
     end
   end
 
+  # @api private
+  def infer_set_Version(o)
+    PSemVerType.new(Semantic::VersionRange.new(o, o))
+  end
+
   def unwrap_single_variant(possible_variant)
     if possible_variant.is_a?(PVariantType) && possible_variant.types.size == 1
       possible_variant.types[0]

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

@@ -0,0 +1,15 @@
+
+module Puppet::Pops::Types
+  # Raised when a conversion of a value to another type failed.
+  #
+  class TypeConversionError < Puppet::Error
+
+    # Creates a new instance with a given message
+    #
+    # @param message [String] The error message describing what failed
+    #
+    def initialize(message)
+      super(message)
+    end
+  end
+end

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

@@ -99,7 +99,7 @@ module TypeFactory
   # @api public
   #
   def self.variant(*types)
-    PVariantType.new(types.map {|v| type_of(v) })
+    PVariantType.maybe_create(types.map {|v| type_of(v) })
   end
 
   # Produces the Struct type, either a non parameterized instance representing
@@ -110,7 +110,7 @@ module TypeFactory
   # The value can be a ruby class, a String (interpreted as the name of a ruby class) or
   # a Type.
   #
-  # @param hash [Hash<Object, Object>] key => value hash
+  # @param hash [{String,PAnyType=>PAnyType}] key => value hash
   # @return [PStructType] the created Struct type
   #
   def self.struct(hash = {})
@@ -148,6 +148,15 @@ module TypeFactory
     PStructType.new(elements)
   end
 
+  # Produces an `Object` type from the given _hash_ that represents the features of the object
+  #
+  # @param hash [{String=>Object}] the hash of feature groups
+  # @return [PObjectType] the created type
+  #
+  def self.object(hash = nil)
+    hash.nil? || hash.empty? ? PObjectType::DEFAULT : PObjectType.new(hash)
+  end
+
   def self.tuple(types = [], size_type = nil)
     PTupleType.new(types.map {|elem| type_of(elem) }, size_type)
   end
@@ -295,21 +304,35 @@ module TypeFactory
     PCatalogEntryType::DEFAULT
   end
 
+  # Produces an instance of the SemVerRange type
+  def self.sem_ver_range
+    PSemVerRangeType::DEFAULT
+  end
+
+  # Produces an instance of the SemVer type
+  def self.sem_ver(*ranges)
+    ranges.empty? ? PSemVerType::DEFAULT : PSemVerType::new(*ranges)
+  end
+
   # Produces a PResourceType with a String type_name A PResourceType with a nil
   # or empty name is compatible with any other PResourceType.  A PResourceType
   # with a given name is only compatible with a PResourceType with the same
   # name.  (There is no resource-type subtyping in Puppet (yet)).
   #
   def self.resource(type_name = nil, title = nil)
-    type_name = type_name.type_name if type_name.is_a?(PResourceType)
-    type_name = type_name.downcase unless type_name.nil?
-    unless type_name.nil? || type_name =~ Patterns::CLASSREF
-      raise ArgumentError, "Illegal type name '#{type.type_name}'"
-    end
-    if type_name.nil? && !title.nil?
-      raise ArgumentError, 'The type name cannot be nil, if title is given'
+    case type_name
+    when PResourceType
+      PResourceType.new(type_name.type_name, title)
+    when String
+      type_name = TypeFormatter.singleton.capitalize_segments(type_name)
+      raise ArgumentError, "Illegal type name '#{type_name}'" unless type_name =~ Patterns::CLASSREF_EXT
+      PResourceType.new(type_name, title)
+    when nil
+      raise ArgumentError, 'The type name cannot be nil, if title is given' unless title.nil?
+      PResourceType::DEFAULT
+    else
+      raise ArgumentError, "The type name cannot be a #{type_name.class.name}"
     end
-    PResourceType.new(type_name, title)
   end
 
   # Produces PHostClassType with a string class_name.  A PHostClassType with
@@ -341,6 +364,17 @@ module TypeFactory
     PHashType.new(type_of(key), type_of(value), size_type)
   end
 
+  # Produces a type for Hash[key,value,size]
+  # @param key_type [PAnyType] the key type
+  # @param value_type [PAnyType] the value type
+  # @param size_type [PIntegerType]
+  # @return [PHashType] the created hash type
+  # @api public
+  #
+  def self.hash_kv(key_type, value_type, size_type = nil)
+    PHashType.new(key_type, value_type, size_type)
+  end
+
   # Produces a type for Array[Data]
   # @api public
   #
@@ -434,17 +468,16 @@ module TypeFactory
   # @param name [String] the name of the unresolved type
   # @param expression [Model::Expression] an expression that will evaluate to a type
   # @return [PTypeAliasType] the type alias
-  def self.type_alias(name, expression)
-    PTypeAliasType.new(name, expression)
+  def self.type_alias(name = nil, expression = nil)
+    name.nil? ? PTypeAliasType::DEFAULT : PTypeAliasType.new(name, expression)
   end
 
   # Returns the type that represents a type reference with a given name and optional
   # parameters.
-  # @param name [String] the name of the type
-  # @param parameters [Array] the parameters
+  # @param type_string [String] the string form of the type
   # @return [PTypeReferenceType] the type reference
-  def self.type_reference(name, parameters = nil)
-    PTypeReferenceType.new(name, parameters)
+  def self.type_reference(type_string = nil)
+    type_string == nil ? PTypeReferenceType::DEFAULT : PTypeReferenceType.new(type_string)
   end
 
   # Returns true if the given type t is of valid range parameter type (integer