puppet 8.4.0 → 8.5.0

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

@@ -31,37 +31,37 @@ class PObjectType < PMetaType
 
   TYPE_ATTRIBUTE =
     TypeFactory
-      .struct({
-                KEY_TYPE => PTypeType::DEFAULT,
-                TypeFactory.optional(KEY_FINAL) => PBooleanType::DEFAULT,
-                TypeFactory.optional(KEY_OVERRIDE) => PBooleanType::DEFAULT,
-                TypeFactory.optional(KEY_KIND) => TYPE_ATTRIBUTE_KIND,
-                KEY_VALUE => PAnyType::DEFAULT,
-                TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
-              })
+    .struct({
+              KEY_TYPE => PTypeType::DEFAULT,
+              TypeFactory.optional(KEY_FINAL) => PBooleanType::DEFAULT,
+              TypeFactory.optional(KEY_OVERRIDE) => PBooleanType::DEFAULT,
+              TypeFactory.optional(KEY_KIND) => TYPE_ATTRIBUTE_KIND,
+              KEY_VALUE => PAnyType::DEFAULT,
+              TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
+            })
 
   TYPE_PARAMETER =
     TypeFactory
-      .struct({
-                KEY_TYPE => PTypeType::DEFAULT,
-                TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
-              })
+    .struct({
+              KEY_TYPE => PTypeType::DEFAULT,
+              TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
+            })
 
   TYPE_CONSTANTS = TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, PAnyType::DEFAULT)
   TYPE_ATTRIBUTES = TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, TypeFactory.not_undef)
   TYPE_PARAMETERS = TypeFactory.hash_kv(Pcore::TYPE_MEMBER_NAME, TypeFactory.not_undef)
-  TYPE_ATTRIBUTE_CALLABLE = TypeFactory.callable(0,0)
+  TYPE_ATTRIBUTE_CALLABLE = TypeFactory.callable(0, 0)
 
   TYPE_FUNCTION_TYPE = PTypeType.new(PCallableType::DEFAULT)
 
   TYPE_FUNCTION =
     TypeFactory
-      .struct({
-                KEY_TYPE => TYPE_FUNCTION_TYPE,
-                TypeFactory.optional(KEY_FINAL) => PBooleanType::DEFAULT,
-                TypeFactory.optional(KEY_OVERRIDE) => PBooleanType::DEFAULT,
-                TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
-              })
+    .struct({
+              KEY_TYPE => TYPE_FUNCTION_TYPE,
+              TypeFactory.optional(KEY_FINAL) => PBooleanType::DEFAULT,
+              TypeFactory.optional(KEY_OVERRIDE) => PBooleanType::DEFAULT,
+              TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
+            })
 
   TYPE_FUNCTIONS = TypeFactory.hash_kv(PVariantType.new([Pcore::TYPE_MEMBER_NAME, PStringType.new('[]')]), TypeFactory.not_undef)
 
@@ -71,18 +71,18 @@ class PObjectType < PMetaType
 
   TYPE_OBJECT_I12N =
     TypeFactory
-      .struct({
-                TypeFactory.optional(KEY_NAME) => TYPE_OBJECT_NAME,
-                TypeFactory.optional(KEY_PARENT) => PTypeType::DEFAULT,
-                TypeFactory.optional(KEY_TYPE_PARAMETERS) => TYPE_PARAMETERS,
-                TypeFactory.optional(KEY_ATTRIBUTES) => TYPE_ATTRIBUTES,
-                TypeFactory.optional(KEY_CONSTANTS) => TYPE_CONSTANTS,
-                TypeFactory.optional(KEY_FUNCTIONS) => TYPE_FUNCTIONS,
-                TypeFactory.optional(KEY_EQUALITY) => TYPE_EQUALITY,
-                TypeFactory.optional(KEY_EQUALITY_INCLUDE_TYPE) => PBooleanType::DEFAULT,
-                TypeFactory.optional(KEY_CHECKS) => TYPE_CHECKS,
-                TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
-              })
+    .struct({
+              TypeFactory.optional(KEY_NAME) => TYPE_OBJECT_NAME,
+              TypeFactory.optional(KEY_PARENT) => PTypeType::DEFAULT,
+              TypeFactory.optional(KEY_TYPE_PARAMETERS) => TYPE_PARAMETERS,
+              TypeFactory.optional(KEY_ATTRIBUTES) => TYPE_ATTRIBUTES,
+              TypeFactory.optional(KEY_CONSTANTS) => TYPE_CONSTANTS,
+              TypeFactory.optional(KEY_FUNCTIONS) => TYPE_FUNCTIONS,
+              TypeFactory.optional(KEY_EQUALITY) => TYPE_EQUALITY,
+              TypeFactory.optional(KEY_EQUALITY_INCLUDE_TYPE) => PBooleanType::DEFAULT,
+              TypeFactory.optional(KEY_CHECKS) => TYPE_CHECKS,
+              TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
+            })
 
   def self.register_ptype(loader, ir)
     type = create_ptype(loader, ir, 'AnyType', '_pcore_init_hash' => TYPE_OBJECT_I12N)
