puppet 8.3.1-x86-mingw32 → 8.4.0-x86-mingw32

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
@@ -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)
@@ -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)
@@ -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}"
@@ -626,7 +630,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
@@ -156,10 +156,10 @@ 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
@@ -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
@@ -332,7 +332,6 @@ 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)
@@ -480,7 +479,7 @@ class TypeFormatter
           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
@@ -585,7 +584,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)
@@ -601,7 +600,7 @@ class TypeFormatter
   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
@@ -625,10 +624,10 @@ class TypeFormatter
   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
@@ -728,6 +727,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 +740,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

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
   # @api private
@@ -127,6 +128,7 @@ module Types
 
     def chop_path(element_index)
       return self if element_index >= @path.size
+
       chopped_path = @path.clone
       chopped_path.delete_at(element_index)
       copy = self.clone
@@ -482,10 +484,6 @@ module Types
 
   # @api private
   class CountMismatch < SizeMismatch
-    def initialize(path, expected, actual)
-      super(path, expected, actual)
-    end
-
     def message(variant, position)
       min = expected.from || 0
       max = expected.to || Float::INFINITY
@@ -513,7 +511,7 @@ module Types
     end
 
     def tense_deprecated
-      #TRANSLATORS TypeMismatchDescriber is a class name and 'tense' is a method name and should not be translated
+      # TRANSLATORS TypeMismatchDescriber is a class name and 'tense' is a method name and should not be translated
       message = _("Passing a 'tense' argument to the TypeMismatchDescriber is deprecated and ignored.")
       message += ' ' + _("Everything is now reported using present tense")
       Puppet.warn_once('deprecations', 'typemismatch#tense', message)
@@ -533,6 +531,7 @@ module Types
       errors = describe_struct_signature(params_struct, given_hash, missing_ok).flatten
       case errors.size
       when 0
+        # do nothing
       when 1
         raise Puppet::ParseError.new("#{subject}:#{errors[0].format}")
       else
@@ -573,6 +572,7 @@ module Types
         errors = describe(param_type, TypeCalculator.singleton.infer_set(value).generalize, [ParameterPathElement.new(param_name)])
         case errors.size
         when 0
+          # do nothing
         when 1
           raise Puppet::ParseError.new("#{subject}:#{errors[0].format}")
         else
@@ -583,10 +583,11 @@ module Types
     end
 
     def get_deferred_function_return_type(value)
-      func = Puppet.lookup(:loaders).private_environment_loader.
-               load(:function, value.name)
+      func = Puppet.lookup(:loaders).private_environment_loader
+               .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
+
       dispatcher.type.return_type
     end
     private :get_deferred_function_return_type
@@ -601,7 +602,7 @@ module Types
     # @return [Array<Mismatch>] An array of found errors. An empty array indicates no errors.
     def describe_struct_signature(params_struct, param_hash, missing_ok = false)
       param_type_hash = params_struct.hashed_elements
-      result =  param_hash.each_key.reject { |name| param_type_hash.include?(name) }.map { |name| InvalidParameter.new(nil, name) }
+      result = param_hash.each_key.reject { |name| param_type_hash.include?(name) }.map { |name| InvalidParameter.new(nil, name) }
 
       params_struct.elements.each do |elem|
         name = elem.name
@@ -741,6 +742,7 @@ module Types
       types.each_with_index do |vt, index|
         d = describe(vt, actual, path + [VariantPathElement.new(index)])
         return EMPTY_ARRAY if d.empty?
+
         variant_descriptions << d
       end
       descriptions = merge_descriptions(path.length, SizeMismatch, variant_descriptions)
@@ -761,6 +763,7 @@ module Types
           # If they all have the same canonical path, then we can compact this into one
           generic_mismatch = mismatches.inject do |prev, curr|
             break nil unless prev.canonical_path == curr.canonical_path
+
             prev.merge(prev.path, curr)
           end
           unless generic_mismatch.nil?
@@ -776,6 +779,7 @@ module Types
 
     def describe_POptionalType(expected, original, actual, path)
       return EMPTY_ARRAY if actual.is_a?(PUndefType) || expected.optional_type.nil?
+
       internal_describe(expected.optional_type, original.is_a?(PTypeAliasType) ? original : expected, actual, path)
     end
 
