puppet 8.3.1-x64-mingw32 → 8.4.0-x64-mingw32

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

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
+
 # @abstract base class for PObjectType and other types that implements lazy evaluation of content
 # @api private
 module Puppet::Pops
 module Types
-
 KEY_NAME = 'name'
 KEY_TYPE = 'type'
 KEY_VALUE = 'value'

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

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
+
 require_relative 'ruby_generator'
 require_relative 'type_with_members'
 
 module Puppet::Pops
 module Types
-
 KEY_ATTRIBUTES = 'attributes'
 KEY_CHECKS = 'checks'
 KEY_CONSTANTS = 'constants'
@@ -29,19 +29,23 @@ class PObjectType < PMetaType
 
   TYPE_OBJECT_NAME = Pcore::TYPE_QUALIFIED_REFERENCE
 
-  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
-  })
-
-  TYPE_PARAMETER = TypeFactory.struct({
-    KEY_TYPE => PTypeType::DEFAULT,
-    TypeFactory.optional(KEY_ANNOTATIONS) => TYPE_ANNOTATIONS
-  })
+  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
+              })
+
+  TYPE_PARAMETER =
+    TypeFactory
+      .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)
@@ -50,30 +54,35 @@ class PObjectType < PMetaType
 
   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
-  })
+  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
+              })
+
   TYPE_FUNCTIONS = TypeFactory.hash_kv(PVariantType.new([Pcore::TYPE_MEMBER_NAME, PStringType.new('[]')]), TypeFactory.not_undef)
 
   TYPE_EQUALITY = TypeFactory.variant(Pcore::TYPE_MEMBER_NAME, TypeFactory.array_of(Pcore::TYPE_MEMBER_NAME))
 
   TYPE_CHECKS = PAnyType::DEFAULT # TBD
 
-  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
-  })
+  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
+              })
 
   def self.register_ptype(loader, ir)
     type = create_ptype(loader, ir, 'AnyType', '_pcore_init_hash' => TYPE_OBJECT_I12N)
@@ -168,12 +177,13 @@ class PObjectType < PMetaType
         raise Puppet::ParseError, _("%{member} attempts to override final %{label}") % { member: member.label, label: label }
       end
       unless member.override?
-        #TRANSLATOR 'override => true' is a puppet syntax and should not be translated
+        # TRANSLATOR 'override => true' is a puppet syntax and should not be translated
         raise Puppet::ParseError, _("%{member} attempts to override %{label} without having override => true") % { member: member.label, label: label }
       end
       unless @type.assignable?(member.type)
         raise Puppet::ParseError, _("%{member} attempts to override %{label} with a type that does not match") % { member: member.label, label: label }
       end
+
       member
     end
 
@@ -244,6 +254,7 @@ class PObjectType < PMetaType
       args_type = TypeCalculator.infer_set(block_given? ? args + [block] : args)
       found = @dispatch.find { |d| d.type.callable?(args_type) }
       raise ArgumentError, TypeMismatchDescriber.describe_signatures(label, @dispatch, args_type) if found.nil?
+
       found.invoke(receiver, scope, args, &block)
     end
 
@@ -272,7 +283,6 @@ class PObjectType < PMetaType
   # Describes a named Attribute in an Object type
   # @api public
   class PAttribute < PAnnotatedMember
-
     # @return [String,nil] The attribute kind as defined by #TYPE_ATTRIBUTE_KIND, or `nil`
     attr_reader :kind
 
@@ -288,12 +298,14 @@ class PObjectType < PMetaType
       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}
       end
+
       @kind = init_hash[KEY_KIND]
       if @kind == ATTRIBUTE_KIND_CONSTANT # final is implied
         if init_hash.include?(KEY_FINAL) && !@final
-          #TRANSLATOR 'final => false' is puppet syntax and should not be translated
+          # TRANSLATOR 'final => false' is puppet syntax and should not be translated
           raise Puppet::ParseError, _("%{label} of kind 'constant' cannot be combined with final => false") % { label: label }
         end
