lutaml-model 0.8.19 → 0.8.23

data/lib/lutaml/model/attribute.rb

@@ -119,6 +119,17 @@ module Lutaml
         @resolver ||= GlobalContext.resolver
       end
 
+      # The value-shaping policy for this attribute. Constructed lazily so
+      # the collection/union/ref flags are settled; memoized because they
+      # are fixed after definition.
+      def value_policy
+        @value_policy ||= ValuePolicy.new(
+          collection: collection?,
+          union: union?,
+          reference: !@options[:ref_model_class].nil?,
+        )
+      end
+
       def type(context_or_register = nil)
         return if unresolved_type.nil?
 
@@ -394,7 +405,9 @@ instance_object = nil)
                                                           instance_object)
         elsif options[:default].is_a?(Proc)
           if instance_object
-            instance_object.instance_exec(&options[:default])
+            ::Lutaml::Model::Attribute.evaluating_default do
+              instance_object.instance_exec(&options[:default])
+            end
           else
             options[:default].call
           end
@@ -405,6 +418,22 @@ instance_object = nil)
         end
       end
 
+      # Marks the dynamic extent in which a default proc runs against a
+      # model instance, so Serialize#method_missing can fall back to the
+      # model class for methods the instance does not define (0.7.x
+      # compatibility, lutaml-model#745).
+      def self.evaluating_default
+        previous = Thread.current[:__lutaml_evaluating_default]
+        Thread.current[:__lutaml_evaluating_default] = true
+        yield
+      ensure
+        Thread.current[:__lutaml_evaluating_default] = previous
+      end
+
+      def self.default_evaluation?
+        Thread.current[:__lutaml_evaluating_default] == true
+      end
+
       def default_set?(register, instance_object = nil)
         !Utils.uninitialized?(default_value(register, instance_object))
       end
@@ -478,7 +507,10 @@ instance_object = nil)
         # Use the default value if the value is nil
         validate_required!(value)
 
-        value = cast_value(default_value(register, instance_object), register) if value.nil?
+        if value.nil?
+          value = cast_value(default_value(register, instance_object),
+                             register)
+        end
         resolved_type = type(register)
 
         valid_value!(value) &&
@@ -551,7 +583,8 @@ instance_object = nil)
       end
 
       def valid_collection!(value, caller)
-        if collection_instance?(value) && !collection?
+        if collection_instance?(value) && !collection? &&
+            !value_policy.whole_value?(unresolved_type)
           raise Lutaml::Model::CollectionTrueMissingError.new(name,
                                                               caller)
         end
@@ -632,7 +665,8 @@ instance_object = nil)
                         else
                           type(register)
                         end
-        if collection_instance?(value) || value.is_a?(Array)
+        if (collection_instance?(value) || value.is_a?(Array)) &&
+            !value_policy.whole_value?(resolved_type)
           merged_opts = options.merge(resolved_type: resolved_type,
                                       converted: true)
           return build_collection(value.map do |v|

data/lib/lutaml/model/collection.rb

@@ -308,6 +308,10 @@ module Lutaml
         end
 
         def to(format, instance, options = {})
+          # Wrap before the branch, not inside it: only XML reaches the
+          # unwrapped path today, but a raw JSON::State must never survive
+          # into either arm.
+          options = Lutaml::Model::Serialize.wrap_generator_state(options)
           mappings = mappings_for(format)
 
           if mappings.no_root? && collection_unwrapped_to?(format)
@@ -456,6 +460,7 @@ lutaml_register: Lutaml::Model::Config.default_register)
       end
 
       def to_format(format, options = {})
+        options = Lutaml::Model::Serialize.wrap_generator_state(options)
         super(format, options.merge(collection: true))
       end
 
@@ -481,8 +486,8 @@ lutaml_register: Lutaml::Model::Config.default_register)
         self.class.new(items - other.items)
       end
 
-      def each(&)
-        collection.each(&)
+      def each(&block)
+        collection.each(&block)
       end
 
       def size

data/lib/lutaml/model/compiled_rule.rb

@@ -192,7 +192,7 @@ module Lutaml
       # @param args [Array] Arguments (ignored for options)
       # @param block [Proc] Block (ignored for options)
       # @return [Object] The option value or nil
-      def method_missing(method_name, *args, &)
+      def method_missing(method_name, *args, &block)
         # Check if this is an option key
         if options.key?(method_name)
           return options[method_name]

