puppet 8.3.1-x64-mingw32 → 8.5.0-x64-mingw32

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/concurrent/thread_local_singleton'
 
 module Puppet::Pops
@@ -106,7 +107,7 @@ class TypeCalculator
 
   # @api public
   def self.assignable?(t1, t2)
-    singleton.assignable?(t1,t2)
+    singleton.assignable?(t1, t2)
   end
 
   # Answers, does the given callable accept the arguments given in args (an array or a tuple)
@@ -139,9 +140,10 @@ class TypeCalculator
       o.instance_of?(Array) ||
       o.instance_of?(Hash) ||
       Types::PUndefType::DEFAULT.instance?(o)
-      )
+       )
       return nil
     end
+
     # For other objects (e.g. PObjectType instances, and runtime types) full inference needed, since that will
     # cover looking into the runtime type registry.
     #
@@ -166,8 +168,8 @@ class TypeCalculator
   # @api public
   #
   def initialize
-    @infer_visitor = Visitor.new(nil, 'infer',0,0)
-    @extract_visitor = Visitor.new(nil, 'extract',0,0)
+    @infer_visitor = Visitor.new(nil, 'infer', 0, 0)
+    @extract_visitor = Visitor.new(nil, 'extract', 0, 0)
   end
 
   # Answers 'can an instance of type t2 be assigned to a variable of type t'.
@@ -197,6 +199,7 @@ class TypeCalculator
   # Answers if the two given types describe the same type
   def equals(left, right)
     return false unless left.is_a?(PAnyType) && right.is_a?(PAnyType)
+
     # Types compare per class only - an extra test must be made if the are mutually assignable
     # to find all types that represent the same type of instance
     #
@@ -211,27 +214,26 @@ class TypeCalculator
     raise ArgumentError, 'Argument must be a Module' unless c.is_a? Module
 
     # Can't use a visitor here since we don't have an instance of the class
-    case
-    when c <= Integer
+    if c <= Integer
       type = PIntegerType::DEFAULT
-    when c == Float
+    elsif c == Float
       type = PFloatType::DEFAULT
-    when c == Numeric
+    elsif c == Numeric
       type = PNumericType::DEFAULT
-    when c == String
+    elsif c == String
       type = PStringType::DEFAULT
-    when c == Regexp
+    elsif c == Regexp
       type = PRegexpType::DEFAULT
-    when c == NilClass
+    elsif c == NilClass
       type = PUndefType::DEFAULT
-    when c == FalseClass, c == TrueClass
+    elsif c == FalseClass || c == TrueClass
       type = PBooleanType::DEFAULT
-    when c == Class
+    elsif c == Class
       type = PTypeType::DEFAULT
-    when c == Array
+    elsif c == Array
       # Assume array of any
       type = PArrayType::DEFAULT
-    when c == Hash
+    elsif c == Hash
       # Assume hash of any
       type = PHashType::DEFAULT
     else
@@ -253,15 +255,16 @@ class TypeCalculator
   def infer(o)
     # Optimize the most common cases into direct calls.
     # Explicit if/elsif/else is faster than case
-    if o.is_a?(String)
+    case o
+    when String
       infer_String(o)
-    elsif o.is_a?(Integer) # need subclasses for Ruby < 2.4
+    when Integer # need subclasses for Ruby < 2.4
       infer_Integer(o)
-    elsif o.is_a?(Array)
+    when Array
       infer_Array(o)
-    elsif o.is_a?(Hash)
+    when Hash
       infer_Hash(o)
-    elsif o.is_a?(Evaluator::PuppetProc)
+    when Evaluator::PuppetProc
       infer_PuppetProc(o)
     else
       @infer_visitor.visit_this_0(self, o)
@@ -291,7 +294,7 @@ class TypeCalculator
   # @api public
   #
   def self.instance?(t, o)
-    singleton.instance?(t,o)
+    singleton.instance?(t, o)
   end
 
   # Answers 'is o an instance of type t'