@@ -889,6 +893,7 @@ module Types
 
     def describe_tuple(expected, original, actual, path, size_mismatch_class)
       return EMPTY_ARRAY if expected == actual || expected.types.empty? && (actual.is_a?(PArrayType))
+
       expected_size = expected.size_type || TypeFactory.range(*expected.size_range)
 
       if actual.is_a?(PTupleType)

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/concurrent/thread_local_singleton'
 
 # This class provides parsing of Type Specification from a string into the Type
@@ -39,6 +40,7 @@ class TypeParser
     if t
       return t
     end
+
     model = @parser.parse_string(string)
     interpret(model.model.body, context)
   end
@@ -162,48 +164,48 @@ class TypeParser
   # @api private
   def self.type_map
     @type_map ||= {
-        'integer'      => TypeFactory.integer,
-        'float'        => TypeFactory.float,
-        'numeric'      => TypeFactory.numeric,
-        'init'         => TypeFactory.init,
-        'iterable'     => TypeFactory.iterable,
-        'iterator'     => TypeFactory.iterator,
-        'string'       => TypeFactory.string,
-        'binary'       => TypeFactory.binary,
-        'sensitive'    => TypeFactory.sensitive,
-        'enum'         => TypeFactory.enum,
-        'boolean'      => TypeFactory.boolean,
-        'pattern'      => TypeFactory.pattern,
-        'regexp'       => TypeFactory.regexp,
-        'array'        => TypeFactory.array_of_any,
-        'hash'         => TypeFactory.hash_of_any,
-        'class'        => TypeFactory.host_class,
-        'resource'     => TypeFactory.resource,
-        'collection'   => TypeFactory.collection,
-        'scalar'       => TypeFactory.scalar,
-        'scalardata'   => TypeFactory.scalar_data,
-        'catalogentry' => TypeFactory.catalog_entry,
-        'undef'        => TypeFactory.undef,
-        'notundef'     => TypeFactory.not_undef,
-        'default'      => TypeFactory.default,
-        'any'          => TypeFactory.any,
-        'variant'      => TypeFactory.variant,
-        'optional'     => TypeFactory.optional,
-        'runtime'      => TypeFactory.runtime,
-        'type'         => TypeFactory.type_type,
-        'tuple'        => TypeFactory.tuple,
-        'struct'       => TypeFactory.struct,
-        'object'       => TypeFactory.object,
-        'typealias'    => TypeFactory.type_alias,
-        'typereference' => TypeFactory.type_reference,
-        'typeset'      => TypeFactory.type_set,
-         # A generic callable as opposed to one that does not accept arguments
-        'callable'     => TypeFactory.all_callables,
-        'semver'       => TypeFactory.sem_ver,
-        'semverrange'  => TypeFactory.sem_ver_range,
-        'timestamp'    => TypeFactory.timestamp,
-        'timespan'     => TypeFactory.timespan,
-        'uri'          => TypeFactory.uri,
+      'integer' => TypeFactory.integer,
+      'float' => TypeFactory.float,
+      'numeric' => TypeFactory.numeric,
+      'init' => TypeFactory.init,
+      'iterable' => TypeFactory.iterable,
+      'iterator' => TypeFactory.iterator,
+      'string' => TypeFactory.string,
+      'binary' => TypeFactory.binary,
+      'sensitive' => TypeFactory.sensitive,
+      'enum' => TypeFactory.enum,
+      'boolean' => TypeFactory.boolean,
+      'pattern' => TypeFactory.pattern,
+      'regexp' => TypeFactory.regexp,
+      'array' => TypeFactory.array_of_any,
+      'hash' => TypeFactory.hash_of_any,
+      'class' => TypeFactory.host_class,
+      'resource' => TypeFactory.resource,
+      'collection' => TypeFactory.collection,
+      'scalar' => TypeFactory.scalar,
+      'scalardata' => TypeFactory.scalar_data,
+      'catalogentry' => TypeFactory.catalog_entry,
+      'undef' => TypeFactory.undef,
+      'notundef' => TypeFactory.not_undef,
+      'default' => TypeFactory.default,
+      'any' => TypeFactory.any,
+      'variant' => TypeFactory.variant,
+      'optional' => TypeFactory.optional,
+      'runtime' => TypeFactory.runtime,
+      'type' => TypeFactory.type_type,
+      'tuple' => TypeFactory.tuple,
+      'struct' => TypeFactory.struct,
+      'object' => TypeFactory.object,
+      'typealias' => TypeFactory.type_alias,
+      'typereference' => TypeFactory.type_reference,
+      'typeset' => TypeFactory.type_set,
+      # A generic callable as opposed to one that does not accept arguments
+      'callable' => TypeFactory.all_callables,
+      'semver' => TypeFactory.sem_ver,
+      'semverrange' => TypeFactory.sem_ver_range,
+      'timestamp' => TypeFactory.timestamp,
+      'timespan' => TypeFactory.timespan,
+      'uri' => TypeFactory.uri,
     }.freeze
   end
 
