lutaml-model 0.8.22 → 0.8.24

data/lib/lutaml/model/toml.rb

@@ -7,6 +7,7 @@ module Lutaml
     module Toml
       Lutaml::Model::RuntimeCompatibility.define_native_aliases(
         self,
+        TeptrisAdapter: "::Lutaml::Toml::Adapter::TeptrisAdapter",
         TomlibAdapter: "::Lutaml::Toml::Adapter::TomlibAdapter",
         TomlRbAdapter: "::Lutaml::Toml::Adapter::TomlRbAdapter",
       )
@@ -18,15 +19,18 @@ module Lutaml
       def self.detect_toml_adapter
         return nil if Lutaml::Model.opal?
 
-        # Skip tomlib on Windows entirely due to segfault issues
-        if Lutaml::Model::RuntimeCompatibility.windows?
-          return :toml_rb if Lutaml::Model::Utils.safe_load("toml-rb", :TomlRb)
+        # teptris 0.2.12+ parses ~3x and dumps ~8x faster than tomlib
+        # and ships prebuilts for every platform (mingw-ucrt restored
+        # in 0.2.4+) — native TOML on Windows retires the tomlib
+        # segfault workaround (previously pure-Ruby toml-rb only).
+        return :teptris if Lutaml::Model::Utils.safe_load("teptris", :Teptris)
 
-          return nil
+        # tomlib segfaults on Windows when parsing invalid TOML
+        if !Lutaml::Model::RuntimeCompatibility.windows? &&
+            Lutaml::Model::Utils.safe_load("tomlib", :Tomlib)
+          return :tomlib
         end
 
-        # On non-Windows, prefer tomlib
-        return :tomlib if Lutaml::Model::Utils.safe_load("tomlib", :Tomlib)
         return :toml_rb if Lutaml::Model::Utils.safe_load("toml-rb", :TomlRb)
 
         nil

data/lib/lutaml/model/transformation.rb

@@ -37,9 +37,14 @@ module Lutaml
         @format = format
         @register = register
         @compiled_rules = compile_rules(mapping_dsl)
+        after_compile
         freeze
       end
 
+      # Hook for format subclasses to derive rule-set-level data after
+      # compilation, before the transformation is frozen and shared.
+      def after_compile; end
+
       # Transform a model instance into format-specific representation
       #
       # @abstract Subclasses must implement this method

data/lib/lutaml/model/type/date_time.rb

@@ -1,7 +1,7 @@
-require "date"
-
 # frozen_string_literal: true
 
+require "date"
+
 module Lutaml
   module Model
     module Type

data/lib/lutaml/model/type/value.rb

@@ -2,6 +2,16 @@
 
 module Lutaml
   module Model
+    # Isolated holder for format_type_serializer_for's memo: Type::Value
+    # can be frozen by suites, which would freeze an ivar Hash with it.
+    SERIALIZER_LOOKUP_CACHE = ::Class.new do
+      class << self
+        def cache
+          @cache ||= {}
+        end
+      end
+    end.cache
+
     module Type
       # Base class for all value types
       class Value
@@ -35,14 +45,26 @@ from: nil)
           # @param type_class [Class] the type class to look up
           # @return [Hash, nil] { to: Proc, from: Proc } or nil
           def format_type_serializer_for(format, type_class)
+            # Hot path: memoize per [format, resolved class] — the hierarchy
+            # walk below only runs on a miss. Format serializers register at
+            # load time, so a hit is stable.
+            cache = SERIALIZER_LOOKUP_CACHE
+            key = [format, type_class]
+            return cache[key] if cache.key?(key)
+
             klass = type_class
+            found = nil
             while klass && klass <= Value
               s = @format_type_serializers[[format, klass]]
-              return s if s
+              if s
+                found = s
+                break
+              end
 
               klass = klass.superclass
             end
-            nil
+            cache[key] = found
+            found
           end
         end
 

data/lib/lutaml/model/utils.rb

@@ -121,11 +121,12 @@ module Lutaml
         end
 
         def blank?(value)
-          case value
-          when ::String, ::Array, ::Hash then value.empty?
-          when ::NilClass then true
-          else false
-          end
+          # Hot path: the nil test is a pointer compare, and nil dominates
+          # in optional-field-heavy documents.
+          return true if value.nil?
+          return false unless value.is_a?(::String) || value.is_a?(::Array) || value.is_a?(::Hash)
+
+          value.empty?
         end
 
         def empty_collection?(collection)

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.22"
+    VERSION = "0.8.24"
   end
 end

