lutaml-model 0.8.19 → 0.8.23

data/lib/lutaml/xml/transformation.rb

@@ -264,6 +264,8 @@ module Lutaml
           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
@@ -291,6 +293,32 @@ module Lutaml
       # @param root [XmlElement] Root element
       # @param model_instance [Object] The model instance
       # @param options [Hash] Options
+      # Reader for the precomputed skip set (#765).
+      def duplicate_element_rules
+        @duplicate_element_rules
+      end
+
+      # lutaml-model#765: several element rules may target one attribute
+      # (spelling tolerance, e.g. editorial-group vs editorialgroup). The
+      # extra spellings exist for parse tolerance only — serialization
+      # emits the value once, under the first declared spelling. Derived
+      # once at compile time (transformations are frozen and shared).
+      def after_compile
+        seen = {}
+        @duplicate_element_rules = {}
+        compiled_rules.each do |rule|
+          next unless rule.option(:mapping_type) == :element
+
+          key = rule.attribute_name.to_s
+          if seen.key?(key)
+            @duplicate_element_rules[rule] = true
+          else
+            seen[key] = true
+          end
+        end
+        @duplicate_element_rules.freeze
+      end
+
       def apply_standard_rules(root, model_instance, options)
         attr_order = model_instance.is_a?(Lutaml::Model::Serialize) &&
           model_instance.attribute_order
@@ -303,6 +331,7 @@ module Lutaml
 
         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,

data/lib/lutaml/xml/xml_element.rb

@@ -360,6 +360,8 @@ module Lutaml
       end
 
       def find_attribute_value(attribute_name)
+        return if attributes.empty?
+
         # Performance: Use hash index for O(1) lookup instead of linear scan
         ensure_attribute_index
 

data/lib/lutaml/xml.rb

@@ -1,331 +1,7 @@
 # frozen_string_literal: true
 
-# Lutaml::Xml - XML serialization module for LutaML
-#
-# This module provides XML-specific serialization functionality.
-# It requires lutaml/model to be loaded first for base classes.
-
-# Ensure base model is loaded
+# Public XML format entrypoint. Loads the base model and the internal
+# implementation. The internal file does not require the model back,
+# which keeps the require graph acyclic.
 require_relative "model"
