lutaml-model 0.8.17 → 0.8.18

data/spec/lutaml/model/boot_manifest_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "tmpdir"
+
+# Guard: the generated Opal boot manifest must stay in sync with the autoloads
+# in lib/lutaml/**. Opal ignores `autoload`, so lutaml_model_boot.rb explicitly
+# requires every autoload target; a deleted/renamed file leaves a stale require
+# that only fails the Opal CI job (`rake spec:opal`) — MRI's autoload hides it.
+# Regenerating here and comparing catches that drift in the fast MRI suite.
+RSpec.describe "Opal boot manifest" do
+  let(:generator) do
+    File.expand_path("../../../lib/compat/opal/generate_boot.rb", __dir__)
+  end
+  let(:manifest) do
+    File.expand_path("../../../lib/compat/opal/lutaml_model_boot.rb", __dir__)
+  end
+
+  it "matches the generator output (regenerate: ruby lib/compat/opal/generate_boot.rb)" do
+    Dir.mktmpdir do |dir|
+      out = File.join(dir, "boot.rb")
+      ok = system({ "OPAL_BOOT_OUTPUT" => out }, RbConfig.ruby, generator,
+                  out: File::NULL, err: File::NULL)
+      expect(ok).to be(true), "generate_boot.rb failed to run"
+      expect(File.read(manifest)).to eq(File.read(out)),
+                                     "lib/compat/opal/lutaml_model_boot.rb is out of date — run " \
+                                     "`ruby lib/compat/opal/generate_boot.rb` after adding/removing autoloads"
+    end
+  end
+end

data/spec/lutaml/model/collection_spec.rb

@@ -323,6 +323,24 @@ RSpec.describe Lutaml::Model::Collection do
       end
     end
 
+    context "when a range collection allows zero elements" do
+      it "validates when the collection is given as empty" do
+        kiln = CollectionTests::Kiln.new(attributes.merge(pots: []))
+
+        expect { kiln.validate! }.not_to raise_error
+      end
+
+      it "validates when the collection is omitted entirely" do
+        kiln = CollectionTests::Kiln.new(attributes.except(:pots))
+
+        expect { kiln.validate! }.not_to raise_error
+      end
+
+      it "does not flag the empty min-zero collection when built with no arguments" do
+        expect { CollectionTests::Kiln.new.validate! }.not_to raise_error
+      end
+    end
+
     context "when collection with unbounded maximum exceeds minimum" do
       let(:valid_attributes) do
         attributes.merge(operators: ["John", "Jane", "Jim", "Jessica"])

data/spec/lutaml/model/mixed_content_spec.rb

@@ -275,6 +275,88 @@ module MixedContentSpec
       map_element "b", to: :bold
     end
   end
+
+  # Regression: nested mixed_content text ownership
+  # Bug report claimed child's direct text was captured by the parent.
+  # Not reproducible with DOM-based adapters — text nodes are parented
+  # by the parser, not by a shared accumulator. These specs lock in
+  # correct behavior.
+  class NestedTextInner < Lutaml::Model::Serializable
+    attribute :text, :string, collection: true
+    attribute :child, :string, collection: true
+
+    xml do
+      element "inner"
+      mixed_content
+      map_content to: :text
+      map_element "child", to: :child
+    end
+  end
+
+  class NestedTextOuter < Lutaml::Model::Serializable
+    attribute :text, :string, collection: true
+    attribute :inner, NestedTextInner, collection: true
+
+    xml do
+      element "outer"
+      mixed_content
+      map_content to: :text
+      map_element "inner", to: :inner
+    end
+  end
+
+  class NestedTextInnerOrdered < Lutaml::Model::Serializable
+    attribute :text, :string, collection: true
+    attribute :child, :string, collection: true
+
+    xml do
+      element "inner"
+      ordered
+      mixed_content
+      map_content to: :text
+      map_element "child", to: :child
+    end
+  end
+
+  class NestedTextOuterOrdered < Lutaml::Model::Serializable
+    attribute :text, :string, collection: true
+    attribute :inner, NestedTextInnerOrdered, collection: true
+
+    xml do
+      element "outer"
+      ordered
+      mixed_content
+      map_content to: :text
+      map_element "inner", to: :inner
+    end
+  end
+
+  # Asymmetric variant: middle layer omits mixed_content while outer
+  # and inner both have it. Mirrors the original trigger from the
+  # metanorma-document BUGS.sts 06 report (FmtStemElement lacked
+  # mixed_content at the time, sandwiched between ParagraphBlock and
+  # SemxElement which both had it). Symmetric coverage alone misses
+  # this case.
+  class AsymmetricMiddle < Lutaml::Model::Serializable
+    attribute :inner, NestedTextInner, collection: true
+
+    xml do
+      element "middle"
+      map_element "inner", to: :inner
+    end
+  end
+
+  class AsymmetricOuter < Lutaml::Model::Serializable
+    attribute :text, :string, collection: true
+    attribute :middle, AsymmetricMiddle, collection: true
+
+    xml do
+      element "outer"
+      mixed_content
+      map_content to: :text
+      map_element "middle", to: :middle
+    end
+  end
 end
 
 RSpec.describe "MixedContent" do
