puppet 8.5.0-x64-mingw32 → 8.6.0-x64-mingw32

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

@@ -170,7 +170,7 @@ class PObjectType < PMetaType
     # @raises [Puppet::ParseError] if the assertion fails
     # @api private
     def assert_can_be_overridden(member)
-      unless self.instance_of?(member.class)
+      unless instance_of?(member.class)
         raise Puppet::ParseError, _("%{member} attempts to override %{label}") % { member: member.label, label: label }
       end
       if @final && !(constant? && member.constant?)
@@ -261,7 +261,7 @@ class PObjectType < PMetaType
     # @api private
     def create_dispatch(instance)
       # TODO: Assumes Ruby implementation for now
-      if (callable_type.is_a?(PVariantType))
+      if callable_type.is_a?(PVariantType)
         callable_type.types.map do |ct|
           Functions::Dispatch.new(ct, RubyGenerator.protect_reserved_name(name), [], false, ct.block_type.nil? ? nil : 'block')
         end
@@ -656,7 +656,7 @@ class PObjectType < PMetaType
           index = param_names.index(ip)
           if index.nil?
             raise Serialization::SerializationError,
-                  "Initializer for class #{impl_class.name} parameter '#{ip}' does not match any of the the attributes of type #{name}"
+                  "Initializer for class #{impl_class.name} parameter '#{ip}' does not match any of the attributes of type #{name}"
           end
           new_param_types << param_types[index]
         end
@@ -901,7 +901,7 @@ class PObjectType < PMetaType
       tc = TypeCalculator.singleton
       constants, others = @attributes.partition do |_, a|
         a.kind == ATTRIBUTE_KIND_CONSTANT && a.type == tc.infer(a.value).generalize
-      end.map { |ha| ha.to_h }
+      end.map(&:to_h)
 
       result[KEY_ATTRIBUTES] = compressed_members_hash(others) unless others.empty?
       unless constants.empty?
@@ -1111,7 +1111,7 @@ class PObjectType < PMetaType
   # @return [PObjectType] the topmost parent who's #equality_attributes include the given _attr_
   def find_equality_definer_of(attr)
     type = self
-    while !type.nil? do
+    until type.nil?
       p = type.resolved_parent
       return type unless p.is_a?(PObjectType)
       return type unless p.equality_attributes.include?(attr.name)

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

@@ -209,12 +209,10 @@ class PObjectTypeExtension < PAnyType
   def test_instance?(o, guard)
     eval = Parser::EvaluatingParser.singleton.evaluator
     @parameters.keys.all? do |pn|
-      begin
-        m = o.public_method(pn)
-        m.arity == 0 ? eval.match?(m.call, @parameters[pn]) : false
-      rescue NameError
-        false
-      end
+      m = o.public_method(pn)
+      m.arity == 0 ? eval.match?(m.call, @parameters[pn]) : false
+    rescue NameError
+      false
     end
   end
 

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

@@ -158,7 +158,7 @@ class PSemVerRangeType < PAnyType
       end
 
       def from_hash(hash)
-        from_versions(hash['min'], hash.fetch('max') { :default }, hash.fetch('exclude_max') { false })
+        from_versions(hash['min'], hash.fetch('max', :default), hash.fetch('exclude_max', false))
       end
     end
   end

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

@@ -72,7 +72,7 @@ class PSensitiveType < PTypeWithContainedType
   private
 
   def _assignable?(o, guard)
-    self.instance_of?(o.class) && @type.assignable?(o.type, guard)
+    instance_of?(o.class) && @type.assignable?(o.type, guard)
   end
 
   DEFAULT = PSensitiveType.new

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

@@ -17,7 +17,7 @@ module Types
     # @return [Boolean] `true` if this range intersects with the other range
     # @api public
     def intersect?(o)
-      self.instance_of?(o.class) && !(@to < o.numeric_from || o.numeric_to < @from)
+      instance_of?(o.class) && !(@to < o.numeric_from || o.numeric_to < @from)
     end
 
     # Returns the lower bound of the numeric range or `nil` if no lower bound is set.
@@ -94,7 +94,7 @@ module Types
     end
 
     def _assignable?(o, guard)
-      self.instance_of?(o.class) && numeric_from <= o.numeric_from && numeric_to >= o.numeric_to
+      instance_of?(o.class) && numeric_from <= o.numeric_from && numeric_to >= o.numeric_to
     end
   end
 

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