data/lib/lutaml/model/config.rb

@@ -42,8 +42,8 @@ module Lutaml
       #   Config.with_adapter(xml: :nokogiri, toml: :tomlib) do
       #     MyModel.from_xml(data)
       #   end
-      def with_adapter(**overrides, &)
-        AdapterScope.with(overrides, &)
+      def with_adapter(**overrides, &block)
+        AdapterScope.with(overrides, &block)
       end
 
       # Delegate configure to Configuration

data/lib/lutaml/model/consolidation_map.rb

@@ -39,8 +39,8 @@ module Lutaml
         end
 
         # Pattern A: declare discriminator routing
-        def dispatch_by(discriminator, &)
-          routes = DispatchBuilder.new.evaluate(&)
+        def dispatch_by(discriminator, &block)
+          routes = DispatchBuilder.new.evaluate(&block)
           @rules << DispatchBlock.new(discriminator, routes)
         end
 

data/lib/lutaml/model/consolidation_rule/dispatch_block.rb

@@ -20,9 +20,9 @@ module Lutaml
 
     # Helper builder for the dispatch_by block
     class DispatchBuilder
-      def evaluate(&)
+      def evaluate(&block)
         @routes = {}
-        instance_eval(&)
+        instance_eval(&block)
         @routes
       end
 

data/lib/lutaml/model/errors.rb

@@ -18,8 +18,8 @@ module Lutaml
         @errors.empty?
       end
 
-      def each(&)
-        @errors.each(&)
+      def each(&block)
+        @errors.each(&block)
       end
 
       def full_messages

data/lib/lutaml/model/global_context.rb

@@ -436,8 +436,10 @@ context_id = nil)
             instance.register_for_namespace(namespace_uri)
           end
 
-          def resolve_type_with_namespace(type_name, namespace_uri = nil, context_id = nil)
-            instance.resolve_type_with_namespace(type_name, namespace_uri, context_id)
+          def resolve_type_with_namespace(type_name, namespace_uri = nil,
+context_id = nil)
+            instance.resolve_type_with_namespace(type_name, namespace_uri,
+                                                 context_id)
           end
 
           def namespace_register_map

data/lib/lutaml/model/mapping/mapping_rule.rb

@@ -67,6 +67,9 @@ module Lutaml
       )
         @name = name
         @to = to
+        # Dynamic symbol built per call allocated ~10% of parse objects on
+        # attribute-heavy documents; `to` is immutable, so build it once.
+        @setter_name = :"#{to}="
         @to_instance = to_instance
         @as_attribute = as_attribute
         @render_nil = render_nil
@@ -457,7 +460,7 @@ module Lutaml
       end
 
       def assign_value(model, value)
-        model.public_send(:"#{to}=", value)
+        model.public_send(@setter_name, value)
       end
     end
   end

data/lib/lutaml/model/mapping/model_mapping.rb

@@ -43,7 +43,7 @@ module Lutaml
         to: nil,
         transform: nil,
         reverse_transform: nil,
-        &
+        &block
       )
         map(
           from: from,
@@ -51,7 +51,7 @@ module Lutaml
           transform: transform,
           reverse_transform: reverse_transform,
           collection: true,
-          &
+          &block
         )
       end
 

data/lib/lutaml/model/runtime_compatibility.rb

@@ -114,8 +114,8 @@ if Lutaml::Model::RuntimeCompatibility.opal?
 
       # Minimal method_missing so the WeakRef quacks like its target
       # for the Store's index lookups.
-      def method_missing(name, *, &)
-        @__target__.public_send(name, *, &)
+      def method_missing(name, ...)
+        @__target__.public_send(name, ...)
       end
 
       def respond_to_missing?(name, include_private = false)

data/lib/lutaml/model/schema/class_loader.rb

@@ -36,7 +36,8 @@ module Lutaml
 
         def load
           Dir.mktmpdir do |dir|
-            FileWriter.write(@output, dir, registry_generator: @registry_generator)
+            FileWriter.write(@output, dir,
+                             registry_generator: @registry_generator)
             require File.join(dir, "#{registry_basename}_registry")
             call_register_all
           end

data/lib/lutaml/model/schema/decorators/definition_collection.rb

@@ -21,12 +21,12 @@ module Lutaml
             resolve_polymorphic_base_types!
           end
 