-
-# XML requires moxml for parsing
-require "moxml"
-
-# Under Opal, moxml's autoloads don't fire (Opal ignores autoload).
-# Pull in the eager-load boot that ships at lib/compat/opal/moxml_boot.rb
-# so Moxml::Adapter::{Oga,Rexml} etc. are actually defined. Without
-# this, `Config.adapter = :oga` later fails with
-# `NameError: uninitialized constant Moxml::Adapter::Oga`.
-if Lutaml::Model.opal?
-  require "moxml_boot"
-end
-
-module Lutaml
-  module Xml
-    # Error module for XML-specific errors
-    module Error
-      autoload :XmlError, "#{__dir__}/xml/error/xml_error"
-      autoload :InvalidNamespaceError,
-               "#{__dir__}/xml/error/invalid_namespace_error"
-      autoload :InvalidXsdTypeError,
-               "#{__dir__}/xml/error/invalid_xsd_type_error"
-      autoload :XmlConfigurationError,
-               "#{__dir__}/xml/error/xml_configuration_error"
-      autoload :NamespaceMismatchError,
-               "#{__dir__}/xml/error/namespace_mismatch_error"
-      autoload :SchemaValidationError,
-               "#{__dir__}/xml/error/schema_validation_error"
-    end
-
-    # XML Configuration modules
-    autoload :Configurable, "#{__dir__}/xml/configurable"
-    autoload :NamespaceTypeResolver, "#{__dir__}/xml/namespace_type_resolver"
-
-    # XML Type modules
-    module Type
-      autoload :ValueXmlMapping, "#{__dir__}/xml/type/value_xml_mapping"
-      autoload :Configurable, "#{__dir__}/xml/type/configurable"
-    end
-
-    # XML Serialization modules
-    autoload :Serialization, "#{__dir__}/xml/serialization"
-
-    # XML Schema modules
-    autoload :Schema, "#{__dir__}/xml/schema"
-
-    # Detect available XML adapter.
-    # Delegates to moxml, which is the authority on XML adapter
-    # availability and platform constraints.
-    #
-    # @return [Symbol] adapter type name
-    def self.detect_xml_adapter
-      Moxml::Config.runtime_default_adapter
-    end
-
-    # Get the current XML adapter
-    #
-    # Provides unified access to the configured XML adapter.
-    # This is a convenience method for consistent adapter access across
-    # Model and Type classes.
-    #
-    # @return [Object] the configured XML adapter instance
-    #
-    # @example Using the adapter
-    #   adapter = Lutaml::Xml.adapter
-    #   doc = adapter.parse(xml_string)
-    #
-    def self.adapter
-      Lutaml::Model::Config.adapter_for(:xml)
-    end
-
-    # Get the current XML adapter type
-    #
-    # @return [Symbol] the configured XML adapter type (:nokogiri, :ox, etc.)
-    def self.adapter_type
-      Lutaml::Model::Config.xml_adapter_type
-    end
-
-    # Autoload core classes
-    autoload :Location, "#{__dir__}/xml/schema_location"
-    autoload :SchemaLocation, "#{__dir__}/xml/schema_location"
-    autoload :Namespace, "#{__dir__}/xml/namespace"
-    autoload :Mapping, "#{__dir__}/xml/mapping"
-    autoload :MappingRule, "#{__dir__}/xml/mapping_rule"
-    autoload :Listener, "#{__dir__}/xml/listener"
-    autoload :Document, "#{__dir__}/xml/document"
-    autoload :Transformation, "#{__dir__}/xml/transformation"
-    autoload :CustomMethodWrapper,
-             "#{__dir__}/xml/transformation/custom_method_wrapper"
-    autoload :Transform, "#{__dir__}/xml/transform"
-    autoload :XsdValidator, "#{__dir__}/xml/xsd_validator"
-    autoload :Adapter, "#{__dir__}/xml/adapter"
-    autoload :XmlElement, "#{__dir__}/xml/xml_element"
-    autoload :AdapterElement, "#{__dir__}/xml/adapter_element"
-    autoload :XmlAttribute, "#{__dir__}/xml/xml_attribute"
-    autoload :Decisions, "#{__dir__}/xml/decisions"
-    autoload :DeclarationPlan, "#{__dir__}/xml/declaration_plan"
-    autoload :DeclarationPlanner, "#{__dir__}/xml/declaration_planner"
-    autoload :NamespaceCollector, "#{__dir__}/xml/namespace_collector"
-    autoload :NamespaceResolver, "#{__dir__}/xml/namespace_resolver"
-    autoload :NamespaceDeclaration, "#{__dir__}/xml/namespace_declaration"
-    autoload :NamespaceClassRegistry, "#{__dir__}/xml/namespace_class_registry"
-    autoload :BlankNamespace, "#{__dir__}/xml/blank_namespace"
-    autoload :EncodingNormalizer, "#{__dir__}/xml/encoding_normalizer"
-    autoload :W3c, "#{__dir__}/xml/w3c"
-    autoload :NamespaceResolutionStrategy,
-             "#{__dir__}/xml/namespace_resolution_strategy"
-    autoload :NamespaceInheritanceStrategy,
-             "#{__dir__}/xml/namespace_inheritance_strategy"
-    autoload :QualifiedInheritanceStrategy,
-             "#{__dir__}/xml/qualified_inheritance_strategy"
-    autoload :UnqualifiedInheritanceStrategy,
-             "#{__dir__}/xml/unqualified_inheritance_strategy"
-    autoload :DataModel, "#{__dir__}/xml/data_model"
-    autoload :TransformationBuilder, "#{__dir__}/xml/transformation_builder"
-    autoload :AdapterLoader, "#{__dir__}/xml/adapter_loader"
-    autoload :Element, "#{__dir__}/xml/element"
-    autoload :ModelTransform, "#{__dir__}/xml/model_transform"
-    autoload :TypeNamespaceResolver, "#{__dir__}/xml/type_namespace_resolver"
-    autoload :NamespaceNeeds, "#{__dir__}/xml/namespace_needs"
-    autoload :NamespaceUsage, "#{__dir__}/xml/namespace_usage"
-    autoload :NamespaceDeclarationData,
-             "#{__dir__}/xml/namespace_declaration_data"
-    autoload :ParsedNamespaceDeclaration,
-             "#{__dir__}/xml/parsed_namespace_declaration"
-    autoload :ParsedNamespaceSet, "#{__dir__}/xml/parsed_namespace_set"
-    autoload :DeclarationHandler, "#{__dir__}/xml/declaration_handler"
-    autoload :PolymorphicValueHandler,
-             "#{__dir__}/xml/polymorphic_value_handler"
-    autoload :AttributeNamespaceResolver,
-             "#{__dir__}/xml/attribute_namespace_resolver"
-    autoload :BlankNamespaceHandler, "#{__dir__}/xml/blank_namespace_handler"
-    autoload :DeclarationPlanQuery, "#{__dir__}/xml/declaration_plan_query"
-    autoload :DocTypeExtractor, "#{__dir__}/xml/doctype_extractor"
-    autoload :NamespaceDeclarationBuilder,
-             "#{__dir__}/xml/namespace_declaration_builder"
-    autoload :ElementPrefixResolver, "#{__dir__}/xml/element_prefix_resolver"
-    autoload :FormatChooser, "#{__dir__}/xml/format_chooser"
-    autoload :HoistingAlgorithm, "#{__dir__}/xml/hoisting_algorithm"
-    autoload :NamespaceInheritanceResolver,
-             "#{__dir__}/xml/namespace_inheritance_resolver"
-    autoload :NamespaceScopeConfig, "#{__dir__}/xml/namespace_scope_config"
-    autoload :Builder, "#{__dir__}/xml/builder"
-    autoload :TypeNamespace, "#{__dir__}/xml/type_namespace"
-    autoload :TransformationSupport, "#{__dir__}/xml/transformation_support"
-    autoload :SharedDsl, "#{__dir__}/xml/shared_dsl"
-
-    autoload :Oga, "#{__dir__}/xml/oga"
-    autoload :Rexml, "#{__dir__}/xml/rexml"
-    Lutaml::Model::RuntimeCompatibility.autoload_native(
-      self,
-      NokogiriElement: "#{__dir__}/xml/nokogiri/element",
-      Nokogiri: "#{__dir__}/xml/nokogiri",
-      Ox: "#{__dir__}/xml/ox",
-    )
-  end
-end
-
-# Register XML format with the model's format registry
-Lutaml::Model::FormatRegistry.register(
-  :xml,
-  mapping_class: Lutaml::Xml::Mapping,
-  adapter_class: nil,
-  transformer: Lutaml::Xml::Transform,
-  adapter_loader: Lutaml::Xml::AdapterLoader,
-  castable_type: Lutaml::Xml::XmlElement,
-  key_value: false,
-  error_types: %w[
-    Moxml::ParseError
-    Nokogiri::XML::SyntaxError
-    Ox::ParseError
-    REXML::ParseException
-  ],
-  adapter_options: if Lutaml::Model.opal?
-                     # Both Oga (vendored opal-oga fork, pure-Ruby lexer)
-                     # and REXML (bundled stdlib gem, pure Ruby) work
-                     # under Opal. Oga is the default because moxml's CI
-                     # verifies it most thoroughly; REXML is selectable
-                     # for callers that prefer a stdlib-only stack.
-                     {
-                       available: %i[oga rexml],
-                       default: :oga,
-                     }
-                   else
-                     {
-                       available: %i[nokogiri ox oga rexml],
-                       default: :nokogiri,
-                     }
-                   end,
-)
-
-# Register XML transformation builder
-Lutaml::Model::TransformationRegistry.register_builder(
-  :xml, Lutaml::Xml::TransformationBuilder
-)
-
-# Extend Type::Value with XML configuration (namespace, xsd_type, xml block)
-Lutaml::Model::Type::Value.include(Lutaml::Xml::Type::Configurable)
-
-# Prepend XML-specific serialization hooks into Serialize::ClassMethods
-# Uses prepend so XML's hook overrides (pre_deserialize_hook, validate_document, etc.)
-# take priority over core's no-op defaults.
-Lutaml::Model::Serialize::ClassMethods.prepend(
-  Lutaml::Xml::Serialization::FormatConversion,
-)
-
-# Prepend XML-specific ModelImport overrides (root?, ensure_format_mapping_imports!, etc.)
-Lutaml::Model::Serialize::ModelImport.prepend(
-  Lutaml::Xml::Serialization::ModelImportExt,
-)
-
-# Prepend XML-specific instance methods (import_declaration_plan, validate_root_mapping!, etc.)
-Lutaml::Model::Serialize.prepend(
-  Lutaml::Xml::Serialization::InstanceMethods,
-)
-
-# Opal does not propagate methods prepended into an already-included module
-# to classes that included it before the prepend. Serializable includes
-# Serialize during model boot, so make the XML instance API available on the
-# concrete base class as well.
-#
-# Anonymous model classes (Class.new { include Serialize }) extend
-# Serialize::ClassMethods rather than inheriting from Serializable, so the
-# ModelImportExt override (root?) must land on ClassMethods too. The other
-# two (FormatConversion, InstanceMethods) are already prepended unconditionally
-# above, so Opal's no-double-prepend rule means we don't repeat them here.
-if Lutaml::Model.opal?
-  Lutaml::Model::Serializable.singleton_class.prepend(
-    Lutaml::Xml::Serialization::ModelImportExt,
-  )
-
-  Lutaml::Model::Serializable.prepend(
-    Lutaml::Xml::Serialization::InstanceMethods,
-  )
-
-  Lutaml::Model::Serialize::ClassMethods.prepend(
-    Lutaml::Xml::Serialization::ModelImportExt,
-  )
-end
-
-# Register XML-specific attribute override warning names
-Lutaml::Model::Attribute.format_specific_warn_names.push(:element_order,
-                                                         :schema_location, :encoding, :doctype, :ordered?, :mixed?)
-
-# Prepend XML-specific Collection overrides (unwrapped collection handling for XML)
-require_relative "xml/serialization/collection_ext"
-Lutaml::Model::Collection.singleton_class.prepend(
-  Lutaml::Xml::Serialization::CollectionExt,
-)
-
-# Register XML type serializers
-require_relative "xml/type/serializers"
-Lutaml::Xml::Type::Serializers.register_all!
-
-# Register XML schema methods
-Lutaml::Model::Schema.register_method(:to_xsd) do |klass, options = {}|
-  if Lutaml::Model.opal?
-    raise NotImplementedError,
-          "XSD schema generation is not available under Opal."
-  end
-
-  Lutaml::Xml::Schema::XsdSchema.generate(klass, options)
-end
-
-Lutaml::Model::Schema.register_method(:to_relaxng) do |klass, options = {}|
-  if Lutaml::Model.opal?
-    raise NotImplementedError,
-          "RELAX NG schema generation requires Nokogiri, " \
-          "which is not available under Opal."
-  end
-
-  Lutaml::Xml::Schema::RelaxngSchema.generate(klass, options)
-end
-
-Lutaml::Model::Schema.register_method(:from_xml) do |xml, options = {}|
-  if Lutaml::Model.opal?
-    raise NotImplementedError,
-          "XML schema compilation is not available under Opal."
-  end
-
-  Lutaml::Model::Schema::XmlCompiler.to_models(xml, options)
-end
-
-Lutaml::Model::Schema.register_method(:from_relaxng) do |rng, options = {}|
-  if Lutaml::Model::RuntimeCompatibility.opal?
-    raise NotImplementedError,
-          "RELAX NG schema compilation is not available under Opal."
-  end
-
-  Lutaml::Model::Schema::RngCompiler.to_models(rng, options)
-end
-
-Lutaml::Model::Schema.register_method(:from_rnc) do |rnc, options = {}|
-  if Lutaml::Model::RuntimeCompatibility.opal?
-    raise NotImplementedError,
-          "RNC schema compilation is not available under Opal."
-  end
-
-  Lutaml::Model::Schema::RncCompiler.to_models(rnc, options)
-end
-
-# Register XML namespace registry with GlobalContext
-Lutaml::Model::GlobalContext.register_format_registry(
-  :xml, Lutaml::Xml::NamespaceClassRegistry.new
-)
-
-# Eagerly load W3C namespace definitions (has registration side effects)
-require_relative "xml/w3c"
-
-# Auto-detection is now handled lazily by AdapterResolver on first use.
-# No eager adapter selection at require time — libraries can configure
-# their preferred adapter before any XML operations occur.
-
-# Namespace identifier validation:
-# - URIs (http://..., urn:...) are valid namespace names per W3C XML
-#   Namespaces (RFC 3986). URNs are first-class identifiers (RFC 8141).
-# - Non-URI identifiers (e.g., FPIs like "-//OASIS//...") are also
-#   accepted for compatibility, though not spec-compliant.
-# Use lenient mode to support FPIs and non-standard identifiers.
-Moxml.configure do |config|
-  config.namespace_validation_mode = :lenient
-end
+require_relative "xml/format"

