lutaml-model 0.8.16 → 0.8.18

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

data/spec/lutaml/model/schema/renderers/model_spec.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/schema/definitions"
+require "lutaml/model/schema/renderers/model"
+
+RSpec.describe Lutaml::Model::Schema::Renderers::Model do
+  let(:defs) { Lutaml::Model::Schema::Definitions }
+
+  it "renders a rooted element with one element attribute" do
+    spec = defs::Model.new(
+      class_name: "Person",
+      xml_root: defs::XmlRoot.new(kind: :element, name: "Person"),
+      members: [
+        defs::Attribute.new(
+          name: "name",
+          type: defs::TypeRef.new(kind: :symbol, value: "string"),
+          xml_name: "name",
+          kind: :element,
+        ),
+      ],
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("class Person < Lutaml::Model::Serializable")
+    expect(output).to include("attribute :name, :string")
+    expect(output).to include("xml do")
+    expect(output).to include('element "Person"')
+    expect(output).to include('map_element "name", to: :name')
+    expect(output).to include("def self.register")
+    expect(output).to include("Person.register_class_with_id")
+  end
+
+  it "renders a fragment (no element / type_name directive)" do
+    spec = defs::Model.new(
+      class_name: "Inner",
+      xml_root: defs::XmlRoot.new(kind: :fragment, name: nil),
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).not_to include("element ")
+    expect(output).not_to include("type_name ")
+  end
+
+  it "renders an attribute mapping with map_attribute" do
+    spec = defs::Model.new(
+      class_name: "Item",
+      xml_root: defs::XmlRoot.new(kind: :element, name: "Item"),
+      members: [
+        defs::Attribute.new(
+          name: "id",
+          type: defs::TypeRef.new(kind: :symbol, value: "string"),
+          xml_name: "id",
+          kind: :attribute,
+        ),
+      ],
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include('map_attribute "id", to: :id')
+  end
+
+  it "renders a class reference type with no leading colon" do
+    spec = defs::Model.new(
+      class_name: "Owner",
+      xml_root: defs::XmlRoot.new(kind: :element, name: "Owner"),
+      members: [
+        defs::Attribute.new(
+          name: "address",
+          type: defs::TypeRef.new(kind: :class_ref, value: "Address"),
+          xml_name: "address",
+          kind: :element,
+        ),
+      ],
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("attribute :address, Address")
+  end
+
+  it "renders a w3c type with the ::-prefixed reference" do
+    spec = defs::Model.new(
+      class_name: "Para",
+      xml_root: defs::XmlRoot.new(kind: :element, name: "Para"),
+      members: [
+        defs::Attribute.new(
+          name: "lang",
+          type: defs::TypeRef.new(kind: :w3c, value: "Lutaml::Xml::W3c::Lang"),
+          xml_name: "lang",
+          kind: :attribute,
+        ),
+      ],
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("attribute :lang, ::Lutaml::Xml::W3c::Lang")
+  end
+
+  it "skips register methods inside a module_namespace" do
+    spec = defs::Model.new(
+      class_name: "Inside",
+      xml_root: defs::XmlRoot.new(kind: :element, name: "Inside"),
+    )
+
+    output = described_class.render(spec, module_namespace: "Mod::Sub")
+
+    expect(output).to include("module Mod")
+    expect(output).to include("module Sub")
+    expect(output).not_to include("def self.register")
+    expect(output).not_to include("register_class_with_id")
+  end
+
+  it "renders a choice block with attributes inside" do
+    spec = defs::Model.new(
+      class_name: "Either",
+      xml_root: defs::XmlRoot.new(kind: :element, name: "Either"),
+      members: [
+        defs::Choice.new(
+          header: "choice",
+          alternatives: [
+            defs::Attribute.new(
+              name: "alpha",
+              type: defs::TypeRef.new(kind: :symbol, value: "string"),
+              xml_name: "alpha",
+              kind: :element,
+            ),
+            defs::Attribute.new(
+              name: "beta",
+              type: defs::TypeRef.new(kind: :symbol, value: "string"),
+              xml_name: "beta",
+              kind: :element,
+            ),
+          ],
+        ),
+      ],
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("choice do")
+    expect(output).to include("attribute :alpha, :string")
+    expect(output).to include("attribute :beta, :string")
+  end
+end

data/spec/lutaml/model/schema/renderers/namespace_spec.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/schema/definitions"
+require "lutaml/model/schema/renderers/namespace"
+
+RSpec.describe Lutaml::Model::Schema::Renderers::Namespace do
+  let(:defs) { Lutaml::Model::Schema::Definitions }
+
+  it "renders a namespace class with uri and prefix_default" do
+    spec = defs::Namespace.new(
+      class_name: "ExampleNs",
+      uri: "http://example.com/ns",
+      prefix_default: "ex",
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("class ExampleNs < Lutaml::Xml::W3c::XmlNamespace")
+    expect(output).to include(%(uri "http://example.com/ns"))
+    expect(output).to include(%(prefix_default "ex"))
+  end
+
+  it "wraps in module when module_namespace is supplied" do
+    spec = defs::Namespace.new(
+      class_name: "Inner",
+      uri: "http://example.com/inner",
+      prefix_default: nil,
+    )
+
+    output = described_class.render(spec, module_namespace: "Mod::Sub")
+
+    expect(output).to include("module Mod")
+    expect(output).to include("module Sub")
+  end
+end

data/spec/lutaml/model/schema/renderers/restricted_type_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/schema/definitions"
+require "lutaml/model/schema/renderers/restricted_type"
+
+RSpec.describe Lutaml::Model::Schema::Renderers::RestrictedType do
+  let(:defs) { Lutaml::Model::Schema::Definitions }
+
+  it "renders min/max facets in the cast body" do
+    spec = defs::RestrictedType.new(
+      class_name: "PositiveInt",
+      parent_class: "Lutaml::Model::Type::Integer",
+      facets: defs::Facet.new(min_inclusive: 1, max_inclusive: 100),
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("class PositiveInt < Lutaml::Model::Type::Integer")
+    expect(output).to include("def self.cast(value, options = {})")
+    expect(output).to include("options[:min] = 1")
+    expect(output).to include("options[:max] = 100")
+    expect(output).to include("value = super(value, options)")
+  end
+
+  it "renders enumerations facet" do
+    spec = defs::RestrictedType.new(
+      class_name: "Color",
+      parent_class: "Lutaml::Model::Type::String",
+      facets: defs::Facet.new(enumerations: %w[red green blue]),
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include('options[:values] = [super("red"), super("green"), super("blue")]')
+    expect(output).not_to include("options[:min]")
+  end
+
+  it "renders pattern facet as a regexp literal" do
+    spec = defs::RestrictedType.new(
+      class_name: "Slug",
+      parent_class: "Lutaml::Model::Type::String",
+      facets: defs::Facet.new(pattern: "[a-z0-9-]+"),
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("options[:pattern] = %r{[a-z0-9-]+}")
+  end
+
+  it "renders transform facet" do
+    spec = defs::RestrictedType.new(
+      class_name: "Upper",
+      parent_class: "Lutaml::Model::Type::String",
+      facets: defs::Facet.new,
+      transform_facet: defs::TransformFacet.new(expression: "value.upcase"),
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("value = value.upcase")
+  end
+
+  it "uses lazy register memoisation" do
+    spec = defs::RestrictedType.new(
+      class_name: "Tiny",
+      parent_class: "Lutaml::Model::Type::Integer",
+      facets: defs::Facet.new(max_inclusive: 5),
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("@register ||= Lutaml::Model::Config.default_register")
+  end
+end

data/spec/lutaml/model/schema/renderers/union_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/model/schema/definitions"
+require "lutaml/model/schema/renderers/union"
+
+RSpec.describe Lutaml::Model::Schema::Renderers::Union do
+  let(:defs) { Lutaml::Model::Schema::Definitions }
+
+  it "renders the :class_refs strategy as an each/begin/rescue loop" do
+    spec = defs::UnionType.new(
+      class_name: "NumberOrString",
+      members: [
+        defs::TypeRef.new(kind: :class_ref, value: "Integer"),
+        defs::TypeRef.new(kind: :class_ref, value: "String"),
+      ],
+      cast_strategy: :class_refs,
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("class NumberOrString < Lutaml::Model::Type::Value")
+    expect(output).to include("[Integer, String].each do |t|")
+    expect(output).to include("casted = t.cast(value, options)")
+    expect(output).to include("return casted unless casted.nil?")
+    expect(output).to include("rescue StandardError")
+  end
+
+  it "renders the :resolve_type strategy as a ||-chained resolve_type call" do
+    spec = defs::UnionType.new(
+      class_name: "IntegerOrToken",
+      members: [
+        defs::TypeRef.new(kind: :symbol, value: "integer"),
+        defs::TypeRef.new(kind: :symbol, value: "token"),
+      ],
+      cast_strategy: :resolve_type,
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include("Lutaml::Model::GlobalContext.resolve_type(:integer, @register).cast(value, options)")
+    expect(output).to include("Lutaml::Model::GlobalContext.resolve_type(:token, @register).cast(value, options)")
+    expect(output).to include(" ||\n")
+  end
+
+  it "emits required_files lines above the module wrap" do
+    spec = defs::UnionType.new(
+      class_name: "AnyOf",
+      members: [defs::TypeRef.new(kind: :class_ref, value: "Integer")],
+      cast_strategy: :class_refs,
+      required_files: ['require_relative "integer"'],
+    )
+
+    output = described_class.render(spec)
+
+    expect(output).to include('require_relative "integer"')
+  end
+end

data/spec/lutaml/model/transform_apply_value_map_spec.rb

@@ -0,0 +1,64 @@
+require "spec_helper"
+
+# Regression: Transform#apply_value_map must handle the nil-attr case used
+# by custom-method-only key-value rules. Pre-consolidation behavior:
+# the default { omitted: :nil, nil: :nil, empty: :empty } map converted
+# UninitializedClass.instance to nil so the downstream Utils.present? guard
+# in KeyValue::Transform#process_mapping_rule would skip the custom method
+# for absent input keys.
+RSpec.describe Lutaml::Model::Transform, "#apply_value_map (nil attr)" do
+  let(:transform_subclass) do
+    Class.new(described_class) do
+      # Expose the protected delegator for direct testing.
+      public :apply_value_map
+    end
+  end
+
+  let(:context) { Class.new(Lutaml::Model::Serializable) }
+  let(:register) { Lutaml::Model::Config.default_register }
+  let(:transform) { transform_subclass.new(context, register) }
+
+  let(:uninit) { Lutaml::Model::UninitializedClass.instance }
+  let(:default_vmap) { { omitted: :nil, nil: :nil, empty: :empty } }
+
+  describe "default mapping with nil attr" do
+    it "converts UninitializedClass to nil via the :omitted => :nil mapping" do
+      # Before the fix: returned uninit unchanged, causing Utils.present? to
+      # be true and the custom method to run for absent fields.
+      expect(transform.apply_value_map(uninit, default_vmap, nil)).to be_nil
+    end
+
+    it "converts nil to nil via the :nil => :nil mapping" do
+      expect(transform.apply_value_map(nil, default_vmap, nil)).to be_nil
+    end
+
+    it "passes initialized values through unchanged" do
+      expect(transform.apply_value_map("hello", default_vmap, nil)).to eq("hello")
+    end
+  end
+
+  describe "explicit :omitted => :omitted with nil attr" do
+    let(:vmap) { { omitted: :omitted, nil: :nil, empty: :empty } }
+
+    it "preserves UninitializedClass for explicit omitted: :omitted" do
+      expect(transform.apply_value_map(uninit, vmap, nil)).to eq(uninit)
+    end
+  end
+
+  # Behavior-preservation: the pre-consolidation attribute-less path mapped the
+  # :omitted option to UninitializedClass.instance (present? => true, so the
+  # 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)
+    end
+
+    it "maps an empty value to uninitialized via empty: :omitted" do
+      expect(transform.apply_value_map("", { empty: :omitted }, nil)).to eq(uninit)
+    end
+
+    it "maps an empty value to nil via empty: :nil" do
+      expect(transform.apply_value_map("", { empty: :nil }, nil)).to be_nil
+    end
+  end
+end

data/spec/lutaml/model/uninitialized_class_spec.rb

@@ -23,7 +23,7 @@ RSpec.describe Lutaml::Model::UninitializedClass do
 
   describe "#match?" do
     it "returns false for any argument" do
-      expect(uninitialized).not_to match /pattern/
+      expect(uninitialized).not_to include("pattern")
       expect(uninitialized).not_to match "string"
       expect(uninitialized).not_to match nil
     end