lutaml-model 0.8.19 → 0.8.23

data/spec/lutaml/model/json_state_nesting_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# json 3.0 removed JSON::State#[]. Ruby's generator passes a JSON::State to
+# #to_json whenever a model is nested inside another JSON.generate call, so the
+# model layer must not read option keys off it.
+RSpec.describe "a model nested inside JSON.generate" do
+  before do
+    stub_const("JsonStateNestingModel", Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :age, :integer
+    end)
+  end
+
+  let(:model) { JsonStateNestingModel.new(name: "John", age: 30) }
+
+  it "serializes inside a Hash" do
+    expect(JSON.generate({ "person" => model }))
+      .to eq('{"person":{"name":"John","age":30}}')
+  end
+
+  it "serializes inside an Array" do
+    expect(JSON.generate([model])).to eq('[{"name":"John","age":30}]')
+  end
+
+  # The generator's JSON::State carries the surrounding indent context. It has
+  # to reach the adapter, not be discarded, or a nested model silently renders
+  # compact inside an otherwise pretty document. Reference values are the
+  # output of unmodified main on json 2.20.0.
+  it "inherits the surrounding indent inside a pretty Hash" do
+    expect(JSON.pretty_generate({ "person" => model }))
+      .to eq(%({\n  "person": {\n    "name": "John",\n    "age": 30\n  }\n}))
+  end
+
+  it "inherits the surrounding indent inside a pretty Array" do
+    expect(JSON.pretty_generate([model]))
+      .to eq(%([\n  {\n    "name": "John",\n    "age": 30\n  }\n]))
+  end
+
+  it "still honours LutaML's own options when called directly" do
+    expect(model.to_json(pretty: true))
+      .to eq(%({\n  "name": "John",\n  "age": 30\n}))
+  end
+
+  # A non-Hash options argument must be replaced, not merely captured -- a
+  # falsy one (nil, false) previously stayed in place and the next line called
+  # .delete on it.
+  it "does not raise on a nil options argument" do
+    expect(model.to_json(nil)).to eq('{"name":"John","age":30}')
+  end
+
+  it "does not raise on a false options argument" do
+    expect(model.to_json(false)).to eq('{"name":"John","age":30}')
+  end
+
+  # A non-Hash options argument reaches every format, not just JSON, so the
+  # normalisation must not skip format-specific validation on the way past.
+  # A type-only model has no root mapping and must refuse to serialise alone.
+  it "still applies XML root validation to a non-Hash argument" do
+    stub_const("TypeOnlyModel", Class.new(Lutaml::Model::Serializable) do
+      attribute :n, :string
+    end)
+
+    expect { TypeOnlyModel.new(n: "a").to_xml(nil) }
+      .to raise_error(Lutaml::Model::TypeOnlyMappingError)
+  end
+
+  # Every example above goes through an INSTANCE entry point. The class-level
+  # one normalises separately, and deleting that normaliser leaves them all
+  # green.
+  it "normalises a state passed to the class-level entry point" do
+    state = JSON::State.new(indent: "  ", object_nl: "\n", space: " ")
+
+    expect(JsonStateNestingModel.to_json(model, state))
+      .to eq(%({\n  "name": "John",\n  "age": 30\n}))
+  end
+
+  it "leaves non-JSON formats untouched" do
+    expect(model.to_yaml).to eq("---\nname: John\nage: 30\n")
+  end
+end

data/spec/lutaml/model/serialize/builder_spec.rb

@@ -112,7 +112,8 @@ RSpec.describe "Lutaml::Model::Serialize::Builder" do
           <items>c</items>
         </container>
       XML
-      expect(obj.element_order.map(&:name)).to eq(%w[singular items items items])
+      expect(obj.element_order.map(&:name)).to eq(%w[singular items items
+                                                     items])
     end
 
     it "all direct setters: emits in call order" do
@@ -298,7 +299,8 @@ RSpec.describe "Lutaml::Model::Serialize::Builder" do
       # so both assignments are recorded. The serializer emits the current
       # value of the attribute via element_order in recorded order; the
       # safety net guarantees no data loss.