data/lib/lutaml/yaml/format.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+# Internal YAML format implementation. Loaded from lib/lutaml/yaml.rb
+# (the public entrypoint) and from lib/lutaml/model.rb (so the model
+# entrypoint triggers the registration side effects).
+# No require_relative "model" here — keeps the require graph acyclic.
+
+module Lutaml
+  module Yaml
+    class Error < StandardError; end
+
+    autoload :Adapter, "#{__dir__}/adapter"
+    autoload :Schema, "#{__dir__}/schema"
+  end
+end
+
+Lutaml::Model::FormatRegistry.register(
+  :yaml,
+  mapping_class: Lutaml::Yaml::Adapter::Mapping,
+  adapter_class: Lutaml::Yaml::Adapter::StandardAdapter,
+  transformer: Lutaml::Yaml::Adapter::Transform,
+  key_value: true,
+  adapter_options: {
+    available: %i[standard standard_yaml],
+    default: :standard,
+  },
+)
+
+require_relative "type/serializers"
+Lutaml::Yaml::Type::Serializers.register_all!

data/lib/lutaml/yaml.rb

@@ -1,30 +1,7 @@
 # frozen_string_literal: true
 
-# YAML format module
-# Provides Lutaml::Yaml namespace for YAML serialization
-
-module Lutaml
-  module Yaml
-    class Error < StandardError; end
-
-    autoload :Adapter, "#{__dir__}/yaml/adapter"
-    autoload :Schema, "#{__dir__}/yaml/schema"
-  end
-end
-
-# Register YAML format with the format registry
-Lutaml::Model::FormatRegistry.register(
-  :yaml,
-  mapping_class: Lutaml::Yaml::Adapter::Mapping,
-  adapter_class: Lutaml::Yaml::Adapter::StandardAdapter,
-  transformer: Lutaml::Yaml::Adapter::Transform,
-  key_value: true,
-  adapter_options: {
-    available: %i[standard standard_yaml],
-    default: :standard,
-  },
-)
-
-# Register YAML type serializers
-require_relative "yaml/type/serializers"
-Lutaml::Yaml::Type::Serializers.register_all!
+# Public YAML format entrypoint. Loads the base model and the internal
+# implementation. The internal file does not require the model back,
+# which keeps the require graph acyclic.
+require_relative "model"
+require_relative "yaml/format"

