lutaml-model 0.8.39 → 0.8.41

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15f9489eb4db353b481f160703e848e35b730cef179d32874941fc537ed962d3
-  data.tar.gz: f0067a5ffc4d66c8312d9cc478d9bd7d1771d9b639111c3158956b2d98e4468e
+  metadata.gz: 6fc47a2bee1b20995c17426890ae3fdc3f9db24317a8cb0c83ea3e81f13372be
+  data.tar.gz: 72b52030485d681b901b077b75195a40d7779c0ec12df982e8bc7f49b3ef9dad
 SHA512:
-  metadata.gz: 9f1372cbf492e141015524382a3ac98cdc5f484441d70c593b7ad67b9021bfa959732700679534bb3690f86c064e3a1a82269833c5c73794fe87af24f21d239b
-  data.tar.gz: '048d412becdba7a8a99070740663d0d0a33e88d02018708818ce816d1ba4669a1f26efbf08d0c67390818c5efede0e362ef8f1785536c4233a2fa6dadd07da61'
+  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/serialize/attribute_definition.rb

@@ -129,6 +129,7 @@ module Lutaml
               end
             end
           elsif attr.unresolved_type == Lutaml::Model::Type::Reference
+            Lutaml::Model::Store.reference_types_in_use!
             define_reference_methods(name, register_id)
           else
             define_regular_attribute_methods(name, attr)

data/lib/lutaml/model/store.rb

@@ -33,11 +33,30 @@ module Lutaml
           @instance ||= new
         end
 
+        # lutaml-model#808: Ruby 3.3's GC has a WeakMap-mark hazard under
+        # heavy insert churn (freed slot dereferenced at wmap mark time).
+        # Registration is only ever consumed by `ref:` resolution — when
+        # no Reference-typed attribute exists anywhere, nothing can
+        # resolve, so registration is skipped entirely and the WeakMap
+        # stays quiet. Set the first time an attribute with a Reference
+        # type is defined.
+        # Not memoized `||=` — the setter flips it to true for the
+        # process lifetime and reads must see that.
+        def reference_types_in_use?
+          @reference_types_in_use ? true : false
+        end
+
+        def reference_types_in_use!
+          @reference_types_in_use = true
+        end
+
         def reset!
           @instance = new
         end
 
         def register(object)
+          return unless reference_types_in_use?
+
           instance.register(object)
         end
 

data/lib/lutaml/model/version.rb

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

data/lib/lutaml/xml/adapter/plan_based_builder.rb

@@ -299,13 +299,23 @@ module Lutaml
           # Create element
           xml.create_and_add_element(tag_name, attributes: attributes,
                                                prefix: prefix) do |inner_xml|
-            # Handle raw content (map_all directive)
+            # Handle raw content (map_all directive). lutaml-model#223:
+            # with coexisting mappings the raw remainder is the TAIL —
+            # mapped children render first through the normal paths
+            # below, then the fragment is appended. Standalone map_all
+            # (raw is the whole content) keeps the historical
+            # raw-only rendering by fronting the fragment and skipping
+            # children only when there is nothing mapped.
             has_raw_content = false
             if element.is_a?(Lutaml::Xml::DataModel::XmlElement)
               raw_content = element.raw_content
               if raw_content && !raw_content.to_s.empty?
-                inner_xml.add_xml_fragment(inner_xml, raw_content.to_s)
-                has_raw_content = true
+                if element.children.empty?
+                  inner_xml.add_xml_fragment(inner_xml, raw_content.to_s)
+                  has_raw_content = true
+                else
+                  (tail_raw_fragments ||= []) << raw_content.to_s
+                end
               end
             end
 
@@ -343,6 +353,9 @@ module Lutaml
                 end
               end
             end
+            (tail_raw_fragments || []).each do |fragment|
+              inner_xml.add_xml_fragment(inner_xml, fragment)
+            end
           end
         end
 

data/lib/lutaml/xml/adapter/xml_serializer.rb

@@ -268,11 +268,20 @@ module Lutaml
           attributes["xmlns"] = "" if needs_xmlns_blank
 
           xml.create_and_add_element(qualified_name, attributes: attributes) do
+            tail_raw = nil
             if xml_element.is_a?(Lutaml::Xml::DataModel::XmlElement)
               raw_content = xml_element.raw_content
               if raw_content && !raw_content.to_s.empty?