-      expect(obj.element_order.map(&:name)).to eq(%w[items items items items items])
+      expect(obj.element_order.map(&:name)).to eq(%w[items items items items
+                                                     items])
       xml = obj.to_xml
       # The serialized output must contain all current items
       expect(xml).to include("<items>c</items>")
@@ -317,7 +319,8 @@ RSpec.describe "Lutaml::Model::Serialize::Builder" do
         xml = obj.to_xml
 
         if !obj.singular.nil? && !obj.singular.to_s.empty?
-          expect(xml).to include("<singular>"), "singular was dropped from output"
+          expect(xml).to include("<singular>"),
+                         "singular was dropped from output"
         end
         return if obj.items.nil? || obj.items.empty?
 

data/spec/lutaml/model/store_spec.rb

@@ -43,7 +43,9 @@ RSpec.describe Lutaml::Model::Store do
 
   describe "indexed lookup" do
     it "builds index lazily on first resolve" do
-      5.times { |i| model_class.new(id: "obj-#{i}") }
+      # Hold strong references: Store keeps WeakRefs, so unreferenced
+      # objects can be collected before resolve runs.
+      _objects = Array.new(5) { |i| model_class.new(id: "obj-#{i}") }
 
       result = described_class.resolve(model_class, :id, "obj-3")
       expect(result.id).to eq("obj-3")

data/spec/lutaml/model/transform_apply_value_map_spec.rb

@@ -33,7 +33,8 @@ RSpec.describe Lutaml::Model::Transform, "#apply_value_map (nil attr)" do
     end
 
     it "passes initialized values through unchanged" do
-      expect(transform.apply_value_map("hello", default_vmap, nil)).to eq("hello")
+      expect(transform.apply_value_map("hello", default_vmap,
+                                       nil)).to eq("hello")
     end
   end
 
@@ -50,11 +51,13 @@ RSpec.describe Lutaml::Model::Transform, "#apply_value_map (nil attr)" do
   # custom method runs), and resolved :nil/:empty consistently for empty inputs.
   describe "non-:nil options with nil attr" do
     it "maps a nil value to uninitialized via nil: :omitted" do
-      expect(transform.apply_value_map(nil, { nil: :omitted }, nil)).to eq(uninit)
+      expect(transform.apply_value_map(nil, { nil: :omitted },
+                                       nil)).to eq(uninit)
     end
 
     it "maps an empty value to uninitialized via empty: :omitted" do
-      expect(transform.apply_value_map("", { empty: :omitted }, nil)).to eq(uninit)
+      expect(transform.apply_value_map("", { empty: :omitted },
+                                       nil)).to eq(uninit)
     end
 
     it "maps an empty value to nil via empty: :nil" do

data/spec/lutaml/model/union_attribute_spec.rb

@@ -311,7 +311,8 @@ RSpec.describe "Union-typed attributes (issue #190)" do
     it "serializes a model member built in plain Ruby identically to a deserialized one" do
       built = UnionAttributeSpec::Ceramic.new(
         firing_temperature:
-          UnionAttributeSpec::TemperatureWithUnit.new(number: 1300.0, unit: "C"),
+          UnionAttributeSpec::TemperatureWithUnit.new(number: 1300.0,
+                                                      unit: "C"),
       )
       round = UnionAttributeSpec::Ceramic.from_yaml(built.to_yaml)
       expect(round.firing_temperature)
@@ -424,7 +425,8 @@ RSpec.describe "Union-typed attributes (issue #190)" do
     end
 
     it "rejects unsupported scalar member types at definition time" do
-      %i[hash symbol time time_without_date date date_time].each do |unsupported|
+      %i[hash symbol time time_without_date date
+         date_time].each do |unsupported|
         expect do
           Class.new(Lutaml::Model::Serializable) do
             attribute :bad, [unsupported, :string]

