lutaml-model 0.8.40 → 0.8.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 597b465123fe390703bdb760a4f6e18e4069b55bea8998633e2a4c0c7f5fcb9c
-  data.tar.gz: e848597e1ad2cef05670d8dc8de6f7480bf028fde627021c5a61f554ad99a2f0
+  metadata.gz: 6fc47a2bee1b20995c17426890ae3fdc3f9db24317a8cb0c83ea3e81f13372be
+  data.tar.gz: 72b52030485d681b901b077b75195a40d7779c0ec12df982e8bc7f49b3ef9dad
 SHA512:
-  metadata.gz: 231f9601a9ce76ae516a6435b2c7185e15c2cc6680d0aefbad27ef328b25f67f0ed2635be8319eff6c3a64338f3bd2f9855ab1daa51058018345eb77cf3aa0d9
-  data.tar.gz: 88af6f65b2fadf91990f6f6f10a03a799007acda351d87a059f00325c85514291fbaccfd99580dd1daac3090bd61f4aa1ec26efffd058438c7e6abdd9a53cea4
+  metadata.gz: dc281b89a9c032cff1f2a38de58b465dccc5385421d9daed7a8244adec62a282a79163b392224a2ead89d93281bbf1d6f5772f879f088a930332ae8821c7784e
+  data.tar.gz: 1d0c2b049cc9c45e7dfe0dd0a6ec6326c98011ab09c6a9f32eff39b36a67cfce1dd97f20341d301258acfc9c9eb282d43718d3a7ab0e0401ae29e6d1a936d724

data/lib/lutaml/model/comparable_model.rb

@@ -32,6 +32,32 @@ module Lutaml
 
       alias == eql?
 
+      # Order-insensitive equality (lutaml-model#17): collection
+      # attributes compare as multisets — document order within a
+      # collection does not affect the result. Non-collection
+      # attributes and nested models keep strict equality.
+      #
+      # @param other [Object] the object to compare with
+      # @param ignore_element_order [Boolean] compare collections
+      #   order-insensitively
+      # @return [Boolean]
+      def same_as?(other, ignore_element_order: true)
+        return true if equal?(other)
+        return false unless instance_of?(other.class)
+
+        unordered_eql?(self, other, {}, ignore_element_order)
+      end
+
+      # Structured diff (lutaml-model#18): returns one entry per
+      # differing attribute path, recursively through nested models
+      # and collections. Equal objects diff to [].
+      #
+      # @param other [Object] the object to diff against
+      # @return [Array<Hash>] [{ path:, left:, right: }] entries
+      def diff(other)
+        Lutaml::Model::ComparableModel::StructuralDiff.diff(self, other)
+      end
+
       def same_class?(other)
         other.instance_of?(self.class)
       end
@@ -145,6 +171,72 @@ module Lutaml
         end
       end
 
+      # Structured, path-addressed diff between two model trees
+      # (lutaml-model#18). Used by ComparableModel#diff.
+      module StructuralDiff
+        Entry = ::Struct.new(:path, :left, :right)
+
+        module_function
+
+        def diff(left, right, path = [])
+          return [] if left.equal?(right)
+          return [Entry.new(path_string(path), left, right)] unless comparable_pair?(left, right)
+
+          entries = []
+          left.class.attributes.each_key do |attr|
+            lval = left.public_send(attr)
+            rval = right.public_send(attr)
+            child_path = path + [attr]
+
+            if comparable_pair?(lval, rval)
+              entries.concat(diff(lval, rval, child_path))
+            elsif lval.is_a?(::Array) && rval.is_a?(::Array)
+              entries.concat(diff_collections(lval, rval, child_path))
+            elsif differing?(lval, rval)
+              entries << Entry.new(path_string(child_path), lval, rval)
+            end
+          end
+          entries
+        end
+
+        def diff_collections(lval, rval, path)
+          entries = []
+          max = [lval.size, rval.size].max
+          max.times do |i|
+            li = lval[i]
+            ri = rval[i]
+            child_path = path + [i]
+
+            if comparable_pair?(li, ri)
+              entries.concat(diff(li, ri, child_path))
+            elsif differing?(li, ri)
+              entries << Entry.new(path_string(child_path), li, ri)
+            end
+          end
+          entries
+        end
+
+        def comparable_pair?(left, right)
+          left.is_a?(ComparableModel) && right.is_a?(ComparableModel) &&
+            left.instance_of?(right.class)
+        end
+
+        def differing?(lval, rval)
+          if lval.is_a?(::Array) && rval.is_a?(::Array)
+            lval.size != rval.size ||
+              lval.zip(rval).any? { |l, r| l != r }
+          else
+            lval != rval
+          end
+        end
+
+        def path_string(path)
+          path.reduce("") do |acc, seg|
+            seg.is_a?(::Integer) ? "#{acc}[#{seg}]" : "#{acc}.#{seg}"
+          end.delete_prefix(".")
+        end
+      end
+
       # DiffContext handles the comparison between two objects
       class DiffContext
         attr_reader :obj1, :obj2, :show_unchanged, :highlight_diff, :use_colors
