puppet 8.4.0 → 8.5.0

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

@@ -43,7 +43,7 @@ class StringConverter
     end
 
     def breaks?
-      is_indenting? && level > 0 && ! first?
+      is_indenting? && level > 0 && !first?
     end
 
     def padding
@@ -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 = {
       '[' => ['[', ']'],
       '{' => ['{', '}'],
@@ -173,7 +173,7 @@ class StringConverter
 
       # drop all formats in lower than is more generic in higher. Lower must never
       # override higher
-      lower = lower.reject { |lk, _| higher.keys.any? { |hk| hk != lk && hk.assignable?(lk) }}
+      lower = lower.reject { |lk, _| higher.keys.any? { |hk| hk != lk && hk.assignable?(lk) } }
 
       merged = (lower.keys + higher.keys).uniq.map do |k|
         [k, merge(lower[k], higher[k])]
@@ -184,7 +184,7 @@ class StringConverter
     # Sorts format based on generality of types - most specific types before general
     #
     def self.sort_formats(format_map)
-      format_map = format_map.sort do |(a,_),(b,_)|
+      format_map = format_map.sort do |(a, _), (b, _)|
         ab = b.assignable?(a)
         ba = a.assignable?(b)
         if a == b
@@ -204,7 +204,7 @@ class StringConverter
           end
         end
       end
-      Hash[format_map]
+      format_map.to_h
     end
 
     # Ranks type on specificity where it matters
@@ -237,7 +237,7 @@ class StringConverter
     # @returns [Array<String>] a tuple with left, right delimiters
     #
     def delimiter_pair(default = StringConverter::DEFAULT_ARRAY_DELIMITERS)
-      DELIMITER_MAP[ @delimiters || @plus ] || default
+      DELIMITER_MAP[@delimiters || @plus] || default
     end
 
     def to_s
@@ -489,10 +489,10 @@ class StringConverter
       # For Array and Hash, the format is given as a Hash where 'format' key is the format for the collection itself
       if Puppet::Pops::Types::PArrayType::DEFAULT.assignable?(value_type)
         # add the format given for the exact type
-        string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => {'format' => string_formats }}
+        string_formats = { Puppet::Pops::Types::PArrayType::DEFAULT => { 'format' => string_formats } }
       elsif Puppet::Pops::Types::PHashType::DEFAULT.assignable?(value_type)
         # add the format given for the exact type
-        string_formats = { Puppet::Pops::Types::PHashType::DEFAULT => {'format' => string_formats }}
+        string_formats = { Puppet::Pops::Types::PHashType::DEFAULT => { 'format' => string_formats } }
       else
         # add the format given for the exact type
         string_formats = { value_type => string_formats }
@@ -535,7 +535,7 @@ class StringConverter
       raise ArgumentError, "expected a hash with type to format mappings, got instance of '#{fmt.class}'"
     end
 
-    fmt.reduce({}) do | result, entry|
+    fmt.each_with_object({}) do |entry, result|
       key, value = entry
       unless key.is_a?(Types::PAnyType)
         raise ArgumentError, "top level keys in the format hash must be data types, got instance of '#{key.class}'"
@@ -546,7 +546,6 @@ class StringConverter
       else
         result[key] = Format.new(value)
       end
-      result
     end
   end
   private :validate_input
@@ -555,7 +554,7 @@ class StringConverter
 
   def validate_container_input(fmt)
     if (fmt.keys - FMT_KEYS).size > 0
-      raise ArgumentError, "only #{FMT_KEYS.map {|k| "'#{k}'"}.join(', ')} are allowed in a container format, got #{fmt}"
+      raise ArgumentError, "only #{FMT_KEYS.map { |k| "'#{k}'" }.join(', ')} are allowed in a container format, got #{fmt}"
     end
 
     result                          = Format.new(fmt['format'])
@@ -591,11 +590,12 @@ class StringConverter
     # Before giving up on this, and use a string representation of the unknown
     # object, a check is made to see if the object can present itself as
     # a hash or an array. If it can, then that representation is used instead.
-    if val.is_a?(Hash)
+    case val
+    when Hash
       hash = val.to_hash
       # Ensure that the returned value isn't derived from Hash
       return string_PHashType(val_type, hash, format_map, indent) if hash.instance_of?(Hash)
