lutaml-model 0.8.136 → 0.8.138

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 78585d088d67236f3378f1860c5916e37a1bad8bde58bb48954fe8057ada72b9
-  data.tar.gz: afbf8b41d1b733685ad4d066c07e5217eff0674a1eb66bbbc75e6d9cdd2bf31e
+  metadata.gz: 9b04af29b0ab95619a185f91ca138ff213b771112707395df0aea9d093978aa5
+  data.tar.gz: c3830c610420cceb888b370417cf2f83a044aa00e10cb3bca7c71c3833587dc4
 SHA512:
-  metadata.gz: c2b9f8b00bfcc541d7ccebc179c9d0ce13fc530c594d605d7c4aeafd5dc1eb386c253eebdcc597a3257be3978e1fe74b8ba19b9bc05053d45a4662bd0bae7c63
-  data.tar.gz: 5e739f42a165ca2280473a03addd0418061f584e28d1f0d8fc7a015e0855a30e56dab47b47024bbc3fdc4ded50927654e2659a5d00ea5bd68b6c997cfca54224
+  metadata.gz: 205e61d1960bfff5771363582c8db6600f6f703a255b69e7684d40abc04434dc9ef786ec260518930afb4584db219acade52068975fea7ac39604cab82891d28
+  data.tar.gz: 1a19fc45f5880487573f2849203247015edd843f9c7000a6de992c70aaa439dbcc36e4741f1027b0ca441ee8358ec3ce1559e3f877f91476b80a3b661a3fecfd

data/.github/workflows/dependent-tests.yml

@@ -25,7 +25,12 @@ jobs:
   rake:
     uses: metanorma/ci/.github/workflows/dependent-rake.yml@main
     with:
-      command: bundle exec rspec
+      # #1020: the spec-file count distinguishes a truncated checkout from
+      # a full one, and the explicit rspec-exit line separates an
+      # in-process exit (green summary, nonzero code) from test failures.
+      # set +e keeps the capture alive under the runner's errexit; the
+      # final exit preserves rspec's own status — nothing is masked.
+      command: set +e; echo "spec-files=$(find spec -name '*_spec.rb' 2>/dev/null | wc -l)"; bundle exec rspec > rspec-run.log 2>&1; code=$?; echo "rspec-exit=$code"; tail -25 rspec-run.log; exit $code
       repos-json-file: .github/workflows/dependent-repos.json
       after-setup-ruby: |
         if [ -f frontend/package.json ]; then cd frontend && npm install && npm run build; fi
@@ -39,7 +44,7 @@ jobs:
   rake-with-tools:
     uses: metanorma/ci/.github/workflows/dependent-rake.yml@main
     with:
-      command: bundle exec rspec
+      command: set +e; echo "spec-files=$(find spec -name '*_spec.rb' 2>/dev/null | wc -l)"; bundle exec rspec; code=$?; echo "rspec-exit=$code"; exit $code
       repos-json-file: .github/workflows/dependent-repos-tools.json
       setup-tools: 'inkscape,ghostscript,exiftool,ffmpeg,imagemagick,yq'
       after-setup-ruby: |

data/lib/lutaml/model/serialize/initialization.rb

@@ -370,11 +370,33 @@ module Lutaml
         def allocate_for_walk(register = nil)
           register_id = extract_register_id(register)
           ensure_imports!(register_id) if finalized? && deferred_imports_pending?(register_id)
+          # Classes with their own initialize set up internal state the
+          # compiled seed cannot know about (SchemaRepository's
+          # @parsed_schemas/@namespace_registry/@type_index): construct
+          # through the real constructor for them, exactly as the walk
+          # did before the compiled seed existed. The seed stays the
+          # fast path for classes using the standard initializer.
+          return new(lutaml_register: register) if constructs_through_initialize?
+          # did before the compiled seed existed, register included. The
+          # seed stays the fast path for classes using the standard
+          # initializer.
+          return new(lutaml_register: register) if constructs_through_initialize?
+
           instance = allocate
           instance.init_walk_state(register_id)
           instance
         end
 