@@ -1244,6 +1326,95 @@ RSpec.describe "MixedContent" do
         end
       end
     end
+
+    # Regression: nested mixed_content text ownership
+    # Verifies that text directly inside a child element with mixed_content
+    # is attributed to the CHILD, not the parent. Covers standard and
+    # ordered variants, single and multiple children, and outer text.
+    context "nested mixed_content text ownership" do
+      context "with standard mixed_content" do
+        it "attributes child's direct text to the child, not the parent" do
+          outer = MixedContentSpec::NestedTextOuter.from_xml(
+            "<outer><inner>target text<child>x</child></inner></outer>",
+          )
+          inner = outer.inner.first
+
+          expect(inner.text).to eq(["target text"])
+          expect(inner.child).to eq(["x"])
+          expect(outer.text).to eq([])
+        end
+
+        it "keeps outer text segments in the outer model" do
+          outer = MixedContentSpec::NestedTextOuter.from_xml(
+            "<outer>prefix<inner>target text<child>x</child></inner>suffix</outer>",
+          )
+          inner = outer.inner.first
+
+          expect(inner.text).to eq(["target text"])
+          expect(outer.text).to eq(%w[prefix suffix])
+        end
+
+        it "handles multiple nested children with their own text" do
+          outer = MixedContentSpec::NestedTextOuter.from_xml(
+            "<outer>p1<inner>i1text<c>x</c>i2text</inner>p2<inner>i3text</inner>p3</outer>",
+          )
+
+          expect(outer.inner[0].text).to eq(%w[i1text i2text])
+          expect(outer.inner[1].text).to eq(["i3text"])
+          expect(outer.text).to eq(%w[p1 p2 p3])
+        end
+      end
+
+      context "with ordered mixed_content" do
+        it "attributes child's direct text to the child, not the parent" do
+          outer = MixedContentSpec::NestedTextOuterOrdered.from_xml(
+            "<outer><inner>target text<child>x</child></inner></outer>",
+          )
+          inner = outer.inner.first
+
+          expect(inner.text).to eq(["target text"])
+          expect(inner.child).to eq(["x"])
+          expect(outer.text).to eq([])
+        end
+
+        it "keeps outer text segments in the outer model" do
+          outer = MixedContentSpec::NestedTextOuterOrdered.from_xml(
+            "<outer>prefix<inner>target text<child>x</child></inner>suffix</outer>",
+          )
+          inner = outer.inner.first
+
+          expect(inner.text).to eq(["target text"])
+          expect(outer.text).to eq(%w[prefix suffix])
+        end
+      end
+
+      context "with asymmetric nesting (middle layer omits mixed_content)" do
+        # Mirrors the original trigger from metanorma-document BUGS.sts 06:
+        # ParagraphBlock (mixed_content) > FmtStemElement (no mixed_content
+        # at the time) > SemxElement (mixed_content). Symmetric coverage
+        # in the prior contexts does not exercise this code path.
+        it "attributes innermost text to the innermost model" do
+          outer = MixedContentSpec::AsymmetricOuter.from_xml(
+            "<outer>prefix<middle><inner>target text<child>x</child></inner></middle>suffix</outer>",
+          )
+          inner = outer.middle.first.inner.first
+
+          expect(inner.text).to eq(["target text"])
+          expect(inner.child).to eq(["x"])
+          expect(outer.text).to eq(%w[prefix suffix])
+        end
+
+        it "preserves innermost text when outer has no own text" do
+          outer = MixedContentSpec::AsymmetricOuter.from_xml(
+            "<outer><middle><inner>target text<child>x</child></inner></middle></outer>",
+          )
+          inner = outer.middle.first.inner.first
+
+          expect(inner.text).to eq(["target text"])
+          expect(outer.text).to eq([])
+        end
+      end
+    end
   end
 
   describe Lutaml::Xml::Adapter::NokogiriAdapter do