data/lib/lutaml/yamls/adapter/mapping.rb

@@ -10,9 +10,9 @@ module Lutaml
           super(:yaml)
         end
 
-        def sequence(&)
+        def sequence(&block)
           @yamls_sequence = YamlsSequence.new
-          @yamls_sequence.instance_eval(&)
+          @yamls_sequence.instance_eval(&block)
         end
 
         def dup_instance

data/lib/lutaml/yamls/format.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Internal YAMLS format implementation. Loaded from lib/lutaml/yamls.rb
+# (the public entrypoint) and from lib/lutaml/model.rb (so the model
+# entrypoint triggers the registration side effects).
+# No require_relative "model" here — keeps the require graph acyclic.
+
+module Lutaml
+  module Yamls
+    class Error < StandardError; end
+
+    autoload :Adapter, "#{__dir__}/adapter"
+  end
+end
+
+Lutaml::Model::FormatRegistry.register(
+  :yamls,
+  mapping_class: Lutaml::Yamls::Adapter::Mapping,
+  adapter_class: Lutaml::Yamls::Adapter::StandardAdapter,
+  transformer: Lutaml::Yamls::Adapter::Transform,
+  key_value: true,
+)

data/lib/lutaml/yamls.rb

@@ -1,21 +1,7 @@
 # frozen_string_literal: true
 
