puppet 8.4.0-x86-mingw32 → 8.5.0-x86-mingw32

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

@@ -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)
@@ -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
@@ -335,7 +333,7 @@ class TypeFormatter
   # @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)
@@ -444,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
@@ -473,7 +471,7 @@ 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
@@ -554,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
 
@@ -584,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)
@@ -597,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)
@@ -612,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
@@ -694,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

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

@@ -90,7 +90,7 @@ module Types
   # @api private
   class SignaturePathElement < VariantPathElement
     def to_s
-      "#{key+1}."
+      "#{key + 1}."
     end
   end
 
@@ -300,7 +300,7 @@ module Types
           e = "#{e[0]} or #{e[1]}"
           multi = true
         else
-          e = "#{e[0..e.size-2].join(', ')}, or #{e[e.size-1]}"
+          e = "#{e[0..e.size - 2].join(', ')}, or #{e[e.size - 1]}"
           multi = true
         end
       else
@@ -332,7 +332,7 @@ module Types
     def short_name(t)
       # Ensure that Optional, NotUndef, Sensitive, and Type are reported with included
       # type parameter.
-      if t.is_a?(PTypeWithContainedType) && !(t.type.nil? || t.type.class == PAnyType)
+      if t.is_a?(PTypeWithContainedType) && !(t.type.nil? || t.type.instance_of?(PAnyType))
         "#{t.name}[#{t.type.name}]"
       else
         t.name.nil? ? t.simple_name : t.name
@@ -367,7 +367,7 @@ module Types
       if e.is_a?(Array)
         e.any? { |t| always_fully_detailed?(t, a) }
       else
-        e.class == a.class || e.is_a?(PTypeAliasType) || a.is_a?(PTypeAliasType) || specialization(e, a)
+        e.instance_of?(a.class) || e.is_a?(PTypeAliasType) || a.is_a?(PTypeAliasType) || specialization(e, a)
       end
     end
 
@@ -584,7 +584,7 @@ module Types
 
     def get_deferred_function_return_type(value)
       func = Puppet.lookup(:loaders).private_environment_loader
-               .load(:function, value.name)
+                   .load(:function, value.name)
       dispatcher = func.class.dispatcher.find_matching_dispatcher(value.arguments)
       raise ArgumentError, "No matching arity found for #{func.class.name} with arguments #{value.arguments}" unless dispatcher
 
@@ -614,7 +614,7 @@ module Types
               result << describe(value_type, df_return_type, [ParameterPathElement.new(name)]) unless value_type.generalize.assignable?(df_return_type.generalize)
             else
               warning_text = _("Deferred function %{function_name} has no return_type, unable to guarantee value type during compilation.") %
-                             {function_name: value.name }
+                             { function_name: value.name }
               Puppet.warn_once('deprecations',
                                "#{value.name}_deferred_warning",
                                warning_text)
@@ -677,9 +677,10 @@ module Types
       params_tuple = signature.type.param_types
       params_size_t = params_tuple.size_type || TypeFactory.range(*params_tuple.size_range)
 
-      if args_tuple.is_a?(PTupleType)
+      case args_tuple
+      when PTupleType
         arg_types = args_tuple.types
-      elsif args_tuple.is_a?(PArrayType)
+      when PArrayType
         arg_types = Array.new(params_tuple.types.size, args_tuple.element_type || PUndefType::DEFAULT)
       else
         return [TypeMismatch.new(path, params_tuple, args_tuple)]
@@ -706,13 +707,11 @@ module Types
           # Check that the block is of the right type
           describe(param_block_t, arg_block_t, path + [BlockPathElement.new])
         end
-      else
+      elsif param_block_t.nil? || param_block_t.assignable?(PUndefType::DEFAULT)
         # Check that the block is optional
-        if param_block_t.nil? || param_block_t.assignable?(PUndefType::DEFAULT)
-          EMPTY_ARRAY
-        else
-          [MissingRequiredBlock.new(path)]
-        end
+        EMPTY_ARRAY
+      else
+        [MissingRequiredBlock.new(path)]
       end
     end
 
@@ -798,7 +797,8 @@ module Types
     def describe_PArrayType(expected, original, actual, path)
       descriptions = []
       element_type = expected.element_type || PAnyType::DEFAULT
-      if actual.is_a?(PTupleType)
+      case actual
+      when PTupleType
         types = actual.types
         expected_size = expected.size_type || PCollectionType::DEFAULT_SIZE
         actual_size = actual.size_type || PIntegerType.new(types.size, types.size)
@@ -809,7 +809,7 @@ module Types
         else
           descriptions << SizeMismatch.new(path, expected_size, actual_size)
         end
-      elsif actual.is_a?(PArrayType)
+      when PArrayType
         expected_size = expected.size_type
         actual_size = actual.size_type || PCollectionType::DEFAULT_SIZE
         if expected_size.nil? || expected_size.assignable?(actual_size)
