lutaml-model 0.8.32 → 0.8.34

data/lib/lutaml/xml/model_transform.rb

@@ -399,7 +399,10 @@ module Lutaml
       def set_instance_ordering(instance, doc, ordered_option,
 mixed_content_option, xml_mapping = nil,
 instance_is_serialize = nil)
-        instance.element_order = doc.root.order
+        # dup: XmlElement#order hands back a frozen cache shared with the
+        # DOM. The model's copy has to stay mutable so callers can maintain
+        # element_order themselves.
+        instance.element_order = doc.root.order.dup
         if instance_is_serialize && doc.root.is_a?(::Lutaml::Xml::XmlElement)
           instance.attribute_order = doc.root.attribute_order
         end
@@ -469,7 +472,31 @@ _effective_register)
         end
       end
 
-      def value_for_xml_attribute(doc, rule, rule_names)
+      # Whether no OTHER attribute rule in the mapping claims the same
+      # local name. A sole claimant is namespace-flexible on the local-
+      # name fallback: real-world documents qualify such attributes in
+      # the element's namespace, a foreign extension namespace, or not
+      # at all (OOXML w:val on w15: elements — lutaml-model#790). When
+      # a sibling claims the name, matching stays strict so each rule
+      # keeps its own namespace (#744, #758).
+      def attribute_rule_sole_local_claimant?(instance, rule,
+                                              effective_register)
+        klass = instance.class
+        return true unless klass.include?(Lutaml::Model::Serialize)
+
+        mapping = klass.mappings_for(:xml, effective_register)
+        return true unless mapping
+
+        expected = Array(rule.name).map(&:to_s)
+        mapping.mappings.none? do |sib|
+          next false unless sib.attribute? && !sib.equal?(rule)
+
+          Array(sib.name).map(&:to_s) == expected
+        end
+      end
+
+      def value_for_xml_attribute(doc, rule, rule_names,
+                                  flexible_local: false)
         # For attributes, rule_names may contain namespaced names, but find_attribute_value
         # expects prefix:name or just name, so we need to convert namespaced names to prefix format.
         #
@@ -496,7 +523,8 @@ _effective_register)
         # This handles the case where the namespace prefix is not declared in the document
         # (e.g., v:ext without xmlns:v="...").
         if value.nil? && rule_names.any? { |rn| rn.include?(":") }
-          value = find_attribute_by_local_name(doc, rule_names)
+          value = find_attribute_by_local_name(doc, rule_names,
+                                               flexible_local: flexible_local)
         end
 
         value = value&.split(rule.delimiter) if rule.delimiter
@@ -559,7 +587,8 @@ _effective_register)
       # @param doc [XmlElement] the parsed XML document root
       # @param rule_names [Array<String>] the rule names to match
       # @return [String, nil] the attribute value or nil
-      def find_attribute_by_local_name(doc, rule_names)
+      def find_attribute_by_local_name(doc, rule_names,
+                                       flexible_local: false)
         rule_names.each do |rn|
           next unless rn.include?(":")
 
@@ -579,7 +608,12 @@ _effective_register)
             # namespaced sibling attribute (lutaml-model#758). An
             # XmlAttribute with a resolved namespace has namespaced_name
             # "URI:local", so this comparison is allocation-free.
-            if attr.namespace.nil?
+            if flexible_local
+              # Sole claimant: any qualification of the local name binds
+              # (element namespace, foreign extension namespace, none).
+              attr.unprefixed_name == local_name ||
+                ((colon = attr.name.rindex(":")) ? attr.name[(colon + 1)..] : attr.name) == local_name
+            elsif attr.namespace.nil?
               next false if attr.namespace_prefix.nil? &&
                 !attr.name.include?(":")
 
@@ -630,7 +664,14 @@ _effective_register)
         # return the same children again.
         rule_names = rule_names.concat(extra_rule_names).uniq if extra_rule_names
 