-          def each(&)
-            @definitions.each(&)
+          def each(&block)
+            @definitions.each(&block)
           end
 
-          def transform_values(&)
-            @definitions.transform_values(&)
+          def transform_values(&block)
+            @definitions.transform_values(&block)
           end
 
           def [](name)

data/lib/lutaml/model/schema/definitions/namespace.rb

@@ -7,7 +7,8 @@ module Lutaml
         # An XML namespace declaration (subclass of
         # Lutaml::Xml::W3c::XmlNamespace).
         class Namespace
-          attr_accessor :class_name, :uri, :prefix_default, :element_form_default
+          attr_accessor :class_name, :uri, :prefix_default,
+                        :element_form_default
 
           def initialize(class_name:, uri:, prefix_default: nil,
                          element_form_default: nil)

data/lib/lutaml/model/schema/file_writer.rb

@@ -45,7 +45,8 @@ module Lutaml
           )
           if registry
             registry_name = module_path.split("/").last
-            File.write(File.join(@dir, "#{registry_name}_registry.rb"), registry)
+            File.write(File.join(@dir, "#{registry_name}_registry.rb"),
+                       registry)
           end
 
           write_sources_to(full_dir)
@@ -57,7 +58,9 @@ module Lutaml
         end
 
         def write_sources_to(target_dir)
-          @output.sources.each { |name, src| write_source(target_dir, name, src) }
+          @output.sources.each do |name, src|
+            write_source(target_dir, name, src)
+          end
         end
 
         def write_source(target_dir, name, src)

data/lib/lutaml/model/schema/renderers/base.rb

@@ -10,11 +10,12 @@ module Lutaml
         # (Union, RestrictedType, Namespace). Model has its own constructor
         # because it computes an opt-out (module-wrappable) namespace.
         class Base
-          def self.render(spec, **)
-            new(spec, **).render
+          def self.render(spec, **options)
+            new(spec, **options).render
           end
 
-          def initialize(spec, indent: 2, module_namespace: nil, register_id: :default)
+          def initialize(spec, indent: 2, module_namespace: nil,
+register_id: :default)
             @spec = spec
             @indent = indent.is_a?(Integer) ? " " * indent : indent
             @extended_indent = @indent * 2

data/lib/lutaml/model/schema/renderers/mappings.rb

@@ -29,7 +29,9 @@ module Lutaml
           def render_one(member, indent)
             case member
             when Definitions::Sequence    then render_sequence(member, indent)
-            when Definitions::Choice      then member.alternatives.map { |a| render_one(a, indent) }.join
+            when Definitions::Choice      then member.alternatives.map do |a|
+              render_one(a, indent)
+            end.join
             when Definitions::Attribute   then render_attribute(member, indent)
             when Definitions::GroupImport then "#{indent}import_model_mappings :#{member.name}\n"
             end
@@ -37,7 +39,9 @@ module Lutaml
 
           def render_sequence(sequence, indent)
             inner_indent = indent + @base_indent
-            inner = sequence.members.map { |m| render_one(m, inner_indent) }.join
+            inner = sequence.members.map do |m|
+              render_one(m, inner_indent)
+            end.join
             "#{indent}sequence do\n#{inner}#{indent}end\n"
           end
 
@@ -63,7 +67,9 @@ module Lutaml
           def simple_content_attribute_mappings
             return "" unless @simple_content
 
-            @simple_content.additional_attributes.map { |a| render_one(a, @indent) }.join
+            @simple_content.additional_attributes.map do |a|
+              render_one(a, @indent)
+            end.join
           end
         end
       end

data/lib/lutaml/model/schema/renderers/member_decls.rb

@@ -35,7 +35,9 @@ module Lutaml
           def render_one(member, indent)
             case member
             when Definitions::Choice      then render_choice(member, indent)
-            when Definitions::Sequence    then member.members.map { |m| render_one(m, indent) }.join
+            when Definitions::Sequence    then member.members.map do |m|
+              render_one(m, indent)
+            end.join
             when Definitions::Attribute   then render_attribute(member, indent)
             when Definitions::GroupImport then "#{indent}import_model_attributes :#{member.name}\n"
             end
@@ -43,7 +45,9 @@ module Lutaml
 
           def render_choice(choice, indent)
             inner_indent = indent + @base_indent