+        # True when the class does not use Serializable's standard
+        # initializer — its initialize is constructor contract, not
+        # optional setup, and the compiled walk seed would skip it.
+        # (The standard initializer's owner is Serialize::Builder; a
+        # class- or parent-defined initialize makes the owner the class.)
+        def constructs_through_initialize?
+          @constructs_through_initialize ||=
+            instance_method(:initialize).owner != Lutaml::Model::Serialize::Builder
+        end
+
         def allocate_for_deserialization(register = nil)
           register_id = extract_register_id(register)
           # Deferred imports (symbol-form import_model_attributes) must
@@ -389,6 +411,14 @@ module Lutaml
           # stack limit — models without pending deferred imports skip
           # it entirely.
           ensure_imports!(register_id) if finalized? && deferred_imports_pending?(register_id)
+          # Custom-initialize classes (#1032's twin): their initialize is
+          # constructor contract — internal state the compiled seeding
+          # cannot know about — so they construct through the real
+          # constructor, then carry the parse's register context.
+          if constructs_through_initialize?
+            instance = new(lutaml_register: register_id)
+            return instance
+          end
           instance = allocate
           instance.finalize_deserialization(register_id)
           instance

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.136"
+    VERSION = "0.8.138"
   end
 end

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

@@ -122,6 +122,8 @@ module Lutaml
             # them (compiling here silently dropped pi_settings).
             return opt_out!(:processing_instruction) unless
               mapping.processing_instruction_mappings.empty?
+            # Wildcard attribute families ride the interpretive path too
+            return opt_out!(:all_attributes) if mapping.all_attributes_rule
 
             rows = []
             attr_rows = [] # [[rule, attr, row_name]] hydration metadata

data/lib/lutaml/xml/mapping.rb

@@ -38,7 +38,7 @@ module Lutaml
         @xml_instance
       end
 
-      attr_reader :root_element, :namespace_uri, :namespace_prefix, :element_sequence, :mappings_imported, :namespace_class, :namespace_param, :element_name, :documentation_text, :type_name_value, :namespace_scope, :mapper_class, :xml_space, :consolidation_maps, :processing_instruction_mappings, :any_element_rule
+      attr_reader :root_element, :namespace_uri, :namespace_prefix, :element_sequence, :mappings_imported, :namespace_class, :namespace_param, :element_name, :documentation_text, :type_name_value, :namespace_scope, :mapper_class, :xml_space, :consolidation_maps, :processing_instruction_mappings, :any_element_rule, :all_attributes_rule
 
       def initialize
         super
@@ -49,6 +49,7 @@ module Lutaml
         @element_sequence = []
         @content_mapping = nil
         @raw_mapping = nil
+        @all_attributes_rule = nil
         @mixed_content = false
         @xml_space = nil
         @format = :xml
@@ -875,6 +876,26 @@ module Lutaml
         )
       end
 
+      # Capture every attribute not claimed by an explicit map_attribute
+      # (and matching an optional pattern) into a Hash attribute, and emit
+      # it back as attributes after the mapped ones on serialization —
+      # the remainder semantics of map_all, for attribute families
+      # (lutaml-model#1031): HTML data-*, ARIA aria-*, on* handlers.
+      #
+      # @param to [Symbol] the Hash attribute name
+      # @param matching [Regexp, nil] optional name filter; nil captures
+      #   every unclaimed attribute
+      #
+      # @example
+      #   xml do
+      #     element "mn"
+      #     map_attribute "name", to: :name
+      #     map_all_attributes to: :other_attributes, matching: /\A(data-|aria-|on)/
+      #   end
+      def map_all_attributes(to:, matching: nil)
+        @all_attributes_rule = AllAttributesMapping.new(to, matching)
+      end
+
       def sequence(&block)
         @element_sequence << ::Lutaml::Model::Sequence.new(self,
                                                            format: :xml).tap do |s|
@@ -1681,5 +1702,21 @@ module Lutaml
         self.class.new(@target.dup, @to)
       end
     end
+
+    # Wildcard attribute-family mapping (#1031): the target Hash collects
+    # every attribute no explicit map_attribute claims and that matches
+    # the optional pattern; serialization emits each pair as an attribute.
+    class AllAttributesMapping
+      attr_reader :to, :matching
+
+      def initialize(to, matching)
+        @to = to
+        @matching = matching
+      end
+
+      def dup
+        self.class.new(@to, @matching)
+      end
+    end
   end
 end

