openvox 7.37.1 → 8.19.0

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

@@ -1,13 +1,13 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Types
-
 # A Puppet Language type that wraps sensitive information. The sensitive type is parameterized by
 # the wrapped value type.
 #
 #
 # @api public
 class PSensitiveType < PTypeWithContainedType
-
   class Sensitive
     def initialize(value)
       @value = value
@@ -50,7 +50,6 @@ class PSensitiveType < PTypeWithContainedType
 
   def self.new_function(type)
     @new_function ||= Puppet::Functions.create_loaded_function(:new_Sensitive, type.loader) do
-
       dispatch :from_sensitive do
         param 'Sensitive', :value
       end
@@ -73,11 +72,10 @@ class PSensitiveType < PTypeWithContainedType
   private
 
   def _assignable?(o, guard)
-    self.class == o.class && @type.assignable?(o.type, guard)
+    instance_of?(o.class) && @type.assignable?(o.type, guard)
   end
 
   DEFAULT = PSensitiveType.new
 end
-
 end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Types
   class PAbstractTimeDataType < PScalarType
@@ -15,7 +17,7 @@ module Types
     # @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)
+      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.
@@ -70,6 +72,7 @@ module Types
         impl_class.new(arg * Time::NSECS_PER_SEC)
       else
         raise ArgumentError, "Unable to create a #{impl_class.name} from a #{arg.class.name}" unless arg.nil? || arg == :default
+
         nil
       end
     end
@@ -91,16 +94,15 @@ module Types
     end
 
     def _assignable?(o, guard)
-      self.class == o.class && numeric_from <= o.numeric_from && numeric_to >= o.numeric_to
+      instance_of?(o.class) && numeric_from <= o.numeric_from && numeric_to >= o.numeric_to
     end
   end
 
   class PTimespanType < PAbstractTimeDataType
     def self.register_ptype(loader, ir)
       create_ptype(loader, ir, 'ScalarType',
-        'from' => { KEY_TYPE => POptionalType.new(PTimespanType::DEFAULT), KEY_VALUE => nil },
-        'to' => { KEY_TYPE => POptionalType.new(PTimespanType::DEFAULT), KEY_VALUE => nil }
-      )
+                   'from' => { KEY_TYPE => POptionalType.new(PTimespanType::DEFAULT), KEY_VALUE => nil },
+                   'to' => { KEY_TYPE => POptionalType.new(PTimespanType::DEFAULT), KEY_VALUE => nil })
     end
 
     def self.new_function(type)

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

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Types
   class PTimestampType < PAbstractTimeDataType
     def self.register_ptype(loader, ir)
       create_ptype(loader, ir, 'ScalarType',
-        'from' => { KEY_TYPE => POptionalType.new(PTimestampType::DEFAULT), KEY_VALUE => nil },
-        'to' => { KEY_TYPE => POptionalType.new(PTimestampType::DEFAULT), KEY_VALUE => nil }
-      )
+                   'from' => { KEY_TYPE => POptionalType.new(PTimestampType::DEFAULT), KEY_VALUE => nil },
+                   'to' => { KEY_TYPE => POptionalType.new(PTimestampType::DEFAULT), KEY_VALUE => nil })
     end
 
     def self.new_function(type)

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

@@ -1,15 +1,15 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Types
-
-KEY_NAME_AUTHORITY = 'name_authority'.freeze
-KEY_TYPES = 'types'.freeze
-KEY_ALIAS = 'alias'.freeze
-KEY_VERSION = 'version'.freeze
-KEY_VERSION_RANGE = 'version_range'.freeze
-KEY_REFERENCES = 'references'.freeze
+KEY_NAME_AUTHORITY = 'name_authority'
+KEY_TYPES = 'types'
+KEY_ALIAS = 'alias'
+KEY_VERSION = 'version'
+KEY_VERSION_RANGE = 'version_range'
+KEY_REFERENCES = 'references'
 
 class PTypeSetType < PMetaType