-            inner = choice.alternatives.map { |alt| render_one(alt, inner_indent) }.join
+            inner = choice.alternatives.map do |alt|
+              render_one(alt, inner_indent)
+            end.join
             "#{indent}#{choice.header} do\n#{inner}#{indent}end\n"
           end
 
@@ -106,7 +110,9 @@ module Lutaml
           def simple_content_extras
             return "" unless @simple_content
 
-            @simple_content.additional_attributes.map { |a| render_attribute(a, @indent) }.join
+            @simple_content.additional_attributes.map do |a|
+              render_attribute(a, @indent)
+            end.join
           end
         end
       end

data/lib/lutaml/model/schema/renderers/model.rb

@@ -10,11 +10,12 @@ module Lutaml
         # subclass as Ruby source. Member-declaration and xml-mapping
         # rendering is delegated to MemberDecls and Mappings.
         class Model
-          def self.render(spec, **)
-            new(spec, **).render
+          def self.render(spec, **options)
+            new(spec, **options).render
           end
 
-          def initialize(spec, indent: 2, module_namespace: nil, register_id: :default)
+          def initialize(spec, indent: 2, module_namespace: nil,
+register_id: :default)
             @spec = spec
             @indent = indent.is_a?(Integer) ? " " * indent : indent
             @extended_indent = @indent * 2
@@ -39,8 +40,15 @@ module Lutaml
 
           def rendered_class_name = @spec.class_name
           def serializable_class_parent = @spec.parent_class
-          def serializable_class_required_files = format_files(@spec.required_files)
-          def serializable_class_documentation = format_doc_block(@spec.documentation)
+
+          def serializable_class_required_files
+            format_files(@spec.required_files)
+          end
+
+          def serializable_class_documentation
+            format_doc_block(@spec.documentation)
+          end
+
           def serializable_class_imports = render_imports
 
           def serializable_class_attributes
@@ -76,7 +84,11 @@ module Lutaml
           end
 
           def xml_mixed_content? = @spec.mixed
-          def xml_text_content? = @spec.text_content || !!@spec.simple_content || @spec.mixed
+
+          def xml_text_content?
+            @spec.text_content || !!@spec.simple_content || @spec.mixed
+          end
+
           def xml_extra_mappings = ""
 
           def module_opening = ModuleNesting.opening(modules)

data/lib/lutaml/model/schema/renderers/required_files_calculator.rb

@@ -34,7 +34,8 @@ module Lutaml
             Definitions::MemberWalk.each_attribute(model.members) do |attr|
               deps.concat(xml_attribute_requires(attr, skippable_type))
             end
-            deps.concat(simple_content_requires(model.simple_content, skippable_type))
+            deps.concat(simple_content_requires(model.simple_content,
+                                                skippable_type))
             deps << namespace_require(model.namespace_class_name) if model.namespace_class_name
             deps.uniq
           end

data/lib/lutaml/model/schema/renderers.rb

@@ -6,7 +6,8 @@ module Lutaml
       module Renderers
         autoload :Base,         "#{__dir__}/renderers/base"
         autoload :Registration, "#{__dir__}/renderers/registration"
-        autoload :RequiredFilesCalculator, "#{__dir__}/renderers/required_files_calculator"
+        autoload :RequiredFilesCalculator,
+                 "#{__dir__}/renderers/required_files_calculator"
         autoload :MemberDecls,    "#{__dir__}/renderers/member_decls"
         autoload :Mappings,       "#{__dir__}/renderers/mappings"
         autoload :Model,          "#{__dir__}/renderers/model"

data/lib/lutaml/model/schema/rnc_compiler/source_resolver.rb

@@ -20,9 +20,13 @@ module Lutaml
             if File.file?(expanded)
               return file_source(expanded) if input.nil? || input.to_s.empty?
 
-              return string_source(input, base_dir: File.dirname(expanded), path: expanded)
+              return string_source(input, base_dir: File.dirname(expanded),
+                                          path: expanded)
+            end
+            if File.directory?(expanded)
+              return string_source(input,
+                                   base_dir: expanded)
             end
-            return string_source(input, base_dir: expanded) if File.directory?(expanded)
 
             string_source(input)
           end

data/lib/lutaml/model/schema/rnc_compiler.rb

@@ -47,7 +47,9 @@ module Lutaml
         # the 0.3.7 release; the released parse_rnc takes only `(rnc)`.
         def rnc_parser_available?
           defined?(::Rng::Grammar) && ::Rng.respond_to?(:parse_rnc) &&
