lutaml-model 0.8.94 → 0.8.96

data/spec/lutaml/model/opal_smoke_spec.rb

@@ -147,6 +147,23 @@ RSpec.describe "Opal compatibility", if: RUBY_ENGINE == "opal" do
     expect(instance.port).to eq(8080)
   end
 
+  # Opal has no TracePoint; a symbol import is resolved on first use.
+  it "resolves a deferred symbol import on first use" do
+    register = Lutaml::Model::GlobalRegister
+      .lookup(Lutaml::Model::Config.default_register)
+    importer = Class.new(Lutaml::Model::Serializable) do
+      import_model :opal_deferred_import
+    end
+    imported = Class.new(Lutaml::Model::Serializable) do
+      attribute :title, :string
+    end
+    register.register_model(imported, id: :opal_deferred_import)
+
+    instance = importer.from_json('{"title":"Deferred"}')
+    expect(instance.title).to eq("Deferred")
+    expect(instance.to_hash).to eq({ "title" => "Deferred" })
+  end
+
   it "RuntimeCompatibility detects Opal" do
     expect(Lutaml::Model::RuntimeCompatibility.opal?).to be true
   end

data/spec/lutaml/model/serialize/attribute_definition_block_form_spec.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require_relative "../../../../lib/lutaml/model"
+require "lutaml/xml/adapter/nokogiri_adapter"
+
+# Runtimes without a source compiler (Opal) define the attribute
+# accessors and the state-defaults seed from blocks instead of a String
+# class_eval. These specs force that block form on MRI and check it
+# behaves exactly like the compiled form.
+module AttributeDefinitionBlockFormSpec
+  module_function
+
+  def define_model(klass)
+    klass.class_eval do
+      attribute :name, :string
+      attribute :count, :integer
+      attribute :tags, :string, collection: true
+      # "char" is an enum shorthand, so the second :char definition
+      # redefines the setter but keeps the first Attribute's accessor.
+      attribute :align, :string, values: %w[char left]
+      attribute :char, :integer
+      attribute :char, :string
+      # String names, mutated once defined: the accessors must keep
+      # reading the ivar named at definition time.
+      label = +"label"
+      notes = +"notes"
+      attribute label, :integer
+      attribute notes, :string, collection: true
+      label << "x"
+      notes << "x"
+
+      # A model may define its own #send; the setters must not dispatch
+      # through it.
+      define_method(:send) { |*| "domain-method" }
+
+      xml do
+        element "item"
+        ordered
+        map_attribute "name", to: :name
+        map_element "count", to: :count
+        map_element "tag", to: :tags
+        map_element "char", to: :char
+      end
+
+      key_value do
+        map "name", to: :name
+        map "count", to: :count
+        map "tags", to: :tags
+        map "char", to: :char
+      end
+    end
+    klass
+  end
+
+  # A model overriding the core methods the block form might dispatch
+  # through: the accessors must behave as the compiled ones do.
+  def override_model(klass)
+    klass.class_eval do
+      attribute :count, :integer
+      attribute :tags, :string, collection: true
+      %i[__send__ instance_variable_get instance_variable_set].each do |m|
+        define_method(m) { |*| :overridden }
+      end
+    end
+    m = klass.new
+    m.count = "5"
+    m.tags = %w[a]
+    m.tags("b")
+    # The collection getter itself reads through the overridden method,
+    # so check what was stored.
+    stored = ::Kernel.instance_method(:instance_variable_get)
+    [stored.bind_call(m, :@count), stored.bind_call(m, :@tags)]
+  end
+
+  # A model whose scope defines its own Array: appends must resolve the
+  # constant where the compiled getter does.
+  # Checked on the defining class and on a subclass that shadows Array,
+  # with the defining class overriding const_get.
+  def array_scope_model(klass)
+    klass.const_set(:Array, Class.new(::Array))
+    klass.class_eval { attribute :tags, :string, collection: true }
+    klass.define_singleton_method(:const_get) { |*| raise "const_get called" }
+    sub = Class.new(klass)
+    sub.const_set(:Array, ::Array)
+    [klass, sub].map do |k|
+      m = k.new
+      m.tags = %w[a]
+      m.tags("b")
+      ::Kernel.instance_method(:instance_variable_get).bind_call(m, :@tags)
+    end
+  end
+
+  # Raw-state readers after the state defaults compiled for a smaller
+  # attribute set: an attribute imported later, and one declared later,
+  # must both get a reader (#933).
+  def late_raw_readers(klass)
+    klass.class_eval { attribute :name, :string }
+    klass.new
+    imported = Class.new(Lutaml::Model::Serializable) do
+      attribute :br, :string
+    end
+    klass.import_model_attributes(imported)
+    klass.class_eval { attribute :late, :string, collection: true }
+    m = klass.new
+    m.br = "b"
+    readers = %i[name br late].map do |a|
+      raw = m.public_send(:"__lutaml_raw_#{a}")
+      [a, Lutaml::Model::Utils.uninitialized?(raw), raw.equal?(Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION) || raw]
+    end
+    readers << register_choice_raw_reader
+  end
+
+  # A choice import into a non-default register merges attribute records
+  # without define_attribute_methods: only the state-defaults
+  # compilation gives the imported name its raw reader.
+  def register_choice_raw_reader
+    register = Lutaml::Model::Register.new(:raw_reader_block_form_spec)
+    Lutaml::Model::GlobalRegister.register(register)
+    imported = Class.new(Lutaml::Model::Serializable) do
+      attribute :br, :string, collection: true
+    end
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      choice { import_model_attributes(imported, :raw_reader_block_form_spec) }
+    end
+    klass.allocate_for_deserialization(:raw_reader_block_form_spec).__lutaml_raw_br
+      .equal?(Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION)
+  ensure
+    Lutaml::Model::GlobalRegister.unregister(:raw_reader_block_form_spec)
+  end
+
+  def build_model
+    define_model(Class.new(Lutaml::Model::Serializable))
+  end
+
+  def element_order(model)
+    model.element_order.map { |e| [e.type, e.name, e.text_content] }
+  end
+
+  def arity_error(model, name)
+    model.public_send(name, "1", "2")
+    nil
+  rescue ArgumentError => e
+    e.message
+  end
+
+  def observe(klass)
+    fresh = klass.new
+    set = klass.new
+    set.name = "a"
+    set.count = "5"
+    set.tags("x")
+    set.tags("y")
+    set.char = "7"
+    # A parsed instance with no tags still holds the lazy sentinel.
+    emptied = klass.from_xml('<item name="z"/>')
+    sentinel_before_nil = emptied.instance_variable_get(:@tags)
+      .equal?(Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION)
+    emptied.tags = nil
+    xml = set.to_xml
+    parsed = klass.from_xml(xml)
+
+    seed = klass.__send__(:compiled_state_defaults_name!, :default)
+    seeded = klass.new.__send__(seed)
+
+    {
+      seed_return: [seeded.class, seeded.equal?(Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION)],
+      fresh_scalar_uninitialized: Lutaml::Model::Utils.uninitialized?(
+        fresh.instance_variable_get(:@name),
+      ),
+      fresh_collection_sentinel: fresh.instance_variable_get(:@tags)
+        .equal?(Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION),
+      fresh_readers: [fresh.name, fresh.count, fresh.tags],
+      set_readers: [set.name, set.count, set.tags, set.char],
+      set_using_default: %i[name count tags].map { |a| set.using_default?(a) },
+      sentinel_before_nil: sentinel_before_nil,
+      nil_keeps_sentinel: emptied.instance_variable_get(:@tags)
+        .equal?(Lutaml::Model::Serialize::LAZY_EMPTY_COLLECTION),
+      getter_with_arg: klass.new.tap { |m| m.count("3") }.count,
+      assign_parsed_skips_cast: klass.new.tap { |m| m.__assign_parsed_count = "3" }.count,
+      built_order: element_order(klass.new do |m|
+        m.count = "1"
+        m.tags = %w[p q]
+        m.tags("r")
+      end),
+      string_names: klass.new.tap do |m|
+        m.label = "4"
+        m.notes("n")
+      end.then { |m| [m.label, m.notes, m.instance_variables.grep(/label|notes/).sort] },
+      two_args: %i[count tags label notes].map { |a| arity_error(klass.new, a) },
+      xml: xml,
+      json: set.to_json,
+      parsed: [parsed.name, parsed.count, parsed.tags, parsed.char],
+      parsed_equal: parsed == set,
+    }
+  end
+end
+
+RSpec.describe Lutaml::Model::Serialize::AttributeDefinition do
+  let(:compiled) { AttributeDefinitionBlockFormSpec.observe(AttributeDefinitionBlockFormSpec.build_model) }
+
+  it "compiles accessors from source by default on MRI" do
+    expect(described_class.source_compilation?).to be(true)
+  end
+
+  it "defines the block form without String class_eval and matches the compiled form" do
+    expected = compiled
+    allow(described_class).to receive(:source_compilation?).and_return(false)
+    klass = Class.new(Lutaml::Model::Serializable)
+    allow(klass).to receive(:class_eval).and_wrap_original do |original, *args, &block|
+      raise "String class_eval used: #{args.first}" if args.first.is_a?(String)
+
+      original.call(*args, &block)
+    end
+    AttributeDefinitionBlockFormSpec.define_model(klass)
+
+    expect(AttributeDefinitionBlockFormSpec.observe(klass)).to eq(expected)
+  end
+
+  it "does not dispatch through a model's own core methods" do
+    expected = AttributeDefinitionBlockFormSpec.override_model(Class.new(Lutaml::Model::Serializable))
+    allow(described_class).to receive(:source_compilation?).and_return(false)
+    actual = AttributeDefinitionBlockFormSpec.override_model(Class.new(Lutaml::Model::Serializable))
+
+    expect(actual).to eq(expected)
+  end
+
+  it "resolves Array in the model's scope when appending" do
+    expected = AttributeDefinitionBlockFormSpec.array_scope_model(Class.new(Lutaml::Model::Serializable))
+    allow(described_class).to receive(:source_compilation?).and_return(false)
+    actual = AttributeDefinitionBlockFormSpec.array_scope_model(Class.new(Lutaml::Model::Serializable))
+
+    expect(actual).to eq(expected)
+  end
+
+  it "defines raw-state readers for imported and late attributes as the compiled form does" do
+    expected = AttributeDefinitionBlockFormSpec.late_raw_readers(Class.new(Lutaml::Model::Serializable))
+    allow(described_class).to receive(:source_compilation?).and_return(false)
+    actual = AttributeDefinitionBlockFormSpec.late_raw_readers(Class.new(Lutaml::Model::Serializable))
+
+    expect(actual).to eq(expected)
+  end
+end