data/spec/lutaml/model/opal_smoke_spec.rb

@@ -71,6 +71,47 @@ RSpec.describe "Opal compatibility", if: RUBY_ENGINE == "opal" do
     expect(instance.flag).to be true
   end
 
+  it "resolves scalar union attributes" do
+    reading = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :value, %i[integer string]
+    end
+
+    expect(reading.from_json('{"value":42}').value).to eq(42)
+    expect(reading.from_json('{"value":"hot"}').value).to eq("hot")
+  end
+
+  it "resolves a union of a model member and a scalar" do
+    temperature = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :celsius, :float
+    end
+    holder = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :temp, [temperature, :string]
+    end
+
+    structured = holder.from_json('{"temp":{"celsius":12.5}}')
+    expect(structured.temp).to be_a(temperature)
+    expect(structured.temp.celsius).to eq(12.5)
+    expect(holder.from_json('{"temp":"cold"}').temp).to eq("cold")
+  end
+
+  it "validates a pattern on a union :string member" do
+    coded = Class.new do
+      include Lutaml::Model::Serialize
+
+      attribute :code, %i[integer string], pattern: /\A[A-Z]+\z/
+    end
+
+    expect(coded.new(code: "ABC").validate).to be_empty
+    expect(coded.new(code: "abc").validate).not_to be_empty
+    expect(coded.new(code: 42).validate).to be_empty
+  end
+
   it "handles nested models" do
     address = Class.new do
       include Lutaml::Model::Serialize
@@ -110,8 +151,32 @@ RSpec.describe "Opal compatibility", if: RUBY_ENGINE == "opal" do
     expect(Lutaml::Model::RuntimeCompatibility.opal?).to be true
   end
 
-  it "AdapterResolver auto-detects REXML" do
+  it "AdapterResolver auto-detects Oga as the default" do
     adapter = Lutaml::Model::AdapterResolver.detect_xml_adapter
-    expect(adapter).to eq(:rexml)
+    expect(adapter).to eq(:oga)
+  end
+
+  it "exposes both Oga and REXML as available adapters under Opal" do
+    # Both are pure Ruby; Nokogiri and Ox are C extensions and excluded.
+    options = Lutaml::Model::FormatRegistry.adapter_options_for(:xml)
+    expect(options).not_to be_nil
+
+    available = options[:available]
+    expect(available).to include(:oga, :rexml)
+    expect(available).not_to include(:nokogiri, :ox)
+  end
+
+  # Opal's Module#prepend raises "Prepending a module multiple times
+  # is not supported" on the second call; runtime_compatibility.rb
+  # patches it to match MRI's idempotent behavior. Top-level lib files
+  # (lib/lutaml/model.rb, lib/lutaml/xml.rb) rely on this when Opal's
+  # eager loader re-evaluates them.
+  it "Module#prepend is idempotent under Opal" do
+    mod = Module.new
+    klass = Class.new
+    klass.prepend(mod)
+
+    expect { klass.prepend(mod) }.not_to raise_error
+    expect(klass.ancestors.count(mod)).to eq(1)
   end
 end

data/spec/lutaml/model/ordered_content_spec.rb

@@ -145,6 +145,36 @@ RSpec.describe "OrderedContent" do
         expect(serialized).to be_xml_equivalent_to(expected_xml)
       end
     end
+
+    # Regression for issue #735: `ordered` builder must honour setter
+    # call order, not declaration order. The @__order_tracking__ flag
+    # was gated on mixed_content? instead of ordered?.
+    context "ordered builder honours setter call order" do
+      it "emits elements in builder-call order, not declaration order" do
+        klass = Class.new(Lutaml::Model::Serializable) do
+          attribute :a, :string
+          attribute :b, :string
+
+          xml do
+            element "item"
+            ordered
+            map_element "a", to: :a
+            map_element "b", to: :b
+          end
+        end
+
+        item = klass.new do |i|
+          i.b "first"
+          i.a "second"
+        end
+
+        xml = item.to_xml
+        b_pos = xml.index("<b>first</b>")
+        a_pos = xml.index("<a>second</a>")
+        expect(b_pos).to be < a_pos
+        expect(item.element_order.map(&:name)).to eq(%w[b a])
+      end
+    end
   end
 
   describe Lutaml::Xml::Adapter::NokogiriAdapter do