@@ -155,7 +155,7 @@ class PObjectType < PMetaType
       if parent_member.nil?
         if @override
           raise Puppet::ParseError, _("expected %{label} to override an inherited %{feature_type}, but no such %{feature_type} was found") %
-              { label: label, feature_type: feature_type }
+                                    { label: label, feature_type: feature_type }
         end
         self
       else
@@ -170,7 +170,7 @@ class PObjectType < PMetaType
     # @raises [Puppet::ParseError] if the assertion fails
     # @api private
     def assert_can_be_overridden(member)
-      unless self.class == member.class
+      unless self.instance_of?(member.class)
         raise Puppet::ParseError, _("%{member} attempts to override %{label}") % { member: member.label, label: label }
       end
       if @final && !(constant? && member.constant?)
@@ -261,7 +261,7 @@ class PObjectType < PMetaType
     # @api private
     def create_dispatch(instance)
       # TODO: Assumes Ruby implementation for now
-      if(callable_type.is_a?(PVariantType))
+      if (callable_type.is_a?(PVariantType))
         callable_type.types.map do |ct|
           Functions::Dispatch.new(ct, RubyGenerator.protect_reserved_name(name), [], false, ct.block_type.nil? ? nil : 'block')
         end
@@ -296,7 +296,7 @@ class PObjectType < PMetaType
     def initialize(name, container, init_hash)
       super(name, container, TypeAsserter.assert_instance_of(nil, TYPE_ATTRIBUTE, init_hash) { "initializer for #{self.class.label(container, name)}" })
       if name == Serialization::PCORE_TYPE_KEY || name == Serialization::PCORE_VALUE_KEY
-        raise Puppet::ParseError, _("The attribute '%{name}' is reserved and cannot be used") % { name: name}
+        raise Puppet::ParseError, _("The attribute '%{name}' is reserved and cannot be used") % { name: name }
       end
 
       @kind = init_hash[KEY_KIND]
@@ -315,7 +315,7 @@ class PObjectType < PMetaType
         end
 
         v = init_hash[KEY_VALUE]
-        @value = v == :default ? v : TypeAsserter.assert_instance_of(nil, type, v) {"#{label} #{KEY_VALUE}" }
+        @value = v == :default ? v : TypeAsserter.assert_instance_of(nil, type, v) { "#{label} #{KEY_VALUE}" }
       else
         raise Puppet::ParseError, _("%{label} of kind 'constant' requires a value") % { label: label } if @kind == ATTRIBUTE_KIND_CONSTANT
 
@@ -734,7 +734,7 @@ class PObjectType < PMetaType
       attr_specs = {}
     else
       # attr_specs might be frozen
-      attr_specs = Hash[attr_specs]
+      attr_specs = attr_specs.to_h
     end
     unless constants.nil? || constants.empty?
       constants.each do |key, value|
@@ -755,7 +755,7 @@ class PObjectType < PMetaType
     end
 
     unless attr_specs.empty?
-      @attributes = Hash[attr_specs.map do |key, attr_spec|
+      @attributes = attr_specs.to_h do |key, attr_spec|
         unless attr_spec.is_a?(Hash)
           attr_type = TypeAsserter.assert_instance_of(nil, PTypeType::DEFAULT, attr_spec) { "attribute #{label}[#{key}]" }
           attr_spec = { KEY_TYPE => attr_type }
@@ -763,19 +763,19 @@ class PObjectType < PMetaType
         end
         attr = PAttribute.new(key, self, attr_spec)
         [attr.name, attr.assert_override(parent_members)]
-      end].freeze
+      end.freeze
     end
 
     func_specs = init_hash[KEY_FUNCTIONS]
     unless func_specs.nil? || func_specs.empty?