-            ::Rng.method(:parse_rnc).parameters.any? { |_type, name| name == :location }
+            ::Rng.method(:parse_rnc).parameters.any? do |_type, name|
+              name == :location
+            end
         end
 
         def default_output_dir

data/lib/lutaml/model/schema/rng_compiler/element_visitor.rb

@@ -23,8 +23,10 @@ module Lutaml
           ].freeze
 
           REPETITION_CTX = {
-            zeroOrMore: { collection: (0..Float::INFINITY), initialize_empty: true },
-            oneOrMore: { collection: (1..Float::INFINITY), initialize_empty: true },
+            zeroOrMore: { collection: (0..Float::INFINITY),
+                          initialize_empty: true },
+            oneOrMore: { collection: (1..Float::INFINITY),
+                         initialize_empty: true },
             list: { collection: (0..Float::INFINITY), initialize_empty: true },
           }.freeze
 
@@ -60,7 +62,8 @@ module Lutaml
             class_name = Utils.camel_case(element.attr_name)
             model = @classes[class_name] ||= Definitions::Model.new(
               class_name: class_name,
-              xml_root: Definitions::XmlRoot.new(kind: :element, name: element.attr_name),
+              xml_root: Definitions::XmlRoot.new(kind: :element,
+                                                 name: element.attr_name),
               documentation: documentation_text(element),
               namespace_class_name: namespace_class_for(element),
             )
@@ -90,7 +93,8 @@ module Lutaml
             wrapping = define.element.size == 1 ? define.element.first : nil
 
             xml_root = if wrapping
-                         Definitions::XmlRoot.new(kind: :element, name: wrapping.attr_name)
+                         Definitions::XmlRoot.new(kind: :element,
+                                                  name: wrapping.attr_name)
                        else
                          Definitions::XmlRoot.new(kind: :fragment)
                        end
@@ -198,22 +202,30 @@ module Lutaml
             doc = documentation_text(child)
             value_type = @value_type_resolver.resolve(child)
             type_ref = type_ref_for_element(child, value_type)
-            push_attribute(parent, build_attribute(child, type_ref, :element, ctx, doc))
+            push_attribute(parent,
+                           build_attribute(child, type_ref, :element, ctx, doc))
           end
 
           def type_ref_for_element(child, value_type)
-            return Definitions::TypeRef.new(kind: :symbol, value: value_type.to_s) if value_type
+            if value_type
+              return Definitions::TypeRef.new(kind: :symbol,
+                                              value: value_type.to_s)
+            end
 
             compiled = compile_element(child)
-            Definitions::TypeRef.new(kind: :class_ref, value: compiled.class_name)
+            Definitions::TypeRef.new(kind: :class_ref,
+                                     value: compiled.class_name)
           end
 
           def handle_attribute(_kind, child, parent, ctx)
             doc = documentation_text(child)
             symbol = attribute_type_symbol(child)
-            type_ref = Definitions::TypeRef.new(kind: :symbol, value: symbol.to_s)
+            type_ref = Definitions::TypeRef.new(kind: :symbol,
+                                                value: symbol.to_s)
             fixed = fixed_value_default(child)
-            push_attribute(parent, build_attribute(child, type_ref, :attribute, ctx, doc, default: fixed))
+            push_attribute(parent,
+                           build_attribute(child, type_ref, :attribute, ctx,
+                                           doc, default: fixed))
           end
 
           # The attribute's value type, as a Symbol. An attribute in a foreign
@@ -225,7 +237,8 @@ module Lutaml
             uri = foreign_namespace_uri(child)
             return base unless uri
 
-            namespaced_attribute_type(child, base, @register_namespace.call(uri))
+            namespaced_attribute_type(child, base,
+                                      @register_namespace.call(uri))
           end
 
           # Give the attribute's value a namespace via a dedicated generated
@@ -300,19 +313,26 @@ module Lutaml
 
           def handle_ref(_kind, ref, parent, ctx)
             target_define = @defines[ref.name]
-            raise Lutaml::Model::Error, "ref to unknown define: #{ref.name}" unless target_define
+            unless target_define
+              raise Lutaml::Model::Error,
+                    "ref to unknown define: #{ref.name}"
+            end
 
             target_class = compile_define(target_define)
 
             if RngHelpers.simple_type?(target_class)