-        return value_for_xml_attribute(doc, rule, rule_names) if rule.attribute?
+        if rule.attribute?
+          return value_for_xml_attribute(
+            doc, rule, rule_names,
+            flexible_local: attribute_rule_sole_local_claimant?(
+              instance, rule, effective_register
+            )
+          )
+        end
 
         # Performance: Pre-compute type-related values used in the hot loop
         attr_type_is_serializable = attr_type && attr_type <= ::Lutaml::Model::Serialize

data/lib/lutaml/xml/schema/xsd/max_exclusive.rb

@@ -6,7 +6,7 @@ module Lutaml
       module Xsd
         class MaxExclusive < Base
           attribute :fixed, :string
-          attribute :value, :integer
+          attribute :value, :string
 
           xml do
             element "maxExclusive"

data/lib/lutaml/xml/schema/xsd/min_exclusive.rb

@@ -6,7 +6,7 @@ module Lutaml
       module Xsd
         class MinExclusive < Base
           attribute :fixed, :string
-          attribute :value, :integer
+          attribute :value, :string
 
           xml do
             element "minExclusive"

data/lib/lutaml/xml/schema/xsd_schema.rb

@@ -583,7 +583,8 @@ module Lutaml
                 xs(xml, "element", element_attrs) do
                   xs(xml, "complexType") do
                     xs(xml, "sequence") do
-                      xs(xml, "element", { name: "item", type: xsd_type })
+                      emit_value_element(xml, { name: "item" }, xsd_type,
+                                         attr_type, attr)
                     end
                   end
                 end
@@ -591,7 +592,8 @@ module Lutaml
                 # Simple element
                 element_attrs = build_element_attributes(name, xsd_type, attr,
                                                          xml_mapping, name)
-                xs(xml, "element", element_attrs)
+                emit_value_element(xml, element_attrs, xsd_type, attr_type,
+                                   attr)
               end
             end
           end
@@ -606,21 +608,191 @@ module Lutaml
 
             attr_type = attr.type(register)
             xsd_type = get_attribute_xsd_type(attr, attr_type, register, rule)
+            emit_xsd_attribute(xml, attr, rule, xsd_type, attr_type)
+          end
+        end
+
+        # Emit an `xs:attribute`, inlining an `xs:restriction` when the attribute
+        # is a constrained value type (its `type=` moves into the restriction
+        # base) and/or an annotation when the mapping carries documentation.
+        def self.emit_xsd_attribute(xml, attr, rule, xsd_type, attr_type)
+          facets = effective_facets(attr, attr_type)
+          restricted = facets.any?
+
+          attr_attrs = { name: rule.name }
+          attr_attrs[:type] = xsd_type unless restricted
+          attr_attrs[:use] = "required" if attr.options[:required]
+          attr_attrs[:form] = rule.form.to_s if rule.form
 
-            attr_attrs = { name: rule.name, type: xsd_type }
-            attr_attrs[:use] = "required" if attr.options[:required]
-            attr_attrs[:form] = rule.form.to_s if rule.form
+          return xs(xml, "attribute", attr_attrs) unless restricted || rule.documentation
 
+          xs(xml, "attribute", attr_attrs) do
             if rule.documentation
-              xs(xml, "attribute", attr_attrs) do
-                xs(xml, "annotation") do
-                  xs(xml, "documentation", rule.documentation)
-                end
+              xs(xml, "annotation") do
+                xs(xml, "documentation", rule.documentation)
               end
-            else
-              xs(xml, "attribute", attr_attrs)
             end