-      @functions = Hash[func_specs.map do |key, func_spec|
+      @functions = func_specs.to_h do |key, func_spec|
         func_spec = { KEY_TYPE => TypeAsserter.assert_instance_of(nil, TYPE_FUNCTION_TYPE, func_spec) { "function #{label}[#{key}]" } } unless func_spec.is_a?(Hash)
         func = PFunction.new(key, self, func_spec)
         name = func.name
         raise Puppet::ParseError, _("%{label} conflicts with attribute with the same name") % { label: func.label } if @attributes.include?(name)
 
         [name, func.assert_override(parent_members)]
-      end].freeze
+      end.freeze
     end
 
     @equality_include_type = init_hash[KEY_EQUALITY_INCLUDE_TYPE]
@@ -799,7 +799,7 @@ class PObjectType < PMetaType
             if parent_eq_attrs.include?(attr_name)
               including_parent = find_equality_definer_of(attr)
               raise Puppet::ParseError, _("%{label} equality is referencing %{attribute} which is included in equality of %{including_parent}") %
-                  { label: label, attribute: attr.label, including_parent: including_parent.label }
+                                        { label: label, attribute: attr.label, including_parent: including_parent.label }
             end
           end
 
@@ -809,11 +809,11 @@ class PObjectType < PMetaType
             end
 
             raise Puppet::ParseError, _("%{label} equality is referencing %{attribute}. Only attribute references are allowed") %
-                { label: label, attribute: attr.label }
+                                      { label: label, attribute: attr.label }
           end
           if attr.kind == ATTRIBUTE_KIND_CONSTANT
             raise Puppet::ParseError, _("%{label} equality is referencing constant %{attribute}.") % { label: label, attribute: attr.label } + ' ' +
-                _("Reference to constant is not allowed in equality")
+                                      _("Reference to constant is not allowed in equality")
           end
         end
       end
@@ -901,7 +901,7 @@ class PObjectType < PMetaType
       tc = TypeCalculator.singleton
       constants, others = @attributes.partition do |_, a|
         a.kind == ATTRIBUTE_KIND_CONSTANT && a.type == tc.infer(a.value).generalize
-      end.map { |ha| Hash[ha] }
+      end.map { |ha| ha.to_h }
 
       result[KEY_ATTRIBUTES] = compressed_members_hash(others) unless others.empty?
       unless constants.empty?
@@ -931,7 +931,7 @@ class PObjectType < PMetaType
     @name.nil? ? [@parent, @type_parameters, @attributes, @functions].hash : @name.hash
   end
 
-  def kind_of_callable?(optional=true, guard = nil)
+  def kind_of_callable?(optional = true, guard = nil)
     @parent.nil? ? false : @parent.kind_of_callable?(optional, guard)
   end
 
@@ -1043,14 +1043,15 @@ class PObjectType < PMetaType
   # An Object type is only assignable from another Object type. The other type
   # or one of its parents must be equal to this type.
   def _assignable?(o, guard)
-    if o.is_a?(PObjectType)
+    case o
+    when PObjectType
       if DEFAULT == self || self == o
         true
       else
         op = o.parent
         op.nil? ? false : assignable?(op, guard)
       end
-    elsif o.is_a?(PObjectTypeExtension)
+    when PObjectTypeExtension
       assignable?(o.base_type, guard)
     else
       false
@@ -1080,7 +1081,7 @@ class PObjectType < PMetaType
       # All attributes except constants participate
       collector.merge!(@attributes.reject { |_, attr| attr.kind == ATTRIBUTE_KIND_CONSTANT })
     else
-      collector.merge!(Hash[@equality.map { |attr_name| [attr_name, @attributes[attr_name]] }])
+      collector.merge!(@equality.to_h { |attr_name| [attr_name, @attributes[attr_name]] })
     end
     nil
   end
@@ -1097,14 +1098,14 @@ class PObjectType < PMetaType
   private
 
   def compressed_members_hash(features)
-    Hash[features.values.map do |feature|
+    features.values.to_h do |feature|
       fh = feature._pcore_init_hash
       if fh.size == 1
         type = fh[KEY_TYPE]
         fh = type unless type.nil?
       end
       [feature.name, fh]
-    end]
+    end
   end
 
   # @return [PObjectType] the topmost parent who's #equality_attributes include the given _attr_

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

@@ -17,8 +17,7 @@ class PObjectTypeExtension < PAnyType
                  },
                  'init_parameters' => {
                    KEY_TYPE => PArrayType::DEFAULT
-                 }
-    )
+                 })
   end
 
   attr_reader :base_type, :parameters

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