-
   # A Loader that makes the types known to the TypeSet visible
   #
   # @api private
@@ -39,23 +39,27 @@ class PTypeSetType < PMetaType
   TYPE_STRING_OR_VERSION = TypeFactory.variant(PStringType::NON_EMPTY, TypeFactory.sem_ver)
   TYPE_STRING_OR_RANGE = TypeFactory.variant(PStringType::NON_EMPTY, TypeFactory.sem_ver_range)
 
-  TYPE_TYPE_REFERENCE_I12N = TypeFactory.struct({
-    KEY_NAME => Pcore::TYPE_QUALIFIED_REFERENCE,
-    KEY_VERSION_RANGE => TYPE_STRING_OR_RANGE,
-    TypeFactory.optional(KEY_NAME_AUTHORITY) => Pcore::TYPE_URI,
-    TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
-  })
-
-  TYPE_TYPESET_I12N = TypeFactory.struct({
-    TypeFactory.optional(Pcore::KEY_PCORE_URI) => Pcore::TYPE_URI,
-    Pcore::KEY_PCORE_VERSION => TYPE_STRING_OR_VERSION,
-    TypeFactory.optional(KEY_NAME_AUTHORITY) => Pcore::TYPE_URI,
-    TypeFactory.optional(KEY_NAME) => Pcore::TYPE_QUALIFIED_REFERENCE,
-    TypeFactory.optional(KEY_VERSION) => TYPE_STRING_OR_VERSION,
-    TypeFactory.optional(KEY_TYPES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, PVariantType.new([PTypeType::DEFAULT, PObjectType::TYPE_OBJECT_I12N]), PCollectionType::NOT_EMPTY_SIZE),
-    TypeFactory.optional(KEY_REFERENCES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, TYPE_TYPE_REFERENCE_I12N, PCollectionType::NOT_EMPTY_SIZE),
-    TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS,
-  })
+  TYPE_TYPE_REFERENCE_I12N =
+    TypeFactory
+    .struct({
+              KEY_NAME => Pcore::TYPE_QUALIFIED_REFERENCE,
+              KEY_VERSION_RANGE => TYPE_STRING_OR_RANGE,
+              TypeFactory.optional(KEY_NAME_AUTHORITY) => Pcore::TYPE_URI,
+              TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
+            })
+
+  TYPE_TYPESET_I12N =
+    TypeFactory
+    .struct({
+              TypeFactory.optional(Pcore::KEY_PCORE_URI) => Pcore::TYPE_URI,
+              Pcore::KEY_PCORE_VERSION => TYPE_STRING_OR_VERSION,
+              TypeFactory.optional(KEY_NAME_AUTHORITY) => Pcore::TYPE_URI,
+              TypeFactory.optional(KEY_NAME) => Pcore::TYPE_QUALIFIED_REFERENCE,
+              TypeFactory.optional(KEY_VERSION) => TYPE_STRING_OR_VERSION,
+              TypeFactory.optional(KEY_TYPES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, PVariantType.new([PTypeType::DEFAULT, PObjectType::TYPE_OBJECT_I12N]), PCollectionType::NOT_EMPTY_SIZE),
+              TypeFactory.optional(KEY_REFERENCES) => TypeFactory.hash_kv(Pcore::TYPE_SIMPLE_TYPE_NAME, TYPE_TYPE_REFERENCE_I12N, PCollectionType::NOT_EMPTY_SIZE),
+              TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS,
+            })
 
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType', '_pcore_init_hash' => TYPE_TYPESET_I12N.resolve(loader))
@@ -112,7 +116,7 @@ class PTypeSetType < PMetaType
     @pcore_version = PSemVerType.convert(init_hash[Pcore::KEY_PCORE_VERSION]).freeze
     unless Pcore::PARSABLE_PCORE_VERSIONS.include?(@pcore_version)
       raise ArgumentError,
