bolt 0.7.0 → 0.8.0

data/vendored/puppet/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/vendored/puppet/lib/puppet/pops/types/puppet_object.rb

@@ -9,7 +9,17 @@ module PuppetObject
   #
   # @return [PObjectType] the type
   def _pcore_type
-    self.class._pcore_type
+    t = self.class._pcore_type
+    if t.parameterized?
+      unless instance_variable_defined?(:@_cached_ptype)
+        # Create a parameterized type based on the values of this instance that
+        # contains a parameter value for each type parameter that matches an
+        # attribute by name and type of value
+        @_cached_ptype = PObjectTypeExtension.create(t, self)
+      end
+      t = @_cached_ptype
+    end
+    t
   end
 
   def _pcore_all_contents(path, &block)

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

@@ -614,12 +614,12 @@ class TypeCalculator
 
   # @api private
   def infer_TrueClass(o)
-    PBooleanType::DEFAULT
+    PBooleanType::TRUE
   end
 
   # @api private
   def infer_FalseClass(o)
-    PBooleanType::DEFAULT
+    PBooleanType::FALSE
   end
 
   # @api private

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

@@ -127,7 +127,13 @@ module TypeFactory
   # @api public
   #
   def self.enum(*values)
-    PEnumType.new(values)
+    last = values.last
+    case_insensitive = false
+    if last == true || last == false
+      case_insensitive = last
+      values = values[0...-1]
+    end
+    PEnumType.new(values, case_insensitive)
   end
 
   # Produces the Variant type, optionally with the "one of" types
@@ -227,8 +233,8 @@ module TypeFactory
   # Produces the Boolean type
   # @api public
   #
-  def self.boolean
-    PBooleanType::DEFAULT
+  def self.boolean(value = nil)
+    value.nil? ? PBooleanType::DEFAULT : (value ? PBooleanType::TRUE : PBooleanType::FALSE)
   end
 
   # Produces the Any type
@@ -511,11 +517,15 @@ module TypeFactory
     inst_type.nil? ? PTypeType::DEFAULT : PTypeType.new(inst_type)
   end
 
-  # Produces a type for Error[K, I]
+  # Produces a type for Error
   # @api public
   #
-  def self.error(kind = nil, issue_code = nil)
-    kind.nil? && issue_code.nil? ? PErrorType::DEFAULT : PErrorType.new(kind, issue_code)
+  def self.error
+    @error_t ||= TypeParser.singleton.parse('Error', Loaders.static_loader)
+  end
+
+  def self.target
+    @target_t ||= TypeParser.singleton.parse('Target')
   end
 
   # Produce a type corresponding to the class of given unless given is a

data/vendored/puppet/lib/puppet/pops/types/type_formatter.rb

@@ -149,7 +149,9 @@ class TypeFormatter
   def string_PDefaultType(_) ; @bld << 'Default' ; end
 
   # @api private
-  def string_PBooleanType(_) ; @bld << 'Boolean' ; end
+  def string_PBooleanType(t)
+    append_array('Boolean', t.value.nil?) { append_string(t.value) }
+  end
 
   # @api private
   def string_PScalarType(_)  ; @bld << 'Scalar'  ; end
@@ -213,7 +215,13 @@ class TypeFormatter
 
   # @api private
   def string_PEnumType(t)
-    append_array('Enum', t.values.empty?) { append_strings(t.values) }
+    append_array('Enum', t.values.empty?) do
+      append_strings(t.values)
+      if t.case_insensitive?
+        @bld << COMMA_SEP
+        append_string(true)
+      end
+    end
   end
 
   # @api private
@@ -322,17 +330,6 @@ class TypeFormatter
     append_array('Pattern', t.patterns.empty?) { append_strings(t.patterns.map(&:regexp)) }
   end
 
-  # @api private
-  def string_PErrorType(t)
-    append_array('Error', t.kind.nil? && t.issue_code.nil?) do
-      t.kind.nil? ? append_default : append_error_param(t.kind)
-      unless t.issue_code.nil?
-        @bld << COMMA_SEP
-        append_error_param(t.issue_code)
-      end
-    end
-  end
-
   def append_error_param(ep)
     case ep
     when PStringType
@@ -490,6 +487,17 @@ class TypeFormatter
     end
   end
 
+  def string_PObjectTypeExtension(t)
+    append_array(@type_set ? @type_set.name_for(t, t.name) : t.name, false) do
+      ips = t.init_parameters
+      if ips.is_a?(Array)
+        append_strings(ips)
+      else
+        append_string(ips)
+      end
+    end
+  end
+
   # @api private
   def string_PSensitiveType(t)
     append_array('Sensitive', PAnyType::DEFAULT == t.type) { append_string(t.type) }