-                xml.add_xml_fragment(xml, raw_content.to_s)
-                return
+                # lutaml-model#223: with coexisting map_all, the raw
+                # remainder is the tail — mapped children render first.
+                # Standalone map_all (no mapped children) keeps the
+                # historical raw-only rendering.
+                if xml_element.children.empty?
+                  xml.add_xml_fragment(xml, raw_content.to_s)
+                  return
+                end
+
+                tail_raw = raw_content.to_s
               end
             end
 
@@ -306,6 +315,8 @@ module Lutaml
               end
             end
 
+            xml.add_xml_fragment(xml, tail_raw) if tail_raw
+
             if xml_element.text_content
               if xml_element.cdata
                 xml.cdata(xml_element.text_content.to_s)

data/lib/lutaml/xml/adapter_element.rb

@@ -109,6 +109,13 @@ module Lutaml
         children.map(&:to_xml).join
       end
 
+      # The element including its own tags — the building block for
+      # scoped raw capture (#223): an unclaimed child contributes its
+      # whole subtree verbatim.
+      def inner_xml_or_self
+        to_xml
+      end
+
       private
 
       def build_element_xml(builder)

data/lib/lutaml/xml/mapping.rb

@@ -979,9 +979,14 @@ module Lutaml
                                "is allowed with #{TYPES[:all_content]}"
         end
 
-        if !(elements.empty? && content_mapping.nil?) && type == TYPES[:all_content]
-          raise StandardError,
-                "#{TYPES[:all_content]} is not allowed with other mappings"
+        if type == TYPES[:all_content] &&
+            !(elements.empty? && content_mapping.nil?)
+          # lutaml-model#223: map_all may coexist with mapped siblings.
+          # The raw capture receives only the UNCLAIMED content — the
+          # verbatim subtree minus children matched by element rules.
+          # The historical exclusivity raised here; the coexistence
+          # contract is enforced by scoped capture on parse and
+          # remainder-after-mapped emission on serialize.
         end
       end
 

data/lib/lutaml/xml/model_transform.rb

@@ -55,14 +55,17 @@ module Lutaml
           # ISO-13849 profile). Memoize one instance per (element, class)
           # for the whole parse; the memo travels in the propagated
           # deserialization options.
-          memo = options[:__lutaml_child_memo] ||= {}
-          memo_key = [data.object_id, model_class.object_id]
-          if (existing = memo[memo_key])
+          # Nested identity maps keyed on the element object itself —
+          # flat object_id pairs could collide after GC id reuse on
+          # long parses (#808 audit).
+          memo = options[:__lutaml_child_memo] ||= {}.compare_by_identity
+          per_class = (memo[data] ||= {}.compare_by_identity)
+          if (existing = per_class[model_class])
             return existing
           end
 
           instance = model_class.allocate_for_deserialization(child_register)
-          memo[memo_key] = instance
+          per_class[model_class] = instance
         else
           instance = model_class.new
           register_accessor_methods_for(instance, child_register)
@@ -345,7 +348,7 @@ module Lutaml
             end
 
           value = if rule.raw_mapping?
-                    doc.root.inner_xml
+                    scoped_raw_inner_xml(doc, xml_mapping)
                   elsif rule.content_mapping?
                     rule.cdata ? doc.cdata : doc.text
                   elsif (group = grouped_plain_rules[rule_to]) &&
@@ -713,6 +716,23 @@ _effective_register)
       # lutaml-model#154: decode HTML entities for mappings that opted in
       # (`html_entities` in the xml block). Values stay untouched
       # otherwise — XML keeps undefined entities literal by design.
+      # lutaml-model#223: with coexisting map_all, the raw capture is
+      # the verbatim subtree MINUS the children claimed by element
+      # rules (they hydrate their own attributes). Standalone map_all
+      # (no element rules) keeps the full inner_xml.
+      def scoped_raw_inner_xml(doc, xml_mapping)
+        claimed = []
+        xml_mapping&.elements&.each do |element_rule|
+          Array(element_rule.name).each { |n| claimed << n.to_s }
+        end
+        return doc.root.inner_xml if claimed.empty?
+
+        doc.root.element_children.reject do |child|
+          claimed.include?(child.unprefixed_name) ||
+            claimed.include?(child.name)
+        end.map(&:inner_xml_or_self).join
+      end
+
       def decode_html_entities_value(value, enabled)
         return value if value.nil? || !value.is_a?(String)
         return value unless enabled

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

