puppet 8.4.0-x64-mingw32 → 8.5.1-x64-mingw32

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

@@ -51,7 +51,7 @@ class TypedModelObject < Object
   end
 
   def self.create_ptype(loader, ir, parent_name, attributes_hash = EMPTY_HASH)
-    @type = Pcore::create_object_type(loader, ir, self, "Pcore::#{simple_name}Type", "Pcore::#{parent_name}", attributes_hash)
+    @type = Pcore.create_object_type(loader, ir, self, "Pcore::#{simple_name}Type", "Pcore::#{parent_name}", attributes_hash)
   end
 
   def self.register_ptypes(loader, ir)
@@ -77,7 +77,7 @@ end
 #
 class PAnyType < TypedModelObject
   def self.register_ptype(loader, ir)
-    @type = Pcore::create_object_type(loader, ir, self, 'Pcore::AnyType', 'Any', EMPTY_HASH)
+    @type = Pcore.create_object_type(loader, ir, self, 'Pcore::AnyType', 'Any', EMPTY_HASH)
   end
 
   def self.create(*args)
@@ -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.class == PAnyType
+      return true if self.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?
 
@@ -298,7 +298,7 @@ class PAnyType < TypedModelObject
   def self.simple_name
     @simple_name ||= (
       n = name
-      n[n.rindex(DOUBLE_COLON)+3..n.size-5].freeze
+      n[n.rindex(DOUBLE_COLON) + 3..n.size - 5].freeze
     )
   end
 
@@ -471,8 +471,7 @@ class PTypeType < PTypeWithContainedType
                  'type' => {
                    KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
                    KEY_VALUE => nil
-                 }
-    )
+                 })
   end
 
   # Returns a new function that produces a Type instance
@@ -490,9 +489,10 @@ class PTypeType < PTypeWithContainedType
   end
 
   def instance?(o, guard = nil)
-    if o.is_a?(PAnyType)
+    case o
+    when PAnyType
       type.nil? || type.assignable?(o, guard)
-    elsif o.is_a?(Module) || o.is_a?(Puppet::Resource) || o.is_a?(Puppet::Parser::Resource)
+    when Module, Puppet::Resource, Puppet::Parser::Resource
       @type.nil? ? true : assignable?(TypeCalculator.infer(o))
     else
       false
@@ -553,12 +553,11 @@ class PNotUndefType < PTypeWithContainedType
                  'type' => {
                    KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
                    KEY_VALUE => nil
-                 }
-    )
+                 })
   end
 
   def initialize(type = nil)
-    super(type.class == PAnyType ? nil : type)
+    super(type.instance_of?(PAnyType) ? nil : type)
   end
 
   def instance?(o, guard = nil)
@@ -569,16 +568,14 @@ class PNotUndefType < PTypeWithContainedType
     n = super
     if n.type.nil?
       n
+    elsif n.type.is_a?(POptionalType)
+      PNotUndefType.new(n.type.type).normalize
+    # No point in having an optional in a NotUndef
+    elsif !n.type.assignable?(PUndefType::DEFAULT)
+      # THe type is NotUndef anyway, so it can be stripped of
+      n.type
     else
-      if n.type.is_a?(POptionalType)
-        # No point in having an optional in a NotUndef
-        PNotUndefType.new(n.type.type).normalize
-      elsif !n.type.assignable?(PUndefType::DEFAULT)
-        # THe type is NotUndef anyway, so it can be stripped of
-        n.type
-      else
-        n
-      end
+      n
     end
   end
 
@@ -655,7 +652,7 @@ class PUnitType < PAnyType
 
   DEFAULT = PUnitType.new
 
-  def assignable?(o, guard=nil)
+  def assignable?(o, guard = nil)
     true
   end
 
@@ -865,8 +862,7 @@ class PNumericType < PScalarDataType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'ScalarDataType',
                  'from' => { KEY_TYPE => POptionalType.new(PNumericType::DEFAULT), KEY_VALUE => nil },
-                 'to' => { KEY_TYPE => POptionalType.new(PNumericType::DEFAULT), KEY_VALUE => nil }
-    )
+                 'to' => { KEY_TYPE => POptionalType.new(PNumericType::DEFAULT), KEY_VALUE => nil })
   end
 
   def self.new_function(type)
@@ -956,7 +952,7 @@ class PNumericType < PScalarDataType
   # @return [Boolean] `true` if this range intersects with the other range
   # @api public
   def intersect?(o)