data/lib/lutaml/xml/model_transform.rb

@@ -503,11 +503,50 @@ module Lutaml
         apply_processing_instruction_deserialization(doc, instance, xml_mapping,
                                                      effective_register)
 
+        apply_all_attributes_deserialization(doc, instance, xml_mapping)
+
         run_consolidation(instance, effective_register, instance_is_serialize)
 
         instance
       end
 
+      # #1031: wildcard attribute families. After the explicit attribute
+      # rules have consumed their names, every remaining unprefixed
+      # attribute matching the rule's pattern lands in the target Hash —
+      # names claimed by explicit rules never leak into it.
+      def apply_all_attributes_deserialization(doc, instance, xml_mapping)
+        rule = xml_mapping.all_attributes_rule
+        return if rule.nil?
+
+        element = doc.is_a?(::Lutaml::Xml::XmlElement) ? doc : doc.root
+        return if element.nil?
+
+        claimed = attribute_names_claimed_by_rules(xml_mapping)
+        remainder = {}
+        element.attributes.each_value do |attr|
+          name = attr.unprefixed_name.to_s
+          next if claimed.include?(name)
+          next if rule.matching && !rule.matching.match?(name)
+
+          remainder[name] = attr.value
+        end
+        return if remainder.empty?
+
+        instance.public_send(:"#{rule.to}=", remainder)
+        instance.value_set_for(rule.to) if instance.is_a?(::Lutaml::Model::Serialize)
+      end
+
+      # Attribute names claimed by explicit map_attribute rules, plus the
+      # engine-handled schemaLocation (which renders through
+      # raw_schema_location, not the remainder).
+      def attribute_names_claimed_by_rules(xml_mapping)
+        names = %w[schemaLocation]
+        xml_mapping.mapping_attributes_hash.each_value do |rule_or_array|
+          Array(rule_or_array).each { |rule| names << rule.name.to_s }
+        end
+        names
+      end
+
       def validate_document!(doc, options)
         return unless doc.is_a?(Array)
 

data/lib/lutaml/xml/transformation.rb

@@ -101,6 +101,9 @@ module Lutaml
           apply_standard_rules(root, model_instance, options)
         end
 
+        # The wildcard attribute family emits after the mapped attributes
+        apply_all_attributes_mappings(root, model_instance, mapping)
+
         root
       end
 
@@ -242,6 +245,27 @@ module Lutaml
       end
 
       # Check if element order should be used for serialization
+
+      # #1031: emit the wildcard attribute family after the mapped
+      # attributes. Attributes render in insertion order; the remainder
+      # follows the explicitly mapped names.
+      def apply_all_attributes_mappings(root, model_instance, mapping)
+        rule = mapping.all_attributes_rule
+        return if rule.nil?
+
+        value = model_instance.public_send(rule.to)
+        return if value.nil? || !value.is_a?(::Hash)
+
+        value.each do |name, attr_value|
+          next if attr_value.nil?
+
+          root.add_attribute(
+            ::Lutaml::Xml::DataModel::XmlAttribute.new(name.to_s,
+                                                       attr_value.to_s, nil),
+          )
+        end
+      end
+
       #
       # @param model_instance [Object] The model instance
       # @param mapping [Xml::Mapping] The mapping