@@ -569,7 +577,7 @@ class TypeFormatter
   end
 
   # @api private
-  def string_NilClass(t)     ; @bld << (@ruby ? 'nil' : '?') ; end
+  def string_NilClass(t)     ; @bld << (@ruby ? 'nil' : 'undef') ; end
 
   # @api private
   def string_Numeric(t)      ; @bld << t.to_s    ; end

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

@@ -201,7 +201,6 @@ class TypeParser
         'semverrange'  => TypeFactory.sem_ver_range,
         'timestamp'    => TypeFactory.timestamp,
         'timespan'     => TypeFactory.timespan,
-        'error'        => TypeFactory.error
     }.freeze
   end
 
@@ -341,27 +340,22 @@ class TypeParser
       TypeFactory.regexp(parameters[0])
 
     when 'enum'
-      # 1..m parameters being strings
+      # 1..m parameters being string
+      last = parameters.last
+      case_insensitive = false
+      if last == true || last == false
+        parameters = parameters[0...-1]
+        case_insensitive = last
+      end
       raise_invalid_parameters_error('Enum', '1 or more', parameters.size) unless parameters.size >= 1
       parameters.each { |p|  raise Puppet::ParseError, 'Enum parameters must be identifiers or strings' unless p.is_a?(String) }
-      TypeFactory.enum(*parameters)
+      PEnumType.new(parameters, case_insensitive)
 
     when 'pattern'
       # 1..m parameters being strings or regular expressions
       raise_invalid_parameters_error('Pattern', '1 or more', parameters.size) unless parameters.size >= 1
       TypeFactory.pattern(*parameters)
 
-    when 'error'
-      # 1 - 2 parameters where both are string, regexp, or type
-      case parameters.size
-      when 1, 2
-        pt = PErrorType::TYPE_ERROR_PARAM
-        parameters.each { |p| raise Puppet::ParseError, "Error parameters must be ${pt}" unless pt.instance?(p) }
-        TypeFactory.error(*parameters)
-      else
-        raise_invalid_parameters_error('Error', '1 - 2', parameters.size)
-      end
-
     when 'variant'
       # 1..m parameters being strings or regular expressions
       raise_invalid_parameters_error('Variant', '1 or more', parameters.size) unless parameters.size >= 1
@@ -405,6 +399,12 @@ class TypeParser
       raise_invalid_type_specification_error(ast) unless h.is_a?(Hash)
       TypeFactory.struct(h)
 
+    when 'boolean'
+      raise_invalid_parameters_error('Boolean', '1', parameters.size) unless parameters.size == 1
+      p = parameters[0]
+      raise Puppet::ParseError, 'Boolean parameter must be true or false' unless p == true || p == false
+      TypeFactory.boolean(p)
+
     when 'integer'
       if parameters.size == 1
         case parameters[0]
@@ -497,7 +497,7 @@ class TypeParser
       assert_type(ast, param) unless param.is_a?(String)
       TypeFactory.optional(param)
 
-    when 'any', 'data', 'catalogentry', 'boolean', 'scalar', 'undef', 'numeric', 'default', 'semverrange'
+    when 'any', 'data', 'catalogentry', 'scalar', 'undef', 'numeric', 'default', 'semverrange'
       raise_unparameterized_type_error(qref)
 
     when 'notundef'
@@ -548,6 +548,8 @@ class TypeParser
       elsif type.is_a?(PResourceType)
         raise_invalid_parameters_error(qref.cased_value, 1, parameters.size) unless parameters.size == 1
         TypeFactory.resource(type.type_name, parameters[0])
+      elsif type.is_a?(PObjectType)
+        PObjectTypeExtension.create(type, parameters)
       else
         # Must be a type alias. They can't use parameters (yet)
         raise_unparameterized_type_error(qref)

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

@@ -482,7 +482,7 @@ class PTypeType < PTypeWithContainedType
   def self.new_function(type)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_type, type.loader) do
       dispatch :from_string do
-        param 'String', :type_string
+        param 'String[1]', :type_string
       end
 
       def from_string(type_string)
@@ -756,13 +756,20 @@ end
 #
 class PEnumType < PScalarDataType
   def self.register_ptype(loader, ir)