@@ -556,6 +648,49 @@ type_info = nil)
           end
         end
       end
+
+      private
+
+      def unordered_eql?(left, right, seen, ignore_order)
+        return true if left.equal?(right)
+        return false unless left.instance_of?(right.class)
+
+        seen[left] ||= {}.compare_by_identity
+        return true if seen[left][right]
+
+        seen[left][right] = true
+        left.class.attributes.keys.all? do |attr|
+          lval = left.public_send(attr)
+          rval = right.public_send(attr)
+
+          if lval.is_a?(ComparableModel) && rval.is_a?(ComparableModel)
+            unordered_eql?(lval, rval, seen, ignore_order)
+          elsif ignore_order && lval.is_a?(::Array) && rval.is_a?(::Array)
+            unordered_items_equal?(lval, rval, seen)
+          else
+            lval == rval
+          end
+        end
+      end
+
+      def unordered_items_equal?(lval, rval, seen)
+        return false unless lval.size == rval.size
+
+        unmatched = rval.dup
+        lval.all? do |litem|
+          idx = unmatched.index do |ritem|
+            if litem.is_a?(ComparableModel) && ritem.is_a?(ComparableModel)
+              unordered_eql?(litem, ritem, seen, true)
+            else
+              litem == ritem
+            end
+          end
+          return false unless idx
+
+          unmatched.delete_at(idx)
+          true
+        end
+      end
     end
 
     # Generates a tree representation of the object

data/lib/lutaml/model/serializable.rb

@@ -3,7 +3,11 @@
 module Lutaml
   module Model
     class Serializable
+      # ComparableModel is included at the Serialize module level; its
+      # ClassMethods (diff_with_score) must extend the class that
+      # model classes actually inherit from (lutaml-model#18).
       include Serialize
+      extend ComparableModel::ClassMethods
     end
   end
 end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.40"
+    VERSION = "0.8.41"
   end
 end

data/lib/lutaml/xml/transformation/rule_applier.rb

@@ -11,6 +11,10 @@ module Lutaml
       # - Content rules -> apply_content_rule
       # - Raw rules -> apply_raw_rule
       module RuleApplier
+        # The answer is static per rule object; transformations are
+        # frozen, so the memo lives here instead — bounded by the
+        # distinct rule count (TODO.max-perf/20).
+        CUSTOM_ONLY_CACHE = {}.compare_by_identity
         include SkipLogic
         include ElementBuilder
 
@@ -226,8 +230,13 @@ register_id)
         #
         # @param rule [CompiledRule] The rule
         # @return [Boolean] true if custom method only
+        # The answer is static per rule object and transformations are
+        # frozen — a process-global identity-keyed memo is bounded by
+        # the distinct rule count and lives no longer than the rules
+        # (240k calls → ~one computation per rule on the ISO-13849
+        # serialize profile, TODO.max-perf/20).
         def custom_method_only?(rule)
-          rule.custom_method_only?
+          CUSTOM_ONLY_CACHE[rule] ||= rule.custom_method_only?
         end
 
         # Extract value for a rule

data/lib/lutaml/xml/transformation.rb

@@ -262,13 +262,15 @@ module Lutaml
       # @param model_instance [Object] The model instance
       # @param options [Hash] Options
       def apply_ordered_rules(root, model_instance, options)
+        # Loop-invariant for the whole ordered walk (see
+        # apply_standard_rules): one merge per model, not per rule.
+        rule_options = options.merge(current_model: model_instance)
         apply_rules_in_order(
           root, model_instance, options,
           compiled_rules, model_class, register_id
         ) do |action, rule, value, set_xsi_nil|
           next if action == :apply_rule && duplicate_element_rules[rule]
 