data/spec/lutaml/model/writer_assigned_attribute_spec.rb

@@ -43,9 +43,9 @@ end
 # unmatched-rule replay must never overwrite a value a writer assigned.
 RSpec.describe "attributes assigned inside another attribute's writer" do
   %i[Plain Defaulted].each do |klass_name|
-    klass = WriterAssigned.const_get(klass_name)
-
     describe "with #{klass_name.to_s.downcase} text attribute" do
+      let(:klass) { WriterAssigned.const_get(klass_name) }
+
       it "keeps the derived value through from_xml" do
         instance = klass.from_xml("<probe><code>67.060</code></probe>")
 

data/spec/lutaml/xml/opal_xml_spec.rb

@@ -144,4 +144,51 @@ RSpec.describe "XML adapters under Opal", if: RUBY_ENGINE == "opal" do
       expect(Lutaml::Model::Config.xml_adapter_type).to eq(:rexml)
     end
   end
+
+  # Opal does not carry modules prepended into Serialize over to
+  # Serializable, which included it at boot; lib/lutaml/model.rb and
+  # lib/lutaml/xml/format.rb prepend onto Serializable directly.
+  describe "Serializable subclasses" do
+    before { Lutaml::Model::Config.xml_adapter_type = :oga }
+
+    it "builds an ordered model from a builder block" do
+      klass = Class.new(Lutaml::Model::Serializable) do
+        attribute :first, :string
+        attribute :second, :string
+        xml do
+          element "pair"
+          ordered
+          map_element "first", to: :first
+          map_element "second", to: :second
+        end
+      end
+
+      instance = klass.new do
+        second "b"
+        first "a"
+      end
+
+      expect([instance.first, instance.second]).to eq(%w[a b])
+      expect(instance.element_order.map(&:name)).to eq(%w[second first])
+      expect(instance.to_xml)
+        .to include("<pair><second>b</second><first>a</first></pair>")
+    end
+
+    it "installs the XML accessors on a plain model class" do
+      plain = Class.new { attr_accessor :name }
+      mapper = Class.new(Lutaml::Model::Serializable) do
+        model plain
+        attribute :name, :string
+        xml do
+          element "person"
+          map_element "name", to: :name
+        end
+      end
+
+      expect(plain.method_defined?(:encoding=)).to be true
+      parsed = mapper.from_xml("<person><name>Alice</name></person>")
+      expect(parsed).to be_a(plain)
+      expect(parsed.name).to eq("Alice")
+    end
+  end
 end