+
         @final = true
       end
 
@@ -301,10 +313,12 @@ class PObjectType < PMetaType
         if @kind == ATTRIBUTE_KIND_DERIVED || @kind == ATTRIBUTE_KIND_GIVEN_OR_DERIVED
           raise Puppet::ParseError, _("%{label} of kind '%{kind}' cannot be combined with an attribute value") % { label: label, kind: @kind }
         end
+
         v = init_hash[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
+
         @value = :undef # Not to be confused with nil or :default
       end
     end
@@ -354,6 +368,7 @@ class PObjectType < PMetaType
     def value
       # An error must be raised here since `nil` is a valid value and it would be bad to leak the :undef symbol
       raise Puppet::Error, "#{label} has no value" if @value == :undef
+
       @value
     end
 
@@ -382,7 +397,6 @@ class PObjectType < PMetaType
   # Describes a named Function in an Object type
   # @api public
   class PFunction < PAnnotatedMember
-
     # @param name [String] The name of the attribute
     # @param container [PObjectType] The containing object type
     # @param init_hash [Hash{String=>Object}] Hash containing function options
@@ -424,7 +438,7 @@ class PObjectType < PMetaType
   #   @param loader [Loaders::Loader,nil] the loader that loaded the type
   #
   # @api private
-  def initialize(_pcore_init_hash, init_hash_expression = nil)
+  def initialize(_pcore_init_hash, init_hash_expression = nil) # rubocop:disable Lint/UnderscorePrefixedVariableName
     if _pcore_init_hash.is_a?(Hash)
       _pcore_init_from_hash(_pcore_init_hash)
       @loader = init_hash_expression unless init_hash_expression.nil?
@@ -443,6 +457,7 @@ class PObjectType < PMetaType
     else
       name = o.class.name
       return false if name.nil? # anonymous class that doesn't implement PuppetObject is not an instance
+
       ir = Loaders.implementation_registry
       type = ir.nil? ? nil : ir.type_for_module(name)
       !type.nil? && assignable?(type, guard)
@@ -485,7 +500,7 @@ class PObjectType < PMetaType
     writer.write(self, value, serializer)
   end
 
-    # @api private
+  # @api private
   def create_new_function
     impl_class = implementation_class
     return impl_class.create_new_function(self) if impl_class.respond_to?(:create_new_function)
@@ -498,7 +513,6 @@ class PObjectType < PMetaType
 
     # Create and return a #new_XXX function where the dispatchers are added programmatically.
     Puppet::Functions.create_loaded_function(:"new_#{name}", loader) do
-
       # The class that creates new instances must be available to the constructor methods
       # and is therefore declared as a variable and accessor on the class that represents
       # this added function.
@@ -558,6 +572,7 @@ class PObjectType < PMetaType
   # @api private
   def implementation_class=(cls)
     raise ArgumentError, "attempt to redefine implementation class for #{label}" unless @implementation_class.nil?
+
     @implementation_class = cls
   end
 
@@ -573,6 +588,7 @@ class PObjectType < PMetaType
     if !@implementation_class.nil? || instance_variable_defined?(:@implementation_override)
       raise ArgumentError, "attempt to redefine implementation override for #{label}"
     end
+
     @implementation_override = block
   end
 
@@ -631,6 +647,7 @@ class PObjectType < PMetaType
       if init_param_names.size < param_count || init_non_opt_count > param_count
         raise Serialization::SerializationError, "Initializer for class #{impl_class.name} does not match the attributes of #{name}"
       end
+
       init_param_names = init_param_names[0, param_count] if init_param_names.size > param_count
       unless init_param_names == param_names
         # Reorder needed to match initialize method arguments
@@ -639,7 +656,7 @@ class PObjectType < PMetaType
           index = param_names.index(ip)
           if index.nil?
             raise Serialization::SerializationError,
-              "Initializer for class #{impl_class.name} parameter '#{ip}' does not match any of the the attributes of type #{name}"
+                  "Initializer for class #{impl_class.name} parameter '#{ip}' does not match any of the the attributes of type #{name}"
           end
           new_param_types << param_types[index]
         end
@@ -686,6 +703,7 @@ class PObjectType < PMetaType
       check_self_recursion(self)
       rp = resolved_parent
       raise Puppet::ParseError, _("reference to unresolved type '%{name}'") % { :name => rp.type_string } if rp.is_a?(PTypeReferenceType)
+
       if rp.is_a?(PObjectType)
         parent_object_type = rp
         parent_members = rp.members(true)
@@ -723,6 +741,7 @@ class PObjectType < PMetaType
         if attr_specs.include?(key)
           raise Puppet::ParseError, _("attribute %{label}[%{key}] is defined as both a constant and an attribute") % { label: label, key: key }
         end
+
         attr_spec = {
           # Type must be generic here, or overrides would become impossible
           KEY_TYPE => TypeCalculator.infer(value).generalize,
@@ -754,6 +773,7 @@ class PObjectType < PMetaType
         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
@@ -765,11 +785,11 @@ class PObjectType < PMetaType
     equality = [equality] if equality.is_a?(String)
     if equality.is_a?(Array)
       unless equality.empty?
-        #TRANSLATORS equality_include_type = false should not be translated
+        # TRANSLATORS equality_include_type = false should not be translated
         raise Puppet::ParseError, _('equality_include_type = false cannot be combined with non empty equality specification') unless @equality_include_type
+
         parent_eq_attrs = nil
         equality.each do |attr_name|
-
           attr = parent_members[attr_name]
           if attr.nil?
             attr = @attributes[attr_name] || @functions[attr_name]
@@ -787,6 +807,7 @@ class PObjectType < PMetaType
             if attr.nil?
               raise Puppet::ParseError, _("%{label} equality is referencing non existent attribute '%{attribute}'") % { label: label, attribute: attr_name }
             end
+
             raise Puppet::ParseError, _("%{label} equality is referencing %{attribute}. Only attribute references are allowed") %
                 { label: label, attribute: attr.label }
           end
@@ -982,6 +1003,7 @@ class PObjectType < PMetaType
   def check_self_recursion(originator)
     unless @parent.nil?
       raise Puppet::Error, "The Object type '#{originator.label}' inherits from itself" if @parent.equal?(originator)
+
       @parent.check_self_recursion(originator)
     end
   end
@@ -1092,6 +1114,7 @@ class PObjectType < PMetaType
       p = type.resolved_parent
       return type unless p.is_a?(PObjectType)
       return type unless p.equality_attributes.include?(attr.name)
+
       type = p
     end
     nil

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
-
 # Base class for Parameterized Object implementations. The wrapper impersonates the base
 # object and extends it with methods to filter assignable types and instances based on parameter
 # values.
@@ -12,12 +12,12 @@ class PObjectTypeExtension < PAnyType
 
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
-      'base_type' => {
-        KEY_TYPE => PTypeType::DEFAULT
-      },
-      'init_parameters' => {
-        KEY_TYPE => PArrayType::DEFAULT
-      }
+                 'base_type' => {
+                   KEY_TYPE => PTypeType::DEFAULT
+                 },
+                 'init_parameters' => {
+                   KEY_TYPE => PArrayType::DEFAULT
+                 }
     )
   end
 
@@ -54,6 +54,7 @@ class PObjectTypeExtension < PAnyType
   def initialize(base_type, init_parameters)
     pts = base_type.type_parameters(true)
     raise Puppet::ParseError, _('The %{label}-Type cannot be parameterized using []') % { label: base_type.label } if pts.empty?
+
     @base_type = base_type
 
     named_args = init_parameters.size == 1 && init_parameters[0].is_a?(Hash)
@@ -70,6 +71,7 @@ class PObjectTypeExtension < PAnyType
         if tp.nil?
           raise Puppet::ParseError, _("'%{pn}' is not a known type parameter for %{label}-Type") % { pn: pn, label: base_type.label }
         end
+
         by_name[pn] = check_param(tp, pv) unless pv == :default
       end
     else
@@ -83,6 +85,7 @@ class PObjectTypeExtension < PAnyType
     if by_name.empty?
       raise Puppet::ParseError, _('The %{label}-Type cannot be parameterized using an empty parameter list') % { label: base_type.label }
     end
+
     @parameters = by_name
   end
 

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

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
-
 # @api public
 class PRuntimeType < PAnyType
   TYPE_NAME_OR_PATTERN = PVariantType.new([PStringType::NON_EMPTY, PTupleType.new([PRegexpType::DEFAULT, PStringType::NON_EMPTY])])
 
   def self.register_ptype(loader, ir)
     create_ptype(loader, ir, 'AnyType',
-      'runtime' => {
-        KEY_TYPE => POptionalType.new(PStringType::NON_EMPTY),
-        KEY_VALUE => nil
-      },
-      'name_or_pattern' => {
-        KEY_TYPE => POptionalType.new(TYPE_NAME_OR_PATTERN),
-        KEY_VALUE => nil
-      }
+                 'runtime' => {
+                   KEY_TYPE => POptionalType.new(PStringType::NON_EMPTY),
+                   KEY_VALUE => nil
+                 },
+                 'name_or_pattern' => {
+                   KEY_TYPE => POptionalType.new(TYPE_NAME_OR_PATTERN),
+                   KEY_VALUE => nil
+                 }
     )
   end
 
@@ -70,8 +70,10 @@ class PRuntimeType < PAnyType
   def class_or_module
     raise "Only ruby classes or modules can be produced by this runtime, got '#{runtime}" unless runtime == :ruby
     raise 'A pattern based Runtime type cannot produce a class or module' if @name_or_pattern.is_a?(Array)
+
     com = ClassLoader.provide(self)
     raise "The name #{@name_or_pattern} does not represent a ruby class or module" if com.nil?
+
     com
   end
 

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
-
 # An unparameterized type that represents all VersionRange instances
 #
 # @api public

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
-
 # A Puppet Language Type that exposes the {{SemanticPuppet::Version}} and {{SemanticPuppet::VersionRange}}.
 # The version type is parameterized with version ranges.
 #
@@ -9,10 +9,10 @@ module Types
 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_VALUE => []
-       }
+                 'ranges' => {
+                   KEY_TYPE => PArrayType.new(PVariantType.new([PSemVerRangeType::DEFAULT,PStringType::NON_EMPTY])),
+                   KEY_VALUE => []
+                 }
     )
   end
 

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

@@ -1,14 +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
@@ -51,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
@@ -79,6 +77,5 @@ class PSensitiveType < PTypeWithContainedType
 
   DEFAULT = PSensitiveType.new
 end
-
 end
 end

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
   class PAbstractTimeDataType < PScalarType
@@ -71,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
@@ -99,8 +101,8 @@ module Types
   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
 

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
 

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
+
 module Puppet::Pops
 module Types
-
 KEY_NAME_AUTHORITY = 'name_authority'
 KEY_TYPES = 'types'
 KEY_ALIAS = 'alias'
@@ -10,7 +10,6 @@ KEY_VERSION_RANGE = 'version_range'
 KEY_REFERENCES = 'references'
 
 class PTypeSetType < PMetaType
-
   # A Loader that makes the types known to the TypeSet visible
   #
   # @api private
@@ -40,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))
@@ -113,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
@@ -146,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
 
@@ -155,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
@@ -173,7 +178,7 @@ 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?
@@ -193,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
 
@@ -354,13 +360,15 @@ 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 =
+    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)
+           })
 
   protected