-    elsif val.is_a?(Array)
+    when Array
       array = val.to_a
       # Ensure that the returned value isn't derived from Array
       return string_PArrayType(val_type, array, format_map, indent) if array.instance_of?(Array)
@@ -686,13 +686,13 @@ class StringConverter
     when :d, :x, :X, :o, :b, :B
       # Boolean in numeric form, formated by integer rule
       numeric_bool = val ? 1 : 0
-      string_formats = { Puppet::Pops::Types::PIntegerType::DEFAULT => f}
+      string_formats = { Puppet::Pops::Types::PIntegerType::DEFAULT => f }
       _convert(TypeCalculator.infer_set(numeric_bool), numeric_bool, string_formats, indentation)
 
     when :e, :E, :f, :g, :G, :a, :A
       # Boolean in numeric form, formated by float rule
       numeric_bool = val ? 1.0 : 0.0
-      string_formats = { Puppet::Pops::Types::PFloatType::DEFAULT => f}
+      string_formats = { Puppet::Pops::Types::PFloatType::DEFAULT => f }
       _convert(TypeCalculator.infer_set(numeric_bool), numeric_bool, string_formats, indentation)
 
     when :s
@@ -734,7 +734,7 @@ class StringConverter
     when :c
       char = [val].pack("U")
       char = f.alt? ? "\"#{char}\"" : char
-      Kernel.format(f.orig_fmt.tr('c','s'), char)
+      Kernel.format(f.orig_fmt.tr('c', 's'), char)
 
     when :s
       fmt = f.alt? ? 'p' : 's'
@@ -826,7 +826,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 { |s| s.capitalize }.join('::')
       f.alt? ? apply_string_flags(f, puppet_quote(c_val)) : Kernel.format(f.orig_fmt.tr('C', 's'), c_val)
 
     when :u
@@ -871,16 +871,14 @@ class StringConverter
       if escaped
         bld << 0x5c << codepoint
         escaped = false
+      elsif codepoint == 0x27
+        bld << 0x5c << codepoint
+      elsif codepoint == 0x5c
+        escaped = true
+      elsif codepoint <= 0x7f
+        bld << codepoint
       else
-        if codepoint == 0x27
-          bld << 0x5c << codepoint
-        elsif codepoint == 0x5c
-          escaped = true
-        elsif codepoint <= 0x7f
-          bld << codepoint
-        else
-          bld << [codepoint].pack('U')
-        end
+        bld << [codepoint].pack('U')
       end
     end
 
@@ -968,14 +966,13 @@ class StringConverter
       # compute widest run in the array, skip nested arrays and hashes
       # then if size > width, set flag if a break on each element should be performed
       if format.alt? && format.width
-        widest = val.each_with_index.reduce([0]) do | memo, v_i |
+        widest = val.each_with_index.each_with_object([0]) do |v_i, memo|
           # array or hash breaks
           if is_a_or_h?(v_i[0])
             memo << 0
           else
             memo[-1] += mapped[v_i[1]].length
           end
-          memo
         end
         widest = widest.max
         sz_break = widest > (format.width || Float::INFINITY)
@@ -998,7 +995,7 @@ class StringConverter
           # if break on each (and breaking will not occur because next is an array or hash)
           # or, if indenting, and previous was an array or hash, then break and continue on next line
           # indented.
-          if (sz_break && !is_a_or_h?(v)) || (format.alt? && i > 0 && is_a_or_h?(val[i-1]) && !is_a_or_h?(v))
+          if (sz_break && !is_a_or_h?(v)) || (format.alt? && i > 0 && is_a_or_h?(val[i - 1]) && !is_a_or_h?(v))
             buf.rstrip! unless buf[-1] == "\n"
             buf << "\n"
             buf << children_indentation.padding
@@ -1047,7 +1044,7 @@ class StringConverter
     string_formats = format.container_string_formats || DEFAULT_CONTAINER_FORMATS
     delims         = format.delimiter_pair(DEFAULT_HASH_DELIMITERS)
 
-    if format.alt? 
+    if format.alt?
       sep = sep.rstrip unless sep[-1] == "\n"
       sep = "#{sep}\n"
     end