data/spec/lutaml/model/value_policy_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+module ValuePolicySpec
+  # A value type whose whole purpose is to wrap any literal:
+  # scalar, list, or map (issue #752).
+  class LiteralValue < Lutaml::Model::Type::Value
+  end
+
+  class LiteralDoc < Lutaml::Model::Serializable
+    attribute :v, LiteralValue
+    key_value do
+      map "v", to: :v
+    end
+  end
+
+  class StringsDoc < Lutaml::Model::Serializable
+    attribute :v, :string
+    key_value do
+      map "v", to: :v
+    end
+  end
+
+  class CollectionDoc < Lutaml::Model::Serializable
+    attribute :v, :string, collection: true
+    key_value do
+      map "v", to: :v
+    end
+  end
+end
+
+RSpec.describe "ValuePolicy shaping of non-collection attributes" do
+  describe "user-defined Type::Value subclass" do
+    it "receives the whole array from key-value data" do
+      expect(ValuePolicySpec::LiteralDoc.from_yaml("v: [a, b]").v)
+        .to eq(["a", "b"])
+    end
+
+    it "receives an empty array from key-value data" do
+      expect(ValuePolicySpec::LiteralDoc.from_yaml("v: []").v).to eq([])
+    end
+
+    it "receives the whole hash from key-value data" do
+      v = ValuePolicySpec::LiteralDoc.from_yaml("v: {a: 1}").v
+      expect(v.value).to eq("a" => 1)
+    end
+
+    it "keeps scalar behavior" do
+      doc = ValuePolicySpec::LiteralDoc.from_yaml(<<~YAML)
+        v: hello
+      YAML
+      expect(doc.v).to eq("hello")
+    end
+
+    it "round-trips an array value through YAML" do
+      doc = ValuePolicySpec::LiteralDoc.from_yaml("v: [a, b]")
+      expect(ValuePolicySpec::LiteralDoc.from_yaml(doc.to_yaml).v)
+        .to eq(["a", "b"])
+    end
+
+    it "accepts an array assigned after construction" do
+      doc = ValuePolicySpec::LiteralDoc.new(v: "seed")
+      doc.v = ["a", "b"]
+      expect(doc.v).to eq(["a", "b"])
+    end
+  end
+
+  describe "built-in scalar types" do
+    it "keep the collection: true guidance error" do
+      expect { ValuePolicySpec::StringsDoc.from_yaml("v: [a]") }
+        .to raise_error(Lutaml::Model::CollectionTrueMissingError)
+    end
+  end
+
+  describe "collection attributes" do
+    it "keep element-wise casting" do
+      expect(ValuePolicySpec::CollectionDoc.from_yaml("v: [a, b]").v)
+        .to eq(["a", "b"])
+    end
+  end
+end

data/spec/lutaml/require_load_order_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string: true
+
+require "spec_helper"
+
+# lutaml-model: every public format entrypoint and `require "lutaml/model"`
+# itself must not produce "circular require considered harmful" warnings
+# under ruby -w (regression guard after the public-wrapper/internal-format
+# restructuring).
+RSpec.describe "require load order" do
+  it "loads lutaml/model with no circular-require warnings under -w" do
+    output = `bundle exec ruby -w -e 'require "lutaml/model"' 2>&1`
+    circular = output.lines.count { |l| l.include?("circular require considered harmful") }
+    expect(circular).to eq(0),
+      "Expected no circular-require warnings, got #{circular}:\n#{output}"
+  end
+
+  %w[json key_value yaml toml hash_format jsonl yamls xml].each do |format|
+    it "loads lutaml/#{format} standalone without circular-require warnings" do
+      output = `bundle exec ruby -w -e 'require "lutaml/#{format}"' 2>&1`
+      circular = output.lines.count { |l| l.include?("circular require considered harmful") }
+      expect(circular).to eq(0),
+        "Expected no circular-require warnings loading lutaml/#{format}, got #{circular}:\n#{output}"
+    end
+  end
+end