@@ -827,7 +827,8 @@ module Types
       descriptions = []
       key_type = expected.key_type || PAnyType::DEFAULT
       value_type = expected.value_type || PAnyType::DEFAULT
-      if actual.is_a?(PStructType)
+      case actual
+      when PStructType
         elements = actual.elements
         expected_size = expected.size_type || PCollectionType::DEFAULT_SIZE
         actual_size = PIntegerType.new(elements.count { |a| !a.key_type.assignable?(PUndefType::DEFAULT) }, elements.size)
@@ -839,7 +840,7 @@ module Types
         else
           descriptions << SizeMismatch.new(path, expected_size, actual_size)
         end
-      elsif actual.is_a?(PHashType)
+      when PHashType
         expected_size = expected.size_type
         actual_size = actual.size_type || PCollectionType::DEFAULT_SIZE
         if expected_size.nil? || expected_size.assignable?(actual_size)
@@ -856,7 +857,8 @@ module Types
     def describe_PStructType(expected, original, actual, path)
       elements = expected.elements
       descriptions = []
-      if actual.is_a?(PStructType)
+      case actual
+      when PStructType
         h2 = actual.hashed_elements.clone
         elements.each do |e1|
           key = e1.name
@@ -869,7 +871,7 @@ module Types
           end
         end
         h2.each_key { |key| descriptions << ExtraneousKey.new(path, key) }
-      elsif actual.is_a?(PHashType)
+      when PHashType
         actual_size = actual.size_type || PCollectionType::DEFAULT_SIZE
         expected_size = PIntegerType.new(elements.count { |e| !e.key_type.assignable?(PUndefType::DEFAULT) }, elements.size)
         if expected_size.assignable?(actual_size)
@@ -896,7 +898,8 @@ module Types
 
       expected_size = expected.size_type || TypeFactory.range(*expected.size_range)
 
-      if actual.is_a?(PTupleType)
+      case actual
+      when PTupleType
         actual_size = actual.size_type || TypeFactory.range(*actual.size_range)
 
         # not assignable if the number of types in actual is outside number of types in expected
@@ -913,7 +916,7 @@ module Types
         else
           [size_mismatch_class.new(path, expected_size, actual_size)]
         end
-      elsif actual.is_a?(PArrayType)
+      when PArrayType
         t2_entry = actual.element_type
 
         if t2_entry.nil?

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

@@ -404,9 +404,9 @@ class TypeParser
         if param_start.nil?
           type = type_str
         else
-          tps = interpret_any(@parser.parse_string(type_str[param_start..-1]).model, context)
+          tps = interpret_any(@parser.parse_string(type_str[param_start..]).model, context)
           raise_invalid_parameters_error(type.to_s, '1', tps.size) unless tps.size == 1
-          type = type_str[0..param_start-1]
+          type = type_str[0..param_start - 1]
           parameters = [type] + tps
         end
       end
@@ -457,13 +457,13 @@ class TypeParser
         assert_range_parameter(ast, parameters[-1])
         max = parameters[-1]
         max = max == :default ? nil : max
-        parameters = parameters[0, length-2]
+        parameters = parameters[0, length - 2]
         size_type = TypeFactory.range(min, max)
       elsif TypeFactory.is_range_parameter?(parameters[-1])
         min = parameters[-1]
         min = (min == :default || min == 'default') ? 0 : min
         max = nil
-        parameters = parameters[0, length-1]
+        parameters = parameters[0, length - 1]
         size_type = TypeFactory.range(min, max)
       end
       TypeFactory.tuple(parameters, size_type)
@@ -563,9 +563,10 @@ class TypeParser
       TypeFactory.string(size_type)
 
     when 'sensitive'
-      if parameters.size == 0
+      case parameters.size
+      when 0
         TypeFactory.sensitive
-      elsif parameters.size == 1
+      when 1
         param = parameters[0]
         assert_type(ast, param)
         TypeFactory.sensitive(param)
@@ -644,9 +645,10 @@ class TypeParser
   private
 
   def create_resource(name, parameters)
-    if parameters.size == 1
+    case parameters.size
+    when 1
       TypeFactory.resource(name)
-    elsif parameters.size == 2
+    when 2
       TypeFactory.resource(name, parameters[1])
     else
       raise_invalid_parameters_error('Resource', '1 or 2', parameters.size)
@@ -664,12 +666,12 @@ class TypeParser
 
   def raise_invalid_type_specification_error(ast)
     raise Puppet::ParseError, _("The expression <%{expression}> is not a valid type specification.") %
-        { expression: original_text_of(ast) }
+                              { expression: original_text_of(ast) }
   end
 
   def raise_invalid_parameters_error(type, required, given)
     raise Puppet::ParseError, _("Invalid number of type parameters specified: %{type} requires %{required}, %{given} provided") %
-        { type: type, required: required, given: given }
+                              { type: type, required: required, given: given }
   end
 
   def raise_unparameterized_type_error(ast)

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

@@ -41,4 +41,3 @@ class AttrReader
 end
 end
 end
-