puppet 8.3.1-universal-darwin → 8.5.0-universal-darwin

data/lib/puppet/pops/serialization/serializer.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative 'extension'
 
 module Puppet::Pops
@@ -16,6 +17,8 @@ module Serialization
     # @option options [Boolean] :type_by_reference `true` if Object types are serialized by name only.
     # @api public
     def initialize(writer, options = EMPTY_HASH)
+      # Hash#compare_by_identity is intentionally not used since we only need to map
+      # object ids to their size and we don't want to store entire objects in memory
       @written = {}
       @writer = writer
       @options = options
@@ -37,7 +40,7 @@ module Serialization
       when :default
         @writer.write(Extension::Default::INSTANCE)
       else
-        index = @written[value.object_id]
+        index = @written[value.object_id] # rubocop:disable Lint/HashCompareByIdentity
         if index.nil?
           write_tabulated_first_time(value)
         else
@@ -76,7 +79,7 @@ module Serialization
     end
 
     def push_written(value)
-      @written[value.object_id] = @written.size
+      @written[value.object_id] = @written.size # rubocop:disable Lint/HashCompareByIdentity
     end
 
     # Write the start of a sensitive object
@@ -102,37 +105,37 @@ module Serialization
     # @param [Object] value the value to write
     # @api private
     def write_tabulated_first_time(value)
-      case
-      when value.instance_of?(Symbol),
-          value.instance_of?(Regexp),
-          value.instance_of?(SemanticPuppet::Version),
-          value.instance_of?(SemanticPuppet::VersionRange),
-          value.instance_of?(Time::Timestamp),
-          value.instance_of?(Time::Timespan),
-          value.instance_of?(Types::PBinaryType::Binary),
-          value.is_a?(URI)
+      if value.instance_of?(Symbol) ||
+         value.instance_of?(Regexp) ||
+         value.instance_of?(SemanticPuppet::Version) ||
+         value.instance_of?(SemanticPuppet::VersionRange) ||
+         value.instance_of?(Time::Timestamp) ||
+         value.instance_of?(Time::Timespan) ||
+         value.instance_of?(Types::PBinaryType::Binary) ||
+         value.is_a?(URI)
         push_written(value)
         @writer.write(value)
-      when value.instance_of?(Array)
+      elsif value.instance_of?(Array)
         push_written(value)
         start_array(value.size)
         value.each { |elem| write(elem) }
-      when value.instance_of?(Hash)
+      elsif value.instance_of?(Hash)
         push_written(value)
         start_map(value.size)
         value.each_pair { |key, val| write(key); write(val) }
-      when value.instance_of?(Types::PSensitiveType::Sensitive)
+      elsif value.instance_of?(Types::PSensitiveType::Sensitive)
         start_sensitive
         write(value.unwrap)
-      when value.instance_of?(Types::PTypeReferenceType)
+      elsif value.instance_of?(Types::PTypeReferenceType)
         push_written(value)
         @writer.write(value)
-      when value.is_a?(Types::PuppetObject)
+      elsif value.is_a?(Types::PuppetObject)
         value._pcore_type.write(value, self)
       else
         impl_class = value.class
         type = Loaders.implementation_registry.type_for_module(impl_class)
         raise SerializationError, _("No Puppet Type found for %{klass}") % { klass: impl_class.name } unless type.is_a?(Types::PObjectType)
+
         type.write(value, self)
       end
     end

data/lib/puppet/pops/serialization/time_factory.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Serialization
   # Implements all the constructors found in the Time class and ensures that
@@ -8,7 +9,6 @@ module Serialization
   # @deprecated No longer in use. Functionality replaced by Timestamp
   # @api private
   class TimeFactory
-
     NANO_DENOMINATOR = 10**9
 
     def self.at(*args)

data/lib/puppet/pops/serialization/to_data_converter.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Serialization
   # Class that can process an arbitrary object into a value that is assignable to `Data`.
@@ -65,7 +66,7 @@ module Serialization
 
     def path_to_s
       s = String.new(@message_prefix || '')
-      s << JsonPath.to_json_path(@path)[1..-1]
+      s << JsonPath.to_json_path(@path)[1..]
       s
     end
 
@@ -270,7 +271,8 @@ module Serialization
 
             # Pop optional arguments that are default
             while args.size > required_count