-    create_ptype(loader, ir, 'ScalarDataType', 'values' => PArrayType.new(PStringType::NON_EMPTY))
+    create_ptype(loader, ir, 'ScalarDataType',
+      'values' => PArrayType.new(PStringType::NON_EMPTY),
+      'case_insensitive' => { 'type' => PBooleanType::DEFAULT, 'value' => false })
   end
 
-  attr_reader :values
+  attr_reader :values, :case_insensitive
 
-  def initialize(values)
+  def initialize(values, case_insensitive = false)
     @values = values.uniq.sort.freeze
+    @case_insensitive = case_insensitive
+  end
+
+  def case_insensitive?
+    @case_insensitive
   end
 
   # Returns Enumerator if no block is given, otherwise, calls the given
@@ -792,15 +799,19 @@ class PEnumType < PScalarDataType
   end
 
   def hash
-    @values.hash
+    @values.hash ^ @case_insensitive.hash
   end
 
   def eql?(o)
-    self.class == o.class && @values == o.values
+    self.class == o.class && @values == o.values && @case_insensitive == o.case_insensitive?
   end
 
   def instance?(o, guard = nil)
-    o.is_a?(String) && @values.any? { |p| p == o }
+    if o.is_a?(String)
+      @case_insensitive ? @values.any? { |p| p.casecmp(o) == 0 } : @values.any? { |p| p == o }
+    else
+      false
+    end
   end
 
   DEFAULT = PEnumType.new(EMPTY_ARRAY)
@@ -819,13 +830,26 @@ class PEnumType < PScalarDataType
         # if the contained string is found in the set of enums
         instance?(o.value, guard)
       when PEnumType
-        !o.values.empty? && o.values.all? { |s| instance?(s, guard) }
+        !o.values.empty? && (case_insensitive? || !o.case_insensitive?) && o.values.all? { |s| instance?(s, guard) }
       else
         false
     end
   end
 end
 
+INTEGER_HEX = '(?:0[xX][0-9A-Fa-f]+)'
+INTEGER_OCT = '(?:0[0-7]+)'
+INTEGER_BIN = '(?:0[bB][01]+)'
+INTEGER_DEC = '(?:0|[1-9]\d*)'
+SIGN_PREFIX = '[+-]?\s*'
+
+OPTIONAL_FRACTION = '(?:\.\d+)?'
+OPTIONAL_EXPONENT = '(?:[eE]-?\d+)?'
+FLOAT_DEC = '(?:' + INTEGER_DEC + OPTIONAL_FRACTION + OPTIONAL_EXPONENT + ')'
+
+INTEGER_PATTERN = '\A' + SIGN_PREFIX + '(?:' + INTEGER_DEC + '|' + INTEGER_HEX + '|' + INTEGER_OCT + '|' + INTEGER_BIN + ')\z'
+FLOAT_PATTERN = '\A' + SIGN_PREFIX + '(?:' + FLOAT_DEC + '|' + INTEGER_HEX + '|' + INTEGER_OCT + '|' + INTEGER_BIN + ')\z'
+
 # @api public
 #
 class PNumericType < PScalarDataType
@@ -839,7 +863,7 @@ class PNumericType < PScalarDataType
   def self.new_function(type)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_numeric, type.loader) do
       local_types do
-        type 'Convertible = Variant[Undef, Integer, Float, Boolean, String, Timespan, Timestamp]'
+        type "Convertible = Variant[Integer, Float, Boolean, Pattern[/#{FLOAT_PATTERN}/], Timespan, Timestamp]"
         type 'NamedArgs   = Struct[{from => Convertible, Optional[abs] => Boolean}]'
       end
 
@@ -852,6 +876,11 @@ class PNumericType < PScalarDataType
         param          'NamedArgs',  :hash_args
       end
 
+      argument_mismatch :on_error do
+        param          'Any',     :from
+        optional_param 'Boolean', :abs
+      end
+
       def from_args(from, abs = false)
         result = from_convertible(from)
         abs ? result.abs : result
@@ -863,8 +892,6 @@ class PNumericType < PScalarDataType
 
       def from_convertible(from)
         case from
-        when NilClass
-          throw :undefined_value
         when Float
           from
         when Integer
@@ -875,7 +902,7 @@ class PNumericType < PScalarDataType
           1
         when FalseClass
           0
-        when String
+        else
           begin
             if from[0] == '0' && (from[1].downcase == 'b' || from[1].downcase == 'x')
               Integer(from)
@@ -887,9 +914,15 @@ class PNumericType < PScalarDataType
           rescue ArgumentError => e
             raise TypeConversionError.new(e.message)
           end