data/spec/lutaml/model/raw_element_spec.rb

@@ -87,6 +87,50 @@ module RawElementSpec
     end
   end
 
+  # mixed_content parent with a collection raw: :element mapping.
+  # Round-trip dispatches through OrderedApplier#apply_element_rule_single
+  # (see issue #727 — previously double-wrapped each fragment).
+  class MixedContentRawCollectionContainer < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :fragments, :string, collection: true
+
+    xml do
+      element "container"
+      mixed_content
+      map_element "name", to: :name
+      map_element "fragment", to: :fragments, raw: :element
+    end
+  end
+
+  # mixed_content parent with a single (non-collection) raw: :element mapping.
+  # Dispatches through OrderedApplier -> :apply_rule -> RuleApplier#apply_rule,
+  # which already had the short-circuit. Kept as a regression guard.
+  class MixedContentRawSingleContainer < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :embedded, :string
+
+    xml do
+      element "container"
+      mixed_content
+      map_element "name", to: :name
+      map_element "foreign", to: :embedded, raw: :element
+    end
+  end
+
+  # ordered (no mixed_content) parent with a collection raw: :element mapping.
+  # Same dispatch path as mixed_content; same bug class.
+  class OrderedRawCollectionContainer < Lutaml::Model::Serializable
+    attribute :name, :string
+    attribute :fragments, :string, collection: true
+
+    xml do
+      element "container"
+      ordered
+      map_element "name", to: :name
+      map_element "fragment", to: :fragments, raw: :element
+    end
+  end
+
   RSpec.describe "map_element raw: :element" do
     describe "deserialization" do
       describe "foreign namespace element capture" do
@@ -378,6 +422,87 @@ module RawElementSpec
         end
       end
 
+      # Regression for issue #727: OrderedApplier#apply_element_rule_single
+      # was missing the raw: :element short-circuit, so each captured fragment
+      # string (which already contains its own <fragment> wrapper) got wrapped
+      # again, producing <fragment><fragment>...</fragment></fragment>.
+      describe "round-trip with mixed_content + raw: :element collection" do
+        let(:mixed_collection_xml) do
+          <<~XML
+            <container>
+              before
+              <name>multi</name>
+              <fragment id="1">first</fragment>
+              <fragment id="2"><nested>second</nested></fragment>
+              after
+            </container>
+          XML
+        end
+
+        it "does not double-wrap fragments on round-trip" do
+          doc = MixedContentRawCollectionContainer.from_xml(mixed_collection_xml)
+          output = doc.to_xml
+
+          expect(output).not_to include("<fragment><fragment")
+          expect(output).to include('id="1"')
+          expect(output).to include("first")
+          expect(output).to include('id="2"')
+          expect(output).to include("<nested>second</nested>")
+        end
+
+        it "is stable across repeated round-trips" do
+          doc = MixedContentRawCollectionContainer.from_xml(mixed_collection_xml)
+          once = MixedContentRawCollectionContainer.from_xml(doc.to_xml)
+          twice = MixedContentRawCollectionContainer.from_xml(once.to_xml)
+
+          expect(twice.fragments.length).to eq(2)
+          expect(twice.fragments[0]).to include("first")
+          expect(twice.fragments[1]).to include("<nested>second</nested>")
+        end
+      end
+
+      # Regression guard: the non-collection path under mixed_content dispatches
+      # through :apply_rule -> RuleApplier#apply_rule, which already had the
+      # short-circuit. Lock in the working behavior.
+      describe "round-trip with mixed_content + raw: :element single" do
+        let(:mixed_single_xml) do
+          '<container>before<name>x</name><foreign attr="v"><child>c</child></foreign>after</container>'
+        end
+
+        it "emits the foreign element verbatim without wrapping" do
+          doc = MixedContentRawSingleContainer.from_xml(mixed_single_xml)
+          output = doc.to_xml
+
+          expect(output).not_to include("<foreign><foreign")
+          expect(output).to include('attr="v"')
+          expect(output).to include("<child>c</child>")
+        end
+      end
+
+      # Same dispatch path (OrderedApplier) as mixed_content; same bug class.
+      describe "round-trip with ordered + raw: :element collection" do
+        let(:ordered_collection_xml) do
+          <<~XML
+            <container>
+              <name>multi</name>
+              <fragment id="1">first</fragment>
+              <fragment id="2">second</fragment>
+            </container>
+          XML
+        end
+
+        it "does not double-wrap fragments on round-trip" do
+          doc = OrderedRawCollectionContainer.from_xml(ordered_collection_xml)
+          output = doc.to_xml
+
+          expect(output).not_to include("<fragment><fragment")
+          expect(output).to include('id="1"')
+          expect(output).to include("first")
+          expect(output).to include('id="2"')
+          expect(output).to include("second")
+        end
+      end
+
       describe "nil and empty values" do
         it "omits raw element when value is nil" do
           model = SvgContainer.new(svg_data: nil)

