lutaml-model 0.8.16 → 0.8.18

data/spec/lutaml/model/choice_restrict_spec.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Lutaml::Model::Choice, "#restrict and #remove_attribute" do
+  before do
+    stub_const("ChoiceRestrictParent", Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :age, :integer
+      attribute :email, :string
+    end)
+  end
+
+  describe "#restrict" do
+    it "restricts a predefined attribute inside a choice block" do
+      stub_const("ChoiceRestrictModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :foo, :string, collection: 1..10
+
+        choice min: 1, max: 1 do
+          restrict :foo, collection: 2..5
+        end
+      end)
+
+      attr = ChoiceRestrictModel.attributes[:foo]
+      expect(attr.options[:collection]).to eq(2..5)
+      choice = ChoiceRestrictModel.choice_attributes.first
+      expect(choice.attributes).to include(attr)
+    end
+
+    it "raises UndefinedAttributeError for non-existent attribute" do
+      expect do
+        stub_const("ChoiceRestrictBadModel", Class.new(Lutaml::Model::Serializable) do
+          choice min: 1, max: 1 do
+            restrict :nonexistent, collection: 1..2
+          end
+        end)
+      end.to raise_error(Lutaml::Model::UndefinedAttributeError)
+    end
+
+    it "restricts an imported model attribute inside a choice block" do
+      stub_const("ChoiceImportModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :age, :integer
+
+        choice min: 1, max: 1 do
+          import_model_attributes ChoiceRestrictParent
+          restrict :age, values: [18, 21, 30]
+        end
+      end)
+
+      attr = ChoiceImportModel.attributes[:age]
+      expect(attr.options[:values]).to eq([18, 21, 30])
+    end
+
+    it "marks the attribute as belonging to the choice" do
+      stub_const("ChoiceRestrictOwnedModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :tag, :string
+
+        choice min: 0, max: 1 do
+          restrict :tag, values: %w[a b c]
+        end
+      end)
+
+      attr = ChoiceRestrictOwnedModel.attributes[:tag]
+      expect(attr.options[:choice]).to be_a(described_class)
+    end
+
+    it "does not duplicate the attribute if restrict is called twice" do
+      stub_const("ChoiceRestrictDupModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :val, :integer
+
+        choice min: 0, max: 1 do
+          restrict :val, values: [1, 2]
+          restrict :val, values: [1, 2, 3]
+        end
+      end)
+
+      choice = ChoiceRestrictDupModel.choice_attributes.first
+      count = choice.attributes.count do |a|
+        !a.is_a?(described_class) && a.name == :val
+      end
+      expect(count).to eq(1)
+      expect(ChoiceRestrictDupModel.attributes[:val].options[:values]).to eq([
+                                                                               1, 2, 3
+                                                                             ])
+    end
+
+    it "restricts an inherited attribute in a child class choice" do
+      stub_const("ChoiceRestrictParent", Class.new(Lutaml::Model::Serializable) do
+        attribute :tag, :string
+        attribute :label, :string
+      end)
+
+      child = Class.new(ChoiceRestrictParent) do
+        include Lutaml::Model::Serialize
+
+        choice min: 1, max: 1 do
+          restrict :tag, values: %w[a b c]
+        end
+      end
+
+      attr = child.attributes[:tag]
+      expect(attr.options[:values]).to eq(%w[a b c])
+      choice = child.choice_attributes.first
+      expect(choice.flat_attributes.any? { |a| a.name == :tag }).to be(true)
+    end
+  end
+
+  describe "#remove_attribute" do
+    it "removes an attribute from the choice block" do
+      stub_const("ChoiceRemoveModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :keep, :string
+        attribute :drop, :string
+
+        choice min: 0, max: 1 do
+          attribute :keep, :string
+          attribute :drop, :string
+          remove_attribute :drop
+        end
+      end)
+
+      choice = ChoiceRemoveModel.choice_attributes.first
+      attr_names = choice.attributes.filter_map do |a|
+        a.is_a?(described_class) ? nil : a.name
+      end
+      expect(attr_names).to eq([:keep])
+    end
+
+    it "clears the choice option from the removed attribute" do
+      stub_const("ChoiceRemoveOptModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :item, :string
+
+        choice min: 0, max: 1 do
+          attribute :item, :string
+          remove_attribute :item
+        end
+      end)
+
+      attr = ChoiceRemoveOptModel.attributes[:item]
+      # The top-level :item attribute should still exist without :choice
+      # since the one in the choice was a different instance
+      expect(attr.options[:choice]).to be_nil
+    end
+
+    it "returns nil if the attribute is not in the choice" do
+      result = nil
+      stub_const("ChoiceRemoveNotFoundModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :x, :string
+
+        choice min: 0, max: 1 do
+          result = remove_attribute(:nonexistent)
+        end
+      end)
+
+      expect(result).to be_nil
+    end
+
+    it "invalidates the flat_attributes cache" do
+      stub_const("ChoiceRemoveCacheModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :a, :string
+        attribute :b, :string
+
+        choice min: 0, max: 1 do
+          attribute :a, :string
+          attribute :b, :string
+        end
+      end)
+
+      choice = ChoiceRemoveCacheModel.choice_attributes.first
+      expect(choice.flat_attributes.map(&:name)).to contain_exactly(:a, :b)
+      choice.remove_attribute(:b)
+      expect(choice.flat_attributes.map(&:name)).to contain_exactly(:a)
+    end
+
+    it "removes an imported attribute from the choice block" do
+      source = Class.new(Lutaml::Model::Serializable) do
+        attribute :name, :string
+        attribute :email, :string
+        attribute :phone, :string
+      end
+      stub_const("ChoiceRemoveImportSource", source)
+
+      stub_const("ChoiceRemoveImportModel", Class.new(Lutaml::Model::Serializable) do
+        choice min: 1, max: 1 do
+          import_model_attributes ChoiceRemoveImportSource
+          remove_attribute :phone
+        end
+      end)
+
+      choice = ChoiceRemoveImportModel.choice_attributes.first
+      names = choice.flat_attributes.map(&:name)
+      expect(names).to contain_exactly(:name, :email)
+    end
+
+    it "removes a restrict-added attribute from the choice" do
+      stub_const("ChoiceRemoveRestrictModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :tag, :string
+
+        choice min: 0, max: 1 do
+          restrict :tag, values: %w[a b c]
+          remove_attribute :tag
+        end
+      end)
+
+      choice = ChoiceRemoveRestrictModel.choice_attributes.first
+      expect(choice.flat_attributes).to be_empty
+      expect(ChoiceRemoveRestrictModel.attributes[:tag].options[:choice]).to be_nil
+    end
+
+    it "returns the removed attribute" do
+      stub_const("ChoiceRemoveReturnModel", Class.new(Lutaml::Model::Serializable) do
+        attribute :item, :string
+
+        choice min: 0, max: 1 do
+          attribute :item, :string
+        end
+      end)
+
+      choice = ChoiceRemoveReturnModel.choice_attributes.first
+      removed = choice.remove_attribute(:item)
+      expect(removed).to be_a(Lutaml::Model::Attribute)
+      expect(removed.name).to eq(:item)
+    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/custom_model_spec.rb