@@ -15,8 +15,7 @@ class PRuntimeType < PAnyType
                  'name_or_pattern' => {
                    KEY_TYPE => POptionalType.new(TYPE_NAME_OR_PATTERN),
                    KEY_VALUE => nil
-                 }
-    )
+                 })
   end
 
   attr_reader :runtime, :name_or_pattern

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

@@ -10,10 +10,9 @@ class PSemVerType < PScalarType
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'ScalarType',
                  'ranges' => {
-                   KEY_TYPE => PArrayType.new(PVariantType.new([PSemVerRangeType::DEFAULT,PStringType::NON_EMPTY])),
+                   KEY_TYPE => PArrayType.new(PVariantType.new([PSemVerRangeType::DEFAULT, PStringType::NON_EMPTY])),
                    KEY_VALUE => []
-                 }
-    )
+                 })
   end
 
   attr_reader :ranges
@@ -25,7 +24,7 @@ class PSemVerType < PScalarType
   end
 
   def instance?(o, guard = nil)
-    o.is_a?(SemanticPuppet::Version) && (@ranges.empty? || @ranges.any? {|range| range.include?(o) })
+    o.is_a?(SemanticPuppet::Version) && (@ranges.empty? || @ranges.any? { |range| range.include?(o) })
   end
 
   def eql?(o)
@@ -120,7 +119,7 @@ class PSemVerType < PScalarType
   protected
 
   def _assignable?(o, guard)
-    return false unless o.class == self.class
+    return false unless o.instance_of?(self.class)
     return true if @ranges.empty?
     return false if o.ranges.empty?
 

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

@@ -72,7 +72,7 @@ class PSensitiveType < PTypeWithContainedType
   private
 
   def _assignable?(o, guard)
-    self.class == o.class && @type.assignable?(o.type, guard)
+    self.instance_of?(o.class) && @type.assignable?(o.type, guard)
   end
 
   DEFAULT = PSensitiveType.new

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

@@ -17,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)
+      self.instance_of?(o.class) && !(@to < o.numeric_from || o.numeric_to < @from)
     end
 
     # Returns the lower bound of the numeric range or `nil` if no lower bound is set.
@@ -94,7 +94,7 @@ module Types
     end
 
     def _assignable?(o, guard)
-      self.class == o.class && numeric_from <= o.numeric_from && numeric_to >= o.numeric_to
+      self.instance_of?(o.class) && numeric_from <= o.numeric_from && numeric_to >= o.numeric_to
     end
   end
 
@@ -102,8 +102,7 @@ module Types
     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 }
-      )
+                   '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

@@ -6,8 +6,7 @@ module Types
     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 }
-      )
+                   '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

@@ -41,25 +41,25 @@ class PTypeSetType < PMetaType
 
   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
-              })
+    .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,
-              })
+    .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))
@@ -183,7 +183,7 @@ class PTypeSetType < PMetaType
     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 { |ref| ref._pcore_init_hash } unless @references.empty?
     result
   end
 
@@ -238,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
@@ -328,11 +326,11 @@ 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)
@@ -362,19 +360,19 @@ class PTypeSetType < PMetaType
 
   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)
-           })
+    .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))
+    self.instance_of?(o.class) && (self == DEFAULT || eql?(o))
   end
 
   private

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

@@ -39,7 +39,7 @@ class PURIType < PAnyType
 
   TYPE_STRING_PARAM =
     TypeFactory
-      .optional(PVariantType
+    .optional(PVariantType
         .new([
                PStringType::NON_EMPTY,
                PRegexpType::DEFAULT,
@@ -51,7 +51,7 @@ class PURIType < PAnyType
 
   TYPE_INTEGER_PARAM =
     TypeFactory
-      .optional(PVariantType
+    .optional(PVariantType
         .new([
                PIntegerType.new(0),
                TypeFactory.type_type(PNotUndefType::DEFAULT),
@@ -75,8 +75,7 @@ class PURIType < PAnyType
     create_ptype(loader, ir, 'AnyType',
                  {
                    'parameters' => { KEY_TYPE => TypeFactory.optional(TYPE_URI_PARAM_TYPE), KEY_VALUE => nil }
-                 }
-    )
+                 })
   end
 
   def self.new_function(type)
@@ -106,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
@@ -156,7 +156,7 @@ 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

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

@@ -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
@@ -78,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)
@@ -115,7 +116,7 @@ class RubyGenerator < TypeFormatter
     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)
@@ -125,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
@@ -170,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)
@@ -290,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

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

@@ -5,13 +5,12 @@ 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)