+        end
+      end
+
+      def on_error(from, abs = false)
+        if from.is_a?(String)
+          _("The string '%{str}' cannot be converted to Numeric") % { str: from }
         else
-          t = Puppet::Pops::Types::TypeCalculator.singleton.infer(from).generalize
-          raise TypeConversionError.new("Value of type '#{t}' cannot be converted to Numeric")
+          t = TypeCalculator.singleton.infer(from).generalize
+          _("Value of type %{type} cannot be converted to Numeric") % { type: t }
         end
       end
     end
@@ -945,7 +978,7 @@ class PNumericType < PScalarDataType
   end
 
   def instance?(o, guard = nil)
-    o.is_a?(Numeric) && o >= @from && o <= @to
+    (o.is_a?(Float) || o.is_a?(Integer)) && o >= @from && o <= @to
   end
 
   def unbounded?
@@ -1050,7 +1083,7 @@ class PIntegerType < PNumericType
     @@new_function ||= Puppet::Functions.create_loaded_function(:new, loader) do
       local_types do
         type 'Radix       = Variant[Default, Integer[2,2], Integer[8,8], Integer[10,10], Integer[16,16]]'
-        type 'Convertible = Variant[Undef, Numeric, Boolean, String, Timespan, Timestamp]'
+        type "Convertible = Variant[Numeric, Boolean, Pattern[/#{INTEGER_PATTERN}/], Timespan, Timestamp]"
         type 'NamedArgs   = Struct[{from => Convertible, Optional[radix] => Radix, Optional[abs] => Boolean}]'
       end
 
@@ -1064,6 +1097,16 @@ class PIntegerType < PNumericType
         param          'NamedArgs',  :hash_args
       end
 
+      argument_mismatch :on_error_hash do
+        param          'Hash',  :hash_args
+      end
+
+      argument_mismatch :on_error do
+        param          'Any',     :from
+        optional_param 'Integer', :radix
+        optional_param 'Boolean', :abs
+      end
+
       def from_args(from, radix = :default, abs = false)
         result = from_convertible(from, radix)
         abs ? result.abs : result
@@ -1075,8 +1118,6 @@ class PIntegerType < PNumericType
 
       def from_convertible(from, radix)
         case from
-        when NilClass
-          throw :undefined_value
         when Float, Time::TimeData
           from.to_i
         when Integer
@@ -1085,9 +1126,9 @@ class PIntegerType < PNumericType
           1
         when FalseClass
           0
-        when String
+        else
           begin
-            radix == :default ? Integer(from) : Integer(from, assert_radix(radix))
+            radix == :default ? Integer(from) : Integer(from, radix)
           rescue TypeError => e
             raise TypeConversionError.new(e.message)
           rescue ArgumentError => e
@@ -1103,17 +1144,34 @@ class PIntegerType < PNumericType
             end
             raise TypeConversionError.new(e.message)
           end
+        end
+      end
+
+      def on_error_hash(args_hash)
+        if args_hash.include?('from')
+          from = args_hash['from']
+          return on_error(from) unless loader.load(:type, 'convertible').instance?(from)
+        end
+        radix = args_hash['radix']
+        assert_radix(radix) unless radix.nil? || radix == :default
+        TypeAsserter.assert_instance_of('Integer.new', loader.load(:type, 'namedargs'), args_hash)
+      end
+
+      def on_error(from, radix = :default, abs = nil)
+        assert_radix(radix) unless radix == :default
+        if from.is_a?(String)
+          _("The string '%{str}' cannot be converted to Integer") % { str: from }
         else
-          t = Puppet::Pops::Types::TypeCalculator.singleton.infer(from).generalize
-          raise TypeConversionError.new("Value of type '#{t}' cannot be converted to an Integer")
+          t = TypeCalculator.singleton.infer(from).generalize
+          _("Value of type %{type} cannot be converted to Integer") % { type: t }
         end
       end
 
       def assert_radix(radix)
         case radix
-        when 2, 8, 10, 16, :default
+        when 2, 8, 10, 16
         else
-          raise ArgumentError.new("Illegal radix: '#{radix}', expected 2, 8, 10, 16, or default")
+          raise ArgumentError.new(_("Illegal radix: %{radix}, expected 2, 8, 10, 16, or default") % { radix: radix })
         end
         radix
       end
@@ -1160,7 +1218,7 @@ class PFloatType < PNumericType
   def self.new_function(type)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_float, type.loader) do
       local_types do