-              break unless pcore_type[names[args.size-1]].default_value?(args.last)
+              break unless pcore_type[names[args.size - 1]].default_value?(args.last)
+
               args.pop
             end
             result = {
@@ -288,7 +290,7 @@ module Serialization
 
     def pcore_type_to_data(pcore_type)
       type_name = pcore_type.name
-      if @type_by_reference  || type_name.start_with?('Pcore::')
+      if @type_by_reference || type_name.start_with?('Pcore::')
         type_name
       else
         with(PCORE_TYPE_KEY) { to_data(pcore_type) }
@@ -304,10 +306,10 @@ module Serialization
           semantic = Puppet::Pops::SemanticError.new(issue, nil, EMPTY_HASH)
         else
           file, line = stacktrace
-          semantic = Puppet::Pops::SemanticError.new(issue, nil, {:file => file, :line => line})
+          semantic = Puppet::Pops::SemanticError.new(issue, nil, { :file => file, :line => line })
         end
       end
-      optionally_fail(issue,  semantic, options)
+      optionally_fail(issue, semantic, options)
     end
   end
 end

data/lib/puppet/pops/serialization/to_stringified_converter.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Serialization
-
   # Class that can process an arbitrary object into a value that is assignable to `Data`
   # and where contents is converted from rich data to one of:
   # * Numeric (Integer, Float)
-  # * Boolean 
+  # * Boolean
   # * Undef (nil)
   # * String
   # * Array
   # * Hash
-  # 
+  #
   # The conversion is lossy - the result cannot be deserialized to produce the original data types.
   # All rich values are transformed to strings..
   # Hashes with rich keys are transformed to use string representation of such keys.
@@ -58,7 +58,7 @@ module Serialization
 
     def path_to_s
       s = @message_prefix || ''
-      s << JsonPath.to_json_path(@path)[1..-1]
+      s << JsonPath.to_json_path(@path)[1..]
       s
     end
 
@@ -201,7 +201,7 @@ module Serialization
         elsif !key.is_a?(String)
           key = unknown_key_to_string(key)
         end
-        if key == "__ptype" || key =="__pvalue"
+        if key == "__ptype" || key == "__pvalue"
           key = "reserved key: #{key}"
         end
         with(key) { result[key] = to_data(value) }
@@ -217,10 +217,10 @@ module Serialization
           semantic = Puppet::Pops::SemanticError.new(issue, nil, EMPTY_HASH)
         else
           file, line = stacktrace
-          semantic = Puppet::Pops::SemanticError.new(issue, nil, {:file => file, :line => line})
+          semantic = Puppet::Pops::SemanticError.new(issue, nil, { :file => file, :line => line })
         end
       end
-      optionally_fail(issue,  semantic, options)
+      optionally_fail(issue, semantic, options)
     end
   end
 end

data/lib/puppet/pops/serialization.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Serialization
   def self.not_implemented(impl, method_name)

data/lib/puppet/pops/time/timespan.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 require_relative '../../../puppet/concurrent/thread_local_singleton'
 
 module Puppet::Pops
@@ -100,7 +101,8 @@ module Time
         hash[KEY_SECONDS] || 0,
         hash[KEY_MILLISECONDS] || 0,
         hash[KEY_MICROSECONDS] || 0,
-        hash[KEY_NANOSECONDS] || 0)
+        hash[KEY_NANOSECONDS] || 0
+      )
     end
 
     def self.parse(str, format = Format::DEFAULTS)
@@ -477,9 +479,10 @@ module Time
           # Using %L or %N to parse a string only makes sense when they are considered to be fractions. Using them
           # as a total quantity would introduce ambiguities.
           raise ArgumentError, _('Format specifiers %L and %N denotes fractions and must be used together with a specifier of higher magnitude') if use_total?
+
           n = group.to_i
           p = 9 - group.length
-          p <= 0 ? n : n * 10 ** p
+          p <= 0 ? n : n * 10**p
         end
 
         def create_format
@@ -519,7 +522,7 @@ module Time
         def multiplier
           width = @width || @default_width
           if width < 9
-            10 ** (9 - width)
+            10**(9 - width)
           else
             1
           end
@@ -530,8 +533,8 @@ module Time
           width = @width || @default_width
           if width < 9
             # Truncate digits to the right, i.e. let %6N reflect microseconds
-            ns /= 10 ** (9 - width)
-            ns %= 10 ** width unless use_total?
+            ns /= 10**(9 - width)
+            ns %= 10**width unless use_total?
           else
             ns %= NSECS_PER_SEC unless use_total?
           end
@@ -553,12 +556,15 @@ module Time
       def parse(timespan)
         md = regexp.match(timespan)
         raise ArgumentError, _("Unable to parse '%{timespan}' using format '%{format}'") % { timespan: timespan, format: @format } if md.nil?
+
         nanoseconds = 0
         md.captures.each_with_index do |group, index|
           segment = @segments[index]
           next if segment.is_a?(LiteralSegment)