-              type_ref = Definitions::TypeRef.new(kind: :symbol, value: RngHelpers.type_symbol(target_class.class_name).to_s)
-              push_attribute(parent, build_ref_attribute(ref, type_ref, ref.name, ctx))
+              type_ref = Definitions::TypeRef.new(kind: :symbol,
+                                                  value: RngHelpers.type_symbol(target_class.class_name).to_s)
+              push_attribute(parent,
+                             build_ref_attribute(ref, type_ref, ref.name, ctx))
             elsif RngHelpers.fragment_model?(target_class) && ctx[:collection].nil?
               push_import(parent, target_class.class_name)
             else
-              type_ref = Definitions::TypeRef.new(kind: :class_ref, value: target_class.class_name)
+              type_ref = Definitions::TypeRef.new(kind: :class_ref,
+                                                  value: target_class.class_name)
               xml_name = target_class.xml_root.name || ref.name
-              push_attribute(parent, build_ref_attribute(ref, type_ref, xml_name, ctx))
+              push_attribute(parent,
+                             build_ref_attribute(ref, type_ref, xml_name, ctx))
             end
           end
 

data/lib/lutaml/model/schema/rng_compiler/value_type_resolver.rb

@@ -57,14 +57,16 @@ module Lutaml
             base = RngCompiler::DATA_TYPE_MAP.fetch(
               data.type, RngCompiler::DEFAULT_DATA_TYPE
             )
-            anonymous_restricted_type(container, base, RngHelpers.facet_from_data(data))
+            anonymous_restricted_type(container, base,
+                                      RngHelpers.facet_from_data(data))
           end
 
           def anonymous_from_enum_choice(container)
             choice = RngHelpers.single(container.choice)
             return nil unless choice && RngHelpers.pure_value_choice?(choice)
 
-            anonymous_restricted_type(container, :string, RngHelpers.facet_from_values(choice.value))
+            anonymous_restricted_type(container, :string,
+                                      RngHelpers.facet_from_values(choice.value))
           end
 
           def anonymous_restricted_type(container, base, facet)

data/lib/lutaml/model/schema/rng_compiler.rb

@@ -20,8 +20,9 @@ module Lutaml
         autoload :MemberCollector,   "#{__dir__}/rng_compiler/member_collector"
         autoload :ElementVisitor,    "#{__dir__}/rng_compiler/element_visitor"
         autoload :DefineClassifier,  "#{__dir__}/rng_compiler/define_classifier"
-        autoload :ValueTypeResolver, "#{__dir__}/rng_compiler/value_type_resolver"
-        autoload :RngHelpers,        "#{__dir__}/rng_compiler/rng_helpers"
+        autoload :ValueTypeResolver,
+                 "#{__dir__}/rng_compiler/value_type_resolver"
+        autoload :RngHelpers, "#{__dir__}/rng_compiler/rng_helpers"
 
         # Map RNG <data type="..."/> values to Lutaml::Model attribute type
         # symbols. Mirrors Lutaml::Xml::Schema::RelaxngSchema.get_relaxng_type
@@ -59,7 +60,9 @@ module Lutaml
           classes, namespaces = compile_grammar(grammar)
 
           entries =
-            classes.map { |name, spec| CompiledOutput::Entry.new(name, spec, :model) } +
+            classes.map do |name, spec|
+              CompiledOutput::Entry.new(name, spec, :model)
+            end +
             namespaces.map { |name, spec| CompiledOutput::Entry.new(name, spec, :namespace) }
 
           CompiledOutput.new(
@@ -89,7 +92,8 @@ module Lutaml
           return rng if rng.is_a?(::Rng::Grammar)
 
           if options[:location]
-            ::Rng.parse(rng, location: options[:location], resolve_external: true)
+            ::Rng.parse(rng, location: options[:location],
+                             resolve_external: true)
           else
             ::Rng::Grammar.from_xml(rng)
           end
@@ -165,7 +169,8 @@ module Lutaml
           ns = Definitions::Namespace.new(
             class_name: class_name,
             uri: uri,
-            prefix_default: unique_prefix(namespaces, NamespaceNaming.prefix_for(uri)),
+            prefix_default: unique_prefix(namespaces,
+                                          NamespaceNaming.prefix_for(uri)),
             element_form_default: :qualified,
           )
           namespaces[class_name] = ns