-# YAMLS format module
-# Provides Lutaml::Yamls namespace for YAMLS serialization
-
-module Lutaml
-  module Yamls
-    class Error < StandardError; end
-
-    autoload :Adapter, "#{__dir__}/yamls/adapter"
-  end
-end
-
-# Register YAMLS format with the format registry
-Lutaml::Model::FormatRegistry.register(
-  :yamls,
-  mapping_class: Lutaml::Yamls::Adapter::Mapping,
-  adapter_class: Lutaml::Yamls::Adapter::StandardAdapter,
-  transformer: Lutaml::Yamls::Adapter::Transform,
-  key_value: true,
-)
+# Public YAMLS format entrypoint. Loads the base model and the internal
+# implementation. The internal file does not require the model back,
+# which keeps the require graph acyclic.
+require_relative "model"
+require_relative "yamls/format"

data/lib/tasks/benchmark_runner.rb

@@ -118,10 +118,10 @@ direction: nil)
     end
   end
 
-  def time_runs(&)
+  def time_runs(&block)
     job = Benchmark::IPS::Job.new
     job.config(time: @run_time, warmup: 5)
-    job.report("#{@label} #{@adapter} #{@direction}_#{@format}", &)
+    job.report("#{@label} #{@adapter} #{@direction}_#{@format}", &block)
     job.run
 
     entry = job.full_report.entries.first

data/lutaml-model.gemspec

@@ -38,7 +38,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "canon"
   spec.add_dependency "concurrent-ruby"
   spec.add_dependency "liquid", ">= 4.0", "< 6.0"
-  spec.add_dependency "moxml", "~> 0.1.25"
+  spec.add_dependency "moxml", "~> 0.5.0"
   spec.add_dependency "ostruct"
   spec.add_dependency "rubyzip", "~> 2.3"
   spec.add_dependency "thor"