+
           group.lstrip!
           raise ArgumentError, _("Unable to parse '%{timespan}' using format '%{format}'") % { timespan: timespan, format: @format } unless group =~ /\A[0-9]+\z/
+
           nanoseconds += segment.nanoseconds(group)
         end
         Timespan.new(timespan.start_with?('-') ? -nanoseconds : nanoseconds)
@@ -608,7 +614,7 @@ module Time
       ]
 
       def bad_format_specifier(format, start, position)
-        _("Bad format specifier '%{expression}' in '%{format}', at position %{position}") % { expression: format[start,position-start], format: format, position: position }
+        _("Bad format specifier '%{expression}' in '%{format}', at position %{position}") % { expression: format[start, position - start], format: format, position: position }
       end
 
       def append_literal(bld, codepoint)
@@ -621,12 +627,13 @@ module Time
 
       # States used by the #internal_parser function
       STATE_LITERAL = 0 # expects literal or '%'
-      STATE_PAD  = 1 # expects pad, width, or format character
+      STATE_PAD = 1 # expects pad, width, or format character
       STATE_WIDTH = 2 # expects width, or format character
 
       def internal_parse(str)
         bld = []
         raise ArgumentError, _('Format must be a String') unless str.is_a?(String)
+
         highest = -1
         state = STATE_LITERAL
         padchar = '0'
@@ -654,10 +661,12 @@ module Time
             state = STATE_LITERAL
           when 0x2D # '-'
             raise ArgumentError, bad_format_specifier(str, fstart, position) unless state == STATE_PAD
+
             padchar = nil
             state = STATE_WIDTH
           when 0x5F # '_'
             raise ArgumentError, bad_format_specifier(str, fstart, position) unless state == STATE_PAD
+
             padchar = ' '
             state = STATE_WIDTH
           when 0x44 # 'D'
@@ -686,6 +695,7 @@ module Time
             state = STATE_LITERAL
           else # only digits allowed at this point
             raise ArgumentError, bad_format_specifier(str, fstart, position) unless codepoint >= 0x30 && codepoint <= 0x39
+
             if state == STATE_PAD && codepoint == 0x30
               padchar = '0'
             else
@@ -700,7 +710,8 @@ module Time
           end
         end
 
-        raise ArgumentError, bad_format_specifier(str, fstart, position)  unless state == STATE_LITERAL
+        raise ArgumentError, bad_format_specifier(str, fstart, position) unless state == STATE_LITERAL
+
         unless highest == -1
           hc = SEGMENT_CLASS_BY_ORDINAL[highest]
           bld.find { |s| s.instance_of?(hc) }.set_use_total

data/lib/puppet/pops/time/timestamp.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Time
 class Timestamp < TimeData
@@ -39,6 +40,7 @@ class Timestamp < TimeData
       hash = DateTime._strptime(timezone, '%z')
       offset = hash.nil? ? nil : hash[:offset]
       raise ArgumentError, _("Illegal timezone '%{timezone}'") % { timezone: timezone } if offset.nil?
+
       offset
     end
   end
@@ -74,6 +76,7 @@ class Timestamp < TimeData
       format.each do |fmt|
         parsed = DateTime._strptime(str, fmt)
         next if parsed.nil?
+
         if parsed.include?(:leftover) || (has_timezone && parsed.include?(:zone))
           parsed = nil
           next
@@ -82,16 +85,19 @@ class Timestamp < TimeData
       end
       if parsed.nil?
         raise ArgumentError, _(
-          "Unable to parse '%{str}' using any of the formats %{formats}") % { str: str, formats: format.join(', ') }
+          "Unable to parse '%{str}' using any of the formats %{formats}"
+        ) % { str: str, formats: format.join(', ') }
       end
     else
       parsed = DateTime._strptime(str, format)
       if parsed.nil? || parsed.include?(:leftover)
         raise ArgumentError, _("Unable to parse '%{str}' using format '%{format}'") % { str: str, format: format }
       end
+
       if has_timezone && parsed.include?(:zone)
         raise ArgumentError, _(
-          'Using a Timezone designator in format specification is mutually exclusive to providing an explicit timezone argument')
+          'Using a Timezone designator in format specification is mutually exclusive to providing an explicit timezone argument'
+        )
       end
     end
     unless has_timezone

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
-
 KEY_ANNOTATIONS = 'annotations'
 
 # Behaviour common to all Pcore annotatable classes

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
   # Pcore variant of the Adaptable::Adapter. Uses a Pcore Object type instead of a Class
@@ -9,7 +10,7 @@ module Types
 
     # Register the Annotation type. This is the type that all custom Annotations will inherit from.
     def self.register_ptype(loader, ir)