-    self.class == o.class && !(@to < o.numeric_from || o.numeric_to < @from)
+    self.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.
@@ -1072,7 +1068,7 @@ class PIntegerType < PNumericType
   def size
     return Float::INFINITY if @from == -Float::INFINITY || @to == Float::INFINITY
 
-    1+(to-from).abs
+    1 + (to - from).abs
   end
 
   # Returns the range as an array ordered so the smaller number is always first.
@@ -1320,8 +1316,7 @@ class PCollectionType < PAnyType
                  'size_type' => {
                    KEY_TYPE => POptionalType.new(PTypeType.new(PIntegerType::DEFAULT)),
                    KEY_VALUE => nil
-                 }
-    )
+                 })
   end
 
   attr_reader :size_type
@@ -1411,8 +1406,7 @@ class PIterableType < PTypeWithContainedType
                  'type' => {
                    KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
                    KEY_VALUE => nil
-                 }
-    )
+                 })
   end
 
   def element_type
@@ -1471,8 +1465,7 @@ class PIteratorType < PTypeWithContainedType
                  'type' => {
                    KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
                    KEY_VALUE => nil
-                 }
-    )
+                 })
   end
 
   def element_type
@@ -1583,9 +1576,10 @@ class PStringType < PScalarDataType
   end
 
   def derived_size_type
-    if @size_type_or_value.is_a?(PIntegerType)
+    case @size_type_or_value
+    when PIntegerType
       @size_type_or_value
-    elsif @size_type_or_value.is_a?(String)
+    when String
       sz = @size_type_or_value.size
       PIntegerType.new(sz, sz)
     else
@@ -1623,7 +1617,7 @@ class PStringType < PScalarDataType
   NON_EMPTY = PStringType.new(PCollectionType::NOT_EMPTY_SIZE)
 
   # Iterates over each character of the string
-  ITERABLE_TYPE = PIterableType.new(PStringType.new(PIntegerType.new(1,1)))
+  ITERABLE_TYPE = PIterableType.new(PStringType.new(PIntegerType.new(1, 1)))
 
   protected
 
@@ -1755,7 +1749,7 @@ class PRegexpType < PScalarType
     self.class == o.class && @pattern == o.pattern
   end
 
-  def instance?(o, guard=nil)
+  def instance?(o, guard = nil)
     o.is_a?(Regexp) && @pattern.nil? || regexp == o
   end
 
@@ -1834,7 +1828,7 @@ class PPatternType < PScalarDataType
         # 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.empty? || o.values.all? { |s| regexps.any? {|re| re.match(s) } }
+        regexps.empty? || o.values.all? { |s| regexps.any? { |re| re.match(s) } }
       end
     when PPatternType
       @patterns.empty?
@@ -1925,9 +1919,9 @@ end
 #
 class PStructElement < TypedModelObject
   def self.register_ptype(loader, ir)
-    @type = Pcore::create_object_type(loader, ir, self, 'Pcore::StructElement', nil,
-                                      'key_type' => PTypeType::DEFAULT,
-                                      'value_type' => PTypeType::DEFAULT)
+    @type = Pcore.create_object_type(loader, ir, self, 'Pcore::StructElement', nil,
+                                     'key_type' => PTypeType::DEFAULT,
+                                     'value_type' => PTypeType::DEFAULT)
   end
 
   attr_accessor :key_type, :value_type
@@ -2033,7 +2027,7 @@ class PStructType < PAnyType
 
   # rubocop:disable Naming/MemoizedInstanceVariableName
   def hashed_elements
-    @hashed ||= @elements.reduce({}) {|memo, e| memo[e.name] = e; memo }
+    @hashed ||= @elements.each_with_object({}) { |e, memo| memo[e.name] = e; }
   end
   # rubocop:enable Naming/MemoizedInstanceVariableName
 
@@ -2051,9 +2045,11 @@ 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 })],
-                       PHashType::KEY_PAIR_TUPLE_SIZE))
+                         PVariantType.maybe_create(@elements.map { |se| se.key_type }),
+                         PVariantType.maybe_create(@elements.map { |se| se.value_type })
+                       ],
+                       PHashType::KEY_PAIR_TUPLE_SIZE)
+      )
     end
   end
 
@@ -2105,7 +2101,8 @@ class PStructType < PAnyType
 
   # @api private
   def _assignable?(o, guard)
-    if o.is_a?(Types::PStructType)
+    case o
+    when Types::PStructType
       h2 = o.hashed_elements
       matched = 0
       elements.all? do |e1|
