lutaml-model 0.8.134 → 0.8.136

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 250473959d5b49e40ab480a2acf1e708d2cac1f8d5b092995be03821bc758122
-  data.tar.gz: 59fc186602fae873d070d23baca950a2330a07abbb251acd16b3a63803877a93
+  metadata.gz: 78585d088d67236f3378f1860c5916e37a1bad8bde58bb48954fe8057ada72b9
+  data.tar.gz: afbf8b41d1b733685ad4d066c07e5217eff0674a1eb66bbbc75e6d9cdd2bf31e
 SHA512:
-  metadata.gz: 82c2a11ef5c20e8342280054b0053e7d07fcca92b71effc4224d6b006889f3873026890d894b98a0791add12444e1cb87cddab51ece3eee47f2d08e8a53106c0
-  data.tar.gz: 95ec3912247f014bc20a9bf2f3ec39a3fc1b0bdf5eeb2b932f55612446b5f3c45af21e6b37c28682b52541e842bc68b7099ce361b6b8184f93265e8254779873
+  metadata.gz: c2b9f8b00bfcc541d7ccebc179c9d0ce13fc530c594d605d7c4aeafd5dc1eb386c253eebdcc597a3257be3978e1fe74b8ba19b9bc05053d45a4662bd0bae7c63
+  data.tar.gz: 5e739f42a165ca2280473a03addd0418061f584e28d1f0d8fc7a015e0855a30e56dab47b47024bbc3fdc4ded50927654e2659a5d00ea5bd68b6c997cfca54224

data/lib/compat/opal/generate_boot.rb

@@ -28,6 +28,10 @@ NATIVE_ONLY_PATTERNS = [
   %r{/schema_builder/(nokogiri|oga)\b},
   %r{/schema/builder/(nokogiri|oga)\b},
   %r{\Alutaml/model/cli\z},
+  # leptris is an FFI wrapper over a native library — Opal::Builder dies
+  # on its requires (and FFI itself does not exist under Opal); the
+  # adapter probe degrades to moxml at runtime (#1008).
+  %r{\Alutaml/xml/leptris},
 ].freeze
 
 # Match `autoload :Name, "...anything..."` where the string argument may

data/lib/compat/opal/lutaml_model_boot.rb

@@ -148,7 +148,6 @@ require "lutaml/xml/format"
 require "lutaml/xml/format_chooser"
 require "lutaml/xml/hoisting_algorithm"
 require "lutaml/xml/html_entities"
-require "lutaml/xml/leptris"
 require "lutaml/xml/listener"
 require "lutaml/xml/mapping"
 require "lutaml/xml/mapping_rule"
@@ -399,12 +398,6 @@ require "lutaml/xml/error/namespace_mismatch_error"
 require "lutaml/xml/error/schema_validation_error"
 require "lutaml/xml/error/xml_configuration_error"
 require "lutaml/xml/error/xml_error"
-require "lutaml/xml/leptris/native_emission"
-require "lutaml/xml/leptris/plan_compiler"
-require "lutaml/xml/leptris/plan_hydrator"
-require "lutaml/xml/leptris/plan_order"
-require "lutaml/xml/leptris/plan_serializer"
-require "lutaml/xml/leptris/plan_walk"
 require "lutaml/xml/oga/element"
 require "lutaml/xml/ox/element"
 require "lutaml/xml/rexml/element"

data/lib/lutaml/model/union.rb

@@ -98,7 +98,26 @@ module Lutaml
               return [member, casted] unless casted == :no_match
             end
 
-            lenient_model_member(value, members, format, register)
+            widest_model_member(value, members, format, register) ||
+              lenient_model_member(value, members, format, register)
+          end
+
+          # No member maps every key, so the hash carries keys no rule claims
+          # (extension keywords, forward-compatible vocabularies): the model
+          # member mapping the most of its keys, the earlier one on a tie, as
+          # the keys no rule claims are ignored outside a union (#987).
+          def widest_model_member(value, members, format, register)
+            keys = input_keys(value, format)
+            return nil if keys.nil? || keys.empty?
+
+            counts = members.select { |member| model_member?(member) }.to_h do |member|
+              field_names = member_field_names(member, format, register)
+              [member, keys.count { |key| field_names.include?(key) }]
+            end
+            member, count = counts.max_by.with_index { |(_, mapped), index| [mapped, -index] }
+            return nil if member.nil? || count.zero?
+
+            [member, build_model(member, value, format, register)]
           end
 
           # With exactly one model member, a Hash that also carries unmapped