-        "The pcore version for TypeSet '#{@name}' is not understood by this runtime. Expected range #{Pcore::PARSABLE_PCORE_VERSIONS}, got #{@pcore_version}"
+            "The pcore version for TypeSet '#{@name}' is not understood by this runtime. Expected range #{Pcore::PARSABLE_PCORE_VERSIONS}, got #{@pcore_version}"
     end
 
     @pcore_uri = init_hash[Pcore::KEY_PCORE_URI].freeze
@@ -145,6 +149,7 @@ class PTypeSetType < PMetaType
           unless ranges.all? { |range| (range & ref.version_range).nil? }
             raise ArgumentError, "TypeSet '#{@name}' references TypeSet '#{ref_na}/#{ref_name}' more than once using overlapping version ranges"
           end
+
           ranges << ref.version_range
         end
 
@@ -154,6 +159,7 @@ class PTypeSetType < PMetaType
         if @types.has_key?(ref_alias)
           raise ArgumentError, "TypeSet '#{@name}' references a TypeSet using alias '#{ref_alias}'. The alias collides with the name of a declared type"
         end
+
         ref_map[ref_alias] = ref
 
         @dc_to_cc_map[ref_alias.downcase] = ref_alias
@@ -172,12 +178,12 @@ class PTypeSetType < PMetaType
   def _pcore_init_hash
     result = super()
     result[Pcore::KEY_PCORE_URI] = @pcore_uri unless @pcore_uri.nil?
-    result[Pcore::KEY_PCORE_VERSION] =  @pcore_version.to_s
+    result[Pcore::KEY_PCORE_VERSION] = @pcore_version.to_s
     result[KEY_NAME_AUTHORITY] = @name_authority unless @name_authority.nil?
     result[KEY_NAME] = @name
     result[KEY_VERSION] = @version.to_s unless @version.nil?
     result[KEY_TYPES] = @types unless @types.empty?
-    result[KEY_REFERENCES] = Hash[@references.map { |ref_alias, ref| [ref_alias, ref._pcore_init_hash] }] unless @references.empty?
+    result[KEY_REFERENCES] = @references.transform_values(&:_pcore_init_hash) unless @references.empty?
     result
   end
 
@@ -192,6 +198,7 @@ class PTypeSetType < PMetaType
   def [](qname)
     if qname.is_a?(Loader::TypedName)
       return nil unless qname.type == :type && qname.name_authority == @name_authority
+
       qname = qname.name
     end
 
@@ -231,15 +238,13 @@ class PTypeSetType < PMetaType
   def name_for(t, default_name)
     key = @types.key(t)
     if key.nil?
-      if @references.empty?
-        default_name
-      else
+      unless @references.empty?
         @references.each_pair do |ref_key, ref|
           ref_name = ref.type_set.name_for(t, nil)
           return "#{ref_key}::#{ref_name}" unless ref_name.nil?
         end
-        default_name
       end
+      default_name
     else
       key
     end
@@ -290,7 +295,7 @@ class PTypeSetType < PMetaType
     types = result[KEY_TYPES]
     if types.is_a?(Hash)
       types.each do |type_name, value|
-        full_name = "#{@name}::#{type_name}".freeze
+        full_name = "#{@name}::#{type_name}"
         typed_name = Loader::TypedName.new(:type, full_name, name_auth)
         if value.is_a?(Model::ResourceDefaultsExpression)
           # This is actually a <Parent> { <key-value entries> } notation. Convert to a literal hash that contains the parent
@@ -321,16 +326,16 @@ class PTypeSetType < PMetaType
 
   # @api private
   def resolve_hash(loader, init_hash)
-    result = Hash[init_hash.map do |key, value|
+    result = init_hash.to_h do |key, value|
       key = resolve_type_refs(loader, key)
       value = resolve_type_refs(loader, value) unless key == KEY_TYPES && value.is_a?(Hash)
       [key, value]
-    end]
+    end
     name_auth = resolve_name_authority(result, loader)
     types = result[KEY_TYPES]
     if types.is_a?(Hash)
       types.each do |type_name, value|