data/spec/lutaml/model/map_all_spec.rb

@@ -185,28 +185,32 @@ module MapAllSpec
       end
     end
 
-    describe "invalid mapping combinations" do
-      it "raises error when combining map_all with other mappings" do
-        expect do
-          InvalidDocument.json do
+    describe "coexistence with other mappings (#223)" do
+      it "captures only unclaimed content alongside mapped elements" do
+        doc_class = Class.new(Lutaml::Model::Serializable) do
+          attribute :title, :string
+          attribute :rest, :string
+
+          xml do
+            element "eref"
             map_element "title", to: :title
+            map_all to: :rest
           end
-        end.to raise_error(
-          StandardError,
-          "map_all is not allowed with other mappings",
-        )
-      end
+        end
 
-      it "raises error when combining other mappings are used with map_all" do
-        expect do
-          InvalidDocument.yaml do
-            map_element "title", to: :title
-            map_all to: :content
-          end
-        end.to raise_error(
-          StandardError,
-          "map_all is not allowed with other mappings",
-        )
+        source = %(<eref><title>T</title><p>para</p><note>N</note></eref>)
+        parsed = doc_class.from_xml(source)
+        expect(parsed.title).to eq("T")
+        expect(parsed.rest).to eq("<p>para</p><note>N</note>")
+
+        out = doc_class.to_xml(parsed)
+        expect(out).to include("<title>T</title>")
+        expect(out).to include("<p>para</p>")
+        expect(out).to include("<note>N</note>")
+
+        reparsed = doc_class.from_xml(out)
+        expect(reparsed.title).to eq("T")
+        expect(reparsed.rest).to eq("<p>para</p><note>N</note>")
       end
     end
   end

data/spec/lutaml/model/store_spec.rb

@@ -3,6 +3,13 @@
 require "spec_helper"
 
 RSpec.describe Lutaml::Model::Store do
+  before do
+    # Registration only runs when a Reference-typed attribute exists
+    # somewhere (#808); the internal specs opt in explicitly.
+    described_class.reference_types_in_use!
+    described_class.clear 
+  end
+
   let(:model_class) do
     Class.new(Lutaml::Model::Serializable) do
       attribute :id, :string
@@ -10,7 +17,6 @@ RSpec.describe Lutaml::Model::Store do
     end
   end
 
-  before { described_class.clear }
   after { described_class.clear }
 
   describe "#register and #resolve" do

data/spec/lutaml/xml/mapping_spec.rb

@@ -974,7 +974,6 @@ RSpec.describe Lutaml::Xml::Mapping do
       end
 
       context "when mixed content is true and child is content_mapping" do
-        let(:map_all_error) { "map_all is not allowed with other mappings" }
         let(:invalid_element) { "must be defined without namespace" }
         let(:mfenced) do
           <<~XML
@@ -994,7 +993,7 @@ RSpec.describe Lutaml::Xml::Mapping do
           XML
         end
 
-        it "raises error when map_all used in content_mapping without custom methods" do
+        it "allows map_all alongside element mappings (#223)" do
           original_mapping = XmlMappingSpec::MmlMath.mappings[:xml].deep_dup
 
           begin
@@ -1005,7 +1004,7 @@ RSpec.describe Lutaml::Xml::Mapping do
               XmlMappingSpec::MmlMath.xml do
                 map_all to: :all_content
               end
-            end.to raise_error(StandardError, map_all_error)
+            end.not_to raise_error
           ensure
             XmlMappingSpec::MmlMath.instance_variable_set(:@mappings,
                                                           { xml: original_mapping })
@@ -1013,16 +1012,16 @@ RSpec.describe Lutaml::Xml::Mapping do
           end
         end
 
-        it "can be defined after any other mapping" do
+        it "still validates its own arguments when combined (#223)" do
           original_mapping = XmlMappingSpec::MmlMath.mappings[:xml].deep_dup
 
           begin
             expect do
               XmlMappingSpec::MmlMath.xml do
-                map_all to: :all_content
-                namespace XmiNewNamespace
+                map_all to: :all_content, namespace: "http://explicit.ns"
               end
-            end.to raise_error(StandardError, map_all_error)
+            end.to raise_error(Lutaml::Model::IncorrectMappingArgumentsError,
+                               /namespace is not allowed/)
           ensure
             XmlMappingSpec::MmlMath.instance_variable_set(:@mappings,
                                                           { xml: original_mapping })

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.39
+  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