@@ -2117,7 +2114,7 @@ class PStructType < PAnyType
           e1.key_type.assignable?(e2.key_type, guard) && e1.value_type.assignable?(e2.value_type, guard)
         end
       end && matched == h2.size
-    elsif o.is_a?(Types::PHashType)
+    when Types::PHashType
       required = 0
       required_elements_assignable = elements.all? do |e|
         key_type = e.key_type
@@ -2158,8 +2155,7 @@ class PTupleType < PAnyType
                  'size_type' => {
                    KEY_TYPE => POptionalType.new(PTypeType.new(PIntegerType::DEFAULT)),
                    KEY_VALUE => nil
-                 }
-    )
+                 })
   end
 
   # If set, describes min and max required of the given types - if max > size of
@@ -2292,9 +2288,9 @@ class PTupleType < PAnyType
 
     types_size = @types.size
     from, to = @size_type.range
-    min = from - (types_size-1)
+    min = from - (types_size - 1)
     min = min <= 0 ? 0 : min
-    max = to - (types_size-1)
+    max = to - (types_size - 1)
     [min, max]
   end
 
@@ -2370,8 +2366,7 @@ class PCallableType < PAnyType
                  'return_type' => {
                    KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
                    KEY_VALUE => PAnyType::DEFAULT
-                 }
-    )
+                 })
   end
 
   # @return [PAnyType] The type for the values returned by this callable. Returns `nil` if return value is unconstrained
@@ -2451,7 +2446,7 @@ class PCallableType < PAnyType
     required_callable_t.assignable?(self, guard)
   end
 
-  def kind_of_callable?(optional=true, guard = nil)
+  def kind_of_callable?(optional = true, guard = nil)
     true
   end
 
@@ -2471,11 +2466,11 @@ class PCallableType < PAnyType
   def block_range
     case block_type
     when POptionalType
-      [0,1]
+      [0, 1]
     when PVariantType, PCallableType
-      [1,1]
+      [1, 1]
     else
-      [0,0]
+      [0, 0]
     end
   end
 
@@ -2528,8 +2523,7 @@ class PArrayType < PCollectionType
                  'element_type' => {
                    KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
                    KEY_VALUE => PAnyType::DEFAULT
-                 }
-    )
+                 })
   end
 
   attr_reader :element_type
@@ -2590,7 +2584,7 @@ class PArrayType < PCollectionType
   def instance?(o, guard = nil)
     # The inferred type of a class derived from Array is either Runtime or Object. It's not assignable to the Array type.
     return false unless o.instance_of?(Array)
-    return false unless o.all? {|element| @element_type.instance?(element, guard) }
+    return false unless o.all? { |element| @element_type.instance?(element, guard) }
 
     size_t = size_type
     size_t.nil? || size_t.instance?(o.size, guard)
@@ -2652,7 +2646,8 @@ class PArrayType < PCollectionType
   # Array is assignable if o is an Array and o's element type is assignable, or if o is a Tuple
   # @api private
   def _assignable?(o, guard)
-    if o.is_a?(PTupleType)
+    case o
+    when PTupleType
       o_types = o.types
       size_s = size_type || DEFAULT_SIZE
       size_o = o.size_type
@@ -2661,7 +2656,7 @@ class PArrayType < PCollectionType
         size_o = PIntegerType.new(type_count, type_count)
       end
       size_s.assignable?(size_o) && o_types.all? { |ot| @element_type.assignable?(ot, guard) }
-    elsif o.is_a?(PArrayType)
+    when PArrayType
       super && @element_type.assignable?(o.element_type, guard)
     else
       false
@@ -2681,8 +2676,7 @@ class PHashType < PCollectionType
                  'value_type' => {
                    KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
                    KEY_VALUE => PAnyType::DEFAULT
-                 }
-    )
+                 })
   end
 
   attr_accessor :key_type, :value_type
@@ -2743,7 +2737,7 @@ class PHashType < PCollectionType
     # The inferred type of a class derived from Hash is either Runtime or Object. It's not assignable to the Hash type.
     return false unless o.instance_of?(Hash)
 
-    if o.keys.all? {|key| @key_type.instance?(key, guard) } && o.values.all? {|value| @value_type.instance?(value, guard) }
+    if o.keys.all? { |key| @key_type.instance?(key, guard) } && o.values.all? { |value| @value_type.instance?(value, guard) }
       size_t = size_type
       size_t.nil? || size_t.instance?(o.size, guard)
     else
@@ -2781,7 +2775,7 @@ class PHashType < PCollectionType
     return value unless value.is_a?(Array)
 
     result = {}