@@ -1076,7 +1073,7 @@ class StringConverter
       end
       buf << delims[0]
       buf << cond_break # break after opening delimiter if pretty printing
-      buf << val.map do |k,v|
+      buf << val.map do |k, v|
         key_type = TypeCalculator.infer_set(k)
         val_type = TypeCalculator.infer_set(v)
         key = _convert(key_type, k, is_container?(key_type) ? format_map : string_formats, children_indentation)
@@ -1132,7 +1129,7 @@ class StringConverter
 
   # Maps the inferred type of o to a formatting rule
   def get_format(val_t, format_options)
-    fmt = format_options.find {|k,_| k.assignable?(val_t) }
+    fmt = format_options.find { |k, _| k.assignable?(val_t) }
     return fmt[1] unless fmt.nil?
 
     return Format.new("%s")

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

@@ -25,9 +25,9 @@ class TreeIterator
   #   `include_containers` to also be `true` to take effect).
   # @option options [Boolean] :include_containers ('true') If containers should be included in the iteration
   # @option options [Boolean] :include_values ('true') If non containers (values) should be included in the iteration
-  # @option options [Boolean] :include_refs ('false') If (non containment) referenced values in Objects should be included 
+  # @option options [Boolean] :include_refs ('false') If (non containment) referenced values in Objects should be included
   #
-  def initialize(enum, options=EMPTY_HASH)
+  def initialize(enum, options = EMPTY_HASH)
     @root = enum
     @element_t = nil
     @value_stack = [enum]
@@ -36,7 +36,7 @@ class TreeIterator
     @recursed = false
     @containers_t = options['container_type'] || DEFAULT_CONTAINERS
     unless DEFAULT_CONTAINERS.assignable?(@containers_t)
-      raise ArgumentError, _("Only Array, Hash, and Object types can be used as container types. Got %{type}") % {type: @containers_t}
+      raise ArgumentError, _("Only Array, Hash, and Object types can be used as container types. Got %{type}") % { type: @containers_t }
     end
 
     @with_root       = extract_option(options, 'include_root', true)
@@ -99,12 +99,10 @@ class TreeIterator
       val.size.times
     elsif val.is_a?(Hash)
       val.each_key
+    elsif @include_refs
+      val._pcore_type.attributes.each_key
     else
-      if @include_refs
-        val._pcore_type.attributes.each_key
-      else
-        val._pcore_type.attributes.reject {|_k,v| v.kind == PObjectType::ATTRIBUTE_KIND_REFERENCE }.each_key
-      end
+      val._pcore_type.attributes.reject { |_k, v| v.kind == PObjectType::ATTRIBUTE_KIND_REFERENCE }.each_key
     end
   end
   private :indexer_on

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

@@ -39,11 +39,11 @@ module TypeAsserter
 
   def self.report_type_mismatch(subject, expected_type, actual_type, what = 'has wrong type')
     subject = yield(subject) if block_given?
-    subject = subject[0] % subject[1..-1] if subject.is_a?(Array)
+    subject = subject[0] % subject[1..] if subject.is_a?(Array)
     raise TypeAssertionError.new(
-      TypeMismatchDescriber.singleton.describe_mismatch("#{subject} #{what},", expected_type, actual_type), expected_type, actual_type)
+      TypeMismatchDescriber.singleton.describe_mismatch("#{subject} #{what},", expected_type, actual_type), expected_type, actual_type
+    )
   end
   private_class_method :report_type_mismatch
 end
 end
-

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

@@ -107,7 +107,7 @@ class TypeCalculator
 
   # @api public
   def self.assignable?(t1, t2)
-    singleton.assignable?(t1,t2)
+    singleton.assignable?(t1, t2)
   end
 
   # Answers, does the given callable accept the arguments given in args (an array or a tuple)
@@ -168,8 +168,8 @@ class TypeCalculator
   # @api public
   #
   def initialize
-    @infer_visitor = Visitor.new(nil, 'infer',0,0)
-    @extract_visitor = Visitor.new(nil, 'extract',0,0)
+    @infer_visitor = Visitor.new(nil, 'infer', 0, 0)
+    @extract_visitor = Visitor.new(nil, 'extract', 0, 0)
   end
 
   # Answers 'can an instance of type t2 be assigned to a variable of type t'.
