lutaml-model 0.8.16 → 0.8.18

data/spec/lutaml/xml/namespace_placement_spec.rb

@@ -91,18 +91,21 @@ RSpec.describe "XML Namespace Placement" do
       end
 
       # This is the INCORRECT pattern - namespace at class level for Models
-      broken_model = Class.new do
-        include Lutaml::Model::Serialize
+      broken_model = nil
+      expect do
+        broken_model = Class.new do
+          include Lutaml::Model::Serialize
 
-        namespace ns # ❌ This doesn't work for Serializable classes!
+          namespace ns # ❌ This doesn't work for Serializable classes!
 
-        attribute :value, :string
+          attribute :value, :string
 
-        xml do
-          element "broken"
-          map_content to: :value
+          xml do
+            element "broken"
+            map_content to: :value
+          end
         end
-      end
+      end.to output(/DEPRECATION WARNING.*Class-level.*namespace/).to_stderr
 
       parent_ns = Class.new(Lutaml::Xml::W3c::XmlNamespace) do
         uri "http://example.com/parent"

data/spec/lutaml/xml/namespace_three_phase_spec.rb

@@ -251,7 +251,7 @@ RSpec.describe "Three-phase namespace algorithm" do
         expect(xml).to include("<version>4.0</version>")
 
         # Should NOT add redundant prefix
-        expect(xml).not_to match(/<vcard:version>/)
+        expect(xml).not_to include("<vcard:version>")
       end
     end
   end

data/spec/lutaml/xml/opal_xml_spec.rb

@@ -2,9 +2,13 @@
 
 require "spec_helper"
 
-RSpec.describe "XML with REXML under Opal", if: RUBY_ENGINE == "opal" do
+# Adapter-agnostic XML round-trip scenarios, shared between Oga and
+# REXML smoke runs. Both adapters are pure Ruby and work under Opal;
+# this shared example is the contract that any future Opal-capable
+# adapter would also need to satisfy.
+RSpec.shared_examples "opal XML adapter round-trip" do |adapter_name|
   before do
-    Lutaml::Model::Config.xml_adapter_type = :rexml
+    Lutaml::Model::Config.xml_adapter_type = adapter_name
   end
 
   it "round-trips XML through parse and serialize" do
@@ -118,28 +122,26 @@ RSpec.describe "XML with REXML under Opal", if: RUBY_ENGINE == "opal" do
     expect(xml).to include("<title>Widget</title>")
     expect(xml).to include("<count>5</count>")
   end
+end
 
-  it "handles XmlOrderable on plain model classes" do
-    plain_model = Class.new do
-      attr_accessor :data
-    end
+# Pure-Ruby XML adapters that ship in the Opal bundle. Each nested
+# group runs the shared contract for its adapter; the top-level guard
+# gates the whole file under Opal.
+RSpec.describe "XML adapters under Opal", if: RUBY_ENGINE == "opal" do
+  describe "with Oga (default)" do
+    it_behaves_like "opal XML adapter round-trip", :oga
 
-    Class.new do
-      include Lutaml::Model::Serialize
-
-      const_set(:MODEL_CLASS, plain_model)
-      model plain_model
-      attribute :data, :string
-      xml do
-        element "data"
-        map_element "data", to: :data
-      end
+    it "uses Oga adapter by default under Opal" do
+      expect(Lutaml::Model::Config.xml_adapter_type).to eq(:oga)
     end
-
-    expect(plain_model.ancestors).to include(Lutaml::Xml::XmlOrderable)
   end
 
-  it "uses REXML adapter by default under Opal" do
-    expect(Lutaml::Model::Config.xml_adapter_type).to eq(:rexml)
+  describe "with REXML" do
+    it_behaves_like "opal XML adapter round-trip", :rexml
+
+    it "selects REXML when explicitly configured" do
+      Lutaml::Model::Config.xml_adapter_type = :rexml
+      expect(Lutaml::Model::Config.xml_adapter_type).to eq(:rexml)
+    end
   end
 end

data/spec/lutaml/xml/prefix_control_spec.rb

@@ -100,8 +100,8 @@ RSpec.describe "XML Prefix Control" do
           expect(xml).to include('<custom:Properties xmlns:custom="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties">')
           expect(xml).to include("<custom:Template>Normal.dotm</custom:Template>")
           # Should not have redundant declarations