-        type 'Convertible = Variant[Undef, Numeric, Boolean, String, Timespan, Timestamp]'
+        type "Convertible = Variant[Numeric, Boolean, Pattern[/#{FLOAT_PATTERN}/], Timespan, Timestamp]"
         type 'NamedArgs   = Struct[{from => Convertible, Optional[abs] => Boolean}]'
       end
 
@@ -1173,6 +1231,11 @@ class PFloatType < PNumericType
         param          'NamedArgs',  :hash_args
       end
 
+      argument_mismatch :on_error do
+        param          'Any',     :from
+        optional_param 'Boolean', :abs
+      end
+
       def from_args(from, abs = false)
         result = from_convertible(from)
         abs ? result.abs : result
@@ -1184,8 +1247,6 @@ class PFloatType < PNumericType
 
       def from_convertible(from)
         case from
-        when NilClass
-          throw :undefined_value
         when Float
           from
         when Integer
@@ -1196,7 +1257,7 @@ class PFloatType < PNumericType
           1.0
         when FalseClass
           0.0
-        when String
+        else
           begin
             # support a binary as float
             if from[0] == '0' && from[1].downcase == 'b'
@@ -1218,9 +1279,15 @@ class PFloatType < PNumericType
             end
             raise TypeConversionError.new(e.message)
           end
+        end
+      end
+
+      def on_error(from, _ = false)
+        if from.is_a?(String)
+          _("The string '%{str}' cannot be converted to Float") % { str: from }
         else
-          t = Puppet::Pops::Types::TypeCalculator.singleton.infer(from).generalize
-          raise TypeConversionError.new("Value of type '#{t}' cannot be converted to Float")
+          t = TypeCalculator.singleton.infer(from).generalize
+          _("Value of type %{type} cannot be converted to Float") % { type: t }
         end
       end
     end
@@ -1577,7 +1644,7 @@ class PStringType < PScalarDataType
         # Must match exactly when value is a string
         @size_type_or_value.nil? || @size_type_or_value == o.size_type_or_value
       when PEnumType
-        @size_type_or_value.nil? ? true : o.values.size == 1 && @size_type_or_value == o.values[0]
+        @size_type_or_value.nil? ? true : o.values.size == 1 && !o.case_insensitive? && o.values[0]
       when PPatternType
         @size_type_or_value.nil?
       else
@@ -1786,46 +1853,73 @@ class PBooleanType < PScalarDataType
     create_ptype(loader, ir, 'ScalarDataType')
   end
 
+  attr_reader :value
+
+  def initialize(value = nil)
+    @value = value
+  end
+
+  def eql?(o)
+    o.is_a?(PBooleanType) && @value == o.value
+  end
+
+  def generalize
+    PBooleanType::DEFAULT
+  end
+
+  def hash
+    31 ^ @value.hash
+  end
+
   def instance?(o, guard = nil)
-    o == true || o == false
+    (o == true || o == false) && (@value.nil? || value == o)
   end
 
   def self.new_function(type)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_boolean, type.loader) do
       dispatch :from_args do
-        param          'Variant[Undef, Integer, Float, Boolean, String]',  :from
+        param "Variant[Integer, Float, Boolean, Enum['false','true','yes','no','y','n',true]]",  :from
+      end
+
+      argument_mismatch :on_error do
+        param  'Any', :from
       end
 
       def from_args(from)
         from = from.downcase if from.is_a?(String)
         case from
-        when NilClass
-          throw :undefined_value
         when Float
           from != 0.0
         when Integer
           from != 0
-        when true, false
-          from
-        when 'false', 'no', 'n'
+        when false, 'false', 'no', 'n'
           false
-        when 'true', 'yes', 'y'
+        else
           true
+        end
+      end
+
+      def on_error(from)
+        if from.is_a?(String)
+          _("The string '%{str}' cannot be converted to Boolean") % { str: from }
         else
-          raise TypeConversionError.new("Value '#{from}' of type '#{from.class}' cannot be converted to Boolean")
+          t = TypeCalculator.singleton.infer(from).generalize
+          _("Value of type %{type} cannot be converted to Boolean") % { type: t }
         end
       end
     end
   end
 
   DEFAULT = PBooleanType.new
+  TRUE = PBooleanType.new(true)
+  FALSE = PBooleanType.new(false)
 
   protected
 
   # @api private
   #
   def _assignable?(o, guard)
-    o.is_a?(PBooleanType)
+    o.is_a?(PBooleanType) && (@value.nil? || @value == o.value)
   end
 end
 