-        full_name = "#{@name}::#{type_name}".freeze
+        full_name = "#{@name}::#{type_name}"
         typed_name = Loader::TypedName.new(:type, full_name, name_auth)
         meta_name = value.is_a?(Hash) ? 'Object' : 'TypeAlias'
         type = Loader::TypeDefinitionInstantiator.create_named_type(full_name, meta_name, value, name_auth)
@@ -353,19 +358,21 @@ class PTypeSetType < PMetaType
     o.is_a?(PTypeSetType)
   end
 
-  DEFAULT = self.new({
-    KEY_NAME => 'DefaultTypeSet',
-    KEY_NAME_AUTHORITY => Pcore::RUNTIME_NAME_AUTHORITY,
-    Pcore::KEY_PCORE_URI => Pcore::PCORE_URI,
-    Pcore::KEY_PCORE_VERSION => Pcore::PCORE_VERSION,
-    KEY_VERSION => SemanticPuppet::Version.new(0,0,0)
-  })
+  DEFAULT =
+
+    new({
+          KEY_NAME => 'DefaultTypeSet',
+          KEY_NAME_AUTHORITY => Pcore::RUNTIME_NAME_AUTHORITY,
+          Pcore::KEY_PCORE_URI => Pcore::PCORE_URI,
+          Pcore::KEY_PCORE_VERSION => Pcore::PCORE_VERSION,
+          KEY_VERSION => SemanticPuppet::Version.new(0, 0, 0)
+        })
 
   protected
 
   # @api_private
   def _assignable?(o, guard)
-    self.class == o.class && (self == DEFAULT || eql?(o))
+    instance_of?(o.class) && (self == DEFAULT || eql?(o))
   end
 
   private

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

@@ -1,18 +1,19 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Types
 class PURIType < PAnyType
-
   # Tell evaluator that an members of instances of this type can be invoked using dot notation
   include TypeWithMembers
 
-  SCHEME = 'scheme'.freeze
-  USERINFO = 'userinfo'.freeze
-  HOST = 'host'.freeze
-  PORT = 'port'.freeze
-  PATH = 'path'.freeze
-  QUERY = 'query'.freeze
-  FRAGMENT = 'fragment'.freeze
-  OPAQUE = 'opaque'.freeze
+  SCHEME = 'scheme'
+  USERINFO = 'userinfo'
+  HOST = 'host'
+  PORT = 'port'
+  PATH = 'path'
+  QUERY = 'query'
+  FRAGMENT = 'fragment'
+  OPAQUE = 'opaque'
 
   URI_MEMBERS = {
     SCHEME => AttrReader.new(SCHEME),
@@ -33,23 +34,29 @@ class PURIType < PAnyType
     TypeFactory.optional(PATH) => PStringType::NON_EMPTY,
     TypeFactory.optional(QUERY) => PStringType::NON_EMPTY,
     TypeFactory.optional(FRAGMENT) => PStringType::NON_EMPTY,
-    TypeFactory.optional(OPAQUE) => PStringType::NON_EMPTY,
+    TypeFactory.optional(OPAQUE) => PStringType::NON_EMPTY
   )
 