data/spec/lutaml/model/map_all_attributes_spec.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# #1031: wildcard attribute families — every attribute no explicit
+# map_attribute claims and that matches the pattern lands in a Hash and
+# is emitted back after the mapped attributes on serialization.
+RSpec.describe "map_all_attributes" do
+  let(:model_class) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :data_attributes, :hash
+
+      xml do
+        element "mn"
+        map_attribute "name", to: :name
+        map_all_attributes to: :data_attributes, matching: /\A(data-|aria-|on)/
+      end
+    end
+  end
+
+  let(:stubbed) do
+    stub_const("MapAllAttributesModel", model_class)
+    MapAllAttributesModel
+  end
+
+  it "captures unclaimed, pattern-matching attributes into the Hash" do
+    xml = '<mn name="x" data-title="T" onclick="f()" aria-label="L" unre="nope"/>'
+    model = stubbed.from_xml(xml)
+
+    expect(model.name).to eq("x")
+    expect(model.data_attributes).to eq(
+      "data-title" => "T", "onclick" => "f()", "aria-label" => "L",
+    )
+  end
+
+  it "never lets mapped names leak into the remainder" do
+    xml = '<mn name="x" data-name="D"/>'
+    model = stubbed.from_xml(xml)
+
+    expect(model.data_attributes).to eq("data-name" => "D")
+  end
+
+  it "emits the remainder after the mapped attributes on serialization" do
+    model = stubbed.from_xml(
+      '<mn name="x" data-title="T" onclick="f()"/>',
+    )
+    out = model.to_xml
+
+    expect(out).to include('name="x"')
+    expect(out).to include('data-title="T"')
+    expect(out).to include('onclick="f()"')
+    expect(out.index("name=")).to be < out.index("data-title=")
+  end
+
+  it "round-trips losslessly" do
+    xml = '<mn name="x" data-title="T" onclick="f()" aria-label="L"/>'
+    model = stubbed.from_xml(xml)
+    round_tripped = stubbed.from_xml(model.to_xml)
+
+    expect(round_tripped.data_attributes).to eq(model.data_attributes)
+    expect(round_tripped.name).to eq(model.name)
+  end
+
+  it "emits nothing when the remainder is empty" do
+    model = stubbed.from_xml('<mn name="x"/>')
+    out = model.to_xml
+
+    expect(out).not_to include("data-")
+  end
+
+  it "captures every unclaimed attribute when no pattern is given" do
+    klass = Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :other_attributes, :hash
+
+      xml do
+        element "el"
+        map_attribute "name", to: :name
+        map_all_attributes to: :other_attributes
+      end
+    end
+    stub_const("MapAllNoPatternModel", klass)
+
+    model = klass.from_xml('<el name="x" zeta="1"/>')
+
+    expect(model.other_attributes).to eq("zeta" => "1")
+  end
+end

data/spec/lutaml/model/walk_constructor_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# A class that defines its own initialize is built through it by the
+# from_* walk, and the walk hands it the register exactly as
+# `new(lutaml_register:)` did before the compiled seed existed: a
+# constructor that tells a blank construction from a caller's by that
+# keyword sees the same call either way.
+RSpec.describe "Walk construction of a custom-initialize class" do
+  let(:model) do
+    Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+
+      json do
+        map "name", to: :name
+      end
+
+      class << self
+        attr_accessor :constructions
+      end
+
+      def initialize(*args, **kwargs)
+        self.class.constructions << [args, kwargs.keys]
+        @internal = :ready
+        super
+      end
+
+      attr_reader :internal
+    end
+  end
+
+  before do
+    stub_const("WalkConstructorModel", model)
+    model.constructions = []
+  end
+
+  it "runs the class's own initialize" do
+    expect(model.from_json('{"name":"a"}').internal).to eq(:ready)
+  end
+
+  it "passes the register, as the walk did through new(lutaml_register:)" do
+    parsed = model.from_json('{"name":"a"}')
+
+    expect(model.constructions).to eq([[[], [:lutaml_register]]])
+    expect(parsed.name).to eq("a")
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.136
+  version: 0.8.138
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-26 00:00:00.000000000 Z
+date: 2026-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -1796,6 +1796,7 @@ files:
 - spec/lutaml/model/liquid/indexed_access_spec.rb
 - spec/lutaml/model/liquid_compatibility_spec.rb
 - spec/lutaml/model/logger_spec.rb
+- spec/lutaml/model/map_all_attributes_spec.rb
 - spec/lutaml/model/map_all_spec.rb
 - spec/lutaml/model/map_content_spec.rb
 - spec/lutaml/model/map_unmapped_spec.rb
@@ -1912,6 +1913,7 @@ files:
 - spec/lutaml/model/value_map_spec.rb
 - spec/lutaml/model/value_policy_spec.rb
 - spec/lutaml/model/value_transformation_comprehensive_spec.rb
+- spec/lutaml/model/walk_constructor_spec.rb
 - spec/lutaml/model/with_child_mapping_spec.rb
 - spec/lutaml/model/writer_assigned_attribute_spec.rb
 - spec/lutaml/model/xml_decoupling_spec.rb