@@ -183,7 +183,7 @@ class PTypeSetType < PMetaType
     result[KEY_NAME] = @name
     result[KEY_VERSION] = @version.to_s unless @version.nil?
     result[KEY_TYPES] = @types unless @types.empty?
-    result[KEY_REFERENCES] = @references.transform_values { |ref| ref._pcore_init_hash } unless @references.empty?
+    result[KEY_REFERENCES] = @references.transform_values(&:_pcore_init_hash) unless @references.empty?
     result
   end
 
@@ -359,20 +359,20 @@ class PTypeSetType < PMetaType
   end
 
   DEFAULT =
-    self
-    .new({
-           KEY_NAME => 'DefaultTypeSet',
-           KEY_NAME_AUTHORITY => Pcore::RUNTIME_NAME_AUTHORITY,
-           Pcore::KEY_PCORE_URI => Pcore::PCORE_URI,
-           Pcore::KEY_PCORE_VERSION => Pcore::PCORE_VERSION,
-           KEY_VERSION => SemanticPuppet::Version.new(0, 0, 0)
-         })
+
+    new({
+          KEY_NAME => 'DefaultTypeSet',
+          KEY_NAME_AUTHORITY => Pcore::RUNTIME_NAME_AUTHORITY,
+          Pcore::KEY_PCORE_URI => Pcore::PCORE_URI,
+          Pcore::KEY_PCORE_VERSION => Pcore::PCORE_VERSION,
+          KEY_VERSION => SemanticPuppet::Version.new(0, 0, 0)
+        })
 
   protected
 
   # @api_private
   def _assignable?(o, guard)
-    self.instance_of?(o.class) && (self == DEFAULT || eql?(o))
+    instance_of?(o.class) && (self == DEFAULT || eql?(o))
   end
 
   private

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

@@ -34,7 +34,7 @@ class PURIType < PAnyType
     TypeFactory.optional(PATH) => PStringType::NON_EMPTY,
     TypeFactory.optional(QUERY) => PStringType::NON_EMPTY,
     TypeFactory.optional(FRAGMENT) => PStringType::NON_EMPTY,
-    TypeFactory.optional(OPAQUE) => PStringType::NON_EMPTY,
+    TypeFactory.optional(OPAQUE) => PStringType::NON_EMPTY
   )
 
   TYPE_STRING_PARAM =
@@ -46,7 +46,7 @@ class PURIType < PAnyType
                TypeFactory.type_type(PPatternType::DEFAULT),
                TypeFactory.type_type(PEnumType::DEFAULT),
                TypeFactory.type_type(PNotUndefType::DEFAULT),
-               TypeFactory.type_type(PUndefType::DEFAULT),
+               TypeFactory.type_type(PUndefType::DEFAULT)
              ]))
 
   TYPE_INTEGER_PARAM =
@@ -55,7 +55,7 @@ class PURIType < PAnyType
         .new([
                PIntegerType.new(0),
                TypeFactory.type_type(PNotUndefType::DEFAULT),
-               TypeFactory.type_type(PUndefType::DEFAULT),
+               TypeFactory.type_type(PUndefType::DEFAULT)
              ]))
 
   TYPE_URI_PARAM_HASH_TYPE = TypeFactory.struct(
@@ -66,7 +66,7 @@ class PURIType < PAnyType
     TypeFactory.optional(PATH) => TYPE_STRING_PARAM,
     TypeFactory.optional(QUERY) => TYPE_STRING_PARAM,
     TypeFactory.optional(FRAGMENT) => TYPE_STRING_PARAM,
-    TypeFactory.optional(OPAQUE) => TYPE_STRING_PARAM,
+    TypeFactory.optional(OPAQUE) => TYPE_STRING_PARAM
   )
 
   TYPE_URI_PARAM_TYPE = PVariantType.new([PStringType::NON_EMPTY, TYPE_URI_PARAM_HASH_TYPE])

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

@@ -46,7 +46,7 @@ class RecursionGuard
   def with_this(instance)
     if (@state & SELF_RECURSION_IN_THIS) == 0
       tc = this_count
-      @state = @state | SELF_RECURSION_IN_THIS if this_put(instance)
+      @state |= SELF_RECURSION_IN_THIS if this_put(instance)
       if tc < this_count
         # recursive state detected
         result = yield(@state)