data/spec/lutaml/xml/attribute_element_namespace_disjoint_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string: true
+
+require "spec_helper"
+require_relative "../../../lib/lutaml/model"
+
+# lutaml-model#758: a plain (unnamespaced) map_attribute rule on an
+# element-namespaced class must not absorb a namespaced sibling attribute
+# (and vice versa), and a type-level `namespace :blank` must not crash.
+module ElementNsDisjointSpec
+  class XmiNs < Lutaml::Xml::Namespace
+    uri "http://www.example.com/xmi"
+    prefix_default "xmi"
+  end
+
+  class ElemNs < Lutaml::Xml::Namespace
+    uri "http://www.example.com/elem"
+    prefix_default "e"
+  end
+
+  class XmiTypeAttr < Lutaml::Model::Type::String
+    xml do
+      namespace XmiNs
+    end
+  end
+
+  class DocBase < Lutaml::Model::Serializable
+    attribute :xmi_type, XmiTypeAttr
+
+    xml do
+      namespace ElemNs
+      map_attribute "type", to: :xmi_type
+    end
+  end
+
+  class Doc < DocBase
+    attribute :plain_type, Lutaml::Model::Type::String
+
+    xml do
+      root "doc"
+      map_attribute "type", to: :plain_type
+    end
+  end
+
+  class BlankType < Lutaml::Model::Type::String
+    xml do
+      namespace :blank
+    end
+  end
+
+  class BlankDoc < Lutaml::Model::Serializable
+    attribute :v, BlankType
+    xml do
+      root "bd"
+      map_attribute "v", to: :v
+    end
+  end
+end
+
+RSpec.describe "attribute namespace-disjointness on element-namespaced classes (#758)" do
+  it "routes xmi:type to the namespaced slot and leaves plain_type nil" do
+    doc = ElementNsDisjointSpec::Doc.from_xml(
+      %(<doc xmlns:xmi="http://www.example.com/xmi" xmi:type="uml:Parameter"/>),
+    )
+    expect(doc.xmi_type).to eq("uml:Parameter")
+    expect(doc.plain_type).to be_nil
+  end
+
+  it "routes an unprefixed type to plain_type, leaves xmi_type nil" do
+    doc = ElementNsDisjointSpec::Doc.from_xml(%(<doc type="EAnone_void"/>))
+    expect(doc.plain_type).to eq("EAnone_void")
+    expect(doc.xmi_type).to be_nil
+  end
+
+  it "round-trips both spellings without emitting a spurious duplicate" do
+    doc = ElementNsDisjointSpec::Doc.from_xml(
+      %(<doc xmlns:xmi="http://www.example.com/xmi" xmi:type="uml:Parameter"/>),
+    )
+    out = doc.to_xml.strip
+    expect(out).to include('xmi:type="uml:Parameter"')
+    expect(out).not_to match(/\stype="uml:Parameter"/)
+  end
+
+  it "survives type-level namespace :blank without crashing" do
+    expect do
+      ElementNsDisjointSpec::BlankDoc.from_xml(%(<bd v="x"/>))
+    end.not_to raise_error
+  end
+end