@@ -214,27 +214,26 @@ class TypeCalculator
     raise ArgumentError, 'Argument must be a Module' unless c.is_a? Module
 
     # Can't use a visitor here since we don't have an instance of the class
-    case
-    when c <= Integer
+    if c <= Integer
       type = PIntegerType::DEFAULT
-    when c == Float
+    elsif c == Float
       type = PFloatType::DEFAULT
-    when c == Numeric
+    elsif c == Numeric
       type = PNumericType::DEFAULT
-    when c == String
+    elsif c == String
       type = PStringType::DEFAULT
-    when c == Regexp
+    elsif c == Regexp
       type = PRegexpType::DEFAULT
-    when c == NilClass
+    elsif c == NilClass
       type = PUndefType::DEFAULT
-    when c == FalseClass, c == TrueClass
+    elsif c == FalseClass || c == TrueClass
       type = PBooleanType::DEFAULT
-    when c == Class
+    elsif c == Class
       type = PTypeType::DEFAULT
-    when c == Array
+    elsif c == Array
       # Assume array of any
       type = PArrayType::DEFAULT
-    when c == Hash
+    elsif c == Hash
       # Assume hash of any
       type = PHashType::DEFAULT
     else
@@ -256,15 +255,16 @@ class TypeCalculator
   def infer(o)
     # Optimize the most common cases into direct calls.
     # Explicit if/elsif/else is faster than case
-    if o.is_a?(String)
+    case o
+    when String
       infer_String(o)
-    elsif o.is_a?(Integer) # need subclasses for Ruby < 2.4
+    when Integer # need subclasses for Ruby < 2.4
       infer_Integer(o)
-    elsif o.is_a?(Array)
+    when Array
       infer_Array(o)
-    elsif o.is_a?(Hash)
+    when Hash
       infer_Hash(o)
-    elsif o.is_a?(Evaluator::PuppetProc)
+    when Evaluator::PuppetProc
       infer_PuppetProc(o)
     else
       @infer_visitor.visit_this_0(self, o)
@@ -294,7 +294,7 @@ class TypeCalculator
   # @api public
   #
   def self.instance?(t, o)
-    singleton.instance?(t,o)
+    singleton.instance?(t, o)
   end
 
   # Answers 'is o an instance of type t'
@@ -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
 
@@ -440,7 +440,7 @@ class TypeCalculator
       return PScalarType::DEFAULT
     end
 
-    if common_data?(t1,t2)
+    if common_data?(t1, t2)
       return TypeFactory.data
     end
 
@@ -449,7 +449,7 @@ class TypeCalculator
       return PTypeType.new(common_type(t1.type, t2.type))
     end
 
-    if common_rich_data?(t1,t2)
+    if common_rich_data?(t1, t2)
       return TypeFactory.rich_data
     end
 
@@ -465,7 +465,7 @@ class TypeCalculator
       c2 = ClassLoader.provide_from_type(t2)
       if c1 && c2
         c2_superclasses = superclasses(c2)
-        superclasses(c1).each do|c1_super|
+        superclasses(c1).each do |c1_super|
           c2_superclasses.each do |c2_super|
             if c1_super == c2_super
               return PRuntimeType.new(:ruby, c1_super.name)
@@ -493,21 +493,21 @@ class TypeCalculator
   # @api public
   #
   def reduce_type(enumerable)
-    enumerable.reduce(nil) {|memo, t| common_type(memo, t) }
+    enumerable.reduce(nil) { |memo, t| common_type(memo, t) }
   end
 
   # Reduce an enumerable of objects to a single common type
   # @api public
   #
   def infer_and_reduce_type(enumerable)
-    reduce_type(enumerable.map {|o| infer(o) })
+    reduce_type(enumerable.map { |o| infer(o) })
   end
 
   # The type of all modules is PTypeType
   # @api private
   #
   def infer_Module(o)
-    PTypeType::new(PRuntimeType.new(:ruby, o.name))
+    PTypeType.new(PRuntimeType.new(:ruby, o.name))
   end
 
   # @api private