@@ -215,58 +217,58 @@ class TypeParser
     # back to the parser for evaluation).
     #
     @opt_type_map ||= {
-        'Integer'      => TypeFactory.integer,
-        'Float'        => TypeFactory.float,
-        'Numeric'      => TypeFactory.numeric,
+      'Integer' => TypeFactory.integer,
+      'Float' => TypeFactory.float,
+      'Numeric' => TypeFactory.numeric,
 
-        'String'       => TypeFactory.string,
-        'String[1]'    => TypeFactory.string(TypeFactory.range(1, :default)),
+      'String' => TypeFactory.string,
+      'String[1]' => TypeFactory.string(TypeFactory.range(1, :default)),
 
-        'Binary'       => TypeFactory.binary,
+      'Binary' => TypeFactory.binary,
 
-        'Boolean'      => TypeFactory.boolean,
-        'Boolean[true]'  => TypeFactory.boolean(true),
-        'Boolean[false]' => TypeFactory.boolean(false),
+      'Boolean' => TypeFactory.boolean,
+      'Boolean[true]' => TypeFactory.boolean(true),
+      'Boolean[false]' => TypeFactory.boolean(false),
 
-        'Array'        => TypeFactory.array_of_any,
-        'Array[1]'     => TypeFactory.array_of(TypeFactory.any, TypeFactory.range(1, :default)),
+      'Array' => TypeFactory.array_of_any,
+      'Array[1]' => TypeFactory.array_of(TypeFactory.any, TypeFactory.range(1, :default)),
 
-        'Hash'         => TypeFactory.hash_of_any,
-        'Collection'   => TypeFactory.collection,
-        'Scalar'       => TypeFactory.scalar,
+      'Hash' => TypeFactory.hash_of_any,
+      'Collection' => TypeFactory.collection,
+      'Scalar' => TypeFactory.scalar,
 
-        'Scalardata'   => TypeFactory.scalar_data,
-        'ScalarData'   => TypeFactory.scalar_data,
+      'Scalardata' => TypeFactory.scalar_data,
+      'ScalarData' => TypeFactory.scalar_data,
 
-        'Catalogentry' => TypeFactory.catalog_entry,
-        'CatalogEntry' => TypeFactory.catalog_entry,
+      'Catalogentry' => TypeFactory.catalog_entry,
+      'CatalogEntry' => TypeFactory.catalog_entry,
 
-        'Undef'        => TypeFactory.undef,
-        'Default'      => TypeFactory.default,
-        'Any'          => TypeFactory.any,
-        'Type'         => TypeFactory.type_type,
-        'Callable'     => TypeFactory.all_callables,
+      'Undef' => TypeFactory.undef,
+      'Default' => TypeFactory.default,
+      'Any' => TypeFactory.any,
+      'Type' => TypeFactory.type_type,
+      'Callable' => TypeFactory.all_callables,
 
-        'Semver'       => TypeFactory.sem_ver,
-        'SemVer'       => TypeFactory.sem_ver,
+      'Semver' => TypeFactory.sem_ver,
+      'SemVer' => TypeFactory.sem_ver,
 
-        'Semverrange'  => TypeFactory.sem_ver_range,
-        'SemVerRange'  => TypeFactory.sem_ver_range,
+      'Semverrange' => TypeFactory.sem_ver_range,
+      'SemVerRange' => TypeFactory.sem_ver_range,
 
-        'Timestamp'    => TypeFactory.timestamp,
-        'TimeStamp'    => TypeFactory.timestamp,
+      'Timestamp' => TypeFactory.timestamp,
+      'TimeStamp' => TypeFactory.timestamp,
 
-        'Timespan'     => TypeFactory.timespan,
-        'TimeSpan'     => TypeFactory.timespan,
+      'Timespan' => TypeFactory.timespan,
+      'TimeSpan' => TypeFactory.timespan,
 
-        'Uri'          => TypeFactory.uri,
-        'URI'          => TypeFactory.uri,
+      'Uri' => TypeFactory.uri,
+      'URI' => TypeFactory.uri,
 
-        'Optional[Integer]'      => TypeFactory.optional(TypeFactory.integer),
-        'Optional[String]'       => TypeFactory.optional(TypeFactory.string),
-        'Optional[String[1]]'    => TypeFactory.optional(TypeFactory.string(TypeFactory.range(1, :default))),
-        'Optional[Array]'        => TypeFactory.optional(TypeFactory.array_of_any),
-        'Optional[Hash]'         => TypeFactory.optional(TypeFactory.hash_of_any),
+      'Optional[Integer]' => TypeFactory.optional(TypeFactory.integer),
+      'Optional[String]' => TypeFactory.optional(TypeFactory.string),
+      'Optional[String[1]]' => TypeFactory.optional(TypeFactory.string(TypeFactory.range(1, :default))),
+      'Optional[Array]' => TypeFactory.optional(TypeFactory.array_of_any),
+      'Optional[Hash]' => TypeFactory.optional(TypeFactory.hash_of_any),
 
     }.freeze
   end