data/lib/lutaml/toml/adapter/teptris_adapter.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require_relative "../../key_value/adapter/toml/teptris_adapter"
+
+module Lutaml
+  module Toml
+    module Adapter
+      # The implementation lives in the KeyValue namespace (the live
+      # surface for adapter resolution); this alias keeps the legacy
+      # Lutaml::Toml::Adapter surface complete.
+      TeptrisAdapter = Lutaml::KeyValue::Adapter::Toml::TeptrisAdapter
+    end
+  end
+end

data/lib/lutaml/toml/adapter.rb

@@ -11,6 +11,7 @@ module Lutaml
       autoload :Transform, "#{__dir__}/adapter/transform"
       Lutaml::Model::RuntimeCompatibility.autoload_native(
         self,
+        TeptrisAdapter: "#{__dir__}/adapter/teptris_adapter",
         TomlRbAdapter: "#{__dir__}/adapter/toml_rb_adapter",
         TomlibAdapter: "#{__dir__}/adapter/tomlib_adapter",
       )

data/lib/lutaml/toml/format.rb

@@ -35,7 +35,7 @@ Lutaml::Model::FormatRegistry.register(
                      nil
                    else
                      {
-                       available: %i[tomlib toml_rb],
+                       available: %i[teptris tomlib toml_rb],
                        default: Lutaml::Model::RuntimeCompatibility.windows? ? :toml_rb : :tomlib,
                      }
                    end,

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "moxml/adapter/leptris"
+
+module Lutaml
+  module Xml
+    module Adapter
+      class LeptrisAdapter < BaseAdapter
+        MOXML_ADAPTER = Moxml::Adapter::Leptris
+        BUILDER_CLASS = Builder::Leptris
+        PARSED_ELEMENT_CLASS = Lutaml::Xml::LeptrisElement
+      end
+    end
+  end
+end

data/lib/lutaml/xml/adapter_element.rb

@@ -22,7 +22,11 @@ module Lutaml
         text = case node
                when Moxml::Element
                  namespace_name = node.namespace&.prefix
-                 ns_defs = node.namespaces
+                 # moxml >= 0.5.33 contract: #namespaces is the full
+                 # in-scope map (parity with Nokogiri, #198/#201); the
+                 # own-declarations shape this parse path needs is
+                 # #namespace_definitions.
+                 ns_defs = node.namespace_definitions
 
                  has_empty_xmlns = ns_defs.any? do |ns|
                    ns.prefix.nil? && ns.uri == ""
@@ -172,14 +176,118 @@ module Lutaml
       def parse_children(node, default_namespace: nil)
         return [] unless node.children
 
+        # Non-element children (text/cdata/comment/PI) stay RAW moxml
+        # nodes in the list — the hot scalar parse path reads text off
+        # the element (inner_text) and never touches their wrappers, so
+        # wrapping every text node eagerly paid half the parse tree for
+        # nothing. #children wraps them on first access; document order
+        # is preserved because they sit at their original positions.
         node.children.filter_map do |child|
           next if (child.is_a?(Moxml::Text) || child.is_a?(Moxml::Cdata)) && child.content.empty?
 
-          self.class.new(child, parent: self,
-                                default_namespace: default_namespace)
+          if child.is_a?(Moxml::Element)
+            self.class.new(child, parent: self,
+                                  default_namespace: default_namespace)
+          else
+            child
+          end
         end
       end
 
+      public
+
+      def children
+        unless @non_element_children_wrapped
+          @children.map! do |child|
+            if child.is_a?(Moxml::Node) && !child.is_a?(Moxml::Element)
+              self.class.new(child, parent: self)
+            else
+              child
+            end
+          end
+          @non_element_children_wrapped = true
+        end
+        @children
+      end
+
+      def children=(new_children)
+        @non_element_children_wrapped = true
+        super
+      end
+
+      def element_children
+        return @element_children if defined?(@element_children)
+
+        @element_children = @children.reject do |child|
+          raw_non_element_child?(child) ||
+            (child.is_a?(XmlElement) &&
+              (child.text? || child.processing_instruction?))
+        end
+      end
+
+      def raw_non_element_child?(child)
+        child.is_a?(Moxml::Node) && !child.is_a?(Moxml::Element)
+      end
+
+      # Order consumes raw non-element children inline: wrapping them
+      # just to read .text/.content would materialize the whole lazy
+      # layer on every parse.
+      def order
+        return @order_cache if @order_cache
+
+        @order_cache = @children.filter_map do |child|
+          case child
+          when Moxml::Cdata
+            Lutaml::Xml::Element.new("Text", "#cdata-section",
+                                     text_content: child.content,
+                                     node_type: :cdata)
+          when Moxml::Text
+            next if child.content.nil?
+
+            Lutaml::Xml::Element.new("Text", "text",
+                                     text_content: child.content,
+                                     node_type: :text)
+          when Moxml::Comment
+            Lutaml::Xml::Element.new("Comment", "comment",
+                                     text_content: child.content,
+                                     node_type: :comment)
+          when Moxml::ProcessingInstruction
+            Lutaml::Xml::Element.new("ProcessingInstruction",
+                                     child.target,
+                                     text_content: child.content.to_s.sub(/\A\s+/, ""),
+                                     node_type: :processing_instruction)
+          else
+            next if child.is_a?(Moxml::Node)
+
+            if child.cdata?
+              Lutaml::Xml::Element.new("Text", "#cdata-section",
+                                       text_content: child.text,
+                                       node_type: :cdata)
+            elsif child.text?
+              next if child.text.nil?
+
+              Lutaml::Xml::Element.new("Text", "text",
+                                       text_content: child.text,
+                                       node_type: :text)
+            elsif child.comment?
+              Lutaml::Xml::Element.new("Comment", "comment",
+                                       text_content: child.text,
+                                       node_type: :comment)
+            elsif child.processing_instruction?
+              Lutaml::Xml::Element.new("ProcessingInstruction",
+                                       child.unprefixed_name,
+                                       text_content: child.text,
+                                       node_type: :processing_instruction)
+            else
+              Lutaml::Xml::Element.new("Element", child.unprefixed_name,
+                                       node_type: :element,
+                                       namespace_uri: child.namespace_uri,
+                                       namespace_prefix: child.namespace_prefix)
+            end
+          end
+        end.each(&:freeze).freeze
+      end
+
       def add_namespaces_from_defs(ns_defs, is_root: false)
         has_default_xmlns = is_root || ns_defs.any? { |ns| ns.prefix.nil? }
 

data/lib/lutaml/xml/builder/base.rb

@@ -223,7 +223,9 @@ module Lutaml
             ns = new_el.in_scope_namespaces.find { |n| n.prefix == prefix }
             new_el.namespace = ns if ns
           elsif !prefix_unset && prefix.nil?
-            new_el.namespace = nil
+            # Skip the no-op clear: namespace-less elements pay the
+            # undeclare path on some engines (leptris) for nothing.
+            new_el.namespace = nil unless new_el.namespace.nil?
           end
         end
 

data/lib/lutaml/xml/builder/leptris.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    module Builder
+      class Leptris < Base
+        def self.moxml_backend
+          :leptris
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/xml/builder/nokogiri.rb

@@ -4,6 +4,9 @@ module Lutaml
   module Xml
     module Builder
       class Nokogiri < Base
+        def self.moxml_backend
+          :nokogiri
+        end
       end
     end
   end

data/lib/lutaml/xml/builder.rb

@@ -11,6 +11,7 @@ module Lutaml
         self,
         Nokogiri: "#{__dir__}/builder/nokogiri",
         Ox: "#{__dir__}/builder/ox",
+        Leptris: "#{__dir__}/builder/leptris",
       )
     end
   end