@@ -720,18 +720,18 @@ class TypeCalculator
     if o.empty?
       PArrayType::EMPTY
     else
-      PTupleType.new(o.map {|x| infer_set(x) })
+      PTupleType.new(o.map { |x| infer_set(x) })
     end
   end
 
   def infer_set_Hash(o)
     if o.empty?
       PHashType::EMPTY
-    elsif o.keys.all? {|k| PStringType::NON_EMPTY.instance?(k) }
-      PStructType.new(o.each_pair.map { |k,v| PStructElement.new(PStringType.new(k), infer_set(v)) })
+    elsif o.keys.all? { |k| PStringType::NON_EMPTY.instance?(k) }
+      PStructType.new(o.each_pair.map { |k, v| PStructElement.new(PStringType.new(k), infer_set(v)) })
     else
-      ktype = PVariantType.maybe_create(o.keys.map {|k| infer_set(k) })
-      etype = PVariantType.maybe_create(o.values.map {|e| infer_set(e) })
+      ktype = PVariantType.maybe_create(o.keys.map { |k| infer_set(k) })
+      etype = PVariantType.maybe_create(o.values.map { |e| infer_set(e) })
       PHashType.new(unwrap_single_variant(ktype), unwrap_single_variant(etype), size_as_type(o))
     end
   end
@@ -755,7 +755,7 @@ class TypeCalculator
   # if range.to == nil max size == Infinity
   #
   def size_range(range)
-    return [1,1] if range.nil?
+    return [1, 1] if range.nil?
 
     from = range.from
     to = range.to
@@ -769,11 +769,11 @@ class TypeCalculator
     t.is_a?(PAnyType) && t.kind_of_callable?(optional)
   end
 
-  def max(a,b)
-    a >=b ? a : b
+  def max(a, b)
+    a >= b ? a : b
   end
 
-  def min(a,b)
+  def min(a, b)
     a <= b ? a : b
   end
 

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

@@ -157,7 +157,7 @@ module TypeFactory
   # @api public
   #
   def self.variant(*types)
-    PVariantType.maybe_create(types.map {|v| type_of(v) })
+    PVariantType.maybe_create(types.map { |v| type_of(v) })
   end
 
   # Produces the Struct type, either a non parameterized instance representing
@@ -241,7 +241,7 @@ module TypeFactory
   end
 
   def self.tuple(types = [], size_type = nil)
-    PTupleType.new(types.map {|elem| type_of(elem) }, size_type)
+    PTupleType.new(types.map { |elem| type_of(elem) }, size_type)
   end
 
   # Produces the Boolean type
@@ -349,7 +349,7 @@ module TypeFactory
       size_type = nil
     end
 
-    types = params.map {|p| type_of(p) }
+    types = params.map { |p| type_of(p) }
 
     # If the specification requires types, and none were given, a Unit type is used
     if types.empty? && !size_type.nil? && size_type.range[1] > 0
@@ -418,7 +418,7 @@ module TypeFactory
 
   # Produces an instance of the SemVer type
   def self.sem_ver(*ranges)
-    ranges.empty? ? PSemVerType::DEFAULT : PSemVerType::new(ranges)
+    ranges.empty? ? PSemVerType::DEFAULT : PSemVerType.new(ranges)
   end
 
   # Produces a PResourceType with a String type_name A PResourceType with a nil
@@ -560,11 +560,12 @@ module TypeFactory
   # a classname.
   #
   def self.type_of(o)
-    if o.is_a?(Class)
+    case o
+    when Class
       @type_calculator.type(o)
-    elsif o.is_a?(PAnyType)
+    when PAnyType
       o
-    elsif o.is_a?(String)
+    when String
       PRuntimeType.new(:ruby, o)
     else
       @type_calculator.infer_generic(o)
@@ -604,7 +605,7 @@ module TypeFactory
   # Generic creator of a RuntimeType - allows creating the type with nil or
   # String runtime_type_name.  Also see ruby_type(o) and ruby(o).
   #
-  def self.runtime(runtime=nil, runtime_type_name = nil)
+  def self.runtime(runtime = nil, runtime_type_name = nil)
     runtime = runtime.to_sym if runtime.is_a?(String)
     PRuntimeType.new(runtime, runtime_type_name)
   end