-  TYPE_STRING_PARAM = TypeFactory.optional(PVariantType.new([
-    PStringType::NON_EMPTY,
-    PRegexpType::DEFAULT,
-    TypeFactory.type_type(PPatternType::DEFAULT),
-    TypeFactory.type_type(PEnumType::DEFAULT),
-    TypeFactory.type_type(PNotUndefType::DEFAULT),
-    TypeFactory.type_type(PUndefType::DEFAULT),
-  ]))
-
-  TYPE_INTEGER_PARAM = TypeFactory.optional(PVariantType.new([
-    PIntegerType.new(0),
-    TypeFactory.type_type(PNotUndefType::DEFAULT),
-    TypeFactory.type_type(PUndefType::DEFAULT),
-  ]))
+  TYPE_STRING_PARAM =
+    TypeFactory
+    .optional(PVariantType
+        .new([
+               PStringType::NON_EMPTY,
+               PRegexpType::DEFAULT,
+               TypeFactory.type_type(PPatternType::DEFAULT),
+               TypeFactory.type_type(PEnumType::DEFAULT),
+               TypeFactory.type_type(PNotUndefType::DEFAULT),
+               TypeFactory.type_type(PUndefType::DEFAULT)
+             ]))
+
+  TYPE_INTEGER_PARAM =
+    TypeFactory
+    .optional(PVariantType
+        .new([
+               PIntegerType.new(0),
+               TypeFactory.type_type(PNotUndefType::DEFAULT),
+               TypeFactory.type_type(PUndefType::DEFAULT)
+             ]))
 
   TYPE_URI_PARAM_HASH_TYPE = TypeFactory.struct(
     TypeFactory.optional(SCHEME) => TYPE_STRING_PARAM,
@@ -59,17 +66,16 @@ class PURIType < PAnyType
     TypeFactory.optional(PATH) => TYPE_STRING_PARAM,
     TypeFactory.optional(QUERY) => TYPE_STRING_PARAM,
     TypeFactory.optional(FRAGMENT) => TYPE_STRING_PARAM,
-    TypeFactory.optional(OPAQUE) => TYPE_STRING_PARAM,
+    TypeFactory.optional(OPAQUE) => TYPE_STRING_PARAM
   )
 
   TYPE_URI_PARAM_TYPE = PVariantType.new([PStringType::NON_EMPTY, TYPE_URI_PARAM_HASH_TYPE])
 
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
-      {
-        'parameters' => { KEY_TYPE => TypeFactory.optional(TYPE_URI_PARAM_TYPE), KEY_VALUE => nil }
-      }
-    )
+                 {
+                   'parameters' => { KEY_TYPE => TypeFactory.optional(TYPE_URI_PARAM_TYPE), KEY_VALUE => nil }
+                 })
   end
 
   def self.new_function(type)
@@ -99,12 +105,13 @@ class PURIType < PAnyType
   attr_reader :parameters
 
   def initialize(parameters = nil)
-    if parameters.is_a?(String)
+    case parameters
+    when String
       parameters = TypeAsserter.assert_instance_of('URI-Type parameter', Pcore::TYPE_URI, parameters, true)
       @parameters = uri_to_hash(URI.parse(parameters))
-    elsif parameters.is_a?(URI)
+    when URI
       @parameters = uri_to_hash(parameters)
-    elsif parameters.is_a?(Hash)
+    when Hash
       params = TypeAsserter.assert_instance_of('URI-Type parameter', TYPE_URI_PARAM_TYPE, parameters, true)
       @parameters = params.empty? ? nil : params
     end
@@ -149,8 +156,9 @@ class PURIType < PAnyType
   protected
 
   def _assignable?(o, guard = nil)
-    return false unless o.class == self.class
+    return false unless o.instance_of?(self.class)
     return true if @parameters.nil?
+
     o_params = o.parameters || EMPTY_HASH
 
     eval = Parser::EvaluatingParser.singleton.evaluator

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

@@ -1,6 +1,7 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Types
-
 # Marker module for implementations that are mapped to Object types
 # @api public
 module PuppetObject

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Types
 # Keeps track of self recursion of conceptual 'this' and 'that' instances using two separate maps and
@@ -7,6 +9,10 @@ module Types
 #
 # All comparisons are made using the `object_id` of the instance rather than the instance itself.
 #
+# Hash#compare_by_identity is intentionally not used since we only need to keep
+# track of object ids we've seen before, based on object_id, so we don't store
+# entire objects in memory.
+#
 # @api private
 class RecursionGuard
   attr_reader :state