-      @type = Pcore::create_object_type(loader, ir, self, 'Annotation', nil, EMPTY_HASH)
+      @type = Pcore.create_object_type(loader, ir, self, 'Annotation', nil, EMPTY_HASH)
     end
 
     def self._pcore_type
@@ -31,8 +32,8 @@ module Types
         if o.is_a?(Annotatable)
           init_hash = o.annotations[_pcore_type]
           init_hash = yield if init_hash.nil? && block_given?
-        else
-          init_hash = yield if block_given?
+        elsif block_given?
+          init_hash = yield
         end
         adapter = associate_adapter(_pcore_type.from_hash(init_hash), o) unless init_hash.nil?
       end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
 # The ClassLoader provides a Class instance given a class name or a meta-type.
@@ -37,6 +38,7 @@ class ClassLoader
     case type
     when PRuntimeType
       raise ArgumentError.new("Only Runtime type 'ruby' is supported, got #{type.runtime}") unless type.runtime == :ruby
+
       provide_from_string(type.runtime_type_name)
 
     when PBooleanType
@@ -54,7 +56,7 @@ class ClassLoader
 
     # Although not expected to be the first choice for getting a concrete class for these
     # types, these are of value if the calling logic just has a reference to type.
-    #
+    # rubocop:disable Layout/SpaceBeforeSemicolon
     when PArrayType    ; Array
     when PTupleType    ; Array
     when PHashType     ; Hash
@@ -67,6 +69,7 @@ class ClassLoader
     when PFloatType    ; Float
     when PUndefType    ; NilClass
     when PCallableType ; Proc
+    # rubocop:enable Layout/SpaceBeforeSemicolon
     else
       nil
     end
@@ -87,7 +90,7 @@ class ClassLoader
     unless result.is_a?(Module)
       # Attempt to load it using the auto loader
       loaded_path = nil
-      if paths_for_name(name_path).find {|path| loaded_path = path; @autoloader.load(path, Puppet.lookup(:current_environment)) }
+      if paths_for_name(name_path).find { |path| loaded_path = path; @autoloader.load(path, Puppet.lookup(:current_environment)) }
         result = find_class(name_path)
         unless result.is_a?(Module)
           raise RuntimeError, "Loading of #{name} using relative path: '#{loaded_path}' did not create expected class"
@@ -95,6 +98,7 @@ class ClassLoader
       end
     end
     return nil unless result.is_a?(Module)
+
     result
   end
   private_class_method :provide_from_string
@@ -115,19 +119,18 @@ class ClassLoader
     # TODO:this is not perfect - it will not produce the correct mix if a mix of styles are used
     # The alternative is to test many additional paths.
     #
-    [fq_named_parts.map {|part| de_camel(part)}.join('/'), fq_named_parts.join('/').downcase ]
+    [fq_named_parts.map { |part| de_camel(part) }.join('/'), fq_named_parts.join('/').downcase]
   end
   private_class_method :paths_for_name
 
   def self.de_camel(fq_name)
-    fq_name.to_s.gsub(/::/, '/').
-    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-    gsub(/([a-z\d])([A-Z])/,'\1_\2').
-    tr("-", "_").
-    downcase
+    fq_name.to_s.gsub(/::/, '/')
+           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+           .tr("-", "_")
+           .downcase
   end
   private_class_method :de_camel
-
 end
 end
 end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
   # The {ImplementationRegistry} maps names types in the Puppet Type System to names of corresponding implementation