-          expect(xml).not_to match(/xmlns="/)
-          expect(xml).not_to match(/xmlns:app=/)
+          expect(xml).not_to include('xmlns="')
+          expect(xml).not_to include("xmlns:app=")
         end
       end
 
@@ -208,8 +208,8 @@ RSpec.describe "XML Prefix Control" do
           expect(xml).to include('<custom:Properties xmlns:custom="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties">')
           expect(xml).to include("<custom:Template>Normal.dotm</custom:Template>")
           # Should not have redundant declarations
-          expect(xml).not_to match(/xmlns="/)
-          expect(xml).not_to match(/xmlns:app=/)
+          expect(xml).not_to include('xmlns="')
+          expect(xml).not_to include("xmlns:app=")
         end
       end
 

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

@@ -41,8 +41,9 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
     it "keeps built-in W3C XML attribute types when processing xml.xsd" do
       described_class.as_models(xml_namespace_schema)
 
-      expect(described_class.attributes["id"].type)
-        .to eq("Lutaml::Xml::W3c::XmlIdType")
+      type_ref = described_class.builder.attributes["id"].type
+      expect(type_ref.kind).to eq(:w3c)
+      expect(type_ref.value).to eq("Lutaml::Xml::W3c::XmlIdType")
     end
   end
 
@@ -227,8 +228,7 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
         end
 
         let(:expected_classes) do
-          types = described_class::SimpleType::SUPPORTED_DATA_TYPES
-          classes = types.filter_map do |name, value|
+          classes = described_class::SupportedDataTypes::TABLE.filter_map do |name, value|
             name.to_s unless value[:skippable]
           end
           classes << "User"
@@ -751,4 +751,21 @@ RSpec.describe Lutaml::Model::Schema::XmlCompiler do
       end
     end
   end
+
+  describe "SupportedDataTypes.skippable?" do
+    # Attribute TypeRefs store the snake_case rendering, simple_content
+    # keeps the XSD spelling; skippable? must accept both for dateTime,
+    # the one skippable name that changes under snake_case.
+    it "matches both the XSD and snake_case spelling of skippable types" do
+      sdt = described_class::SupportedDataTypes
+      expect(sdt.skippable?("dateTime")).to be true
+      expect(sdt.skippable?("date_time")).to be true
+    end
+
+    it "still rejects non-skippable types in both spellings" do
+      sdt = described_class::SupportedDataTypes
+      expect(sdt.skippable?("nonNegativeInteger")).to be false
+      expect(sdt.skippable?("non_negative_integer")).to be false
+    end
+  end
 end

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

@@ -0,0 +1,404 @@
+require "rng"
+require "spec_helper"
+require "lutaml/model/schema"
+require "tmpdir"
+
+RSpec.describe Lutaml::Model::Schema::RncCompiler do
+  before do
+    default_ctx = Lutaml::Model::GlobalContext.context(:default)
+    if default_ctx
+      default_ctx.registry.clear
+      Lutaml::Model::Type.register_builtin_types_in(default_ctx.registry)
+    end
+  end
+
+  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(:sources) { described_class.to_models(schema) }
+
+      it "compiles RNC through the RNG compiler" do
+        expect(sources.keys).to contain_exactly(
+          "AddressBook", "Card", "Name", "Email"
+        )
+        expect(sources["AddressBook"]).to include("class AddressBook")
+        expect(sources["AddressBook"]).to include('map_element "card", to: :card')
+      end
+
+      it "does not emit a synthetic Start class for the RNC start pattern" do
+        expect(sources).not_to have_key("Start")
+      end
+    end
+
+    context "with an inline start containing a named reference" do
+      let(:schema) do
+        <<~RNC
+          item = element item { text }
+          start = element root { item* }
+        RNC
+      end
+
+      it "generates the root model, not just the referenced child" do
+        sources = described_class.to_models(schema)
+
+        expect(sources.keys).to contain_exactly("Root", "Item")
+        expect(sources["Root"]).to include("class Root")
+        expect(sources["Root"]).to include('map_element "item", to: :item')
+      end
+    end
+
+    context "with a ref-only inline start defined after its target" do
+      let(:schema) do
+        <<~RNC
+          library = element library { text }
+          start = library
+        RNC
+      end
+
+      it "roots the referenced define without emitting a Start class" do
+        sources = described_class.to_models(schema)
+
+        expect(sources.keys).to include("Library")
+        expect(sources).not_to have_key("Start")
+      end
+    end
+
+    context "with create_files output" do
+      let(:dir) { Dir.mktmpdir }
+      let(:schema) { File.read("spec/fixtures/xml/schema/rnc/address_book.rnc") }
+
+      before do
+        stub_const("RncAddressBookSpec", Module.new)
+        described_class.to_models(
+          schema,
+          output_dir: dir,
+          create_files: true,
+          module_namespace: "RncAddressBookSpec",
+        )
+        require File.join(dir, "rncaddressbookspec_registry.rb")
+        RncAddressBookSpec.register_all
+      end
+
+      after do
+        FileUtils.rm_rf(dir)
+      end
+
+      it "writes namespaced files and registry output" do
+        module_dir = File.join(dir, "rncaddressbookspec")
+        expect(File).to exist(File.join(dir, "rncaddressbookspec_registry.rb"))
+        expect(File).to exist(File.join(module_dir, "address_book.rb"))
+        expect(File).to exist(File.join(module_dir, "card.rb"))
+      end
+
+      it "loads generated classes that can parse XML" do
+        xml = <<~XML
+          <addressBook>
+            <card>
+              <name>Alice</name>
+              <email>alice@example.com</email>
+            </card>
+          </addressBook>
+        XML
+
+        book = RncAddressBookSpec::AddressBook.from_xml(xml)
+        expect(book.card.first.name.content).to eq("Alice")
+        expect(book.card.first.email.content).to eq("alice@example.com")
+      end
+    end
+
+    context "with RNC-specific syntax used by RFC XML schemas" do
+      let(:sources) do
+        described_class.to_models(
+          File.read("spec/fixtures/xml/schema/rnc/book_features.rnc"),
+        )
+      end
+
+      it "accepts compatibility annotations before attributes" do
+        expect(sources["Book"]).to include("class Book")
+        expect(sources["Book"]).to include('map_attribute "format", to: :format')
+      end
+
+      it "treats an attribute choice mixing text with a fixed value as a string" do
+        expect(sources["Book"]).to include("attribute :indent, :string")
+        expect(sources["Book"]).to include('map_attribute "indent", to: :indent')
+        expect(sources.keys).not_to include("IndentType")
+      end
+
+      it "preserves xml-prefixed attributes in the XML mapping" do
+        expect(sources["Book"]).to include("attribute :xml_lang")
+        expect(sources["Book"]).to include('map_attribute "xml:lang", to: :xml_lang')
+      end
+
+      it "normalizes escaped identifiers into generated class names" do
+        expect(sources.keys).to include("List")
+        expect(sources["Book"]).to include("attribute :list, List")
+      end
+
+      it "loads generated classes that parse normalized RNC mappings" do
+        stub_const("RncFeatureSpec", Module.new)
+        described_class.to_models(
+          File.read("spec/fixtures/xml/schema/rnc/book_features.rnc"),
+          load_classes: true,
+          module_namespace: "RncFeatureSpec",
+        )
+
+        xml = <<~XML
+          <book xml:lang="en" indent="adaptive">
+            <title>Example</title>
+            <list>
+              <item>First</item>
+              <item>Second</item>
+            </list>
+          </book>
+        XML
+
+        book = RncFeatureSpec::Book.from_xml(xml)
+        expect(book.xml_lang).to eq("en")
+        expect(book.indent).to eq("adaptive")
+        expect(book.title.content).to eq("Example")
+        expect(book.list.item.map(&:content)).to eq(%w[First Second])
+      end
+
+      it "does not rewrite attributes with nested datatype parameter braces" do
+        source = <<~RNC
+          root =
+            element root {
+              attribute code { xsd:string { pattern = "[A-Z]+" } }
+            }
+
+          start |= root
+        RNC
+
+        sources = described_class.to_models(source)
+
+        expect(sources.keys).to include("Root", "CodeType")
+        expect(sources["Root"]).to include("attribute :code, :code_type")
+        # The `[A-Z]` inside the string literal must survive: if annotation
+        # stripping wrongly treated `[` in the string as a bracket annotation,
+        # the pattern would be corrupted.
+        expect(sources["CodeType"]).to include("[A-Z]+")
+      end
+    end
+
+    context "with include resolution through the location option" do
+      let(:path) do
+        "spec/fixtures/xml/schema/rnc/includes/library.rnc"
+      end
+
+      it "loads included RNC definitions before delegating to RngCompiler" do
+        sources = described_class.to_models(File.read(path), location: path)
+
+        expect(sources.keys).to include("Library", "Book", "Title")
+        expect(sources["Library"]).to include("attribute :book, Book")
+      end
+
+      it "raises a clear error for missing include files" do
+        expect do
+          described_class.to_models(
+            'include "missing.rnc"',
+            location: "spec/fixtures/xml/schema/rnc/includes",
+          )
+        end.to raise_error(/missing\.rnc/)
+      end
+
+      it "raises a clear error for circular includes" do
+        circular_path =
+          "spec/fixtures/xml/schema/rnc/includes/circular_a.rnc"
+
+        expect do
+          described_class.to_models(File.read(circular_path), location: circular_path)
+        end.to raise_error(/circular_a\.rnc/)
+      end
+    end
+
+    context "with load_classes mode" do
+      let!(:sources) do
+        stub_const("RncLoadClassesSpec", Module.new)
+        described_class.to_models(
+          File.read("spec/fixtures/xml/schema/rnc/address_book.rnc"),
+          load_classes: true,
+          module_namespace: "RncLoadClassesSpec",
+        )
+      end
+
+      it "returns generated source and loads constants" do
+        expect(sources.keys).to contain_exactly(
+          "AddressBook", "Card", "Name", "Email"
+        )
+        expect(defined?(RncLoadClassesSpec::AddressBook)).to eq("constant")
+      end
+    end
+
+    context "with input text and a file location" do
+      # Regression for the SourceResolver override bug: when caller passed
+      # both `input` and `location:` pointing at a file, the resolver
+      # silently read the file from disk and discarded the input.
+      it "uses the caller-provided text, not the file contents" do
+        Dir.mktmpdir do |dir|
+          path = File.join(dir, "real_file.rnc")
+          File.write(path, "start = element from_disk { text }")
+          inline = "start = element from_inline { text }"
+
+          sources = described_class.to_models(inline, location: path)
+
+          expect(sources.keys).to include("FromInline")
+          expect(sources.keys).not_to include("FromDisk")
+        end
+      end
+    end
+
+    context "with an attribute in a foreign namespace" do
+      let(:source) do
+        %(namespace ex = "urn:test"\n) +
+          %(start = element root { attribute ex:code { text } })
+      end
+
+      it "generates a namespaced value type for the attribute" do
+        sources = described_class.to_models(source)
+
+        code_type = sources.keys.find { |k| k.include?("Type") }
+        expect(code_type).not_to be_nil
+        expect(sources[code_type]).to match(/namespace \w+Namespace/)
+        expect(sources[code_type]).to match(/require_relative ".*namespace"/)
+        expect(sources["Root"]).to include('map_attribute "code", to: :code')
+      end
+
+      it "round-trips the foreign-namespace attribute (parse + fresh serialize)" do
+        stub_const("RncForeignNs", Module.new)
+        described_class.to_models(
+          source, load_classes: true, module_namespace: "RncForeignNs"
+        )
+
+        parsed = RncForeignNs::Root.from_xml(%(<root xmlns:ex="urn:test" ex:code="q"/>))
+        expect(parsed.code).to eq("q")
+
+        # The attribute round-trips in its namespace; the emitted prefix is a
+        # generated one (rng does not expose the source prefix), so match the
+        # URI and a namespace-qualified `code` attribute rather than "ex".
+        out = RncForeignNs::Root.new(code: "f").to_xml
+        expect(out).to match(/xmlns:\w+="urn:test"/)
+        expect(out).to match(/\w+:code="f"/)
+      end
+
+      it "does not namespace a type shared with an unqualified member" do
+        sources = described_class.to_models(<<~RNC)
+          namespace ex = "urn:test"
+          codeType = xsd:string { maxLength = "5" }
+          start = element root {
+            attribute plain { codeType },
+            attribute ex:tagged { codeType }
+          }
+        RNC
+
+        # The shared codeType must NOT gain a namespace (plain uses it
+        # unqualified); the foreign attribute gets its own namespaced type.
+        expect(sources["CodeType"]).not_to match(/namespace \w+Namespace/)
+        namespaced = sources.keys.find do |k|
+          k != "DefaultNamespace" && sources[k].match?(/namespace \w+Namespace/)
+        end
+        expect(namespaced).not_to be_nil
+      end
+
+      it "namespaces a foreign-ns attribute with inline facets via a subclass" do
+        sources = described_class.to_models(
+          %(namespace ex = "urn:test"\n) +
+          %(start = element root { attribute ex:code { xsd:string { maxLength = "5" } } }),
+        )
+
+        # 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/) }
+        expect(subclass).not_to be_nil
+        expect(sources[subclass]).to match(/namespace \w+Namespace/)
+      end
+
+      it "keeps distinct URIs and prefixes when their generated names collide" do
+        sources = described_class.to_models(<<~RNC)
+          namespace x = "urn:a"
+          namespace y = "urn:b"
+          start = element root { attribute x:one { text }, attribute y:two { text } }
+        RNC
+
+        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] }
+        expect(uris).to contain_exactly("urn:a", "urn:b")
+        expect(prefixes.uniq.size).to eq(2)
+      end
+
+      it "does not let a define shadow a built-in type of the same name" do
+        # `element pre { dateTime }` forces the custom `dateTime` define into
+        # the class set BEFORE the foreign-ns attribute resolves, so the guard
+        # is actually exercised: the attribute's primitive xsd:dateTime must
+        # still subclass the built-in DateTime, not the custom `dateTime`.
+        sources = described_class.to_models(<<~RNC)
+          dateTime = xsd:string { pattern = "custom" }
+          start = element root {
+            element pre { dateTime },
+            attribute ex:when { xsd:dateTime }
+          }
+        RNC
+
+        wrapper = sources.keys.find { |k| sources[k].match?(/namespace \w+Namespace/) && !k.include?("Namespace") }
+        expect(sources[wrapper]).to include("< Lutaml::Model::Type::DateTime")
+      end
+    end
+
+    context "with namespaced root and child elements" do
+      let(:source) do
+        %(namespace ex = "urn:test"\n) +
+          %(start = element ex:root { element ex:child { text } })
+      end
+
+      it "declares a class-level namespace with qualified element form" do
+        sources = described_class.to_models(source)
+        ns_key = sources.keys.find { |k| k.include?("Namespace") }
+
+        expect(sources["Root"]).to match(/namespace \w+Namespace/)
+        expect(sources[ns_key]).to include('uri "urn:test"')
+        expect(sources[ns_key]).to include("element_form_default :qualified")
+      end
+
+      it "round-trips root and child in their namespace" do
+        stub_const("RncNsElem", Module.new)
+        described_class.to_models(
+          source, load_classes: true, module_namespace: "RncNsElem"
+        )
+
+        xml = %(<ex:root xmlns:ex="urn:test"><ex:child>hi</ex:child></ex:root>)
+        expect(RncNsElem::Root.from_xml(xml).child).to eq("hi")
+
+        out = RncNsElem::Root.new(child: "x").to_xml
+        expect(out).to match(/xmlns(:\w+)?="urn:test"/)
+        expect(out).not_to include('xmlns=""')
+      end
+    end
+
+    context "with bracket annotations handled natively by rng" do
+      it "compiles an annotation before a non-leading definition" do
+        sources = described_class.to_models(<<~RNC)
+          foo = element foo { text }
+          [ a:defaultValue = "x" ]
+          bar = element bar { text }
+          start = element root { foo, bar }
+        RNC
+
+        expect(sources.keys).to include("Root", "Foo", "Bar")
+      end
+    end
+
+    context "via Schema.from_rnc entry point" do
+      it "delegates through the registered XML schema method" do
+        result = Lutaml::Model::Schema.from_rnc(
+          File.read("spec/fixtures/xml/schema/rnc/address_book.rnc"),
+        )
+
+        expect(result.keys).to contain_exactly(
+          "AddressBook", "Card", "Name", "Email"
+        )
+      end
+    end
+  end
+end