+            emit_restriction(xml, xsd_type, facets, attr_type) if restricted
+          end
+        end
+
+        def self.effective_facets(attr, attr_type)
+          return {} unless attr_type.is_a?(Class) &&
+            attr_type < Lutaml::Model::Type::Value
+
+          attr.effective_restriction_facets(attr_type)
+        end
+
+        def self.emit_value_element(xml, attrs, xsd_type, attr_type, attr)
+          facets = effective_facets(attr, attr_type)
+          if facets.any?
+            xs(xml, "element", attrs.except(:type)) do
+              emit_restriction(xml, xsd_type, facets, attr_type)
+            end
+          else
+            xs(xml, "element", attrs.merge(type: xsd_type))
+          end
+        end
+
+        def self.emit_restriction(xml, base, facets, type)
+          xs(xml, "simpleType") do
+            xs(xml, "restriction", base: base) do
+              emit_restriction_facets(xml, facets, type)
+            end
+          end
+        end
+
+        def self.emit_restriction_facets(xml, facets, type)
+          emit_bound(xml, :minExclusive, facets[:min_exclusive], type)
+          emit_bound(xml, :minInclusive, facets[:min_inclusive], type)
+          emit_bound(xml, :maxExclusive, facets[:max_exclusive], type)
+          emit_bound(xml, :maxInclusive, facets[:max_inclusive], type)
+          emit_facet(xml, :totalDigits, facets[:total_digits])
+          emit_facet(xml, :fractionDigits, facets[:fraction_digits])
+          emit_facet(xml, :length, facets[:length])
+          emit_facet(xml, :minLength, facets[:min_length])
+          emit_facet(xml, :maxLength, facets[:max_length])
+          Array(facets[:enumeration]).each do |value|
+            emit_facet(xml, :enumeration, lexical_value(type, value))
           end
