lutaml-model 0.8.17 → 0.8.19

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/serialize/builder_spec.rb

@@ -0,0 +1,358 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require_relative "../../../../lib/lutaml/model"
+require "lutaml/xml/adapter/nokogiri_adapter"
+
+# Specs for Lutaml::Model::Serialize::Builder — the module that gives
+# Serializable the `Klass.new do |x| ... end` block syntax.
+#
+# These specs exist because of a regression where direct setters
+# (`x.attr = v`) inside the builder block silently dropped attributes
+# from serialized output while appender calls (`x.attr(v)`) worked.
+# The root cause was that only getter-with-arg paths called track_order;
+# generated setters did not. The fix centralises mutation recording via
+# Builder#record_mutation / record_mutation_collection, and the
+# serializer's apply_remaining_rules acts as a safety net so element
+# values are never silently dropped.
+#
+# These specs cover the invariant ("no silent data loss"), call-order
+# preservation, round-trip parity, equivalence between .tap and block,
+# the no-op guarantee for non-ordered models, and the wholesale
+# collection assignment case.
+RSpec.describe "Lutaml::Model::Serialize::Builder" do
+  let(:ordered_klass) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :singular, :string
+      attribute :items, :string, collection: true
+
+      xml do
+        element "container"
+        ordered
+        map_element "singular", to: :singular
+        map_element "items", to: :items
+      end
+    end
+  end
+
+  let(:mixed_klass) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :singular, :string
+      attribute :items, :string, collection: true
+
+      xml do
+        element "container"
+        mixed_content
+        map_element "singular", to: :singular
+        map_element "items", to: :items
+      end
+    end
+  end
+
+  let(:plain_klass) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :singular, :string
+      attribute :items, :string, collection: true
+
+      xml do
+        element "container"
+        map_element "singular", to: :singular
+        map_element "items", to: :items
+      end
+    end
+  end
+
+  shared_examples "no silent data loss across mutation styles" do
+    it "appender-only: emits every call in order" do
+      obj = ordered_klass.new do |x|
+        x.singular "first"
+        x.items "a"
+        x.items "b"
+      end
+
+      xml = obj.to_xml
+      expect(xml).to be_xml_equivalent_to(<<~XML)
+        <container>
+          <singular>first</singular>
+          <items>a</items>
+          <items>b</items>
+        </container>
+      XML
+      expect(obj.element_order.map(&:name)).to eq(%w[singular items items])
+    end
+
+    it "direct setter for singular: still emits the element" do
+      obj = ordered_klass.new do |x|
+        x.singular = "first"
+        x.items "a"
+      end
+
+      xml = obj.to_xml
+      expect(xml).to be_xml_equivalent_to(<<~XML)
+        <container>
+          <singular>first</singular>
+          <items>a</items>
+        </container>
+      XML
+      expect(obj.element_order.map(&:name)).to eq(%w[singular items])
+    end
+
+    it "wholesale collection assignment: emits one element per item" do
+      obj = ordered_klass.new do |x|
+        x.singular "first"
+        x.items = %w[a b c]
+      end
+
+      xml = obj.to_xml
+      expect(xml).to be_xml_equivalent_to(<<~XML)
+        <container>
+          <singular>first</singular>
+          <items>a</items>
+          <items>b</items>
+          <items>c</items>
+        </container>
+      XML
+      expect(obj.element_order.map(&:name)).to eq(%w[singular items items items])
+    end
+
+    it "all direct setters: emits in call order" do
+      obj = ordered_klass.new do |x|
+        x.singular = "first"
+        x.items = %w[a b]
+      end
+
+      xml = obj.to_xml
+      expect(xml).to be_xml_equivalent_to(<<~XML)
+        <container>
+          <singular>first</singular>
+          <items>a</items>
+          <items>b</items>
+        </container>
+      XML
+    end
+
+    it "mixed style preserves call order across setters and appenders" do
+      obj = ordered_klass.new do |x|
+        x.items "a"
+        x.singular = "middle"
+        x.items "b"
+      end
+
+      xml = obj.to_xml
+      expect(xml).to be_xml_equivalent_to(<<~XML)
+        <container>
+          <items>a</items>
+          <singular>middle</singular>
+          <items>b</items>
+        </container>
+      XML
+    end
+  end
+
+  describe "no silent data loss" do
+    it_behaves_like "no silent data loss across mutation styles"
+
+    it "mixed_content model emits setter-only attributes too" do
+      obj = mixed_klass.new do |x|
+        x.singular = "first"
+        x.items "a"
+      end
+
+      xml = obj.to_xml
+      expect(xml).to include("<singular>first</singular>")
+      expect(xml).to include("<items>a</items>")
+      expect(obj.element_order.map(&:name)).to eq(%w[singular items])
+    end
+  end
+
+  describe "call order preservation" do
+    it "reverse declaration order is honoured via direct setters" do
+      obj = ordered_klass.new do |x|
+        x.items = %w[a b]
+        x.singular = "last"
+      end
+
+      xml = obj.to_xml
+      items_pos = xml.index("<items>")
+      singular_pos = xml.index("<singular>")
+      expect(items_pos).to be < singular_pos
+      expect(obj.element_order.map(&:name)).to eq(%w[items items singular])
+    end
+
+    it "reverse declaration order is honoured via appenders" do
+      obj = ordered_klass.new do |x|
+        x.items "a"
+        x.singular "last"
+      end
+
+      xml = obj.to_xml
+      items_pos = xml.index("<items>")
+      singular_pos = xml.index("<singular>")
+      expect(items_pos).to be < singular_pos
+      expect(obj.element_order.map(&:name)).to eq(%w[items singular])
+    end
+  end
+
+  describe "round-trip parity" do
+    it "ordered: parses and re-emits equivalent XML" do
+      original = <<~XML
+        <container>
+          <items>a</items>
+          <singular>middle</singular>
+          <items>b</items>
+        </container>
+      XML
+
+      parsed = ordered_klass.from_xml(original)
+      expect(parsed.to_xml).to be_xml_equivalent_to(original)
+    end
+
+    it "mixed_content: parses and re-emits equivalent XML" do
+      original = <<~XML
+        <container>before <items>a</items> mid <singular>x</singular> end</container>
+      XML
+
+      parsed = mixed_klass.from_xml(original)
+      roundtrip = parsed.to_xml
+      expect(roundtrip).to include("<items>a</items>")
+      expect(roundtrip).to include("<singular>x</singular>")
+    end
+  end
+
+  describe ".tap vs builder block equivalence" do
+    it "produces identical element_order presence and XML shape" do
+      via_tap = ordered_klass.new.tap do |x|
+        x.singular = "first"
+        x.items = %w[a b]
+      end
+
+      via_block = ordered_klass.new do |x|
+        x.singular = "first"
+        x.items = %w[a b]
+      end
+
+      # .tap path does not enable tracking; both must still emit the same XML.
+      expect(via_tap.element_order).to be_nil
+      expect(via_block.element_order).not_to be_nil
+      expect(via_tap.to_xml).to be_xml_equivalent_to(via_block.to_xml)
+    end
+  end
+
+  describe "setter return value contract" do
+    # Ruby's setter contract: `obj.foo = v` evaluates to `v`. Callers
+    # like `obj.foo || (obj.foo = [])` depend on this. Generated
+    # setters must continue to honour this contract regardless of
+    # whether order tracking is enabled.
+    it "singular setter returns the assigned value" do
+      obj = plain_klass.new
+      expect((obj.singular = "v")).to eq("v")
+    end
+
+    it "collection setter returns the assigned value" do
+      obj = plain_klass.new
+      expect((obj.items = %w[a b])).to eq(%w[a b])
+    end
+
+    it "supports the `obj.foo || (obj.foo = [])` pattern from downstream consumers" do
+      obj = plain_klass.new
+      # Mirror Docbook::Elements::Para#try_add_inline, which relies on
+      # the setter returning the array (not nil) when the getter is nil.
+      # The bug: when the setter returned nil (because record_mutation
+      # returned nil with tracking disabled), `collection` was nil and
+      # `collection << element` failed with NoMethodError.
+      collection = obj.items || (obj.items = [])
+      expect(collection).to eq([])
+      expect { collection << "x" }.not_to raise_error
+    end
+  end
+
+  describe "no-op guarantee when not tracking" do
+    it "plain (non-ordered) models do not allocate element_order entries" do
+      obj = plain_klass.new do |x|
+        x.singular = "first"
+        x.items "a"
+      end
+
+      expect(obj.element_order).to be_nil
+      expect { obj.to_xml }.not_to raise_error
+    end
+
+    it "ordered models constructed without a block do not track" do
+      obj = ordered_klass.new
+      obj.singular = "first"
+      obj.items = %w[a b]
+
+      expect(obj.element_order).to be_nil
+      expect(obj.to_xml).to include("<singular>first</singular>")
+    end
+  end
+
+  describe "wholesale collection reassignment" do
+    it "tracks one entry per item across multiple assignments" do
+      obj = ordered_klass.new do |x|
+        x.items = %w[a b]
+        x.items = %w[c d e]
+      end
+
+      # element_order is a log of mutations, not a reflection of final state,
+      # 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])
+      xml = obj.to_xml
+      # The serialized output must contain all current items
+      expect(xml).to include("<items>c</items>")
+      expect(xml).to include("<items>d</items>")
+      expect(xml).to include("<items>e</items>")
+    end
+  end
+
+  describe "no-silent-drop invariant (cross-cutting)" do
+    # The bug class: any attribute with a non-default value MUST appear in
+    # the serialized output, regardless of how it was set. This spec is the
+    # regression guard for the whole class of bug, not just one instance.
+    shared_examples "no silent drop" do |description, mutation_block|
+      it "does not silently drop any attribute set via: #{description}" do
+        obj = ordered_klass.new(&mutation_block)
+        xml = obj.to_xml
+
+        if !obj.singular.nil? && !obj.singular.to_s.empty?
+          expect(xml).to include("<singular>"), "singular was dropped from output"
+        end
+        return if obj.items.nil? || obj.items.empty?
+
+        obj.items.each do |item|
+          expect(xml).to include("<items>#{item}</items>"),
+                         "items element for #{item.inspect} was dropped from output"
+        end
+      end
+    end
+
+    it_behaves_like "no silent drop",
+                    "singular setter + wholesale items setter",
+                    lambda { |x|
+                      x.singular = "v"
+                      x.items = %w[a b]
+                    }
+    it_behaves_like "no silent drop",
+                    "all appenders",
+                    lambda { |x|
+                      x.singular "v"
+                      x.items "a"
+                      x.items "b"
+                    }
+    it_behaves_like "no silent drop",
+                    "singular setter + items appender (the original bug)",
+                    lambda { |x|
+                      x.singular = "v"
+                      x.items "a"
+                      x.items "b"
+                    }
+    it_behaves_like "no silent drop",
+                    "singular appender + wholesale items setter",
+                    lambda { |x|
+                      x.singular "v"
+                      x.items = %w[a b]
+                    }
+  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