@@ -66,7 +66,7 @@ class RecursionGuard
   def with_that(instance)
     if (@state & SELF_RECURSION_IN_THAT) == 0
       tc = that_count
-      @state = @state | SELF_RECURSION_IN_THAT if that_put(instance)
+      @state |= SELF_RECURSION_IN_THAT if that_put(instance)
       if tc < that_count
         # recursive state detected
         result = yield(@state)
@@ -85,7 +85,7 @@ class RecursionGuard
   # @return [Integer] the resulting state
   def add_this(instance)
     if (@state & SELF_RECURSION_IN_THIS) == 0
-      @state = @state | SELF_RECURSION_IN_THIS if this_put(instance)
+      @state |= SELF_RECURSION_IN_THIS if this_put(instance)
     end
     @state
   end
@@ -95,7 +95,7 @@ class RecursionGuard
   # @return [Integer] the resulting state
   def add_that(instance)
     if (@state & SELF_RECURSION_IN_THAT) == 0
-      @state = @state | SELF_RECURSION_IN_THAT if that_put(instance)
+      @state |= SELF_RECURSION_IN_THAT if that_put(instance)
     end
     @state
   end

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

@@ -64,7 +64,7 @@ class RubyGenerator < TypeFormatter
         class_body(key, EMPTY_ARRAY, class_def)
         cls = Class.new(parent_class)
         cls.class_eval(class_def)
-        cls.define_singleton_method(:_pcore_type) { return key }
+        cls.define_singleton_method(:_pcore_type) { key }
         key.implementation_class = cls
       end
       hash[key] = cls
@@ -220,7 +220,7 @@ class RubyGenerator < TypeFormatter
     end
 
     init_params = others.reject { |a| a.kind == PObjectType::ATTRIBUTE_KIND_DERIVED }
-    opt, non_opt = init_params.partition { |ip| ip.value? }
+    opt, non_opt = init_params.partition(&:value?)
     derived_attrs, obj_attrs = others.select { |a| a.container.equal?(obj) }.partition { |ip| ip.kind == PObjectType::ATTRIBUTE_KIND_DERIVED }
 
     include_type = obj.equality_include_type? && !(obj.parent.is_a?(PObjectType) && obj.parent.equality_include_type?)

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

@@ -47,7 +47,7 @@ class StringConverter
     end
 
     def padding
-      return ' ' * 2 * level
+      ' ' * 2 * level
     end
   end
 
@@ -89,7 +89,7 @@ class StringConverter
 
     FMT_PATTERN_STR = '^%([\s\[+#0{<(|-]*)([1-9][0-9]*)?(?:\.([0-9]+))?([a-zA-Z])$'
     FMT_PATTERN = Regexp.compile(FMT_PATTERN_STR)