-    value.each_with_index {|v, idx| result[idx] = array_as_hash(v) }
+    value.each_with_index { |v, idx| result[idx] = array_as_hash(v) }
     result
   end
 
@@ -2809,7 +2803,7 @@ class PHashType < PCollectionType
       end
 
       def from_tuples(tuple_array)
-        Hash[tuple_array]
+        tuple_array.to_h
       end
 
       def from_tree(tuple_array, build_option = nil)
@@ -2829,13 +2823,13 @@ class PHashType < PCollectionType
             # An array must be changed to a hash first as this is the root
             # (Cannot return an array from a Hash.new)
             if value.is_a?(Array)
-              value.each_with_index {|v, idx| result[idx] = v }
+              value.each_with_index { |v, idx| result[idx] = v }
             else
               result.merge!(value)
             end
           else
-            r = path[0..-2].reduce(result) {|memo, idx| (memo.is_a?(Array) || memo.has_key?(idx)) ? memo[idx] : memo[idx] = {}}
-            r[path[-1]]= (all_hashes ? PHashType.array_as_hash(value) : value)
+            r = path[0..-2].reduce(result) { |memo, idx| (memo.is_a?(Array) || memo.has_key?(idx)) ? memo[idx] : memo[idx] = {} }
+            r[path[-1]] = (all_hashes ? PHashType.array_as_hash(value) : value)
           end
         end
         result
@@ -2847,7 +2841,7 @@ class PHashType < PCollectionType
           if from.size == 0
             {}
           else
-            unless from.size % 2 == 0
+            unless from.size.even?
               raise TypeConversionError.new(_('odd number of arguments for Hash'))
             end
 
@@ -2868,7 +2862,7 @@ class PHashType < PCollectionType
   end
 
   DEFAULT = PHashType.new(nil, nil)
-  KEY_PAIR_TUPLE_SIZE = PIntegerType.new(2,2)
+  KEY_PAIR_TUPLE_SIZE = PIntegerType.new(2, 2)
   DEFAULT_KEY_PAIR_TUPLE = PTupleType.new([PUnitType::DEFAULT, PUnitType::DEFAULT], KEY_PAIR_TUPLE_SIZE)
   EMPTY = PHashType.new(PUnitType::DEFAULT, PUnitType::DEFAULT, PIntegerType.new(0, 0))
 
@@ -2890,7 +2884,7 @@ class PHashType < PCollectionType
       # hash must accept the size of the struct
       o_elements = o.elements
       (size_type || DEFAULT_SIZE).instance?(o_elements.size, guard) &&
-          o_elements.all? {|e| @key_type.instance?(e.name, guard) && @value_type.assignable?(e.value_type, guard) }
+        o_elements.all? { |e| @key_type.instance?(e.name, guard) && @value_type.assignable?(e.value_type, guard) }
     else
       false
     end
@@ -3056,7 +3050,7 @@ class PVariantType < PAnyType
   # @api private
   def swap_not_undefs(array)
     if array.size > 1
-      parts = array.partition {|t| t.is_a?(PNotUndefType) }
+      parts = array.partition { |t| t.is_a?(PNotUndefType) }
       not_undefs = parts[0]
       if not_undefs.size > 1
         others = parts[1]
@@ -3071,7 +3065,7 @@ class PVariantType < PAnyType
   def merge_enums(array)
     # Merge case sensitive enums and strings
     if array.size > 1
-      parts = array.partition {|t| t.is_a?(PEnumType) && !t.values.empty? && !t.case_insensitive? || t.is_a?(PStringType) && !t.value.nil? }
+      parts = array.partition { |t| t.is_a?(PEnumType) && !t.values.empty? && !t.case_insensitive? || t.is_a?(PStringType) && !t.value.nil? }
       enums = parts[0]
       if enums.size > 1
         others = parts[1]
@@ -3082,12 +3076,12 @@ class PVariantType < PAnyType
 
     # Merge case insensitive enums
     if array.size > 1
-      parts = array.partition {|t| t.is_a?(PEnumType) && !t.values.empty? && t.case_insensitive? }
+      parts = array.partition { |t| t.is_a?(PEnumType) && !t.values.empty? && t.case_insensitive? }
       enums = parts[0]
       if enums.size > 1
         others = parts[1]
         values = []
-        enums.each { |enum| enum.values.each { |value| values << value.downcase }}
+        enums.each { |enum| enum.values.each { |value| values << value.downcase } }
         values.uniq!
         others << PEnumType.new(values, true)
         array = others