data/spec/lutaml/model/rule_value_extractor_spec.rb

@@ -9,19 +9,10 @@ RSpec.describe Lutaml::Model::RuleValueExtractor do
   let(:rule) { instance_double(Lutaml::Model::Jsonl::MappingRule) }
   let(:doc) { { "name" => "Test", "value" => 123 } }
   let(:format) { :json }
-  let(:attr) { instance_double(Lutaml::Model::Attribute) }
-  let(:register) { instance_double(Lutaml::Model::Register) }
+  let(:attr) { Lutaml::Model::Attribute.new("name", :string) }
+  let(:register) { Lutaml::Model::Config.default_register }
   let(:options) { {} }
 
-  def mock_resolver(default_set_value, default_value_data = nil)
-    resolver_double = instance_double(Lutaml::Model::Services::DefaultValueResolver,
-                                      default_set?: default_set_value,
-                                      default_value: default_value_data)
-    allow(Lutaml::Model::Services::DefaultValueResolver).to receive(:new)
-      .with(attr, register, instance)
-      .and_return(resolver_double)
-  end
-
   describe "#call" do
     context "when rule has single mapping" do
       before do
@@ -82,7 +73,7 @@ RSpec.describe Lutaml::Model::RuleValueExtractor do
       end
     end
 
-    context "when value is not found" do
+    context "when value is not found and attribute has no default" do
       before do
         allow(rule).to receive_messages(
           multiple_mappings?: false,
@@ -90,7 +81,6 @@ RSpec.describe Lutaml::Model::RuleValueExtractor do
           root_mapping?: false,
           raw_mapping?: false,
         )
-        mock_resolver(false)
       end
 
       it "returns uninitialized value" do
@@ -99,6 +89,10 @@ RSpec.describe Lutaml::Model::RuleValueExtractor do
     end
 
     context "when attribute has default value" do
+      let(:attr) do
+        Lutaml::Model::Attribute.new("name", :string, default: "default_value")
+      end
+
       before do
         allow(rule).to receive_messages(
           multiple_mappings?: false,
@@ -106,7 +100,6 @@ RSpec.describe Lutaml::Model::RuleValueExtractor do
           root_mapping?: false,
           raw_mapping?: false,
         )
-        mock_resolver(true, "default_value")
       end
 
       it "returns default value" do

data/spec/lutaml/model/runtime_compatibility_spec.rb

@@ -33,4 +33,29 @@ RSpec.describe Lutaml::Model::RuntimeCompatibility do
         .to eq(error_class)
     end
   end
+
+  # lib/lutaml/model.rb and lib/lutaml/xml.rb re-evaluate their top-level
+  # prepend calls when Opal's eager loader processes them more than once.
+  # Opal's Module#prepend raises "Prepending a module multiple times is
+  # not supported" in that case; runtime_compatibility.rb aligns Opal
+  # with MRI's idempotent behavior. MRI has been idempotent since 2.0,
+  # so the spec applies to both runtimes.
+  describe "Module#prepend idempotency" do
+    it "is a no-op when the module is already in the ancestor chain" do
+      mod = Module.new
+      klass = Class.new
+      klass.prepend(mod)
+
+      expect { klass.prepend(mod) }.not_to raise_error
+      expect(klass.ancestors.count(mod)).to eq(1)
+    end
+
+    it "still prepends when the module is not yet present" do
+      mod = Module.new
+      klass = Class.new
+
+      expect { klass.prepend(mod) }.not_to raise_error
+      expect(klass.ancestors).to include(mod)
+    end
+  end
 end