lutaml-model 0.8.95 → 0.8.96

data/lib/lutaml/xml/leptris/plan_serializer.rb

@@ -38,16 +38,84 @@ module Lutaml
             return nil if plan[:ordered] && instance.element_order.nil?
 
             doc = ::Leptris::XML::Document.create
-            root = doc.create_element(plan[:tree][:name])
+            ns_ctx = Namespaces.new(plan)
+            return nil if ns_ctx.unspellable?
+
+            root = doc.create_element(
+              ns_ctx.spell(plan[:tree][:name], plan[:tree][:ns]),
+            )
             doc.root = root
+            ns_ctx.declare_on(root)
             if plan[:ordered]
               build_ordered(root, instance, plan, doc, register)
             else
-              build(root, instance, plan, doc, register)
+              build(root, instance, plan, doc, register, ns_ctx)
             end
             doc.to_xml(indent: 2, no_decl: true)
           end
 
+          # Namespace spelling for namespaced plans (#847): every ns
+          # form resolves to a wire spelling (prefix:local, or local
+          # under a default xmlns), and every distinct (prefix, uri)
+          # pair is declared exactly once on the output root in
+          # first-encounter order — the #1558 contract on the DOM
+          # path. A nested plan's own tree ns overrides the inherited
+          # one; rows without an ns form inherit.
+          class Namespaces
+            attr_reader :unspellable
+
+            def initialize(plan)
+              @forms = {}
+              @declared = {}
+              @unspellable = false
+              collect(plan[:tree])
+            end
+
+            def unspellable?
+              @unspellable
+            end
+
+            def collect(tree)
+              register(tree[:ns])
+              (tree[:attributes] || []).each { |attr| register(attr[:ns]) }
+              (tree[:children] || []).each do |row|
+                register(row[:ns]) if row[:ns].is_a?(Hash)
+                collect(row[:plan]) if row[:kind] == :nested && row[:plan]
+              end
+            end
+
+            def register(ns_form)
+              return if ns_form.nil? || ns_form == :none || ns_form == :any
+
+              form = { prefix: ns_form[:prefix], uri: ns_form[:exact] }
+              @forms[ns_form[:exact]] ||= form
+              @unspellable = true if ns_form[:exact] && !ns_form.key?(:prefix)
+            end
+
+            # The wire spelling for a local name under this form.
+            def spell(local, ns_form = nil)
+              form = ns_form.is_a?(Hash) ? ns_form : @forms[ns_form]
+              prefix = form && form[:prefix]
+              prefix ? "#{prefix}:#{local}" : local
+            end
+
+            def form_for(ns_form)
+              return nil if ns_form.nil? || ns_form == :none
+
+              ns_form.is_a?(Hash) ? ns_form : @forms[ns_form]
+            end
+
+            def declare_on(root)
+              @forms.each_value do |form|
+                key = form[:uri]
+                next if key.nil? || @declared[key]
+
+                @declared[key] = true
+                root.add_namespace_definition(form[:prefix], form[:uri])
+              end
+            end
+          end
+
           # Whether the compiled plan is serialize-shaped. Ordered/mixed
           # models serialize through build_ordered from element_order;
           # plain models through plan rows.
@@ -63,9 +131,10 @@ module Lutaml
             Lutaml::Model::Config.default_register
           end
 
-          def build(element, instance, plan, doc, reg = nil)
+          def build(element, instance, plan, doc, reg = nil, ns_ctx = nil,
+                    inherited_ns = nil)
             reg ||= register
-            write_attributes(element, instance, plan, reg)
+            write_attributes(element, instance, plan, reg, ns_ctx)
             plan[:rows].each do |rule, attr, kind, spelling, delegate|
               value = value_of(instance, attr, delegate)
               next unless rule.render?(value, instance)
@@ -76,33 +145,46 @@ module Lutaml
                 # several occurrences serializes one element per item,
                 # as the interpretive writer does. A plain scalar skips
                 # the Array() wrap — the common case.
+                row_ns = plan[:tree][:children]&.find do |r|
+                  r[:name] == rule.name.to_s
+                end&.[](:ns) || inherited_ns
                 if value.is_a?(::Array)
                   value.each do |item|