data/lib/lutaml/xml/format.rb

@@ -21,6 +21,8 @@ end
 
 module Lutaml
   module Xml
+    autoload :PlanCompiler, "#{__dir__}/plan_compiler"
+    autoload :PlanHydrator, "#{__dir__}/plan_hydrator"
     # Error module for XML-specific errors
     module Error
       autoload :XmlError, "#{__dir__}/error/xml_error"
@@ -161,6 +163,7 @@ module Lutaml
       NokogiriElement: "#{__dir__}/nokogiri/element",
       Nokogiri: "#{__dir__}/nokogiri",
       Ox: "#{__dir__}/ox",
+      LeptrisElement: "#{__dir__}/leptris/element",
     )
   end
 end
@@ -192,7 +195,7 @@ Lutaml::Model::FormatRegistry.register(
                      }
                    else
                      {
-                       available: %i[nokogiri ox oga rexml],
+                       available: %i[nokogiri ox oga rexml leptris],
                        default: :nokogiri,
                      }
                    end,

data/lib/lutaml/xml/leptris/element.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Xml
+    class LeptrisElement < AdapterElement
+      def initialize(node, parent: nil, default_namespace: nil)
+        @raw_text = node.raw_content if node.is_a?(Moxml::Text)
+        super
+      end
+
+      private
+
+      def adapter_class
+        Lutaml::Xml::Adapter::LeptrisAdapter
+      end
+
+      def build_text_for_xml
+        @raw_text || @text
+      end
+
+      def build_element_xml(builder)
+        builder.create_and_add_element(name,
+                                       prefix: namespace_prefix,
+                                       attributes: build_attributes(self)) do |xml|
+          children.each { |child| child.build_xml(xml) }
+        end
+      end
+
+      def attribute_value_for_build(attr)
+        attr.raw_value
+      end
+    end
+  end
+end

data/lib/lutaml/xml/mapping.rb