data/spec/lutaml/xml/attribute_namespace_disjointness_spec.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Two map_attribute rules that share a local name but are distinguished by
+# their type classes' bound namespaces must parse disjointly, mirroring
+# serialization (lutaml-model#744).
+#
+# The coexisting-spelling cases under nokogiri/rexml additionally require the
+# moxml adapter fixes (lutaml/moxml#94, lutaml/moxml#95); oga and ox already
+# preserve same-local-name attributes across namespaces.
+module AttributeNamespaceDisjointnessSpec
+  class XmiNs < Lutaml::Xml::Namespace
+    uri "http://www.example.com/xmi"
+    prefix_default "xmi"
+  end
+
+  class XmiNsType < Lutaml::Model::Type::String
+    xml do
+      namespace XmiNs
+    end
+  end
+
+  class Probe < Lutaml::Model::Serializable
+    attribute :xmi_type, XmiNsType
+    attribute :plain_type, Lutaml::Model::Type::String
+
+    xml do
+      element "probe"
+      map_attribute "type", to: :xmi_type
+      map_attribute "type", to: :plain_type
+    end
+  end
+
+  def self.parse(xml, adapter)
+    Lutaml::Model::Config.with_adapter(xml: adapter) { Probe.from_xml(xml) }
+  end
+end
+
+RSpec.describe "Attribute namespace-disjoint parsing" do
+  let(:namespaced_xmi) do
+    %(<probe xmlns:xmi="http://www.example.com/xmi" xmi:type="uml:Parameter"/>)
+  end
+
+  let(:namespaced_foo) do
+    %(<probe xmlns:foo="http://www.example.com/xmi" foo:type="uml:Parameter"/>)
+  end
+
+  let(:plain) { %(<probe type="EAnone_void"/>) }
+
+  let(:both_spellings) do
+    %(<probe xmlns:xmi="http://www.example.com/xmi" xmi:type="uml:Parameter" type="EAnone_void"/>)
+  end
+
+  let(:both_spellings_plain_first) do
+    %(<probe type="EAnone_void" xmlns:xmi="http://www.example.com/xmi" xmi:type="uml:Parameter"/>)
+  end
+
+  %i[oga ox nokogiri].each do |adapter|
+    context "with the #{adapter} adapter" do
+      it "routes a namespaced rule to the attribute bound to its URI" do
+        probe = AttributeNamespaceDisjointnessSpec.parse(namespaced_xmi,
+                                                         adapter)
+
+        expect(probe.xmi_type).to eq("uml:Parameter")
+        expect(probe.plain_type).to be_nil
+      end
+
+      it "accepts any prefix bound to the namespace URI" do
+        probe = AttributeNamespaceDisjointnessSpec.parse(namespaced_foo,
+                                                         adapter)
+
+        expect(probe.xmi_type).to eq("uml:Parameter")
+        expect(probe.plain_type).to be_nil
+      end
+
+      it "does not let a namespace-less attribute satisfy the namespaced rule" do
+        probe = AttributeNamespaceDisjointnessSpec.parse(plain, adapter)
+
+        expect(probe.xmi_type).to be_nil
+        expect(probe.plain_type).to eq("EAnone_void")
+      end
+    end
+  end
+
+  # Same-local-name attributes coexisting on one element require the moxml
+  # fixes (lutaml/moxml#94 drops one under nokogiri; lutaml/moxml#95 crashes
+  # under rexml), so these cases run on the adapters that preserve both.
+  %i[oga ox].each do |adapter|
+    context "with the #{adapter} adapter" do
+      it "keeps both spellings disjoint regardless of document order" do
+        [both_spellings, both_spellings_plain_first].each do |xml|
+          probe = AttributeNamespaceDisjointnessSpec.parse(xml, adapter)
+
+          expect(probe.xmi_type).to eq("uml:Parameter")
+          expect(probe.plain_type).to eq("EAnone_void")
+        end
+      end
+    end
+  end
+
+  describe "serialization" do
+    it "writes each rule in its own namespace" do
+      probe = AttributeNamespaceDisjointnessSpec::Probe.new(
+        xmi_type: "uml:Parameter",
+        plain_type: "EAnone_void",
+      )
+
+      expect(probe.to_xml.strip).to be_xml_equivalent_to(
+        %(<probe xmlns:xmi="http://www.example.com/xmi" xmi:type="uml:Parameter" type="EAnone_void"/>),
+      )
+    end
+
+    it "round-trips both spellings through parsing" do
+      probe = AttributeNamespaceDisjointnessSpec::Probe.new(
+        xmi_type: "uml:Parameter",
+        plain_type: "EAnone_void",
+      )
+      reparsed = AttributeNamespaceDisjointnessSpec.parse(probe.to_xml, :oga)
+
+      expect(reparsed.xmi_type).to eq("uml:Parameter")
+      expect(reparsed.plain_type).to eq("EAnone_void")
+    end
+  end
+end

