puppet 8.5.1 → 8.6.0

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

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

@@ -57,7 +57,7 @@ class TypedModelObject < Object
   def self.register_ptypes(loader, ir)
     types = [
       Annotation.register_ptype(loader, ir),
-      RubyMethod.register_ptype(loader, ir),
+      RubyMethod.register_ptype(loader, ir)
     ]
     Types.constants.each do |c|
       next if c == :PType || c == :PHostClassType
@@ -131,7 +131,7 @@ class PAnyType < TypedModelObject
       end
     when PVariantType
       # Assignable if all contained types are assignable, or if this is exactly Any
-      return true if self.instance_of?(PAnyType)
+      return true if instance_of?(PAnyType)
       # An empty variant may be assignable to NotUndef[T] if T is assignable to empty variant
       return _assignable?(o, guard) if is_a?(PNotUndefType) && o.types.empty?
 
@@ -342,7 +342,7 @@ class PAnyType < TypedModelObject
   # @raises ArgumentError
   #
   def self.new_function(type)
-    raise ArgumentError.new("Creation of new instance of type '#{type}' is not supported")
+    raise ArgumentError, "Creation of new instance of type '#{type}' is not supported"
   end
 
   # Answers the question if instances of this type can represent themselves as a string that
@@ -400,7 +400,7 @@ class PAnyType < TypedModelObject
     modified = false
     modified_types = types.map do |t|
       t_mod = t.send(method, *method_args)
-      modified = !t.equal?(t_mod) unless modified
+      modified ||= !t.equal?(t_mod)
       t_mod
     end
     if modified
@@ -737,7 +737,7 @@ class PScalarDataType < PScalarType
   end
 
   def instance?(o, guard = nil)
-    return o.instance_of?(String) || o.is_a?(Integer) || o.is_a?(Float) || o.is_a?(TrueClass) || o.is_a?(FalseClass)
+    o.instance_of?(String) || o.is_a?(Integer) || o.is_a?(Float) || o.is_a?(TrueClass) || o.is_a?(FalseClass)
   end
 
   DEFAULT = PScalarDataType.new
@@ -919,9 +919,9 @@ class PNumericType < PScalarDataType
 
             Puppet::Pops::Utils.to_n(from)
           rescue TypeError => e
-            raise TypeConversionError.new(e.message)
+            raise TypeConversionError, e.message
           rescue ArgumentError => e
-            raise TypeConversionError.new(e.message)
+            raise TypeConversionError, e.message
           end
         end
       end
@@ -952,7 +952,7 @@ class PNumericType < PScalarDataType
   # @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.
@@ -1088,7 +1088,11 @@ class PIntegerType < PNumericType
   # numbers are converted to zero
   # @return [PIntegerType] a positive range
   def to_size
-    @from >= 0 ? self : PIntegerType.new(0, @to < 0 ? 0 : @to)
+    if @from >= 0
+      self
+    else
+      PIntegerType.new(0, @to < 0 ? 0 : @to)
+    end
   end
 
   def new_function
@@ -1142,7 +1146,7 @@ class PIntegerType < PNumericType
           begin
             radix == :default ? Integer(from) : Integer(from, radix)
           rescue TypeError => e
-            raise TypeConversionError.new(e.message)
+            raise TypeConversionError, e.message
           rescue ArgumentError => e
             # Test for special case where there is whitespace between sign and number
             match = Patterns::WS_BETWEEN_SIGN_AND_NUMBER.match(from)
@@ -1154,7 +1158,7 @@ class PIntegerType < PNumericType
                 # Ignored to retain original error
               end
             end
-            raise TypeConversionError.new(e.message)
+            raise TypeConversionError, e.message
           end
         end
       end
@@ -1184,7 +1188,7 @@ class PIntegerType < PNumericType
         when 2, 8, 10, 16
           # do nothing
         else
-          raise ArgumentError.new(_("Illegal radix: %{radix}, expected 2, 8, 10, 16, or default") % { radix: radix })
+          raise ArgumentError, _("Illegal radix: %{radix}, expected 2, 8, 10, 16, or default") % { radix: radix }
         end
         radix
       end