@@ -1071,6 +1071,30 @@ module Lutaml
         result
       end
 
+      # lutaml-model#765: plain element rules grouped by target attribute
+      # name, for spelling-tolerance mapping (several element names feeding
+      # one attribute). Cached per register so the parse hot path only pays
+      # a hash lookup. Grouping uses rule-level properties only — the
+      # transform applies the collection-attribute filter.
+      #
+      # @return [Hash{Symbol, String => Array<MappingRule>}]
+      def plain_element_rules_by_attr(register_id = nil)
+        reg_key = register_id || :default
+        @plain_element_rules_by_attr ||= {}
+        @plain_element_rules_by_attr[reg_key] ||= begin
+          grouped = {}
+          mappings(reg_key).each do |r|
+            next if r.attribute? || r.raw_mapping? || r.content_mapping? ||
+              r.cdata || r.has_custom_method_for_deserialization? ||
+              (r.transform.is_a?(Hash) && !r.transform.empty?) ||
+              r.transform.is_a?(Class)
+
+            (grouped[r.to] ||= []) << r
+          end
+          grouped
+        end
+      end
+
       def importable_mappings
         @importable_mappings ||= []
       end

data/lib/lutaml/xml/model_transform.rb

@@ -258,6 +258,18 @@ module Lutaml
           end
         end
 
+        # lutaml-model#765: several plain element rules may target one
+        # collection attribute (spelling tolerance, e.g. editorial-group vs
+        # editorialgroup). The first rule of such a group performs matching
+        # widened to every spelling so content merges in document order;
+        # the remaining rules are no-ops so their assignment cannot
+        # silently overwrite the merged value.
+        # Grouping is cached on the mapping DSL (per register); only the
+        # collection filter runs here.
+        grouped_plain_rules = xml_mapping.plain_element_rules_by_attr(
+          effective_register,
+        )
+
         mappings.each do |rule|
           # Performance: Cache rule properties accessed multiple times
           rule.name
@@ -268,6 +280,11 @@ module Lutaml
           attr = attribute_for_rule(rule)
           next if attr&.derived?
 
+          if (group = grouped_plain_rules[rule_to]) &&
+              group.size > 1 && attr&.collection? && !group.first.equal?(rule)
+            next
+          end
+
           raise "Attribute '#{rule_to}' not found in #{context}" unless valid_rule?(
             rule, attr
           )
@@ -285,6 +302,26 @@ module Lutaml
                     doc.root.inner_xml
                   elsif rule.content_mapping?
                     rule.cdata ? doc.cdata : doc.text
+                  elsif (group = grouped_plain_rules[rule_to]) &&
+                      group.size > 1 && attr&.collection?
+                    # First rule of a #765 group: match every spelling of
+                    # the group so the children merge in document order.
+                    if child_names_set &&
+                        group.drop(1).none? do |s|
+                          child_matches_rule?(s, child_names_set,
+                                              default_namespace)
+                        end && !child_matches_rule?(rule, child_names_set,
+                                                    default_namespace)
+                      ::Lutaml::Model::UninitializedClass.instance
+                    else
+                      extra_names = group.drop(1).flat_map do |s|
+                        resolve_rule_names_with_type(s, attr, new_opts,
+                                                     effective_register,
+                                                     attr&.type(effective_register))
+                      end
+                      value_for_rule(session, rule, new_opts, attr,
+                                     extra_names)
+                    end
                   elsif child_names_set && !rule.attribute? &&
                       !child_matches_rule?(rule, child_names_set,
                                            default_namespace)
@@ -551,7 +588,8 @@ _effective_register)
         nil
       end
 
-      def value_for_rule(session, rule, options, cached_attr = nil)
+      def value_for_rule(session, rule, options, cached_attr = nil,
+                         extra_rule_names = nil)
         doc = session.doc
         instance = session.instance
         instance_is_serialize = session.instance_is_serialize
@@ -576,6 +614,12 @@ _effective_register)
                        resolve_rule_names_with_type(rule, attr, options,
                                                     effective_register, attr_type)
                      end
+        # lutaml-model#765: widened matching for the first rule of a
+        # shared-attribute group — children of sibling spellings must be
+        # selected too, in document order. Deduped: sibling resolution can
+        # yield the same spelling twice, and the child index would then
+        # 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?
 
@@ -643,6 +687,13 @@ _effective_register)
             children = nil # fall through to select for alias matching
           else
             children = indexed.flatten(1)
+            # #765 widened matching: rule_names spans several spellings, so
+            # the flatten above yields rule-name order; restore document
+            # order for the merged group.
+            if extra_rule_names
+              position = element_children.each_with_index.to_h
+              children = children.sort_by { |c| position[c] }
+            end
           end
         else
           children = nil