@@ -24,14 +30,14 @@ class RecursionGuard
   # @param instance [Object] the instance to check
   # @return [Integer] the resulting state
   def recursive_this?(instance)
-    instance_variable_defined?(:@recursive_this_map) && @recursive_this_map.has_key?(instance.object_id)
+    instance_variable_defined?(:@recursive_this_map) && @recursive_this_map.has_key?(instance.object_id) # rubocop:disable Lint/HashCompareByIdentity
   end
 
   # Checks if recursion was detected for the given argument in the 'that' context
   # @param instance [Object] the instance to check
   # @return [Integer] the resulting state
   def recursive_that?(instance)
-    instance_variable_defined?(:@recursive_that_map) && @recursive_that_map.has_key?(instance.object_id)
+    instance_variable_defined?(:@recursive_that_map) && @recursive_that_map.has_key?(instance.object_id) # rubocop:disable Lint/HashCompareByIdentity
   end
 
   # Add the given argument as 'this' invoke the given block with the resulting state
@@ -40,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)
@@ -60,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)
@@ -79,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
@@ -89,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

@@ -1,9 +1,9 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Types
-
 # @api private
 class RubyGenerator < TypeFormatter
-
   RUBY_RESERVED_WORDS = {
     'alias' => '_alias',
     'begin' => '_begin',
@@ -30,7 +30,7 @@ class RubyGenerator < TypeFormatter
     'yield' => '_yield',
   }
 
-  RUBY_RESERVED_WORDS_REVERSED = Hash[RUBY_RESERVED_WORDS.map { |k, v| [v, k] }]
+  RUBY_RESERVED_WORDS_REVERSED = RUBY_RESERVED_WORDS.to_h { |k, v| [v, k] }
 
   def self.protect_reserved_name(name)
     RUBY_RESERVED_WORDS[name] || name
@@ -44,6 +44,7 @@ class RubyGenerator < TypeFormatter
     segments = name.split(TypeFormatter::NAME_SEGMENT_SEPARATOR)
     namespace_segments.size.times do |idx|
       break if segments.empty? || namespace_segments[idx] != segments[0]
+
       segments.shift
     end
     segments
@@ -59,16 +60,17 @@ class RubyGenerator < TypeFormatter
       if cls.nil?
         rp = key.resolved_parent
         parent_class = rp.is_a?(PObjectType) ? rp.implementation_class : Object
-        class_def = ''
+        class_def = ''.dup
         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
     end
     raise ArgumentError, "Expected a Puppet Type, got '#{obj.class.name}'" unless obj.is_a?(PAnyType)
+
     @dynamic_classes[obj]
   end
 
@@ -76,7 +78,8 @@ class RubyGenerator < TypeFormatter
     module_definition(
       typeset.types.values,
       "# Generated by #{self.class.name} from TypeSet #{typeset.name} on #{Date.new}\n",
-      *impl_subst)
+      *impl_subst
+    )
   end
 
   def module_definition(types, comment, *impl_subst)
@@ -104,15 +107,16 @@ class RubyGenerator < TypeFormatter
     min_prefix_length.times do |idx|
       segment = segments_array[0][idx]
       break unless segments_array.all? { |sn| sn[idx] == segment }
+
       common_prefix << segment
     end
 
     # Create class definition of all contained types
-    bld = ''
+    bld = ''.dup
     start_module(common_prefix, comment, bld)
     class_names = []
     names_by_prefix.each_pair do |seg_array, index_and_name_array|
-      added_to_common_prefix = seg_array[common_prefix.length..-1]
+      added_to_common_prefix = seg_array[common_prefix.length..]
       added_to_common_prefix.each { |name| bld << 'module ' << name << "\n" }
       index_and_name_array.each do |idx, name, full_name|
         scoped_class_definition(object_types[idx], name, bld, full_name, *impl_subst)
