openvox 7.37.1 → 8.19.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'extension'
 
 module Puppet::Pops
@@ -15,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
@@ -36,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
@@ -75,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
@@ -101,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,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Serialization
   # Implements all the constructors found in the Time class and ensures that
@@ -7,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,3 +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`.
@@ -63,8 +65,8 @@ module Serialization
     private
 
     def path_to_s
-      s = @message_prefix || ''
-      s << JsonPath.to_json_path(@path)[1..-1]
+      s = String.new(@message_prefix || '')
+      s << JsonPath.to_json_path(@path)[1..]
       s
     end
 
@@ -269,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 = {
@@ -287,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) }
@@ -303,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,15 +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.
@@ -57,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
 
@@ -200,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) }
@@ -216,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,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Serialization
   def self.not_implemented(impl, method_name)
@@ -7,28 +9,28 @@ module Serialization
   class SerializationError < Puppet::Error
   end
 
-  PCORE_TYPE_KEY = '__ptype'.freeze
+  PCORE_TYPE_KEY = '__ptype'
 
   # Key used when the value can be represented as, and recreated from, a single string that can
   # be passed to a `from_string` method or an array of values that can be passed to the default
   # initializer method.
-  PCORE_VALUE_KEY = '__pvalue'.freeze
+  PCORE_VALUE_KEY = '__pvalue'
 
   # Type key used for hashes that contain keys that are not of type String
-  PCORE_TYPE_HASH = 'Hash'.freeze
+  PCORE_TYPE_HASH = 'Hash'
 
   # Type key used for symbols
-  PCORE_TYPE_SENSITIVE = 'Sensitive'.freeze
-  PCORE_TYPE_BINARY = 'Binary'.freeze
+  PCORE_TYPE_SENSITIVE = 'Sensitive'
+  PCORE_TYPE_BINARY = 'Binary'
 
   # Type key used for symbols
-  PCORE_TYPE_SYMBOL = 'Symbol'.freeze
+  PCORE_TYPE_SYMBOL = 'Symbol'
 
   # Type key used for Default
-  PCORE_TYPE_DEFAULT = 'Default'.freeze
+  PCORE_TYPE_DEFAULT = 'Default'
 
   # Type key used for document local references
-  PCORE_LOCAL_REF_SYMBOL = 'LocalRef'.freeze
+  PCORE_LOCAL_REF_SYMBOL = 'LocalRef'
 end
 end
 

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../../../puppet/concurrent/thread_local_singleton'
 
 module Puppet::Pops
@@ -9,16 +11,16 @@ module Time
   NSECS_PER_HOUR = NSECS_PER_MIN  * 60
   NSECS_PER_DAY  = NSECS_PER_HOUR * 24
 
-  KEY_STRING = 'string'.freeze
-  KEY_FORMAT = 'format'.freeze
-  KEY_NEGATIVE = 'negative'.freeze
-  KEY_DAYS = 'days'.freeze
-  KEY_HOURS = 'hours'.freeze
-  KEY_MINUTES = 'minutes'.freeze
-  KEY_SECONDS = 'seconds'.freeze
-  KEY_MILLISECONDS = 'milliseconds'.freeze
-  KEY_MICROSECONDS = 'microseconds'.freeze
-  KEY_NANOSECONDS = 'nanoseconds'.freeze
+  KEY_STRING = 'string'
+  KEY_FORMAT = 'format'
+  KEY_NEGATIVE = 'negative'
+  KEY_DAYS = 'days'
+  KEY_HOURS = 'hours'
+  KEY_MINUTES = 'minutes'
+  KEY_SECONDS = 'seconds'
+  KEY_MILLISECONDS = 'milliseconds'
+  KEY_MICROSECONDS = 'microseconds'
+  KEY_NANOSECONDS = 'nanoseconds'
 
   # TimeData is a Numeric that stores its value internally as nano-seconds but will be considered to be seconds and fractions of
   # seconds when used in arithmetic or comparison with other Numeric types.
@@ -99,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)
@@ -476,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
@@ -518,7 +522,7 @@ module Time
         def multiplier
           width = @width || @default_width
           if width < 9
-            10 ** (9 - width)
+            10**(9 - width)
           else
             1
           end
@@ -529,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
@@ -544,7 +548,7 @@ module Time
       end
 
       def format(timespan)
-        bld = timespan.negative? ? '-' : ''
+        bld = timespan.negative? ? '-'.dup : ''.dup
         @segments.each { |segment| segment.append_to(bld, timespan) }
         bld
       end
@@ -552,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)
@@ -574,7 +581,7 @@ module Time
       end
 
       def build_regexp
-        bld = '\A-?'
+        bld = '\A-?'.dup
         @segments.each { |segment| segment.append_regexp(bld) }
         bld << '\z'
         Regexp.new(bld)
@@ -607,12 +614,12 @@ 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)
         if bld.empty? || !bld.last.is_a?(Format::LiteralSegment)
-          bld << Format::LiteralSegment.new(''.concat(codepoint))
+          bld << Format::LiteralSegment.new(''.dup.concat(codepoint))
         else
           bld.last.concat(codepoint)
         end
@@ -620,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'
@@ -653,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'
@@ -685,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
@@ -699,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,11 +1,13 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Time
 class Timestamp < TimeData
   DEFAULT_FORMATS_WO_TZ = ['%FT%T.%N', '%FT%T', '%F %T.%N', '%F %T', '%F']
   DEFAULT_FORMATS = ['%FT%T.%N %Z', '%FT%T %Z', '%F %T.%N %Z', '%F %T %Z', '%F %Z'] + DEFAULT_FORMATS_WO_TZ
 
-  CURRENT_TIMEZONE = 'current'.freeze
-  KEY_TIMEZONE = 'timezone'.freeze
+  CURRENT_TIMEZONE = 'current'
+  KEY_TIMEZONE = 'timezone'
 
   # Converts a timezone that strptime can parse using '%z' into '-HH:MM' or '+HH:MM'
   # @param [String] tz the timezone to convert
@@ -38,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
@@ -73,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
@@ -81,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
@@ -100,7 +107,7 @@ class Timestamp < TimeData
     fraction = parsed[:sec_fraction]
 
     # Convert msec rational found in _strptime hash to usec
-    fraction = fraction * 1000000 unless fraction.nil?
+    fraction *= 1_000_000 unless fraction.nil?
 
     # Create the Time instance and adjust for timezone
     parsed_time = ::Time.utc(parsed[:year], parsed[:mon], parsed[:mday], parsed[:hour], parsed[:min], parsed[:sec], fraction)

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

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

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

@@ -1,14 +1,16 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Types
   # Pcore variant of the Adaptable::Adapter. Uses a Pcore Object type instead of a Class
   class Annotation < Adaptable::Adapter
     include Types::PuppetObject
 
-    CLEAR = 'clear'.freeze
+    CLEAR = 'clear'
 
     # 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
@@ -30,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,3 +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.
@@ -35,7 +37,8 @@ class ClassLoader
   def self.provide_from_type(type)
     case type
     when PRuntimeType
-      raise ArgumentError.new("Only Runtime type 'ruby' is supported, got #{type.runtime}") unless type.runtime == :ruby
+      raise ArgumentError, "Only Runtime type 'ruby' is supported, got #{type.runtime}" unless type.runtime == :ruby
+
       provide_from_string(type.runtime_type_name)
 
     when PBooleanType
@@ -53,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
@@ -66,6 +69,7 @@ class ClassLoader
     when PFloatType    ; Float
     when PUndefType    ; NilClass
     when PCallableType ; Proc
+    # rubocop:enable Layout/SpaceBeforeSemicolon
     else
       nil
     end
@@ -86,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"
@@ -94,17 +98,16 @@ class ClassLoader
       end
     end
     return nil unless result.is_a?(Module)
+
     result
   end
   private_class_method :provide_from_string
 
   def self.find_class(name_path)
     name_path.reduce(Object) do |ns, name|
-      begin
-        ns.const_get(name, false) # don't search ancestors
-      rescue NameError
-        return nil
-      end
+      ns.const_get(name, false) # don't search ancestors
+    rescue NameError
+      return nil
     end
   end
   private_class_method :find_class
@@ -114,19 +117,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,3 +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
@@ -47,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