@@ -1277,7 +1281,7 @@ class PFloatType < PNumericType
             end
             Float(from)
           rescue TypeError => e
-            raise TypeConversionError.new(e.message)
+            raise TypeConversionError, e.message
           rescue ArgumentError => e
             # Test for special case where there is whitespace between sign and number
             match = Patterns::WS_BETWEEN_SIGN_AND_NUMBER.match(from)
@@ -1289,7 +1293,7 @@ class PFloatType < PNumericType
                 # Ignored to retain original error
               end
             end
-            raise TypeConversionError.new(e.message)
+            raise TypeConversionError, e.message
           end
         end
       end
@@ -1816,7 +1820,7 @@ class PPatternType < PScalarDataType
       else
         # the string in String type must match one of the patterns in Pattern type,
         # or Pattern represents all Patterns == all Strings
-        regexps = @patterns.map { |p| p.regexp }
+        regexps = @patterns.map(&:regexp)
         regexps.empty? || regexps.any? { |re| re.match(v) }
       end
     when PEnumType
@@ -1827,7 +1831,7 @@ class PPatternType < PScalarDataType
       else
         # all strings in String/Enum type must match one of the patterns in Pattern type,
         # or Pattern represents all Patterns == all Strings
-        regexps = @patterns.map { |p| p.regexp }
+        regexps = @patterns.map(&:regexp)
         regexps.empty? || o.values.all? { |s| regexps.any? { |re| re.match(s) } }
       end
     when PPatternType
@@ -1963,7 +1967,7 @@ class PStructElement < TypedModelObject
   end
 
   def <=>(o)
-    self.name <=> o.name
+    name <=> o.name
   end
 
   def eql?(o)
@@ -2045,8 +2049,8 @@ class PStructType < PAnyType
     else
       PIterableType.new(
         PTupleType.new([
-                         PVariantType.maybe_create(@elements.map { |se| se.key_type }),
-                         PVariantType.maybe_create(@elements.map { |se| se.value_type })
+                         PVariantType.maybe_create(@elements.map(&:key_type)),
+                         PVariantType.maybe_create(@elements.map(&:value_type))
                        ],
                        PHashType::KEY_PAIR_TUPLE_SIZE)
       )
@@ -2434,7 +2438,7 @@ class PCallableType < PAnyType
     return false unless @param_types.instance?(args)
 
     if @block_type.nil?
-      block == nil
+      block.nil?
     else
       @block_type.instance?(block)
     end
@@ -2842,7 +2846,7 @@ class PHashType < PCollectionType
             {}
           else
             unless from.size.even?
-              raise TypeConversionError.new(_('odd number of arguments for Hash'))
+              raise TypeConversionError, _('odd number of arguments for Hash')
             end
 
             Hash[*from]
@@ -2854,7 +2858,7 @@ class PHashType < PCollectionType
             Hash[*Iterable.on(from).to_a]
           else
             t = TypeCalculator.singleton.infer(from).generalize
-            raise TypeConversionError.new(_("Value of type %{type} cannot be converted to Hash") % { type: t })
+            raise TypeConversionError, _("Value of type %{type} cannot be converted to Hash") % { type: t }
           end
         end
       end
@@ -3054,7 +3058,7 @@ class PVariantType < PAnyType
       not_undefs = parts[0]
       if not_undefs.size > 1
         others = parts[1]
-        others << PNotUndefType.new(PVariantType.maybe_create(not_undefs.map { |not_undef| not_undef.type }).normalize)
+        others << PNotUndefType.new(PVariantType.maybe_create(not_undefs.map(&:type)).normalize)
         array = others
       end
     end
@@ -3097,7 +3101,7 @@ class PVariantType < PAnyType
       patterns = parts[0]
       if patterns.size > 1
         others = parts[1]
-        others << PPatternType.new(patterns.map { |pattern| pattern.patterns }.flatten.uniq)
+        others << PPatternType.new(patterns.map(&:patterns).flatten.uniq)
         array = others
       end
     end