@@ -3099,7 +3093,7 @@ class PVariantType < PAnyType
   # @api private
   def merge_patterns(array)
     if array.size > 1
-      parts = array.partition {|t| t.is_a?(PPatternType) }
+      parts = array.partition { |t| t.is_a?(PPatternType) }
       patterns = parts[0]
       if patterns.size > 1
         others = parts[1]
@@ -3113,7 +3107,7 @@ class PVariantType < PAnyType
   # @api private
   def merge_numbers(clazz, array)
     if array.size > 1
-      parts = array.partition {|t| t.is_a?(clazz) }
+      parts = array.partition { |t| t.is_a?(clazz) }
       ranges = parts[0]
       array = merge_ranges(ranges) + parts[1] if ranges.size > 1
     end
@@ -3122,7 +3116,7 @@ class PVariantType < PAnyType
 
   def merge_version_ranges(array)
     if array.size > 1
-      parts = array.partition {|t| t.is_a?(PSemVerType) }
+      parts = array.partition { |t| t.is_a?(PSemVerType) }
       ranges = parts[0]
       array = [PSemVerType.new(ranges.map(&:ranges).flatten)] + parts[1] if ranges.size > 1
     end
@@ -3183,8 +3177,7 @@ class PClassType < PCatalogEntryType
                  'class_name' => {
                    KEY_TYPE => POptionalType.new(PStringType::NON_EMPTY),
                    KEY_VALUE => nil
-                 }
-    )
+                 })
   end
 
   def initialize(class_name)
@@ -3230,8 +3223,7 @@ class PResourceType < PCatalogEntryType
                  'title' => {
                    KEY_TYPE => POptionalType.new(PStringType::NON_EMPTY),
                    KEY_VALUE => nil
-                 }
-    )
+                 })
   end
 
   attr_reader :type_name, :title, :downcased_name
@@ -3270,15 +3262,14 @@ class POptionalType < PTypeWithContainedType
                  'type' => {
                    KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
                    KEY_VALUE => nil
-                 }
-    )
+                 })
   end
 
   def optional_type
     @type
   end
 
-  def kind_of_callable?(optional=true, guard = nil)
+  def kind_of_callable?(optional = true, guard = nil)
     optional && !@type.nil? && @type.kind_of_callable?(optional, guard)
   end
 
@@ -3290,16 +3281,14 @@ class POptionalType < PTypeWithContainedType
     n = super
     if n.type.nil?
       n
+    elsif n.type.is_a?(PNotUndefType)
+      POptionalType.new(n.type.type).normalize
+    # No point in having an NotUndef in an Optional
+    elsif n.type.assignable?(PUndefType::DEFAULT)
+      # THe type is Optional anyway, so it can be stripped of
+      n.type
     else
-      if n.type.is_a?(PNotUndefType)
-        # No point in having an NotUndef in an Optional
-        POptionalType.new(n.type.type).normalize
-      elsif n.type.assignable?(PUndefType::DEFAULT)
-        # THe type is Optional anyway, so it can be stripped of
-        n.type
-      else
-        n
-      end
+      n
     end
   end
 
@@ -3380,8 +3369,7 @@ class PTypeAliasType < PAnyType
                  'resolved_type' => {
                    KEY_TYPE => POptionalType.new(PTypeType::DEFAULT),
                    KEY_VALUE => nil
-                 }
-    )
+                 })
   end
 
   attr_reader :loader, :name
@@ -3424,7 +3412,7 @@ class PTypeAliasType < PAnyType
     resolved_type.check_self_recursion(originator) unless originator.equal?(self)
   end
 
-  def kind_of_callable?(optional=true, guard = nil)
+  def kind_of_callable?(optional = true, guard = nil)
     guarded_recursion(guard, false) { |g| resolved_type.kind_of_callable?(optional, g) }
   end
 

data/lib/puppet/pops/utils.rb

@@ -59,7 +59,7 @@ module Utils
           radix = 10
           if match[3].to_s.length > 0
             radix = 16
-          elsif match[4].to_s.length > 1 && match[4][0,1] == '0'
+          elsif match[4].to_s.length > 1 && match[4][0, 1] == '0'
             radix = 8
           end
           # Ruby 1.8.7 does not have a second argument to Kernel method that creates an
@@ -115,7 +115,7 @@ module Utils
   end
 
   def self.relativize_name name
-    is_absolute?(name) ? name[2..-1] : name
+    is_absolute?(name) ? name[2..] : name
   end
 end
 end