data/spec/lutaml/xml/plan_fast_path_spec.rb

@@ -64,10 +64,12 @@ RSpec.describe "XML plan fast path" do
     expect(parsed).to be_a(node)
   end
 
-  # lutaml-model#744: attribute plan rows are local-name keyed — a
-  # type-namespaced attribute (xmi:type vs type) must take the
-  # interpretive matcher, or the namespaced value is silently lost.
-  it "opts models with type-namespaced attributes out to the interpretive path" do
+  # lutaml-model#744/#758: a local name claimed by BOTH a
+  # type-namespaced attribute row and a plain row stays interpretive —
+  # the walk's ns form :none matches any qualification, so the plain
+  # row would capture the qualified spelling too. The interpretive
+  # matcher dispatches the spellings correctly.
+  it "opts shared-local-name attribute claims out to the interpretive path" do
     xmi_ns = Class.new(Lutaml::Xml::Namespace) do
       uri "http://www.omg.org/spec/XMI/20131001"
       prefix_default "xmi"

data/spec/lutaml/xml/plan_namespaced_serialize_spec.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XML plan serializer: namespaced models" do
+  # lutaml-model#847: the plan path used to refuse namespaced models
+  # outright (the xmlns dropped). The DOM emission now spells prefixed
+  # names, hoists every distinct (prefix, uri) declaration exactly once
+  # onto the output root, and prefixes type-namespaced attribute rows —
+  # byte-equal with the interpretive writer.
+
+  let(:wml_ns) do
+    Class.new(Lutaml::Xml::Namespace) do
+      uri "http://example.com/gate2/wml"
+      prefix_default "w"
+    end
+  end
+
+  let(:val_type) do
+    stub_const("Gate2Ns::WmlNs", wml_ns)
+    type = Class.new(Lutaml::Model::Type::String) do
+      include Lutaml::Xml::Type::Configurable
+
+      xml do
+        namespace Gate2Ns::WmlNs
+      end
+    end
+    stub_const("Gate2Ns::ValType", type)
+    type
+  end
+
+  let(:doc_class) do
+    val_type
+    body_class
+    model = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, Gate2Ns::ValType
+      attribute :body, Gate2Ns::Body
+
+      xml do
+        element "document"
+        namespace Gate2Ns::WmlNs
+        map_attribute "name", to: :name
+        map_element "body", to: :body
+      end
+    end
+    stub_const("Gate2Ns::Document", model)
+    model
+  end
+
+  let(:body_class) do
+    val_type
+    model = Class.new(Lutaml::Model::Serializable) do
+      attribute :text, Gate2Ns::ValType, collection: true
+
+      xml do
+        element "body"
+        namespace Gate2Ns::WmlNs
+        map_element "t", to: :text
+      end
+    end
+    stub_const("Gate2Ns::Body", model)
+    model
+  end
+
+  let(:default_ns_model) do
+    ns = Class.new(Lutaml::Xml::Namespace) do
+      uri "http://example.com/gate2/default"
+    end
+    stub_const("Gate2Ns::DefaultNs", ns)
+    model = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+
+      xml do
+        element "root"
+        namespace Gate2Ns::DefaultNs
+        map_attribute "name", to: :name
+      end
+    end
+    stub_const("Gate2Ns::DefaultDoc", model)
+    model
+  end
+
+  around do |example|
+    old = Lutaml::Model::Config.instance.xml_plan_fast_path
+    Lutaml::Model::Config.instance.xml_plan_fast_path = true
+    Lutaml::Model::Config.with_adapter(xml: :leptris) { example.run }
+  ensure
+    Lutaml::Model::Config.instance.xml_plan_fast_path = old
+  end
+
+  def plan_to_xml(klass, instance)
+    plan = Lutaml::Xml::Leptris::PlanCompiler.compile(
+      klass, Lutaml::Model::Config.default_register
+    )
+    Lutaml::Xml::Leptris::PlanSerializer.call(
+      instance, plan, Lutaml::Model::Config.default_register
+    )
+  end
+
+  it "emits prefixed names with the declaration exactly once" do
+    instance = doc_class.new(
+      name: "d1",
+      body: body_class.new(text: ["hello"]),
+    )
+
+    out = plan_to_xml(doc_class, instance)
+    expect(out).to include(%(xmlns:w="http://example.com/gate2/wml"))
+    expect(out.scan("xmlns:w=").count).to eq(1)
+    expect(out).to include("<w:document")
+    expect(out).to include("w:name=\"d1\"")
+    expect(out).to include("<w:body>")
+    expect(out).to include("<w:t>hello</w:t>")
+  end
+
+  # The plan path spells the type-namespaced attribute w:name=; the
+  # interpretive writer emits name= unprefixed (a long-standing
+  # interpretive serialize gap — the unprefixed form does not rebind
+  # to the (URI, local) rule on reparse). Element tree, declarations,
+  # and values are compared; the attribute spelling divergence is
+  # pinned by the round-trip example below.
+  it "matches the interpretive element tree and declarations" do
+    instance = doc_class.new(
+      name: "d1",
+      body: body_class.new(text: ["hello", "world"]),
+    )
+
+    interpretive = Lutaml::Model::Config.with_adapter(xml: :nokogiri) do
+      instance.to_xml
+    end
+
+    plan_out = plan_to_xml(doc_class, instance)
+    expect(plan_out.sub(" w:name=\"d1\"", "")).to eq(
+      interpretive.sub(" name=\"d1\"", "").strip,
+    )
+  end
+
+  it "round-trips through the plan parse path" do
+    instance = doc_class.new(
+      name: "d1",
+      body: body_class.new(text: ["hello"]),
+    )
+    xml = plan_to_xml(doc_class, instance)
+
+    reparsed = doc_class.from_xml(xml)
+    expect(reparsed.name).to eq("d1")
+    expect(reparsed.body.text).to eq(["hello"])
+  end
+
+  it "spells default-namespace models unprefixed with xmlns on the root" do
+    instance = default_ns_model.new(name: "plain")
+
+    out = plan_to_xml(default_ns_model, instance)
+    expect(out).to include(%(xmlns="http://example.com/gate2/default"))
+    expect(out).to include("<root")
+    expect(out).not_to include("xmlns:xmlns")
+  end
+end