-          rule_options = options.merge(current_model: model_instance)
           case action
           when :apply_rule
             apply_rule(root, rule, model_instance, rule_options, model_class,
@@ -331,11 +333,14 @@ module Lutaml
                   compiled_rules
                 end
 
+        # The merge is loop-invariant (model_instance is fixed for the
+        # walk) — hoisted out of the per-rule loop. It was ~220k
+        # allocations on the ISO-13849 serialize profile (TODO.max-perf/20).
+        rule_options = options.merge(current_model: model_instance)
         rules.each do |rule|
           next unless valid_mapping?(rule, options)
           next if duplicate_element_rules[rule]
 
-          rule_options = options.merge(current_model: model_instance)
           apply_rule(root, rule, model_instance, rule_options, model_class,
                      register_id, register)
         end

data/spec/lutaml/model/comparison_family_spec.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# lutaml-model#17 (order-insensitive equality) and #18 (structured
+# diff), on top of the existing eql?/diff_with_score machinery.
+RSpec.describe "Comparison family" do
+  let(:phone_a) { Phone.new(kind: "home", number: "555-0100") }
+  let(:phone_b) { Phone.new(kind: "work", number: "555-0177") }
+
+  before do
+    stub_const("Phone", Class.new(Lutaml::Model::Serializable) do
+      attribute :kind, :string
+      attribute :number, :string
+    end)
+    stub_const("Person", Class.new(Lutaml::Model::Serializable) do
+      attribute :name, :string
+      attribute :age, :integer
+      attribute :phones, Phone, collection: true
+    end)
+  end
+
+  describe "#same_as? (#17)" do
+    it "treats reordered collections as equal" do
+      a = Person.new(phones: [phone_a, phone_b])
+      b = Person.new(phones: [phone_b, phone_a])
+      expect(a == b).to be(false)
+      expect(a.same_as?(b)).to be(true)
+    end
+
+    it "detects genuinely different collections regardless of order" do
+      a = Person.new(phones: [phone_a, phone_b])
+      b = Person.new(phones: [phone_a, Phone.new(kind: "fax", number: "9")])
+      expect(a.same_as?(b)).to be(false)
+    end
+
+    it "respects strict mode" do
+      a = Person.new(phones: [phone_a, phone_b])
+      b = Person.new(phones: [phone_b, phone_a])
+      expect(a.same_as?(b, ignore_element_order: false)).to be(false)
+    end
+
+    it "compares nested models recursively order-insensitively" do
+      box1 = Class.new(Lutaml::Model::Serializable) do
+        attribute :people, Person, collection: true
+      end
+      p1 = Person.new(name: "Ada", phones: [phone_a, phone_b])
+      p2 = Person.new(name: "Ada", phones: [phone_b, phone_a])
+      expect(box1.new(people: [p1]).same_as?(box1.new(people: [p2]))).to be(true)
+    end
+  end
+
+  describe "#diff (#18)" do
+    it "returns one entry per differing path" do
+      a = Person.new(name: "Ada", age: 36, phones: [phone_a])
+      b = Person.new(name: "Ada", age: 37, phones: [phone_b])
+      entries = a.diff(b)
+
+      paths = entries.map(&:path)
+      expect(paths).to contain_exactly("age", "phones[0].kind", "phones[0].number")
+    end
+
+    it "reports length differences at the collection level" do
+      a = Person.new(phones: [phone_a])
+      b = Person.new(phones: [phone_a, phone_b])
+      entries = a.diff(b)
+
+      expect(entries.size).to eq(1)
+      expect(entries.first.path).to eq("phones[1]")
+      expect(entries.first.right).to eq(phone_b)
+    end
+
+    it "diffs equal objects to nothing" do
+      a = Person.new(name: "Ada", age: 36, phones: [phone_a])
+      expect(a.diff(a.dup)).to be_empty
+    end
+  end
+
+  describe ".diff_with_score (#18, pre-existing)" do
+    it "is reachable from model classes" do
+      a = Person.new(age: 36)
+      b = Person.new(age: 37)
+      score, tree = Person.diff_with_score(a, b)
+      expect(score).to be_a(Float)
+      expect(tree).to include("age")
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.40
+  version: 0.8.41
 platform: ruby
 authors:
 - Ribose Inc.
@@ -1711,6 +1711,7 @@ files:
 - spec/lutaml/model/collection_state_nesting_spec.rb
 - spec/lutaml/model/collection_validation_spec.rb
 - spec/lutaml/model/comparable_model_spec.rb
+- spec/lutaml/model/comparison_family_spec.rb
 - spec/lutaml/model/compiled_rule_spec.rb
 - spec/lutaml/model/consolidation_spec.rb
 - spec/lutaml/model/context_registry_spec.rb