@@ -371,20 +373,21 @@ class TypeParser
 
     when 'collection'
       size_type = case parameters.size
-        when 1
-          if parameters[0].is_a?(PIntegerType)
-            parameters[0]
-          else
-            assert_range_parameter(ast, parameters[0])
-            TypeFactory.range(parameters[0], :default)
-          end
-        when 2
-          assert_range_parameter(ast, parameters[0])
-          assert_range_parameter(ast, parameters[1])
-          TypeFactory.range(parameters[0], parameters[1])
-        else
-          raise_invalid_parameters_error('Collection', '1 to 2', parameters.size)
-        end
+                  when 1
+                    if parameters[0].is_a?(PIntegerType)
+                      parameters[0]
+                    else
+                      assert_range_parameter(ast, parameters[0])
+                      TypeFactory.range(parameters[0], :default)
+                    end
+                  when 2
+                    assert_range_parameter(ast, parameters[0])
+                    assert_range_parameter(ast, parameters[1])
+                    TypeFactory.range(parameters[0], parameters[1])
+                  else
+                    raise_invalid_parameters_error('Collection', '1 to 2',
+                                                   parameters.size)
+                  end
       TypeFactory.collection(size_type)
 
     when 'class'
@@ -483,6 +486,7 @@ class TypeParser
       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'
@@ -541,21 +545,21 @@ class TypeParser
 
     when 'string'
       size_type =
-      case parameters.size
-      when 1
-        if parameters[0].is_a?(PIntegerType)
-          parameters[0]
-        else
+        case parameters.size
+        when 1
+          if parameters[0].is_a?(PIntegerType)
+            parameters[0]
+          else
+            assert_range_parameter(ast, parameters[0])
+            TypeFactory.range(parameters[0], :default)
+          end
+        when 2
           assert_range_parameter(ast, parameters[0])
-          TypeFactory.range(parameters[0], :default)
+          assert_range_parameter(ast, parameters[1])
+          TypeFactory.range(parameters[0], parameters[1])
+        else
+          raise_invalid_parameters_error('String', '1 to 2', parameters.size)
         end
-      when 2
-        assert_range_parameter(ast, parameters[0])
-        assert_range_parameter(ast, parameters[1])
-        TypeFactory.range(parameters[0], parameters[1])
-      else
-        raise_invalid_parameters_error('String', '1 to 2', parameters.size)
-      end
       TypeFactory.string(size_type)
 
     when 'sensitive'

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
 class TypeSetReference
@@ -49,6 +50,7 @@ class TypeSetReference
     unless @version_range.include?(@type_set.version)
       raise ArgumentError, "#{self} resolves to an incompatible version. Expected #{@version_range}, got #{type_set.version}"
     end
+
     nil
   end
 

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
-
 # Interface implemented by a type that has InvocableMembers
 module TypeWithMembers
   # @return [InvocableMember,nil] An invocable member if it exists, or `nil`