data/spec/lutaml/xml/plan_ns_less_document_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe "XML plan fast path: namespace-less models on namespaced documents" do
+  # lutaml-model#932: elements (unlike attributes) inherit the default
+  # xmlns, so the walk's strict no-URI default dropped every child of a
+  # namespaced document for models that declare no namespace. The
+  # ns_lenient flag restores the interpretive matcher's behavior:
+  # children match by local name under any document qualification.
+
+  let(:child_class) do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :fileref, :string
+
+      xml do
+        element "imagedata"
+        map_attribute "fileref", to: :fileref
+      end
+    end
+    stub_const("NsLessDoc::Imagedata", klass)
+    klass
+  end
+
+  def define_parent
+    child_class
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :imagedata, NsLessDoc::Imagedata
+      attribute :content, :string, collection: true
+
+      xml do
+        element "imageobject"
+        map_element "imagedata", to: :imagedata
+        map_content to: :content
+      end
+    end
+    
+  end
+
+  around do |example|
+    old = Lutaml::Model::Config.instance.xml_plan_fast_path
+    Lutaml::Model::Config.instance.xml_plan_fast_path = true
+    Lutaml::Model::Config.with_adapter(xml: :leptris) { example.run }
+  ensure
+    Lutaml::Model::Config.instance.xml_plan_fast_path = old
+  end
+
+  it "binds nested children under a default namespace" do
+    parent = define_parent
+    doc = '<imageobject xmlns="http://docbook.org/ns/docbook">' \
+          '<imagedata fileref="x.png"/></imageobject>' 
+
+    expect(parent.from_xml(doc).imagedata.fileref).to eq("x.png")
+  end
+
+  it "binds nested children under a prefixed namespace" do
+    parent = define_parent
+    doc = '<db:imageobject xmlns:db="http://docbook.org/ns/docbook">' \
+          '<db:imagedata fileref="x.png"/></db:imageobject>' 
+
+    expect(parent.from_xml(doc).imagedata.fileref).to eq("x.png")
+  end
+
+  it "keeps binding on namespace-less documents" do
+    parent = define_parent
+    doc = %(<imageobject><imagedata fileref="x.png"/></imageobject>)
+
+    expect(parent.from_xml(doc).imagedata.fileref).to eq("x.png")
+  end
+
+  it "binds nested children of mixed-content models under a default namespace" do
+    parent = define_parent
+    parent.xml do
+      element "imageobject"
+      mixed_content
+      map_content to: :content
+      map_element "imagedata", to: :imagedata
+    end
+    doc = '<imageobject xmlns="http://docbook.org/ns/docbook">' \
+          'text<imagedata fileref="x.png"/>tail</imageobject>' 
+
+    parsed = parent.from_xml(doc)
+    expect(parsed.imagedata.fileref).to eq("x.png")
+    expect(parsed.content).to include("text")
+  end
+end