data/spec/lutaml/xml/out_of_namespace_parsing_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# lutaml-model#754: parsing a document whose elements live in a namespace
+# different from the model's bound namespace must not silently drop
+# element content. The document's own namespace is adopted as an implicit
+# alias of the model's namespace for the duration of the parse, so
+# lenient (out-of-namespace) parsing is lossless for element content the
+# way in-namespace parsing is.
+module OutOfNamespaceParsingSpec
+  class Gml32 < Lutaml::Xml::Namespace
+    uri "http://www.opengis.net/gml/3.2"
+    prefix_default "gml"
+  end
+
+  class Code < Lutaml::Model::Serializable
+    attribute :value, :string
+
+    xml do
+      root "name"
+      namespace Gml32
+      map_content to: :value
+    end
+  end
+
+  class EntryDefinition < Lutaml::Model::Serializable
+    attribute :description, :string
+    attribute :name, Code, collection: true
+
+    xml do
+      element "Definition"
+      namespace Gml32
+      map_element "description", to: :description
+      map_element "name", to: :name
+    end
+  end
+
+  class DictionaryEntry < Lutaml::Model::Serializable
+    attribute :definition, EntryDefinition
+
+    xml do
+      element "dictionaryEntry"
+      namespace Gml32
+      map_element "Definition", to: :definition
+    end
+  end
+
+  class Dictionary < Lutaml::Model::Serializable
+    attribute :name, Code, collection: true
+    attribute :dictionary_entry, DictionaryEntry, collection: true
+
+    xml do
+      element "Dictionary"
+      namespace Gml32
+      map_element "name", to: :name
+      map_element "dictionaryEntry", to: :dictionary_entry
+    end
+  end
+
+  def self.gml_doc(uri)
+    <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <gml:Dictionary xmlns:gml="#{uri}">
+        <gml:name>codes</gml:name>
+        <gml:dictionaryEntry>
+          <gml:Definition>
+            <gml:description>first</gml:description>
+            <gml:name>ONE</gml:name>
+          </gml:Definition>
+        </gml:dictionaryEntry>
+      </gml:Dictionary>
+    XML
+  end
+end
+
+RSpec.describe "out-of-namespace document parsing" do
+  let(:in_namespace_xml) { OutOfNamespaceParsingSpec.gml_doc("http://www.opengis.net/gml/3.2") }
+  let(:out_of_namespace_xml) { OutOfNamespaceParsingSpec.gml_doc("http://www.opengis.net/gml") }
+
+  it "parses simple-type element content from a document in the bound namespace" do
+    definition = OutOfNamespaceParsingSpec::Dictionary
+      .from_xml(in_namespace_xml).dictionary_entry.first.definition
+    expect(definition.description).to eq("first")
+  end
+
+  it "keeps simple-type element content when the document namespace differs (#754)" do
+    definition = OutOfNamespaceParsingSpec::Dictionary
+      .from_xml(out_of_namespace_xml).dictionary_entry.first.definition
+    expect(definition.description).to eq("first")
+  end
+
+  it "keeps serializable-typed element content when the document namespace differs" do
+    definition = OutOfNamespaceParsingSpec::Dictionary
+      .from_xml(out_of_namespace_xml).dictionary_entry.first.definition
+    expect(definition.name.map(&:value)).to eq(["ONE"])
+  end
+
+  it "keeps simple-type content at the document root level" do
+    dictionary = OutOfNamespaceParsingSpec::Dictionary.from_xml(out_of_namespace_xml)
+    expect(dictionary.name.map(&:value)).to eq(["codes"])
+  end
+
+  it "does not adopt an unrelated child namespace" do
+    xml = <<~XML
+      <?xml version="1.0" encoding="UTF-8"?>
+      <gml:Dictionary xmlns:gml="http://www.opengis.net/gml"
+                      xmlns:city="http://www.opengis.net/citygml/2.0">
+        <city:name>not mine</city:name>
+      </gml:Dictionary>
+    XML
+    dictionary = OutOfNamespaceParsingSpec::Dictionary.from_xml(xml)
+    expect(dictionary.name).to be_empty
+  end
+
+  it "round-trips out-of-namespace content without losing the description" do
+    dictionary = OutOfNamespaceParsingSpec::Dictionary.from_xml(out_of_namespace_xml)
+    output = dictionary.to_xml(prefix: true)
+    expect(output).to include("first")
+    reparsed = OutOfNamespaceParsingSpec::Dictionary.from_xml(output)
+    expect(reparsed.dictionary_entry.first.definition.description).to eq("first")
+  end
+end

