lutaml-model 0.8.19 → 0.8.22

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"

data/spec/lutaml/model/attribute_apply_value_map_spec.rb

@@ -18,7 +18,8 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
 
     it "maps nil through value_map[:nil] => :empty to [] (collection)" do
       expect(
-        attribute(:string, collection: true).apply_value_map(nil, { nil: :empty }),
+        attribute(:string, collection: true).apply_value_map(nil,
+                                                             { nil: :empty }),
       ).to eq([])
     end
 
@@ -34,13 +35,15 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
       custom_collection_class = Class.new(Lutaml::Model::Collection) do
         instances :items, member_class
       end
-      attr = described_class.new("items", member_class, collection: custom_collection_class)
+      attr = described_class.new("items", member_class,
+                                 collection: custom_collection_class)
       result = attr.apply_value_map(nil, { nil: :empty })
       expect(result).to be_a(custom_collection_class)
     end
 
     it "maps nil through value_map[:nil] => :omitted to UninitializedClass" do
-      expect(attribute(:string).apply_value_map(nil, { nil: :omitted })).to eq(uninit)
+      expect(attribute(:string).apply_value_map(nil,
+                                                { nil: :omitted })).to eq(uninit)
     end
   end
 
@@ -50,12 +53,14 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
     end
 
     it "maps '' through value_map[:empty] => :empty preserving '' for scalar" do
-      expect(attribute(:string).apply_value_map("", { empty: :empty })).to eq("")
+      expect(attribute(:string).apply_value_map("",
+                                                { empty: :empty })).to eq("")
     end
 
     it "maps [] through value_map[:empty] => :empty preserving [] for collection" do
       expect(
-        attribute(:string, collection: true).apply_value_map([], { empty: :empty }),
+        attribute(:string, collection: true).apply_value_map([],
+                                                             { empty: :empty }),
       ).to eq([])
     end
 
@@ -69,11 +74,13 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
 
   describe "omitted handling" do
     it "maps UninitializedClass through value_map[:omitted] => :nil" do
-      expect(attribute(:string).apply_value_map(uninit, { omitted: :nil })).to be_nil
+      expect(attribute(:string).apply_value_map(uninit,
+                                                { omitted: :nil })).to be_nil
     end
 
     it "maps UninitializedClass through value_map[:omitted] => :empty" do
-      expect(attribute(:string).apply_value_map(uninit, { omitted: :empty })).to eq("")
+      expect(attribute(:string).apply_value_map(uninit,
+                                                { omitted: :empty })).to eq("")
     end
 
     it "does NOT route UninitializedClass through the :empty branch" do
@@ -81,18 +88,21 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
       # utils.rb:132-137. Ensure dispatch order matches the originals: uninit
       # values go to :omitted, not :empty.
       expect(
-        attribute(:string).apply_value_map(uninit, { empty: :nil, omitted: :empty }),
+        attribute(:string).apply_value_map(uninit,
+                                           { empty: :nil, omitted: :empty }),
       ).to eq("")
     end
   end
 
   describe "Boolean bare-form (Boolean attribute type required)" do
     it "returns false directly for Boolean attribute, value_map[:empty] = false" do
-      expect(attribute(:boolean).apply_value_map("", { empty: false })).to be(false)
+      expect(attribute(:boolean).apply_value_map("",
+                                                 { empty: false })).to be(false)
     end
 
     it "returns true directly for Boolean attribute, value_map[:omitted] = true" do
-      expect(attribute(:boolean).apply_value_map(uninit, { omitted: true })).to be(true)
+      expect(attribute(:boolean).apply_value_map(uninit,
+                                                 { omitted: true })).to be(true)
     end
 
     it "does NOT apply bare-boolean form to a non-Boolean attribute (documented tightening)" do
@@ -106,15 +116,18 @@ RSpec.describe Lutaml::Model::Attribute, "#apply_value_map" do
 
   describe "Boolean nested-form (value_map[:from][:empty] / [:omitted])" do
     it "returns false from value_map[:from][:empty] unconditionally for Boolean attribute" do
-      expect(attribute(:boolean).apply_value_map("", { from: { empty: false } })).to be(false)
+      expect(attribute(:boolean).apply_value_map("",
+                                                 { from: { empty: false } })).to be(false)
     end
 
     it "returns true from value_map[:from][:omitted] unconditionally for Boolean attribute" do
-      expect(attribute(:boolean).apply_value_map(uninit, { from: { omitted: true } })).to be(true)
+      expect(attribute(:boolean).apply_value_map(uninit,
+                                                 { from: { omitted: true } })).to be(true)
     end
 
     it "returns false from nested form even for non-Boolean attribute (no type gate)" do
-      expect(attribute(:string).apply_value_map("", { from: { empty: false } })).to be(false)
+      expect(attribute(:string).apply_value_map("",
+                                                { from: { empty: false } })).to be(false)
     end
   end
 

data/spec/lutaml/model/attribute_spec.rb

@@ -358,7 +358,8 @@ RSpec.describe Lutaml::Model::Attribute do
       it "executes the proc in the instance context (reads instance attribute)" do
         instance = model_class.new(name: "Alice")
         attribute = model_class.attributes[:greeting]
-        expect(attribute.default_value(register, instance)).to eq("Hello, Alice")
+        expect(attribute.default_value(register,
+                                       instance)).to eq("Hello, Alice")
       end
     end
   end
@@ -413,7 +414,9 @@ RSpec.describe Lutaml::Model::Attribute do
         end
         instance = model_class.new(prefix: "Dr")
         attr = model_class.attributes[:name]
-        expect { attr.validate_value!(nil, register, instance_object: instance) }
+        expect do
+          attr.validate_value!(nil, register, instance_object: instance)
+        end
           .to raise_error(Lutaml::Model::InvalidValueError) do |error|
             # The error carries the value that was used for validation.
             # If instance_exec ran, value is "Dr_default"; if not, error
@@ -427,7 +430,9 @@ RSpec.describe Lutaml::Model::Attribute do
       it "short-circuits without raising" do
         uninit = Lutaml::Model::UninitializedClass.instance
         attr = described_class.new("name", :string)
-        expect { attr.validate_value!(uninit, register, instance_object: model) }
+        expect do
+          attr.validate_value!(uninit, register, instance_object: model)
+        end
           .not_to raise_error
       end
     end

data/spec/lutaml/model/custom_bibtex_adapter_spec.rb

@@ -298,9 +298,9 @@ module CustomBibtexAdapterSpec
       add_mapping(name, to, field_type: :field, render_nil: render_nil)
     end
 
-    def add_mapping(name, to, **)
+    def add_mapping(name, to, **options)
       # validate!(name, to, {})
-      @mappings << BibtexMappingRule.new(name, to: to, **)
+      @mappings << BibtexMappingRule.new(name, to: to, **options)
     end
 
     def mapping_for_field(field)