@@ -369,7 +372,7 @@ class TypeCalculator
     # when both are resources, reduce to Resource[T] or Resource[] (since one was not assignable to the other)
     if t1.is_a?(PResourceType) && t2.is_a?(PResourceType)
       # only Resource[] unless the type name is the same
-      return t1.type_name == t2.type_name ?  PResourceType.new(t1.type_name, nil) : PResourceType::DEFAULT
+      return t1.type_name == t2.type_name ? PResourceType.new(t1.type_name, nil) : PResourceType::DEFAULT
     end
 
     # Integers have range, expand the range to the common range
@@ -383,7 +386,7 @@ class TypeCalculator
     end
 
     if t1.is_a?(PStringType) && (t2.is_a?(PStringType) || t2.is_a?(PEnumType))
-      if(t2.is_a?(PEnumType))
+      if (t2.is_a?(PEnumType))
         return t1.value.nil? ? PEnumType::DEFAULT : PEnumType.new(t2.values | [t1.value])
       end
 
@@ -437,7 +440,7 @@ class TypeCalculator
       return PScalarType::DEFAULT
     end
 
-    if common_data?(t1,t2)
+    if common_data?(t1, t2)
       return TypeFactory.data
     end
 
@@ -446,7 +449,7 @@ class TypeCalculator
       return PTypeType.new(common_type(t1.type, t2.type))
     end
 
-    if common_rich_data?(t1,t2)
+    if common_rich_data?(t1, t2)
       return TypeFactory.rich_data
     end
 
@@ -455,13 +458,14 @@ class TypeCalculator
       if t1.runtime == t2.runtime && t1.runtime_type_name == t2.runtime_type_name
         return t1
       end
+
       # finding the common super class requires that names are resolved to class
       # NOTE: This only supports runtime type of :ruby
       c1 = ClassLoader.provide_from_type(t1)
       c2 = ClassLoader.provide_from_type(t2)
       if c1 && c2
         c2_superclasses = superclasses(c2)
-        superclasses(c1).each do|c1_super|
+        superclasses(c1).each do |c1_super|
           c2_superclasses.each do |c2_super|
             if c1_super == c2_super
               return PRuntimeType.new(:ruby, c1_super.name)
@@ -478,7 +482,7 @@ class TypeCalculator
   # Produces the superclasses of the given class, including the class
   def superclasses(c)
     result = [c]
-    while s = c.superclass #rubocop:disable Lint/AssignmentInCondition
+    while s = c.superclass # rubocop:disable Lint/AssignmentInCondition
       result << s
       c = s
     end
@@ -489,21 +493,21 @@ class TypeCalculator
   # @api public
   #
   def reduce_type(enumerable)
-    enumerable.reduce(nil) {|memo, t| common_type(memo, t) }
+    enumerable.reduce(nil) { |memo, t| common_type(memo, t) }
   end
 
   # Reduce an enumerable of objects to a single common type
   # @api public
   #
   def infer_and_reduce_type(enumerable)
-    reduce_type(enumerable.map {|o| infer(o) })
+    reduce_type(enumerable.map { |o| infer(o) })
   end
 
   # The type of all modules is PTypeType
   # @api private
   #
   def infer_Module(o)
-    PTypeType::new(PRuntimeType.new(:ruby, o.name))
+    PTypeType.new(PRuntimeType.new(:ruby, o.name))
   end
 
   # @api private
@@ -528,9 +532,11 @@ class TypeCalculator
     else
       name = o.class.name
       return PRuntimeType.new(:ruby, nil) if name.nil? # anonymous class that doesn't implement PuppetObject is impossible to infer
+
       ir = Loaders.implementation_registry
       type = ir.nil? ? nil : ir.type_for_module(name)
       return PRuntimeType.new(:ruby, name) if type.nil?