+          emit_facet(xml, :whiteSpace, facets[:white_space])
+          patterns = Array(facets[:pattern])
+          if patterns.size > 1
+            raise Lutaml::Model::Error,
+                  "Cannot export #{patterns.size} conjunctive patterns on " \
+                  "#{type} to a single xs:restriction: sibling xs:pattern " \
+                  "facets are alternatives (OR), and XSD cannot express " \
+                  "conjunction (AND) without nested restriction derivation, " \
+                  "which is not yet supported."
+          end
+          patterns.each { |re| emit_facet(xml, :pattern, pattern_value(re)) }
+        end
+
+        def self.emit_bound(xml, element, value, type)
+          emit_facet(xml, element, lexical_value(type, value)) unless value.nil?
+        end
+
+        def self.emit_facet(xml, element, value)
+          return if value.nil?
+
+          xml.public_send(qn(element), value: value.to_s)
+        end
+
+        def self.pattern_value(regexp)
+          reject_unsupported_regex_flags!(regexp)
+          source = strip_ruby_anchors(regexp.source)
+          reject_invalid_xsd_pattern!(regexp, source)
+          source
+        end
+
+        def self.reject_unsupported_regex_flags!(regexp)
+          return if regexp.options.nobits?(UNSUPPORTED_XSD_REGEX_FLAGS)
+
+          raise Lutaml::Model::Error,
+                "Cannot export pattern #{regexp.inspect} to xs:pattern: " \
+                "the i/m/x flags are not expressible in XSD's regexp subset."
+        end
+
+        def self.strip_ruby_anchors(source)
+          source = strip_leading_anchor(source)
+          strip_trailing_anchor(source)
+        end
+
+        def self.strip_leading_anchor(source)
+          return source[1..] if source.start_with?("^")
+
+          run = leading_backslash_run(source)
+          return source unless run.odd? && source[run] == "A"
+
+          # Keep the escaped-pair backslashes; drop the anchor's `\A`.
+          source[0, run - 1] + source[(run + 1)..]
+        end
+
+        def self.strip_trailing_anchor(source)
+          last = source[-1]
+          before = source.length - 1
+          if ["z", "Z"].include?(last) &&
+              trailing_backslash_run(source, before).odd?
+            return source[0...-2]
+          end
+          if last == "$" && trailing_backslash_run(source, before).even?
+            return source[0...-1]
+          end
+
+          source
+        end
+
+        def self.leading_backslash_run(source)
+          run = 0
+          run += 1 while source[run] == "\\"
+          run
+        end
+
+        def self.trailing_backslash_run(source, pos)
+          run = 0
+          i = pos - 1
+          while i >= 0 && source[i] == "\\"
+            run += 1
+            i -= 1
+          end
+          run
+        end
+
+        def self.raise_inexpressible_pattern!(regexp, detail)
+          raise Lutaml::Model::Error,
+                "Cannot export pattern #{regexp.inspect} to xs:pattern: " \
+                "it is not expressible in XSD's regexp subset (#{detail})."
+        end
+
+        def self.reject_invalid_xsd_pattern!(regexp, source)
+          return unless defined?(::Nokogiri::XML::Schema)
+
+          probe = <<~XSD
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+              <xs:simpleType name="p">
+                <xs:restriction base="xs:string">
+                  <xs:pattern value="#{xsd_escape(source)}"/>
+                </xs:restriction>
+              </xs:simpleType>
+            </xs:schema>
+          XSD
+          schema = ::Nokogiri::XML::Schema(probe)
+          return if schema.errors.empty?
+
+          raise_inexpressible_pattern!(regexp, schema.errors.first.message)
+        rescue ::Nokogiri::XML::SyntaxError => e
+          raise_inexpressible_pattern!(regexp, e.message)
+        end
+
+        UNSUPPORTED_XSD_REGEX_FLAGS =
+          Regexp::IGNORECASE | Regexp::MULTILINE | Regexp::EXTENDED
+
+        def self.xsd_escape(text)
+          text.gsub("&", "&amp;").gsub("<", "&lt;").gsub('"', "&quot;")
+        end
+
+        def self.lexical_value(type, value)
+          type.serialize(type.cast(value))
         end
 
         def self.attr_is_xml_attribute?(xml_mapping, attr_name)

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

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    module TransformationSupport
+      # Aligns a model's element_order with the values it currently holds.
+      #
+      # element_order describes the source document, not the model. Anything
+      # assigned after parsing has no entry in it, so OrderedApplier would
+      # never emit that value. Reconciliation inserts the missing entries
+      # before serialization starts.
+      #
+      # Only insertion is needed. A collection that shrank already emits the
+      # right count, because process_collection_item stops yielding once the
+      # index passes the value length.
+      #
+      # The model's own element_order is never modified: the reconciled array
+      # is a local view, so repeated to_xml calls stay idempotent.
+      module OrderReconciler
+        # @param model_instance [Object] The model instance
+        # @param compiled_rules [Array<CompiledRule>] The compiled rules
+        # @param options [Hash] Transformation options
+        # @return [Array(Array, Array<CompiledRule>)] the element order with
+        #   any missing entries inserted, and the rules it could not
+        #   reconcile that still hold an unemitted value. The caller must
+        #   emit those the ordinary way or their value is lost. When nothing
+        #   is missing the model's own order comes back untouched.
+        def reconciled_element_order(model_instance, compiled_rules, options)
+          order = model_instance.element_order
+          element_rules = element_typed_rules(compiled_rules)
+
+          # Resolve every entry to its rule once. Coverage, insertion
+          # anchors and the final array all read from this, so no later
+          # step rescans the order or re-matches a rule.
+          resolved = order.map { |object| find_rule_for_element(object, compiled_rules) }
+          coverage = ::Hash.new(0)
+          resolved.each { |rule| coverage[rule] += 1 if rule }
+
+          deficits, fallback = classify_rules(element_rules, coverage,
+                                              model_instance, options)
+          return [order, fallback] if deficits.empty?
+
+          [insert_deficits(order, deficits, element_rules, resolved), fallback]
+        end
+
+        private
+
+        def element_typed_rules(compiled_rules)
+          compiled_rules.select do |rule|
+            rule.is_a?(::Lutaml::Model::CompiledRule) &&
+              rule.option(:mapping_type) == :element
+          end
+        end
+
+        # Custom-method element rules are compiled without a backing
+        # attribute, so they expose no value whose cardinality or
+        # explicitness could be measured. OrderedApplier invokes them
+        # directly and never reads their value either.
+        def reconcilable?(rule, options)
+          !attributeless_custom_rule?(rule) && valid_mapping?(rule, options)
+        end
+
+        def attributeless_custom_rule?(rule)
+          rule.has_custom_methods? && rule.attribute_type.nil?
+        end
+
+        # Split the element rules that are short of entries into the ones
+        # reconciliation can place and the ones it cannot.
+        #
+        # A rule it cannot place still holds a value nothing has emitted, so
+        # it comes back as a fallback for the caller to serialize the
+        # ordinary way. Dropping it would be the very data loss this file
+        # exists to stop.
+        #
+        # A rule that is neither short nor unemitted costs only the
+        # `using_default?` lookup inside expected_element_count, and the
+        # ambiguity scan runs solely for the ones that are short.
+        #
+        # @return [Array(Hash<CompiledRule, Integer>, Array<CompiledRule>)]
+        def classify_rules(element_rules, coverage, model_instance, options)
+          deficits = {}
+          fallback = []
+
+          element_rules.each do |rule|
+            missing = expected_element_count(rule, model_instance) -
+              coverage[rule]
+            next unless missing.positive?
+
+            if reconcilable?(rule, options) &&
+                unambiguous?(rule, element_rules)
+              deficits[rule] = missing
+            elsif coverage[rule].zero? &&
+                emit_uncovered?(rule, element_rules, model_instance)
+              fallback << rule
+            end
+          end
+
+          [deficits, fallback]
+        end
+
+        # Whether a rule reconciliation could not place should still be
+        # emitted the ordinary way.
+        #
+        # Yes for an unambiguous rule: nothing else will emit its value.
+        #
+        # For rules sharing a serialized name, it depends on where
+        # element_order came from, because the dispatcher cannot tell them
+        # apart. A parsed order already stands for all of them — every one
+        # parsed from the same entry — so emitting the ones it did not
+        # resolve to would duplicate the element on a plain round-trip. An
+        # order built by a builder block records one entry per mutation, so
+        # a rule with no coverage genuinely has not been emitted.
+        def emit_uncovered?(rule, element_rules, model_instance)
+          return true if unambiguous?(rule, element_rules)
+
+          model_instance.respond_to?(:order_tracking_enabled?) &&
+            model_instance.order_tracking_enabled?
+        end
+
+        # Entries to insert, keyed by the position in the original order
+        # they go before. Built in declaration order so several rules
+        # landing on one position keep their mapping order.
+        def insert_deficits(order, deficits, element_rules, resolved)
+          rule_index = {}
+          element_rules.each_with_index { |rule, i| rule_index[rule] = i }
+
+          insertions = deficits.each_with_object({}) do |(rule, missing), acc|
+            at = insertion_index(resolved, rule, rule_index)
+            entries = ::Array.new(missing) { new_order_entry(rule) }
+            (acc[at] ||= []).concat(entries)
+          end
+
+          rebuild_order(order, insertions)
+        end
+
+        def rebuild_order(order, insertions)
+          result = []
+          order.each_with_index do |object, index|
+            pending = insertions[index]
+            result.concat(pending) if pending
+            result << object
+          end
+          tail = insertions[order.length]
+          result.concat(tail) if tail
+          result
+        end
+
+        # How many child elements the rule's current value should produce.
+        #
+        # Only values the caller explicitly set are counted. A parsed model
+        # keeps defaults and the uninitialized sentinel for elements absent
+        # from the source document, and turning those into new elements is
+        # exactly the over-emission that reverted an earlier attempt at this
+        # fix.
+        def expected_element_count(rule, model_instance)
+          owner = value_owner(rule, model_instance)
+          return 0 unless owner.respond_to?(:using_default?)
+          # A custom-method rule compiled without an attribute exposes no
+          # value to measure, and reading one would call a method that does
+          # not exist.
+          return 0 if attributeless_custom_rule?(rule)
+
+          value = extract_ordered_rule_value(rule, model_instance)
+          return 0 if unmutated_default?(owner, rule, value)
+          return 0 if should_skip_delegated_value?(value, rule, owner)
+          # A custom `to:` method is handed the whole model and emits every
+          # value itself, and OrderedApplier calls it once per matching
+          # entry. One entry means one invocation, however many values the
+          # attribute holds.
+          return 1 if rule.custom_methods[:to]
+          return 1 unless rule.collection?
+
+          collection_element_count(value, rule)
+        end
+
+        def collection_element_count(value, rule)
+          # Mirror the applier's own dispatch. A value it will not iterate
+          # — nil, or a String — never reaches process_collection_item; it
+          # goes through apply_rule, which emits one element (xsi:nil under
+          # render_nil).
+          return 1 unless value.respond_to?(:each) && !value.is_a?(String)
+
+          # Same length/size fallback process_collection_item uses, so the
+          # two cannot disagree about how many items a collection holds.
+          length = value.respond_to?(:length) ? value.length : value.size
+          return length if length.positive?
+
+          empty_collection_renders_element?(rule) ? 1 : 0
+        end
+
+        # Whether the attribute still holds its default and nothing has put
+        # real data in it.
+        #
+        # This is the guard that keeps a parsed model from turning defaults
+        # and uninitialized sentinels into elements the source document
+        # never had. It follows RenderPolicy#should_skip_default? rather
+        # than inventing a second rule: a collection mutated in place is
+        # real data, because `items << "x"` never reaches the setter and so
+        # leaves `using_default?` true.
+        def unmutated_default?(owner, rule, value)
+          return false unless owner.using_default?(rule.attribute_name)
+          return false if rule.option(:render_default)
+          return false if ::Lutaml::Model::RenderPolicy
+            .derived_attribute_for?(owner, rule.attribute_name)
+          return false if rule.collection? &&
+            !::Lutaml::Model::Utils.empty?(value)
+
+          true
+        end
+
+        def value_owner(rule, model_instance)
+          delegate = rule.option(:delegate_from)
+          return model_instance unless delegate
+
+          model_instance.public_send(delegate)
+        end
+
+        # find_rule_for_element resolves an inserted entry back to the FIRST
+        # element rule matching its name and namespace, and that match
+        # accepts a nil rule namespace, namespace aliases and name aliases.
+        # When more than one rule would claim the entry, reconciling would
+        # feed the value to the wrong rule, so leave the rule alone.
+        def unambiguous?(rule, element_rules)
+          matches = element_rules.select do |candidate|
+            matches_element_rule?(candidate, rule.serialized_name,
+                                  rule.namespace_class&.uri)
+          end
+
+          matches == [rule]
+        end
+
+        def new_order_entry(rule)
+          ::Lutaml::Xml::Element.new(
+            "Element",
+            rule.serialized_name,
+            node_type: :element,
+            namespace_uri: rule.namespace_class&.uri,
+            namespace_prefix: nil,
+          )
+        end
+
+        # Where a rule's new entries go:
+        # - after the last entry that already resolves to it, so extra
+        #   collection items follow the existing ones and any interleaved
+        #   element keeps its place
+        # - otherwise at the first entry declared after it, so a newly-set
+        #   element lands in mapping-declaration order
+        def insertion_index(resolved, rule, rule_index)
+          own = rule_index[rule]
+          last_own = nil
+          first_later = nil
+
+          resolved.each_with_index do |matched, index|
+            next unless matched
+
+            last_own = index if matched.equal?(rule)
+            first_later ||= index if rule_index[matched] > own
+          end
+
+          return last_own + 1 if last_own
+
+          first_later || resolved.length
+        end
+      end
+    end
+  end
+end