-                    add_leaf(element, row_name(rule, spelling),
+                    add_leaf(element,
+                             ns_ctx ? ns_ctx.spell(row_name(rule, spelling), row_ns) : row_name(rule, spelling),
                              attr.serialize(item, :xml, reg), doc,
                              attrs: rule.when_attribute)
                   end
                 else
-                  add_leaf(element, row_name(rule, spelling),
+                  add_leaf(element,
+                           ns_ctx ? ns_ctx.spell(row_name(rule, spelling), row_ns) : row_name(rule, spelling),
                            attr.serialize(value, :xml, reg), doc,
                            attrs: rule.when_attribute)
                 end
               when :collection_native, :collection_cb
+                row_ns = plan[:tree][:children]&.find do |r|
+                  r[:name] == rule.name.to_s
+                end&.[](:ns) || inherited_ns
                 Array(value).each do |item|
-                  add_leaf(element, rule.name.to_s,
+                  add_leaf(element,
+                           ns_ctx ? ns_ctx.spell(rule.name.to_s, row_ns) : rule.name.to_s,
                            attr.serialize(item, :xml, reg), doc,
                            attrs: rule.when_attribute)
                 end
               when :nested, :ordered_deferred
                 Array(value).each do |item|
                   child_plan = PlanCompiler.compile(item.class, reg)
-                  child = element.create_child(child_plan[:tree][:name])
+                  child_ns = child_plan[:tree][:ns] || inherited_ns
+                  child = element.create_child(
+                    ns_ctx ? ns_ctx.spell(child_plan[:tree][:name], child_ns) : child_plan[:tree][:name],
+                  )
+                  ns_ctx&.collect(child_plan[:tree])
                   if child_plan[:ordered]
-                    return nil unless build_ordered(child, item, child_plan,
-                                                    doc, reg)
+                    next unless build_ordered(child, item, child_plan,
+                                              doc, reg, ns_ctx, child_ns)
 
                   else
-                    build(child, item, child_plan, doc, reg)
+                    build(child, item, child_plan, doc, reg, ns_ctx, child_ns)
                   end
                 end
               when :raw
@@ -121,9 +203,11 @@ module Lutaml
           # the model are reflected; element_order text is the fallback.
           # PIs drop (interpretive parity). Returns nil when a nested
           # ordered child lacks element_order (caller falls back).
-          def build_ordered(element, instance, plan, doc, reg = nil)
+          def build_ordered(element, instance, plan, doc, reg = nil,
+                            ns_ctx = nil, _inherited_ns = nil)
             reg ||= register
-            write_attributes(element, instance, plan, reg)
+            ns_ctx&.collect(plan[:tree])
+            write_attributes(element, instance, plan, reg, ns_ctx)
             rows_by_name = {}
             plan[:rows].each do |rule, attr, kind, spelling, delegate|
               next unless rule.name
@@ -213,8 +297,16 @@ module Lutaml
 
           # Attributes in document order when the instance recorded it
           # (parsed models), else plan row order.
-          def write_attributes(element, instance, plan, _reg = nil)
+          def write_attributes(element, instance, plan, reg = nil,
+                               ns_ctx = nil)
             recorded = instance.attribute_order
+            attr_prefixes = {}
+            if ns_ctx
+              (plan[:tree][:attributes] || []).each do |a|
+                form = a[:ns].is_a?(Hash) ? a[:ns] : nil
+                attr_prefixes[a[:name]] = form && form[:prefix]
+              end
+            end
             if recorded && !recorded.empty?
               by_name = {}
               plan[:attr_rows].each do |rule, attr, _sp, delegate|
@@ -223,24 +315,28 @@ module Lutaml
               names = recorded |
                 plan[:attr_rows].map { |rule, _a, _s, _d| rule.name.to_s }
               names.each do |name|
-                write_attribute(element, instance, name, by_name[name])
+                write_attribute(element, instance, name, by_name[name],
+                                reg, attr_prefixes[name])
               end
             else
               plan[:attr_rows].each do |rule, attr, _sp, delegate|
                 write_attribute(element, instance, rule.name.to_s,
-                                [rule, attr, delegate])
+                                [rule, attr, delegate], reg,
+                                attr_prefixes[rule.name.to_s])
               end
             end
           end
 
-          def write_attribute(element, instance, name, entry, reg = nil)
+          def write_attribute(element, instance, name, entry, reg = nil,
+                              prefix = nil)
             return unless entry
 
             _rule, attr, delegate = entry
             value = value_of(instance, attr, delegate)
             return if value.nil?
 
-            element.set_attribute(name,
+            spelled = prefix ? "#{prefix}:#{name}" : name
+            element.set_attribute(spelled,
                                   attr.serialize(value, :xml, reg || register).to_s)
           end
 

data/lib/lutaml/xml/leptris.rb

@@ -21,6 +21,18 @@ module Lutaml
       # type-namespaced attributes on the interpretive path.
       MIN_LEPTRIS_ATTR_NS_VERSION = "1.9.289.0"
 
+      # Nested child plans capture their declared attribute rows
+      # correctly again as of 1.9.313.0 (leptris#1563: the walk dropped
+      # children's attribute capture when the parent plan carried an
+      # exact-URI attribute row). Older gems keep those models
+      # interpretive.
+      MIN_LEPTRIS_NESTED_ATTR_VERSION = "1.9.313.0"
+
+      # Wildcard child rows (leptris#1552: named-rows-take-precedence
+      # two-pass walk, ns-form aware, type_tag echo) — the plan path's
+      # map_any_element catch-all. Ships with the 1.9.313 binding.
+      MIN_LEPTRIS_WILDCARD_VERSION = "1.9.313.0"
+
       def self.plan_path_compatible?
         return false unless defined?(Gem)
 
@@ -35,6 +47,20 @@ module Lutaml
         spec && spec.version >= Gem::Version.new(MIN_LEPTRIS_ATTR_NS_VERSION)
       end
 
+      def self.nested_attr_capture_compatible?
+        return false unless defined?(Gem)
+
+        spec = Gem.loaded_specs["leptris"]
+        spec && spec.version >= Gem::Version.new(MIN_LEPTRIS_NESTED_ATTR_VERSION)
+      end
+
+      def self.wildcard_rows_compatible?
+        return false unless defined?(Gem)
+
+        spec = Gem.loaded_specs["leptris"]
+        spec && spec.version >= Gem::Version.new(MIN_LEPTRIS_WILDCARD_VERSION)
+      end
+
       autoload :PlanCompiler, "lutaml/xml/leptris/plan_compiler"
       autoload :PlanHydrator, "lutaml/xml/leptris/plan_hydrator"
       autoload :PlanOrder, "lutaml/xml/leptris/plan_order"

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/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