@@ -170,14 +189,12 @@ module Lutaml
             member.is_a?(::Class) && member.include?(Serialize)
           end
 
-          # Structural selection: at least one input key maps to one of the
-          # member's mapped fields. Keys no rule claims are ignored exactly
-          # as they are when the same hash reaches the model outside a
-          # union — extension keys (x-** vendor keywords, forward-compatible
-          # vocabularies) must not defeat dispatch (#987). Once selected,
-          # field values cast leniently via the member's normal path. An
-          # existing member instance conforms as-is, keeping conformance
-          # idempotent — values can re-enter casting (e.g. a value
+          # Structural (key-coverage) selection: every input key maps to one of
+          # the member's mapped fields, which is what tells members sharing a
+          # key apart. A hash no member covers falls to widest_model_member.
+          # Once selected, field values cast leniently via the member's normal
+          # path. An existing member instance conforms as-is, keeping
+          # conformance idempotent — values can re-enter casting (e.g. a value
           # transformer builds the member before the cast runs).
           def conform_model(member, value, format, register)
             return value if value.is_a?(member)
@@ -186,13 +203,17 @@ module Lutaml
             return :no_match if keys.nil? || keys.empty?
 
             field_names = member_field_names(member, format, register)
-            return :no_match unless keys.any? do |key|
+            return :no_match unless keys.all? do |key|
               field_names.include?(key)
             end
 
-            # Plain-Ruby assignment (format nil) builds straight from the
-            # attribute hash, mirroring how non-union model attributes accept
-            # `Model.new(child: { ... })`; a format builds via the mappings.
+            build_model(member, value, format, register)
+          end
+
+          # Plain-Ruby assignment (format nil) builds straight from the
+          # attribute hash, mirroring how non-union model attributes accept
+          # `Model.new(child: { ... })`; a format builds via the mappings.
+          def build_model(member, value, format, register)
             return member.new(value) if format.nil?
 
             member.apply_mappings(value, format, register: register)

data/lib/lutaml/model/version.rb

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

data/spec/lutaml/model/union_attribute_spec.rb

@@ -710,6 +710,76 @@ RSpec.describe "Union-typed attributes (issue #190)" do
     end
   end
 
+  describe "model members that share a key" do
+    # Two members both map "source"; only their other keys tell them
+    # apart. The member mapping every key wins over an earlier one that
+    # maps only the shared key, as before #987; with an extension key
+    # neither maps every key, so the member mapping the most keys wins.
+    let(:report) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :source, :string
+        attribute :issues, :string, collection: true
+        key_value do
+          map "source", to: :source
+          map "issues", to: :issues
+        end
+      end
+    end
+
+    let(:conversion) do
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :source, :string
+        attribute :target, :string
+        key_value do
+          map "source", to: :source
+          map "target", to: :target
+        end
+      end
+    end
+
+    let(:holder) do
+      members = [report, conversion]
+      Class.new(Lutaml::Model::Serializable) do
+        attribute :result, members
+        key_value { map "result", to: :result }
+      end
+    end
+
+    before do
+      stub_const("SharedKeyReport", report)
+      stub_const("SharedKeyConversion", conversion)
+      stub_const("SharedKeyHolder", holder)
+    end
+
+    it "selects the later member whose fields cover every key" do
+      parsed = holder.from_json('{"result":{"source":"a.emf","target":"svg"}}')
+
+      expect(parsed.result).to be_a(conversion)
+      expect(parsed.result.target).to eq("svg")
+    end
+
+    it "keeps the earlier member when it covers every key" do
+      parsed = holder.from_json('{"result":{"source":"a.emf","issues":["m"]}}')
+
+      expect(parsed.result).to be_a(report)
+      expect(parsed.result.issues).to eq(["m"])
+    end
+
+    it "selects the member mapping the most keys when an extension key is present" do
+      parsed = holder.from_json(
+        '{"result":{"source":"a.emf","target":"svg","x-ext":1}}',
+      )
+
+      expect(parsed.result).to be_a(conversion)
+    end
+
+    it "keeps declared order when members map equally many keys" do
+      parsed = holder.from_json('{"result":{"source":"a.emf","x-ext":1}}')
+
+      expect(parsed.result).to be_a(report)
+    end
+  end
+
   describe "value transformers (cast idempotence)" do
     it "keeps a model member built by transform: before the cast runs" do
       reading = UnionAttributeSpec::TransformedReading.from_yaml(<<~YAML)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.134
+  version: 0.8.136
 platform: ruby
 authors:
 - Ribose Inc.