+
       if type.is_a?(PObjectType) && type.parameterized?
         type = PObjectTypeExtension.create_from_instance(type, o)
       end
@@ -714,18 +720,18 @@ class TypeCalculator
     if o.empty?
       PArrayType::EMPTY
     else
-      PTupleType.new(o.map {|x| infer_set(x) })
+      PTupleType.new(o.map { |x| infer_set(x) })
     end
   end
 
   def infer_set_Hash(o)
     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(k), infer_set(v)) })
+    elsif o.keys.all? { |k| PStringType::NON_EMPTY.instance?(k) }
+      PStructType.new(o.each_pair.map { |k, v| PStructElement.new(PStringType.new(k), infer_set(v)) })
     else
-      ktype = PVariantType.maybe_create(o.keys.map {|k| infer_set(k) })
-      etype = PVariantType.maybe_create(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
@@ -749,7 +755,8 @@ class TypeCalculator
   # if range.to == nil max size == Infinity
   #
   def size_range(range)
-    return [1,1] if range.nil?
+    return [1, 1] if range.nil?
+
     from = range.from
     to = range.to
     x = from.nil? ? 1 : from
@@ -762,11 +769,11 @@ class TypeCalculator
     t.is_a?(PAnyType) && t.kind_of_callable?(optional)
   end
 
-  def max(a,b)
-    a >=b ? a : b
+  def max(a, b)
+    a >= b ? a : b
   end
 
-  def min(a,b)
+  def min(a, b)
     a <= b ? a : b
   end
 
@@ -817,7 +824,6 @@ class TypeCalculator
   def common_numeric?(t1, t2)
     PNumericType::DEFAULT.assignable?(t1) && PNumericType::DEFAULT.assignable?(t2)
   end
-
 end
 end
 end

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

@@ -3,14 +3,5 @@
 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
+  class TypeConversionError < Puppet::Error; end
 end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
 # Helper module that makes creation of type objects simpler.
@@ -114,7 +115,7 @@ module TypeFactory
       size_type_or_value.nil? ? PStringType::DEFAULT : PStringType.new(size_type_or_value)
     else
       if Puppet[:strict] != :off
-        #TRANSLATORS 'TypeFactory#string' is a class and method name and should not be translated
+        # TRANSLATORS 'TypeFactory#string' is a class and method name and should not be translated
         message = _("Passing more than one argument to TypeFactory#string is deprecated")
         Puppet.warn_once('deprecations', "TypeFactory#string_multi_args", message)
       end
@@ -156,7 +157,7 @@ module TypeFactory
   # @api public
   #
   def self.variant(*types)
-    PVariantType.maybe_create(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
@@ -179,6 +180,7 @@ module TypeFactory
       # TODO: Should have stricter name rule
       if key_type.is_a?(String)
         raise ArgumentError, 'Struct element key cannot be an empty String' if key_type.empty?
+
         key_type = string(key_type)
         # Must make key optional if the value can be Undef
         key_type = optional(key_type) if tc.assignable?(value_type, PUndefType::DEFAULT)
@@ -239,7 +241,7 @@ module TypeFactory
   end
 
   def self.tuple(types = [], size_type = nil)
-    PTupleType.new(types.map {|elem| type_of(elem) }, size_type)
+    PTupleType.new(types.map { |elem| type_of(elem) }, size_type)
   end
 
   # Produces the Boolean type
@@ -270,7 +272,7 @@ module TypeFactory
       case re
       when String
         re_t = PRegexpType.new(re)
-        re_t.regexp  # compile it to catch errors
+        re_t.regexp # compile it to catch errors
         re_t
 
       when Regexp
@@ -283,7 +285,7 @@ module TypeFactory
         re.patterns
 
       else
-       raise ArgumentError, "Only String, Regexp, Pattern-Type, and Regexp-Type are allowed: got '#{re.class}"
+        raise ArgumentError, "Only String, Regexp, Pattern-Type, and Regexp-Type are allowed: got '#{re.class}"
       end
     end.flatten.uniq
     PPatternType.new(patterns)
@@ -347,7 +349,7 @@ module TypeFactory
       size_type = nil
     end
 
-    types = params.map {|p| type_of(p) }
+    types = params.map { |p| type_of(p) }
 
     # If the specification requires types, and none were given, a Unit type is used
     if types.empty? && !size_type.nil? && size_type.range[1] > 0
@@ -416,7 +418,7 @@ module TypeFactory
 
   # Produces an instance of the SemVer type
   def self.sem_ver(*ranges)
-    ranges.empty? ? PSemVerType::DEFAULT : PSemVerType::new(ranges)
+    ranges.empty? ? PSemVerType::DEFAULT : PSemVerType.new(ranges)
   end
 
   # Produces a PResourceType with a String type_name A PResourceType with a nil
@@ -431,9 +433,11 @@ module TypeFactory
     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}"
@@ -556,11 +560,12 @@ module TypeFactory
   # a classname.
   #
   def self.type_of(o)
-    if o.is_a?(Class)
+    case o
+    when Class
       @type_calculator.type(o)
-    elsif o.is_a?(PAnyType)
+    when PAnyType
       o
-    elsif o.is_a?(String)
+    when String
       PRuntimeType.new(:ruby, o)
     else
       @type_calculator.infer_generic(o)
@@ -600,7 +605,7 @@ module TypeFactory
   # Generic creator of a RuntimeType - allows creating the type with nil or
   # String runtime_type_name.  Also see ruby_type(o) and ruby(o).
   #
-  def self.runtime(runtime=nil, runtime_type_name = nil)
+  def self.runtime(runtime = nil, runtime_type_name = nil)
     runtime = runtime.to_sym if runtime.is_a?(String)
     PRuntimeType.new(runtime, runtime_type_name)
   end
@@ -626,7 +631,6 @@ module TypeFactory
   def self.is_range_parameter?(t)
     t.is_a?(Integer) || t == 'default' || :default == t
   end
-
 end
 end
 end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/concurrent/thread_local_singleton'
 
 module Puppet::Pops
@@ -97,7 +98,6 @@ class TypeFormatter
     end
   end
 
-
   def append_default
     @bld << 'default'
   end
@@ -142,13 +142,13 @@ class TypeFormatter
   end
 
   # @api private
-  def string_PAnyType(_)     ; @bld << 'Any'     ; end
+  def string_PAnyType(_); @bld << 'Any'; end
 
   # @api private
-  def string_PUndefType(_)   ; @bld << 'Undef'   ; end
+  def string_PUndefType(_); @bld << 'Undef'; end
 
   # @api private
-  def string_PDefaultType(_) ; @bld << 'Default' ; end
+  def string_PDefaultType(_); @bld << 'Default'; end
 
   # @api private
   def string_PBooleanType(t)
@@ -156,16 +156,16 @@ class TypeFormatter
   end
 
   # @api private
-  def string_PScalarType(_)  ; @bld << 'Scalar'  ; end
+  def string_PScalarType(_); @bld << 'Scalar'; end
 
   # @api private
-  def string_PScalarDataType(_)  ; @bld << 'ScalarData'  ; end
+  def string_PScalarDataType(_); @bld << 'ScalarData'; end
 
   # @api private
-  def string_PNumericType(_) ; @bld << 'Numeric' ; end
+  def string_PNumericType(_); @bld << 'Numeric'; end
 
   # @api private
-  def string_PBinaryType(_)  ; @bld << 'Binary' ; end
+  def string_PBinaryType(_); @bld << 'Binary'; end
 
   # @api private
   def string_PIntegerType(t)
@@ -179,12 +179,12 @@ class TypeFormatter
 
   # @api private
   def string_PInitType(t)
-    append_array('Init', t.type.nil?)  { append_strings([t.type, *t.init_args]) }
+    append_array('Init', t.type.nil?) { append_strings([t.type, *t.init_args]) }
   end
 
   # @api private
   def string_PIterableType(t)
-    append_array('Iterable', t.element_type.nil?)  { append_string(t.element_type) }
+    append_array('Iterable', t.element_type.nil?) { append_string(t.element_type) }
   end
 
   # @api private
@@ -194,7 +194,7 @@ class TypeFormatter
 
   # @api private
   def string_PFloatType(t)
-    append_array('Float', t.unbounded? ) { append_elements(range_array_part(t)) }
+    append_array('Float', t.unbounded?) { append_elements(range_array_part(t)) }
   end
 
   # @api private
@@ -280,22 +280,20 @@ class TypeFormatter
   def string_PCallableType(t)
     if t.return_type.nil?
       append_array('Callable', t.param_types.nil?) { append_callable_params(t) }
+    elsif t.param_types.nil?
+      append_array('Callable', false) { append_strings([[], t.return_type], false) }
     else
-      if t.param_types.nil?
-        append_array('Callable', false) { append_strings([[], t.return_type], false) }
-      else
-        append_array('Callable', false) do
-          append_array('', false) { append_callable_params(t) }
-          @bld << COMMA_SEP
-          append_string(t.return_type)
-        end
+      append_array('Callable', false) do
+        append_array('', false) { append_callable_params(t) }
+        @bld << COMMA_SEP
+        append_string(t.return_type)
       end
     end
   end
 
   def append_callable_params(t)
     # translate to string, and skip Unit types
-    append_strings(t.param_types.types.reject {|t2| t2.class == PUnitType }, true)
+    append_strings(t.param_types.types.reject { |t2| t2.instance_of?(PUnitType) }, true)
 
     if t.param_types.types.empty?
       append_strings([0, 0], true)
@@ -311,7 +309,7 @@ class TypeFormatter
 
   # @api private
   def string_PStructType(t)
-    append_array('Struct', t.elements.empty?) { append_hash(Hash[t.elements.map {|e| struct_element_pair(e) }]) }
+    append_array('Struct', t.elements.empty?) { append_hash(t.elements.to_h { |e| struct_element_pair(e) }) }
   end
 
   # @api private
@@ -332,11 +330,10 @@ class TypeFormatter
     append_array('Pattern', t.patterns.empty?) { append_strings(t.patterns.map(&:regexp)) }
   end
 
-
   # @api private
   def string_PCollectionType(t)
     range = range_array_part(t.size_type)
-    append_array('Collection', range.empty? ) { append_elements(range) }
+    append_array('Collection', range.empty?) { append_elements(range) }
   end
 
   def string_Object(t)
@@ -445,7 +442,7 @@ class TypeFormatter
   # @api private
   def string_PNotUndefType(t)
     contained_type = t.type
-    append_array('NotUndef', contained_type.nil? || contained_type.class == PAnyType) do
+    append_array('NotUndef', contained_type.nil? || contained_type.instance_of?(PAnyType)) do
       if contained_type.is_a?(PStringType) && !contained_type.value.nil?
         append_string(contained_type.value)
       else
@@ -474,13 +471,13 @@ class TypeFormatter
   # @api private
   def string_PTypeSetType(t)
     append_array('TypeSet') do
-      append_hash(t._pcore_init_hash.each, proc { |k| @bld << symbolic_key(k) }) do |k,v|
+      append_hash(t._pcore_init_hash.each, proc { |k| @bld << symbolic_key(k) }) do |k, v|
         case k
         when KEY_TYPES
           old_ts = @type_set
           @type_set = t
           begin
-            append_hash(v, proc { |tk| @bld << symbolic_key(tk) }) do |tk, tv|
+            append_hash(v, proc { |tk| @bld << symbolic_key(tk) }) do |_tk, tv|
               if tv.is_a?(Hash)
                 append_object_hash(tv)
               else
@@ -555,12 +552,10 @@ class TypeFormatter
         @bld << ' = '
         append_string(t.resolved_type)
       end
+    elsif expand && @type_set.defines_type?(t)
+      append_string(t.resolved_type)
     else
-      if expand && @type_set.defines_type?(t)
-        append_string(t.resolved_type)
-      else
-        @bld << @type_set.name_for(t, t.name)
-      end
+      @bld << @type_set.name_for(t, t.name)
     end
   end
 
@@ -585,7 +580,7 @@ class TypeFormatter
   end
 
   # @api private
-  def string_FalseClass(t)   ; @bld << 'false'       ; end
+  def string_FalseClass(t); @bld << 'false'; end
 
   # @api private
   def string_Hash(t)
@@ -598,13 +593,13 @@ class TypeFormatter
   end
 
   # @api private
-  def string_NilClass(t)     ; @bld << (@ruby ? 'nil' : 'undef') ; end
+  def string_NilClass(t); @bld << (@ruby ? 'nil' : 'undef'); end
 
   # @api private
-  def string_Numeric(t)      ; @bld << t.to_s    ; end
+  def string_Numeric(t); @bld << t.to_s; end
 
   # @api private
-  def string_Regexp(t)       ; @bld << PRegexpType.regexp_to_s_with_delimiters(t); end
+  def string_Regexp(t); @bld << PRegexpType.regexp_to_s_with_delimiters(t); end
 
   # @api private
   def string_String(t)
@@ -613,22 +608,22 @@ class TypeFormatter
   end
 
   # @api private
-  def string_Symbol(t)       ; @bld << t.to_s    ; end
+  def string_Symbol(t); @bld << t.to_s; end
 
   # @api private
-  def string_TrueClass(t)    ; @bld << 'true'    ; end
+  def string_TrueClass(t); @bld << 'true'; end
 
   # @api private
-  def string_Version(t)      ; @bld << "'#{t}'"  ; end
+  def string_Version(t); @bld << "'#{t}'"; end
 
   # @api private
-  def string_VersionRange(t) ; @bld << "'#{t}'"  ; end
+  def string_VersionRange(t); @bld << "'#{t}'"; end
 
   # @api private
-  def string_Timespan(t)    ; @bld << "'#{t}'"  ; end
+  def string_Timespan(t); @bld << "'#{t}'"; end
 
   # @api private
-  def string_Timestamp(t)    ; @bld << "'#{t}'"  ; end
+  def string_Timestamp(t); @bld << "'#{t}'"; end
 
   # Debugging to_s to reduce the amount of output
   def to_s
@@ -695,13 +690,13 @@ class TypeFormatter
     begin
       @expanded = false
       append_array('Object') do
-        append_hash(hash, proc { |k| @bld << symbolic_key(k) }) do |k,v|
+        append_hash(hash, proc { |k| @bld << symbolic_key(k) }) do |k, v|
           case k
           when KEY_ATTRIBUTES, KEY_FUNCTIONS
             # Types might need to be output as type references
             append_hash(v) do |_, fv|
               if fv.is_a?(Hash)
-                append_hash(fv, proc { |fak| @bld << symbolic_key(fak) }) do |fak,fav|
+                append_hash(fv, proc { |fak| @bld << symbolic_key(fak) }) do |fak, fav|
                   case fak
                   when KEY_KIND
                     @bld << fav
@@ -728,6 +723,7 @@ class TypeFormatter
   def append_elements(array, to_be_continued = false)
     case array.size
     when 0
+      # do nothing
     when 1
       @bld << array[0]
       @bld << COMMA_SEP if to_be_continued
@@ -740,6 +736,7 @@ class TypeFormatter
   def append_strings(array, to_be_continued = false)
     case array.size
     when 0
+      # do nothing
     when 1
       append_string(array[0])
       @bld << COMMA_SEP if to_be_continued