@@ -122,7 +126,7 @@ class RubyGenerator < TypeFormatter
       added_to_common_prefix.size.times { bld << "end\n" }
     end
 
-    aliases = Hash[aliased_types.map { |type| [type.name, type.resolved_type] }]
+    aliases = aliased_types.to_h { |type| [type.name, type.resolved_type] }
     end_module(common_prefix, aliases, class_names, bld)
     bld
   end
@@ -158,6 +162,7 @@ class RubyGenerator < TypeFormatter
       ir = Loaders.implementation_registry
       impl_name = ir.module_name_for_type(type)
       raise Puppet::Error, "Unable to create an instance of #{type.name}. No mapping exists to runtime object" if impl_name.nil?
+
       impl_name
     end
   end
@@ -166,7 +171,7 @@ class RubyGenerator < TypeFormatter
     module_segments = remove_common_namespace(namespace_segments, class_name)
     leaf_name = module_segments.pop
     module_segments.each { |segment| bld << 'module ' << segment << "\n" }
-    scoped_class_definition(obj,leaf_name, bld, class_name, *impl_subst)
+    scoped_class_definition(obj, leaf_name, bld, class_name, *impl_subst)
     module_segments.size.times { bld << "end\n" }
     module_segments << leaf_name
     module_segments.join(TypeFormatter::NAME_SEGMENT_SEPARATOR)
@@ -215,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?)
@@ -286,7 +291,7 @@ class RubyGenerator < TypeFormatter
       derived_attrs.each do |a|
         bld << "\n  def " << rname(a.name) << "\n"
         code_annotation = RubyMethod.annotate(a)
-        ruby_body = code_annotation.nil? ? nil: code_annotation.body
+        ruby_body = code_annotation.nil? ? nil : code_annotation.body
         if ruby_body.nil?
           bld << "    raise Puppet::Error, \"no method is implemented for derived #{a.label}\"\n"
         else
@@ -362,7 +367,7 @@ class RubyGenerator < TypeFormatter
         if array_type?(cp.type)
           bld << '    @' << rname(cp.name) << ".each { |value| yield(value) }\n"
         else
-          bld << '    yield(@' << rname(cp.name) << ') unless @' << rname(cp.name)  << ".nil?\n"
+          bld << '    yield(@' << rname(cp.name) << ') unless @' << rname(cp.name) << ".nil?\n"
         end
       end
       bld << "  end\n\n  def _pcore_all_contents(path, &block)\n    path << self\n"
@@ -404,7 +409,7 @@ class RubyGenerator < TypeFormatter
       bld << "\n  def eql?(o)\n"
       bld << "    super &&\n" unless obj.parent.nil?
       bld << "    o.instance_of?(self.class) &&\n" if include_type
-      eq_names.each { |eqn| bld << '    @' << rname(eqn) << '.eql?(o.' <<  rname(eqn) << ") &&\n" }
+      eq_names.each { |eqn| bld << '    @' << rname(eqn) << '.eql?(o.' << rname(eqn) << ") &&\n" }
       bld.chomp!(" &&\n")
       bld << "\n  end\n  alias == eql?\n"
     end

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

@@ -1,15 +1,16 @@
+# frozen_string_literal: true
+
 module Puppet::Pops
 module Types
   class RubyMethod < Annotation
     # 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, 'RubyMethod', 'Annotation',
-        'body' => PStringType::DEFAULT,
-        'parameters' => {
-          KEY_TYPE => POptionalType.new(PStringType::NON_EMPTY),
-          KEY_VALUE => nil
-        }
-      )
+      @type = Pcore.create_object_type(loader, ir, self, 'RubyMethod', 'Annotation',
+                                       'body' => PStringType::DEFAULT,
+                                       'parameters' => {
+                                         KEY_TYPE => POptionalType.new(PStringType::NON_EMPTY),
+                                         KEY_VALUE => nil
+                                       })
     end
 
     def self.from_hash(init_hash)