lutaml-model 0.8.91 → 0.8.92

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f05bb7edf0d4a86ba5bc0105d3d269b2f3c28532cdd88e03be857fb4e426a505
-  data.tar.gz: 806a73d21e506337a5d039563225e3b000e7f1a3c0e701ca58ae8d58fdbe3c8d
+  metadata.gz: 19d1cc9a53554486e1dda21b67751062851d1990b9878aac1dcd6ccd2542d28e
+  data.tar.gz: 459cecd7cbdd127bb65a52cd6058d027e5139f2926e46d408bea5a28b13f2e7f
 SHA512:
-  metadata.gz: 0d02bf01cd956193aeab21358508339542b2f104c767347dd7fd2fbc7134c461692d4358f755e952082570683e7ecaf0e39c989d977d5b458b87807892b24997
-  data.tar.gz: e833ac9280da9e33ebb3427f6d34d53f3da5dd5f7d43d408144cefc4c5087507cc92013b956d1d7b857a4d4e5bde119e58ea926195f07d95eba4ceef4e73a704
+  metadata.gz: 92637d4ab1efbd63d746983b4e359f2d49c00469e94bb249a050f36f1b80f15b18ae705245fdd8ab563d854e814fea54ce99993f64dbc17beb9c87555f7b3a95
+  data.tar.gz: 54412f06f6f1bed27f74a85495b414cfc6da3274ab03214220c27edd344aff8cd58f70874fa317fb61b9e8523a04725d69152dfde490b3aa61a2d75540a161ed

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.91"
+    VERSION = "0.8.92"
   end
 end

data/lib/lutaml/xml/mapping.rb

@@ -1197,6 +1197,31 @@ module Lutaml
       # transform applies the collection-attribute filter.
       #
       # @return [Hash{Symbol, String => Array<MappingRule>}]
+      # The when_attribute siblings-vs-plain-names partition of the
+      # element rules. A ParseSession used to rebuild this per parsed
+      # node (sessions are per-element), paying an O(rules) pass on
+      # every node of large documents; it is a pure function of the
+      # rules, so it memoizes here — same lifetime as
+      # plain_element_rules_by_attr.
+      def when_attribute_partition
+        @when_attribute_partition ||= begin
+          siblings = {}
+          plain_names = {}
+          mappings.each do |rule|
+            next if rule.attribute? || rule.content_mapping? ||
+              rule.raw_mapping? || rule.cdata
+
+            pairs = rule.when_attribute
+            if pairs && !pairs.empty?
+              (siblings[rule.name.to_s] ||= []) << rule
+            else
+              plain_names[rule.name.to_s] = true
+            end
+          end
+          [siblings, plain_names]
+        end
+      end
+
       def plain_element_rules_by_attr(register_id = nil)
         reg_key = register_id || :default
         @plain_element_rules_by_attr ||= {}

data/lib/lutaml/xml/model_transform.rb

@@ -344,6 +344,14 @@ module Lutaml
         deserialize_attributes = attributes
         mappings.each do |rule|
           record = records&.[](rule)
+
+          # #903: replay-or-drop unmatched named element rules before
+          # any per-rule machinery (see replay_unmatched_rule).
+          if replay_unmatched_rule(child_names_set, record, rule,
+                                   instance, defaults_used, xml_mapping)
+            next
+          end
+
           rule_to = rule.to
 
           if record
@@ -847,7 +855,9 @@ _effective_register)
         Lutaml::Xml::HtmlEntities.decode(value)
       end
 
-      Record = Struct.new(:attr, :derived, :group_skip, :valid)
+      Record = Struct.new(:attr, :derived, :group_skip, :valid,
+                          :unmatched_mode, :replay_writer,
+                          :unmatched_names)
 
       def compiled_rule_records(model_class, register, grouped_plain_rules)
         return {}.compare_by_identity unless model_class.include?(Lutaml::Model::Serialize)
@@ -866,12 +876,76 @@ _effective_register)
         mapping&.mappings(register)&.each do |rule| # rubocop:disable Style/SafeNavigationChain,Style/SafeNavigation
           attr = attribute_for_rule_static(model_class, rule, register)
           group = grouped_plain_rules[rule.to]