@@ -48,7 +49,8 @@ module Types
       ns = TypeFormatter::NAME_SEGMENT_SEPARATOR
       register_implementation_regexp(
         [/\A#{type_namespace}#{ns}(\w+)\z/, "#{impl_namespace}#{ns}\\1"],
-        [/\A#{impl_namespace}#{ns}(\w+)\z/, "#{type_namespace}#{ns}\\1"])
+        [/\A#{impl_namespace}#{ns}(\w+)\z/, "#{type_namespace}#{ns}\\1"]
+      )
     end
 
     # Register a bidirectional regexp mapping

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
-module Puppet::Pops::Types
 
+module Puppet::Pops::Types
   # Implemented by classes that can produce an iterator to iterate over their contents
   module IteratorProducer
     def iterator
@@ -34,6 +34,7 @@ module Puppet::Pops::Types
     def self.asserted_iterable(my_caller, obj, infer_elements = false)
       iter = self.on(obj, nil, infer_elements)
       raise ArgumentError, "#{my_caller.class}(): wrong argument type (#{obj.class}; is not Iterable." if iter.nil?
+
       iter
     end
 
@@ -73,7 +74,7 @@ module Puppet::Pops::Types
         else
           if element_type.nil? && infer_elements
             tc = TypeCalculator.singleton
-            element_type = PVariantType.maybe_create(o.map {|e| tc.infer_set(e) })
+            element_type = PVariantType.maybe_create(o.map { |e| tc.infer_set(e) })
           end
           Iterator.new(element_type, o.each)
         end
@@ -84,9 +85,13 @@ module Puppet::Pops::Types
         else
           if element_type.nil? && infer_elements
             tc = TypeCalculator.singleton
-            element_type = PTupleType.new([
-              PVariantType.maybe_create(o.keys.map {|e| tc.infer_set(e) }),
-              PVariantType.maybe_create(o.values.map {|e| tc.infer_set(e) })], PHashType::KEY_PAIR_TUPLE_SIZE)
+            element_type =
+              PTupleType
+              .new([
+                     PVariantType.maybe_create(o.keys.map { |e| tc.infer_set(e) }),
+                     PVariantType.maybe_create(o.values.map { |e| tc.infer_set(e) })
+                   ],
+                   PHashType::KEY_PAIR_TUPLE_SIZE)
           end
           HashIterator.new(element_type, o.each_pair)
         end
@@ -139,7 +144,7 @@ module Puppet::Pops::Types
       case object
       when Iterable
         object.unbounded?
-      when String,Integer,Array,Hash,Enumerator,PIntegerType,PEnumType,Dir
+      when String, Integer, Array, Hash, Enumerator, PIntegerType, PEnumType, Dir
         false
       else
         TypeAsserter.assert_instance_of('', PIterableType::DEFAULT, object, false)
@@ -169,6 +174,7 @@ module Puppet::Pops::Types
 
     def to_a
       raise Puppet::Error, 'Attempt to create an Array from an unbounded Iterable' if unbounded?
+
       super
     end
 
@@ -231,16 +237,17 @@ module Puppet::Pops::Types
 
     def step(step, &block)
       raise ArgumentError if step <= 0
+
       r = self
       r = r.step_iterator(step) if step > 1
 
       if block_given?
         begin
-        if block.arity == 1
-          loop { yield(r.next) }
-        else
-          loop { yield(*r.next) }
-        end
+          if block.arity == 1
+            loop { yield(r.next) }
+          else
+            loop { yield(*r.next) }
+          end
         rescue StopIteration
         end
         self
@@ -283,6 +290,7 @@ module Puppet::Pops::Types
     def initialize(element_type, enumeration, step_size)
       super(element_type, enumeration)
       raise ArgumentError if step_size <= 0
+
       @step_size = step_size
     end
 
@@ -314,6 +322,7 @@ module Puppet::Pops::Types
 
     def initialize(range, step = 1)
       raise ArgumentError if step == 0
+
       @range = range
       @step_size = step
       @current = (step < 0 ? range.to : range.from) - step
@@ -327,8 +336,8 @@ module Puppet::Pops::Types
       value = @current + @step_size
       if @step_size < 0
         raise StopIteration if value < @range.from
-      else
-        raise StopIteration if value > @range.to
+      elsif value > @range.to
+        raise StopIteration
       end
       @current = value
     end

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

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
+
 require 'base64'
 module Puppet::Pops
 module Types
-
 # A Puppet Language Type that represents binary data content (a sequence of 8-bit bytes).
 # Instances of this data type can be created from `String` and `Array[Integer[0,255]]`
 # values. Also see the `binary_file` function for reading binary content from a file.
@@ -15,7 +15,6 @@ module Types
 #
 # @api public
 class PBinaryType < PAnyType
-
   # Represents a binary buffer
   # @api public
   class Binary
@@ -77,6 +76,7 @@ class PBinaryType < PAnyType
       unless encoded_string.valid_encoding?
         raise ArgumentError, _("The given string in encoding '%{enc}' is invalid. Cannot create a Binary UTF-8 representation") % { enc: enc }
       end
+
       # Convert to UTF-8 (if not already UTF-8), and then to binary
       encoded_string = (enc == "UTF-8") ? encoded_string.dup : encoded_string.encode('UTF-8')
       encoded_string.force_encoding("ASCII-8BIT")
@@ -125,7 +125,7 @@ class PBinaryType < PAnyType
       self.eql?(o)
     end
 
-    def length()
+    def length
       @binary_buffer.length
     end
   end
@@ -225,9 +225,8 @@ class PBinaryType < PAnyType
   protected
 
   def _assignable?(o, guard)
-    o.class == self.class
+    o.instance_of?(self.class)
   end
-
 end
 end
 end