@@ -2504,41 +2598,43 @@ class PArrayType < PCollectionType
   def self.new_function(type)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_array, type.loader) do
 
-      dispatch :from_args do
-        param           'Any',  :from
-        optional_param  'Boolean',      :wrap
+      dispatch :to_array do
+        param           'Variant[Array,Hash,Binary,Iterable]', :from
+        optional_param  'Boolean[false]', :wrap
+      end
+
+      dispatch :wrapped do
+        param  'Any',           :from
+        param  'Boolean[true]', :wrap
+      end
+
+      argument_mismatch :on_error do
+        param  'Any',             :from
+        optional_param 'Boolean', :wrap
       end
 
-      def from_args(from, wrap = false)
+      def wrapped(from, _)
+        from.is_a?(Array) ? from : [from]
+      end
+
+      def to_array(from, _ = false)
         case from
-        when NilClass
-          if wrap
-            [nil]
-          else
-            throw :undefined_value
-          end
         when Array
           from
         when Hash
-          wrap ? [from] : from.to_a
-
+          from.to_a
         when PBinaryType::Binary
           # For older rubies, the #bytes method returns an Enumerator that must be rolled out
-          wrap ? [from] : from.binary_buffer.bytes.to_a
-
+          from.binary_buffer.bytes.to_a
         else
-          if wrap
-            [from]
-          else
-            if PIterableType::DEFAULT.instance?(from)
-              Iterable.on(from).to_a
-            else
-              t = Puppet::Pops::Types::TypeCalculator.singleton.infer(from).generalize
-              raise TypeConversionError.new("Value of type '#{t}' cannot be converted to Array")
-            end
-          end
+          Iterable.on(from).to_a
         end
       end
+
+      def on_error(from, _ = false)
+        t = TypeCalculator.singleton.infer(from).generalize
+        _("Value of type %{type} cannot be converted to Array") % { type: t }
+      end
     end
   end
 
@@ -2738,14 +2834,12 @@ class PHashType < PCollectionType
 
       def from_array(from)
         case from
-        when NilClass
-          throw :undefined_value
         when Array
           if from.size == 0
             {}
           else
             unless from.size % 2 == 0
-              raise TypeConversionError.new("odd number of arguments for Hash")
+              raise TypeConversionError.new(_('odd number of arguments for Hash'))
             end
             Hash[*from]
           end
@@ -2755,8 +2849,8 @@ class PHashType < PCollectionType
           if PIterableType::DEFAULT.instance?(from)
             Hash[*Iterable.on(from).to_a]
           else
-            t = Puppet::Pops::Types::TypeCalculator.singleton.infer(from).generalize
-            raise TypeConversionError.new("Value of type '#{t}' cannot be converted to Hash")
+            t = TypeCalculator.singleton.infer(from).generalize
+            raise TypeConversionError.new(_("Value of type %{type} cannot be converted to Hash") % { type: t })
           end
         end
       end
@@ -2948,8 +3042,9 @@ class PVariantType < PAnyType
 
   # @api private
   def merge_enums(array)
+    # Merge case sensitive enums and strings
     if array.size > 1
-      parts = array.partition {|t| t.is_a?(PEnumType) && !t.values.empty? || t.is_a?(PStringType) && !t.value.nil? }
+      parts = array.partition {|t| t.is_a?(PEnumType) && !t.values.empty? && !t.case_insensitive? || t.is_a?(PStringType) && !t.value.nil? }
       enums = parts[0]
       if enums.size > 1
         others = parts[1]
@@ -2957,6 +3052,20 @@ class PVariantType < PAnyType
         array = others
       end
     end
+
+    # Merge case insensitive enums
+    if array.size > 1
+      parts = array.partition {|t| t.is_a?(PEnumType) && !t.values.empty? && t.case_insensitive? }
+      enums = parts[0]
+      if enums.size > 1
+        others = parts[1]
+        values = []
+        enums.each { |enum| enum.values.each { |value| values << value.downcase }}
+        values.uniq!
+        others <<  PEnumType.new(values, true)
+        array = others
+      end
+    end
     array
   end
 
@@ -3513,7 +3622,7 @@ require_relative 'p_timespan_type'
 require_relative 'p_timestamp_type'
 require_relative 'p_binary_type'
 require_relative 'p_init_type'
-require_relative 'p_error_type'
+require_relative 'p_object_type_extension'
 require_relative 'type_set_reference'
 require_relative 'implementation_registry'
 require_relative 'tree_iterators'