@@ -153,16 +153,16 @@ module CustomModelSpecs
   end
 
   class MixedWithNestedContent < Lutaml::Model::Serializable
-    attribute :street, :string, raw: true
-    attribute :city, :string, raw: true
+    attribute :street, :string
+    attribute :city, :string
     attribute :bibdata, Bibdata
 
     xml do
       element "MixedWithNestedContent"
       mixed_content
 
-      map_element "street", to: :street
-      map_element "city", to: :city
+      map_element "street", to: :street, raw: :content
+      map_element "city", to: :city, raw: :content
       map_element "bibdata",
                   to: :bibdata,
                   with: { from: :bibdata_from_xml, to: :bibdata_to_xml }

data/spec/lutaml/model/mixed_content_spec.rb

@@ -107,12 +107,12 @@ module MixedContentSpec
   end
 
   class SpecialCharContentWithRawAndMixedOption < Lutaml::Model::Serializable
-    attribute :special, :string, raw: true
+    attribute :special, :string
 
     xml do
       element "SpecialCharContentWithRawOptionAndMixedOption"
       mixed_content
-      map_element :special, to: :special
+      map_element :special, to: :special, raw: :content
     end
   end
 
@@ -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/multiple_mapping_spec.rb

@@ -240,12 +240,12 @@ RSpec.describe MultipleMapping do
         expect(product1.name).to eq("Coffee Maker")
         expect(product1.description).to eq("Premium coffee maker")
         expect(product1.status).to eq("active")
-        expect(product1.content.to_s).to match(/Some content here/)
+        expect(product1.content.to_s).to include("Some content here")
 
         expect(product2.name).to eq("Coffee Maker")
         expect(product2.description).to eq("Premium coffee maker")
         expect(product2.status).to eq("in-stock")
-        expect(product2.content.to_s).to match(/Different content/)
+        expect(product2.content.to_s).to include("Different content")
 
         # Test round-trip: serialize and deserialize should preserve data
         # (Note: exact XML format differs between adapters due to mixed content whitespace handling)
@@ -253,13 +253,13 @@ RSpec.describe MultipleMapping do
         expect(round_trip1.name).to eq(product1.name)
         expect(round_trip1.description).to eq(product1.description)
         expect(round_trip1.status).to eq(product1.status)
-        expect(round_trip1.content.to_s).to match(/Some content here/)
+        expect(round_trip1.content.to_s).to include("Some content here")
 
         round_trip2 = MultipleMapping::Product.from_xml(product2.to_xml)
         expect(round_trip2.name).to eq(product2.name)
         expect(round_trip2.description).to eq(product2.description)
         expect(round_trip2.status).to eq(product2.status)
-        expect(round_trip2.content.to_s).to match(/Different content/)
+        expect(round_trip2.content.to_s).to include("Different content")
       end
     end
 

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

@@ -102,8 +102,8 @@ RSpec.describe "OrderedContent" do
         expect(obj.bold).to eq(["bell", "cool"])
         expect(obj.italic).to eq(["384,400 km"])
         expect(obj.underline).to eq("craters")
-        expect(obj.content.first.to_s).to match(/The Earth's Moon rings like a/)
-        expect(obj.content.join).to match(/Ain't that/)
+        expect(obj.content.first.to_s).to include("The Earth's Moon rings like a")
+        expect(obj.content.join).to include("Ain't that")
 
         # Verify round-trip preserves data
         # (Note: exact XML format differs between adapters in ordered mode)
@@ -112,7 +112,7 @@ RSpec.describe "OrderedContent" do
         expect(round_trip.bold).to eq(obj.bold)
         expect(round_trip.italic).to eq(obj.italic)
         expect(round_trip.underline).to eq(obj.underline)
-        expect(round_trip.content.first.to_s).to match(/The Earth's Moon rings like a/)
+        expect(round_trip.content.first.to_s).to include("The Earth's Moon rings like a")
       end
     end
 
@@ -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