data/spec/lutaml/xml/schema/rnc_compiler_spec.rb

@@ -14,7 +14,9 @@ RSpec.describe Lutaml::Model::Schema::RncCompiler do
 
   describe ".to_models" do
     context "with an RNC schema using named patterns and start |=" do
-      let(:schema) { File.read("spec/fixtures/xml/schema/rnc/address_book.rnc") }
+      let(:schema) do
+        File.read("spec/fixtures/xml/schema/rnc/address_book.rnc")
+      end
       let(:sources) { described_class.to_models(schema) }
 
       it "compiles RNC through the RNG compiler" do
@@ -65,7 +67,9 @@ RSpec.describe Lutaml::Model::Schema::RncCompiler do
 
     context "with create_files output" do
       let(:dir) { Dir.mktmpdir }
-      let(:schema) { File.read("spec/fixtures/xml/schema/rnc/address_book.rnc") }
+      let(:schema) do
+        File.read("spec/fixtures/xml/schema/rnc/address_book.rnc")
+      end
 
       before do
         stub_const("RncAddressBookSpec", Module.new)
@@ -206,7 +210,8 @@ RSpec.describe Lutaml::Model::Schema::RncCompiler do
           "spec/fixtures/xml/schema/rnc/includes/circular_a.rnc"
 
         expect do
-          described_class.to_models(File.read(circular_path), location: circular_path)
+          described_class.to_models(File.read(circular_path),
+                                    location: circular_path)
         end.to raise_error(/circular_a\.rnc/)
       end
     end
@@ -308,7 +313,9 @@ RSpec.describe Lutaml::Model::Schema::RncCompiler do
         # The inline restricted type is subclassed (not mutated) so a fresh
         # namespaced type inherits its constraints and carries the namespace.
         expect(sources["CodeType"]).not_to match(/namespace \w+Namespace/)
-        subclass = sources.keys.find { |k| sources[k].match?(/class \w+ < CodeType/) }
+        subclass = sources.keys.find do |k|
+          sources[k].match?(/class \w+ < CodeType/)
+        end
         expect(subclass).not_to be_nil
         expect(sources[subclass]).to match(/namespace \w+Namespace/)
       end
@@ -323,7 +330,9 @@ RSpec.describe Lutaml::Model::Schema::RncCompiler do
         namespaces = sources.select { |_, v| v.include?("Lutaml::Xml::W3c::XmlNamespace") }
         expect(namespaces.size).to eq(2)
         uris = namespaces.values.map { |v| v[/uri "([^"]+)"/, 1] }
-        prefixes = namespaces.values.map { |v| v[/prefix_default "([^"]+)"/, 1] }
+        prefixes = namespaces.values.map do |v|
+          v[/prefix_default "([^"]+)"/, 1]
+        end
         expect(uris).to contain_exactly("urn:a", "urn:b")
         expect(prefixes.uniq.size).to eq(2)
       end
@@ -341,7 +350,9 @@ RSpec.describe Lutaml::Model::Schema::RncCompiler do
           }
         RNC
 
-        wrapper = sources.keys.find { |k| sources[k].match?(/namespace \w+Namespace/) && !k.include?("Namespace") }
+        wrapper = sources.keys.find do |k|
+          sources[k].match?(/namespace \w+Namespace/) && !k.include?("Namespace")
+        end
         expect(sources[wrapper]).to include("< Lutaml::Model::Type::DateTime")
       end
     end