-    DELIMITERS  = ['[', '{', '(', '<', '|',]
+    DELIMITERS  = ['[', '{', '(', '<', '|']
     DELIMITER_MAP = {
       '[' => ['[', ']'],
       '{' => ['{', '}'],
@@ -119,13 +119,17 @@ class StringConverter
 
       @left  = flags.include?('-')
       @alt   = flags.include?('#')
-      @plus  = (flags.include?(' ') ? :space : (flags.include?('+') ? :plus : :ignore))
+      @plus  = if flags.include?(' ')
+                 :space
+               else
+                 flags.include?('+') ? :plus : :ignore
+               end
       @zero_pad = flags.include?('0')
 
       @delimiters = nil
       DELIMITERS.each do |d|
         next unless flags.include?(d)
-        if !@delimiters.nil?
+        unless @delimiters.nil?
           raise ArgumentError, "Only one of the delimiters [ { ( < | can be given in the format flags, got '#{fmt}'"
         end
 
@@ -550,7 +554,7 @@ class StringConverter
   end
   private :validate_input
 
-  FMT_KEYS = %w{separator separator2 format string_formats}.freeze
+  FMT_KEYS = %w[separator separator2 format string_formats].freeze
 
   def validate_container_input(fmt)
     if (fmt.keys - FMT_KEYS).size > 0
@@ -786,7 +790,7 @@ class StringConverter
       Kernel.format(f.orig_fmt.gsub('s', substitute), val_to_convert)
 
     when :p
-      # width & precision applied to string, not the the name of the type
+      # width & precision applied to string, not the name of the type
       "Binary(\"#{Kernel.format(f.orig_fmt.tr('p', 's'), val.to_s)}\")"
 
     when :b
@@ -826,7 +830,7 @@ class StringConverter
       f.alt? ? apply_string_flags(f, puppet_quote(c_val)) : Kernel.format(f.orig_fmt.tr('c', 's'), c_val)
 
     when :C
-      c_val = val.split('::').map { |s| s.capitalize }.join('::')
+      c_val = val.split('::').map(&:capitalize).join('::')
       f.alt? ? apply_string_flags(f, puppet_quote(c_val)) : Kernel.format(f.orig_fmt.tr('C', 's'), c_val)
 
     when :u
@@ -1132,7 +1136,7 @@ class StringConverter
     fmt = format_options.find { |k, _| k.assignable?(val_t) }
     return fmt[1] unless fmt.nil?
 
-    return Format.new("%s")
+    Format.new("%s")
   end
   private :get_format
 end

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

@@ -108,12 +108,10 @@ class TreeIterator
   private :indexer_on
 
   def has_next?(iterator)
-    begin
-      iterator.peek
-      true
-    rescue StopIteration
-      false
-    end
+    iterator.peek
+    true
+  rescue StopIteration
+    false
   end
   private :has_next?
 

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

@@ -132,15 +132,15 @@ class TypeCalculator
   # @api private
   def self.infer_callable_methods_t(o)
     # If being a value that cannot have Pcore based methods callable from Puppet Language
-    if (o.is_a?(String) ||
-      o.is_a?(Numeric) ||
-      o.is_a?(TrueClass) ||
-      o.is_a?(FalseClass) ||
-      o.is_a?(Regexp) ||
-      o.instance_of?(Array) ||
-      o.instance_of?(Hash) ||
-      Types::PUndefType::DEFAULT.instance?(o)
-       )
+    if o.is_a?(String) ||
+       o.is_a?(Numeric) ||
+       o.is_a?(TrueClass) ||
+       o.is_a?(FalseClass) ||
+       o.is_a?(Regexp) ||
+       o.instance_of?(Array) ||
+       o.instance_of?(Hash) ||
+       Types::PUndefType::DEFAULT.instance?(o)
+
       return nil
     end
 
@@ -386,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
 

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

@@ -248,7 +248,11 @@ module TypeFactory
   # @api public
   #
   def self.boolean(value = nil)
-    value.nil? ? PBooleanType::DEFAULT : (value ? PBooleanType::TRUE : PBooleanType::FALSE)
+    if value.nil?
+      PBooleanType::DEFAULT
+    else
+      value ? PBooleanType::TRUE : PBooleanType::FALSE
+    end
   end
 
   # Produces the Any type
@@ -309,7 +313,7 @@ module TypeFactory
   # @api public
   #
   def self.all_callables
-    return PCallableType::DEFAULT
+    PCallableType::DEFAULT
   end
 
   # Produces a Callable type with one signature without support for a block
@@ -623,7 +627,7 @@ module TypeFactory
   # @param type_string [String] the string form of the type
   # @return [PTypeReferenceType] the type reference
   def self.type_reference(type_string = nil)
-    type_string == nil ? PTypeReferenceType::DEFAULT : PTypeReferenceType.new(type_string)
+    type_string.nil? ? PTypeReferenceType::DEFAULT : PTypeReferenceType.new(type_string)
   end
 
   # Returns true if the given type t is of valid range parameter type (integer

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

@@ -687,37 +687,35 @@ class TypeFormatter
   end
 
   def append_object_hash(hash)
-    begin
-      @expanded = false
-      append_array('Object') do
-        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|
-                  case fak
-                  when KEY_KIND
-                    @bld << fav
-                  else
-                    append_string(fav)
-                  end
+    @expanded = false
+    append_array('Object') do
+      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|
+                case fak
+                when KEY_KIND
+                  @bld << fav
+                else
+                  append_string(fav)
                 end
-              else
-                append_string(fv)
               end
+            else
+              append_string(fv)
             end
-          when KEY_EQUALITY
-            append_array('') { append_strings(v) } if v.is_a?(Array)
-          else
-            append_string(v)
           end
+        when KEY_EQUALITY
+          append_array('') { append_strings(v) } if v.is_a?(Array)
+        else
+          append_string(v)
         end
       end
-    ensure
-      @expanded = true
     end
+  ensure
+    @expanded = true
   end
 
   def append_elements(array, to_be_continued = false)

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

@@ -131,7 +131,7 @@ module Types
 
       chopped_path = @path.clone
       chopped_path.delete_at(element_index)
-      copy = self.clone
+      copy = clone
       copy.instance_variable_set(:@path, chopped_path)
       copy
     end
@@ -287,7 +287,7 @@ module Types
       if e.is_a?(Array)
         if report_detailed?(e, a)
           a = detailed_actual_to_s(e, a)
-          e = e.map { |t| t.to_alias_expanded_s }
+          e = e.map(&:to_alias_expanded_s)
         else
           e = e.map { |t| short_name(t) }.uniq
           a = short_name(a)
@@ -533,10 +533,10 @@ module Types
       when 0
         # do nothing
       when 1
-        raise Puppet::ParseError.new("#{subject}:#{errors[0].format}")
+        raise Puppet::ParseError, "#{subject}:#{errors[0].format}"
       else
-        errors_str = errors.map { |error| error.format }.join("\n ")
-        raise Puppet::ParseError.new("#{subject}:\n #{errors_str}")
+        errors_str = errors.map(&:format).join("\n ")
+        raise Puppet::ParseError, "#{subject}:\n #{errors_str}"
       end
     end
 
@@ -556,7 +556,7 @@ module Types
       when 1
         errors[0].format.strip
       else
-        errors.map { |error| error.format }.join("\n ")
+        errors.map(&:format).join("\n ")
       end
     end
 
@@ -574,10 +574,10 @@ module Types
         when 0
           # do nothing
         when 1
-          raise Puppet::ParseError.new("#{subject}:#{errors[0].format}")
+          raise Puppet::ParseError, "#{subject}:#{errors[0].format}"
         else
-          errors_str = errors.map { |error| error.format }.join("\n ")
-          raise Puppet::ParseError.new("#{subject}:\n #{errors_str}")
+          errors_str = errors.map(&:format).join("\n ")
+          raise Puppet::ParseError, "#{subject}:\n #{errors_str}"
         end
       end
     end
@@ -758,19 +758,19 @@ module Types
       descriptions = variant_descriptions.flatten
       [size_mismatch_class, MissingRequiredBlock, UnexpectedBlock, TypeMismatch].each do |mismatch_class|
         mismatches = descriptions.select { |desc| desc.is_a?(mismatch_class) }
-        if mismatches.size == variant_descriptions.size
-          # 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
+        next unless mismatches.size == variant_descriptions.size
 
-            prev.merge(prev.path, curr)
-          end
-          unless generic_mismatch.nil?
-            # Report the generic mismatch and skip the rest
-            descriptions = [generic_mismatch]
-            break
-          end
+        # 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
+        next if generic_mismatch.nil?
+
+        # Report the generic mismatch and skip the rest
+        descriptions = [generic_mismatch]
+        break
       end
       descriptions = descriptions.uniq
       descriptions.size == 1 ? [descriptions[0].chop_path(varying_path_position)] : descriptions
@@ -894,7 +894,7 @@ module Types
     end
 
     def describe_tuple(expected, original, actual, path, size_mismatch_class)
-      return EMPTY_ARRAY if expected == actual || expected.types.empty? && (actual.is_a?(PArrayType))
+      return EMPTY_ARRAY if expected == actual || expected.types.empty? && actual.is_a?(PArrayType)
 
       expected_size = expected.size_type || TypeFactory.range(*expected.size_range)
 
@@ -954,9 +954,7 @@ module Types
           if param_errors.empty?
             this_return_t = expected.return_type || PAnyType::DEFAULT
             that_return_t = actual.return_type || PAnyType::DEFAULT
-            unless this_return_t.assignable?(that_return_t)
-              [TypeMismatch.new(path + [ReturnTypeElement.new], this_return_t, that_return_t)]
-            else
+            if this_return_t.assignable?(that_return_t)
               # names are ignored, they are just information
               # Blocks must be compatible
               this_block_t = expected.block_type || PUndefType::DEFAULT
@@ -966,6 +964,8 @@ module Types
               else
                 [TypeMismatch.new(path + [BlockPathElement.new], this_block_t, that_block_t)]
               end
+            else
+              [TypeMismatch.new(path + [ReturnTypeElement.new], this_return_t, that_return_t)]
             end
           else
             param_errors