+          # #903: for a plain rule, what an unmatched visit writes is
+          # known statically. The fast-skip branch hands the attribute's
+          # uninitialized sentinel to the pipeline; with no value-map
+          # overrides and no transformers every step is identity except
+          # apply_value_map, which maps the :omitted key: the default
+          # map (:nil) yields nil and the visit writes nil through the
+          # setter; an explicit omitted: :omitted map treats it as
+          # treat_omitted? == false and the omission gate ends the
+          # visit untouched. Both endings replay without the walk:
+          # :write_nil (setter write + flag churn) or :drop (nothing).
+          # Everything else -- defaults, aliases, custom from:,
+          # delegates, when_attribute dispatch, transformers, value
+          # maps beyond those two -- keeps its visit.
+          unmatched_mode = nil
+          replay_writer = nil
+          if attr && !attr.derived? &&
+              !rule.render_default && !rule.multiple_mappings? &&
+              !rule.has_custom_method_for_deserialization? &&
+              !rule.delegate &&
+              !(rule.when_attribute && !rule.when_attribute.empty?)
+            rule_transform = rule.transform
+            attr_transform = attr.transform
+            no_transforms =
+              (rule_transform.nil? ||
+               (rule_transform.respond_to?(:empty?) &&
+                rule_transform.empty?)) &&
+              (attr_transform.nil? ||
+               (attr_transform.respond_to?(:empty?) &&
+                attr_transform.empty?))
+            rule_default = attr.default(register)
+            if no_transforms &&
+                (rule_default.nil? ||
+                 rule_default.is_a?(::Lutaml::Model::UninitializedClass)) &&
+                rule.class.transform_dispatch(rule, attr) == :assign
+              if group && group.size > 1 && attr.collection? &&
+                  !group.first.equal?(rule)
+                # Non-first spelling of a #765 group: the visit is a
+                # guarded next (the first member does the merged match).
+                unmatched_mode = :drop
+              else
+                omitted_val = rule.value_map(:from)[:omitted]
+                if omitted_val == :nil
+                  unmatched_mode = :write_nil
+                elsif omitted_val == :omitted
+                  unmatched_mode = :drop
+                end
+              end
+            end
+          end
+          # A first group member does the merged match for every
+          # spelling, so its name-miss test spans the whole group.
+          unmatched_names = if group && group.size > 1
+                              group.map { |r| r.name.to_s }
+                            else
+                              [rule.name.to_s]
+                            end
+          if unmatched_mode == :write_nil
+            replay_writer =
+              rule.class.parsed_assign_writer(model_class, rule.to)
+            unmatched_mode = nil unless replay_writer
+          end
           records[rule] = Record.new(
             attr,
             attr&.derived? || false,
             !!(group && group.size > 1 && attr&.collection? &&
                !group.first.equal?(rule)),
             !!(attr || rule.custom_methods[:from]),
+            unmatched_mode,
+            replay_writer,
+            unmatched_names,
           )
         end
         entry = Struct.new(:version, :records).new(version, records)
@@ -1551,6 +1625,34 @@ effective_register = lutaml_register)
       # @param child_names_set [Set] Set of child namespaced_name and unprefixed_name
       # @param default_namespace [String, nil] the default namespace
       # @return [Boolean] true if a matching child likely exists
+      # #903: for an unmatched named element rule whose record classed
+      # it, replay what the visit would write without the walk: :drop
+      # (the visit ended at the omission gate or was a guarded next)
+      # writes nothing; :write_nil replays the nil the default value
+      # map produces, plus the flag churn. Returns true when handled.
+      def replay_unmatched_rule(child_names_set, record, rule, instance,
+                                defaults_used, xml_mapping)
+        return false unless child_names_set && record
+
+        mode = record.unmatched_mode
+        return false unless mode
+        return false if rule.attribute? || rule.content_mapping? ||
+          rule.raw_mapping? || !rule.name ||
+          xml_mapping.any_element_rule.equal?(rule)
+
+        matched = record.unmatched_names.any? do |n|
+          child_names_set.include?(n)
+        end
+        return false if matched
+
+        return true if mode == :drop
+
+        defaults_used << rule.to
+        instance.public_send(record.replay_writer, nil)
+        instance.value_set_for(rule.to)
+        true
+      end
+
       def child_matches_rule?(rule, child_names_set, default_namespace)
         rule_names = rule.namespaced_names(default_namespace)
         # Array#intersect? requires an Array argument; child_names_set may

data/lib/lutaml/xml/parse_session.rb

@@ -84,25 +84,9 @@ module Lutaml
       # Empty unless the mapping uses when_attribute at all; non-Serialize
       # custom models have no mappings to partition.
       def when_attribute_partition
-        @when_attribute_partition ||=
-          if instance_is_serialize && (mapping = xml_mapping)
-            siblings = {}
-            plain_names = {}
-            mapping.mappings.each do |rule|
-              next if rule.attribute? || rule.content_mapping? ||
-                rule.raw_mapping? || rule.cdata
-
-              pairs = rule.when_attribute
-              if pairs && !pairs.empty?
-                (siblings[rule.name.to_s] ||= []) << rule
-              else
-                plain_names[rule.name.to_s] = true
-              end
-            end
-            [siblings, plain_names]
-          else
-            [{}, {}]
-          end
+        return [{}, {}] unless instance_is_serialize && (mapping = xml_mapping)
+
+        mapping.when_attribute_partition
       end
 
       def when_attribute_siblings_by_name

data/lutaml-model.gemspec

@@ -43,7 +43,7 @@ Gem::Specification.new do |spec|
   # input-buffer cap (lutaml-model#871).
   spec.add_dependency "moxml", "~> 0.5.84"
   spec.add_dependency "ostruct"
-  spec.add_dependency "rubyzip", "~> 3.4"
+  spec.add_dependency "rubyzip", "~> 3.7"
   spec.add_dependency "thor"
 
   spec.metadata["rubygems_mfa_required"] = "true"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.91
+  version: 0.8.92
 platform: ruby
 authors:
 - Ribose Inc.
@@ -120,14 +120,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '3.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.4'
+        version: '3.7'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement