lutaml-model 0.8.0 → 0.8.2

data/lib/lutaml/model/configuration.rb

@@ -2,75 +2,25 @@
 
 module Lutaml
   module Model
-    # Single source of truth for Lutaml::Model configuration
+    # Single source of truth for Lutaml::Model configuration.
+    #
+    # Adapter methods delegate to AdapterResolver. This class retains
+    # the configure block API, register, and non-adapter settings.
     #
     # @example Basic configuration
     #   Lutaml::Model::Configuration.configure do |config|
     #     config.xml_adapter = :nokogiri
     #     config.json_adapter = :standard
-    #     config.toml_adapter = :toml_rb
     #   end
     #
     class Configuration
-      # Static defaults captured at boot. Use RuntimeCompatibility directly for
-      # per-call runtime checks that tests may stub.
-      OPAL_RUNTIME = Lutaml::Model::RuntimeCompatibility.opal?
-      WINDOWS_PLATFORM = Lutaml::Model::RuntimeCompatibility.windows?
-
-      # Bootstrap format list for key-value adapters.
-      # NOTE: XML is NOT listed here — it registers dynamically via FormatRegistry.
-      AVAILABLE_FORMATS = %i[json jsonl yaml toml hash].freeze
-      KEY_VALUE_FORMATS = AVAILABLE_FORMATS
-
-      # Available key-value formats and their adapters.
-      # XML adapter metadata is registered dynamically via FormatRegistry
-      # when `require "lutaml/xml"` is called.
-      ADAPTERS = begin
-        h = {
-          json: {
-            available: %i[standard standard_json multi_json oj],
-            default: :standard,
-          },
-          yaml: {
-            available: %i[standard standard_yaml],
-            default: :standard,
-          },
-          toml: {
-            available: OPAL_RUNTIME ? [] : %i[tomlib toml_rb],
-            default: if OPAL_RUNTIME
-                       nil
-                     elsif WINDOWS_PLATFORM
-                       :toml_rb
-                     else
-                       :tomlib
-                     end,
-          },
-          hash: {
-            available: %i[standard standard_hash],
-            default: :standard,
-          },
-          jsonl: {
-            available: %i[standard],
-            default: :standard,
-          },
-          yamls: {
-            available: %i[standard],
-            default: :standard,
-          },
-        }
-        h.freeze
-      end
-
-      attr_reader :adapter_types
+      attr_reader :default_register
 
       def initialize
-        @adapter_types = {}
-        @adapters = {}
         @default_register = :default
         @configured = false
       end
 
-      # Configure the library using a block
       def configure
         yield self if block_given?
         @configured = true
@@ -81,48 +31,21 @@ module Lutaml
         @configured
       end
 
-      # Check if running on Windows platform
-      def self.windows_platform?
-        WINDOWS_PLATFORM
-      end
-
-      # Dynamic accessor for adapter types
+      # Dynamic accessor for adapter types — delegates to AdapterResolver
       def adapter_for(format)
-        @adapter_types[format.to_sym]
+        AdapterResolver.configured_type(format)
       end
 
-      # Dynamic setter for adapter types with validation
+      # Dynamic setter for adapter types — delegates to AdapterResolver
       def set_adapter(format, adapter_type)
-        format = format.to_sym
-        adapter_type = adapter_type.to_sym
-
-        validate_adapter!(format, adapter_type)
-        @adapter_types[format] = adapter_type
-
-        # Load the adapter immediately
-        load_adapter(format, adapter_type)
+        AdapterResolver.set_adapter_type(format, adapter_type)
       end
 
-      # Define dynamic accessor methods for each format
-      ADAPTERS.each_key do |format|
-        # Getter method: config.xml_adapter
-        define_method(:"#{format}_adapter") do
-          @adapter_types[format] || ADAPTERS[format][:default]
-        end
-
-        # Setter method: config.xml_adapter = :nokogiri
-        define_method(:"#{format}_adapter=") do |adapter_type|
-          set_adapter(format, adapter_type)
-        end
-
-        # Aliased setter with _type suffix: config.xml_adapter_type = :nokogiri
-        alias_method :"#{format}_adapter_type=", :"#{format}_adapter="
-        alias_method :"#{format}_adapter_type", :"#{format}_adapter"
+      # Get adapter class for a format
+      def get_adapter(format)
+        AdapterResolver.adapter_for(format)
       end
 
-      # Default register/context ID accessor
-      attr_reader :default_register
-
       def default_register=(value)
         @default_register = case value
                             when Symbol then value
@@ -134,190 +57,35 @@ module Lutaml
                             end
       end
 
-      # Alias for terminology alignment
       alias default_context_id default_register
       alias default_context_id= default_register=
 
-      # Get adapter class for a format
-      def get_adapter(format)
-        @adapters[format.to_sym]
-      end
-
       # Reset configuration to defaults
       def reset!
-        @adapter_types = {}
-        @adapters = {}
         @default_register = :default
         @configured = false
+        AdapterResolver.reset!
+        AdapterScope.reset!
       end
 
-      # Get all current settings as a hash
       def to_h
         {
-          adapter_types: @adapter_types.dup,
           default_register: @default_register,
           configured: @configured,
         }
       end
 
-      # Mappings class for a format
       def mappings_class_for(format)
         Lutaml::Model::FormatRegistry.mappings_class_for(format)
       end
 
-      # Transformer for a format
       def transformer_for(format)
         Lutaml::Model::FormatRegistry.transformer_for(format)
       end
 
-      private
-
-      # Validate that the adapter is available for the format.
-      # Checks both static ADAPTERS hash and FormatRegistry for dynamically
-      # registered formats (e.g., XML).
-      def validate_adapter!(format, adapter_type)
-        adapter_config = ADAPTERS[format] || FormatRegistry.adapter_options_for(format)
-
-        unless adapter_config
-          all_formats = (ADAPTERS.keys + FormatRegistry.formats).uniq
-          available_formats = all_formats.map { |f| "`:#{f}`" }.join(", ")
-          raise ArgumentError,
-                "Unknown format: `:#{format}`. Available formats: #{available_formats}."
-        end
-
-        # Check for Windows + tomlib incompatibility
-        if format == :toml && adapter_type == :tomlib && self.class.windows_platform?
-          raise ArgumentError,
-                "The `:tomlib` adapter is not supported on Windows due to " \
-                "segmentation fault issues. Please use `:toml_rb` instead."
-        end
-
-        available = adapter_config[:available]
-        return unless available
-        return if available.include?(adapter_type)
-
-        available_list = available.map { |a| "`:#{a}`" }.join(", ")
-        closest = find_suggestion(adapter_type.to_s, available.map(&:to_s))
-
-        msg = "Unknown adapter: `:#{adapter_type}` for `:#{format}` format. " \
-              "Available adapters: #{available_list}."
-        msg += " Did you mean `:#{closest}`?" if closest
-
-        raise ArgumentError, msg
-      end
-
-      # Load an adapter for a format
-      def load_adapter(format, adapter_type)
-        adapter = format.to_s
-        type = normalize_type_name(adapter_type, format)
-
-        load_adapter_file(adapter, type)
-        load_moxml_adapter(adapter_type, format)
-
-        adapter_class = class_for(adapter, type)
-        @adapters[format] = adapter_class
-
-        # Also set in Config's adapters for FormatRegistry compatibility
-        Config.set_adapter_for(format, adapter_class)
-      end
-
-      def normalize_type_name(type_name, adapter_name)
-        if type_name.to_s.start_with?("multi_json")
-          "multi_json_adapter"
-        else
-          "#{type_name.to_s.gsub("_#{adapter_name}", '')}_adapter"
-        end
-      end
-
-      def load_adapter_file(adapter, type)
-        # Check FormatRegistry for a custom adapter loader
-        loader = FormatRegistry.adapter_loader_for(adapter.to_sym)
-        if loader.respond_to?(:load_adapter_file)
-          loader.load_adapter_file(adapter, type)
-          return
-        end
-
-        # Default key-value adapter loading
-        adapter_path = if Lutaml::Model::RuntimeCompatibility.opal?
-                         "lutaml/key_value/adapter/#{adapter}/#{type}"
-                       else
-                         File.join(__dir__, "../key_value/adapter", adapter,
-                                   type)
-                       end
-        require adapter_path
-      rescue LoadError
-        raise UnknownAdapterTypeError.new(adapter, type), cause: nil
-      end
-
-      def load_moxml_adapter(type_name, adapter_name)
-        # Delegate to FormatRegistry adapter loader if available
-        loader = FormatRegistry.adapter_loader_for(adapter_name)
-        if loader.respond_to?(:load_moxml_adapter)
-          loader.load_moxml_adapter(type_name, adapter_name)
-          nil
-        end
-
-        # Key-value formats don't need moxml loading
-        # Non-key-value formats without a registered loader are no-ops
-      end
-
-      def class_for(adapter, type)
-        # Check FormatRegistry for a custom adapter loader
-        loader = FormatRegistry.adapter_loader_for(adapter.to_sym)
-        if loader.respond_to?(:class_for)
-          return loader.class_for(adapter, type)
-        end
-
-        # Default key-value adapter class resolution
-        Lutaml::KeyValue::Adapter.const_get(to_class_name(adapter))
-          .const_get(to_class_name(type))
-      end
-
-      def to_class_name(str)
-        str.to_s.split("_").map(&:capitalize).join
-      end
-
-      # Find closest string match for suggestions
-      def find_suggestion(input, candidates)
-        return nil if input.nil? || input.empty?
-
-        candidates.min_by do |candidate|
-          levenshtein_distance(input.downcase, candidate.downcase)
-        end.tap do |closest|
-          max_dist = ([input.length, closest.length].max / 2) + 1
-          return nil if closest && levenshtein_distance(input.downcase,
-                                                        closest.downcase) > max_dist
-        end
-      end
-
-      # Calculate Levenshtein distance between two strings
-      def levenshtein_distance(a, b)
-        return a.length if b.empty?
-        return b.length if a.empty?
-
-        matrix = Array.new(a.length + 1) do |i|
-          Array.new(b.length + 1) do |j|
-            if i.zero?
-              j
-            else
-              (j.zero? ? i : 0)
-            end
-          end
-        end
-
-        (1..a.length).each do |i|
-          (1..b.length).each do |j|
-            cost = a[i - 1] == b[j - 1] ? 0 : 1
-            matrix[i][j] = [
-              matrix[i - 1][j] + 1,
-              matrix[i][j - 1] + 1,
-              matrix[i - 1][j - 1] + cost,
-            ].min
-          end
-        end
-
-        matrix[a.length][b.length]
-      end
+      # Adapter accessors are defined dynamically by FormatRegistry.register
+      # via define_method. These forward to AdapterResolver.
+      # The generic set_adapter/get_adapter handle any format.
     end
   end
 end

data/lib/lutaml/model/format_registry.rb

@@ -2,37 +2,28 @@
 
 module Lutaml
   module Model
-    # Registry for serialization formats and their associated components
+    # Registry for serialization formats and their associated components.
     #
-    # This class manages the registration of formats (xml, json, yaml, etc.)
-    # and their associated mapping classes, adapters, and transformers.
-    #
-    # @example Registering a custom format
-    #   Lutaml::Model::FormatRegistry.register(:custom,
-    #     mapping_class: MyMapping,
-    #     adapter_class: MyAdapter,
-    #     transformer: MyTransformer
-    #   )
-    #
-    # @example Checking if a format is registered
-    #   Lutaml::Model::FormatRegistry.registered?(:xml) #=> true
-    #
-    # @example Listing all registered formats
-    #   Lutaml::Model::FormatRegistry.formats #=> [:xml, :json, :yaml, ...]
+    # Manages the registration of formats (xml, json, yaml, etc.) and their
+    # mapping classes, transformers, and adapter metadata. Adapter loading
+    # and resolution is delegated to AdapterResolver.
     #
     class FormatRegistry
       class << self
-        # Register a new format with its associated components
+        # Register a new format with its associated components.
         #
         # @param format [Symbol] the format name (e.g., :xml, :json)
         # @param mapping_class [Class] the mapping class for this format
-        # @param adapter_class [Class, nil] the adapter class (nil for abstract formats)
+        # @param adapter_class [Class, nil] the adapter class (nil for selectable formats)
         # @param transformer [Class] the transformer class for serialization
-        # @raise [ArgumentError] if format is invalid or required params missing
-        # @return [Hash] the registered format configuration
-        # @param adapter_loader [Module, nil] optional module with load_adapter_file and class_for methods
+        # @param adapter_loader [Module, nil] optional module with load_adapter_file and class_for
+        # @param castable_type [Class, nil] the castable type class
+        # @param key_value [Boolean] whether this is a key-value format
+        # @param error_types [Array<String, Class>] error types for this format
+        # @param adapter_options [Hash, nil] { available: [...], default: :name }
         def register(format, mapping_class:, adapter_class:, transformer:,
-adapter_loader: nil, castable_type: nil, key_value: nil, error_types: nil, adapter_options: nil)
+                     adapter_loader: nil, castable_type: nil, key_value: nil,
+                     error_types: nil, adapter_options: nil)
           validate_registration!(format, mapping_class, transformer)
 
           registered_formats[format] = {
@@ -47,206 +38,142 @@ adapter_loader: nil, castable_type: nil, key_value: nil, error_types: nil, adapt
             registered_at: Time.now,
           }
 
+          # Register type methods on model classes
           ::Lutaml::Model::Type::Value.register_format_to_from_methods(format)
           ::Lutaml::Model::Serialize.register_format_mapping_method(format)
           ::Lutaml::Model::Serialize.register_from_format_method(format)
           ::Lutaml::Model::Serialize.register_to_format_method(format)
 
-          # Push format-specific serialization method name to warn list
           ::Lutaml::Model::Attribute.format_specific_warn_names.push(:"to_#{format}")
 
-          Lutaml::Model::Config.set_adapter_for(format, adapter_class)
-
-          # Define raw adapter getter/setter on Config module
-          Lutaml::Model::Config.define_singleton_method(:"#{format}_adapter") do
-            @adapters[format] || adapter_class
-          end
-
-          Lutaml::Model::Config.define_singleton_method(:"#{format}_adapter=") do |adapter_klass|
-            @adapters ||= {}
-            @adapters[format] = adapter_klass
-          end
-
-          # Define _type suffixed methods on Config module (delegate to Configuration#set_adapter)
-          Lutaml::Model::Config.define_singleton_method(:"#{format}_adapter_type=") do |type_name|
-            instance.set_adapter(format, type_name)
+          # Register adapter metadata with AdapterResolver
+          if adapter_options
+            # Selectable adapters — have multiple options (xml, toml, json, yaml, hash)
+            AdapterResolver.register_metadata(format, adapter_options)
+          elsif adapter_class
+            # Fixed adapter (jsonl, yamls) — register as sole available adapter
+            adapter_name = derive_adapter_name(adapter_class)
+            AdapterResolver.register_fixed(format, adapter_class, adapter_name)
           end
 
-          Lutaml::Model::Config.define_singleton_method(:"#{format}_adapter_type") do
-            instance.adapter_for(format)
-          end
+          # Define adapter type accessor methods on Config module
+          ::Lutaml::Model::Config.define_adapter_type_methods(format)
 
-          # Define adapter methods on Configuration class for this format
+          # Define adapter accessor methods on Configuration class
           define_configuration_adapter_methods(format, adapter_options)
 
           registered_formats[format]
         end
 
-        # Unregister a format
-        #
-        # @param format [Symbol] the format to unregister
-        # @return [Hash, nil] the removed format configuration or nil if not found
         def unregister(format)
           registered_formats.delete(format)
         end
 
-        # Check if a format is registered
-        #
-        # @param format [Symbol] the format to check
-        # @return [Boolean]
         def registered?(format)
           registered_formats.key?(format)
         end
 
-        # Get the mapping class for a format
-        #
-        # @param format [Symbol] the format name
-        # @return [Class, nil] the mapping class or nil if not registered
         def mappings_class_for(format)
           registered_formats.dig(format, :mapping_class)
         end
 
-        # Get the transformer for a format
-        #
-        # @param format [Symbol] the format name
-        # @return [Class, nil] the transformer class or nil if not registered
         def transformer_for(format)
           registered_formats.dig(format, :transformer)
         end
 
-        # Get the adapter class for a format
-        #
-        # @param format [Symbol] the format name
-        # @return [Class, nil] the adapter class or nil if not registered
         def adapter_class_for(format)
           registered_formats.dig(format, :adapter_class)
         end
 
-        # Get the adapter loader for a format
-        #
-        # @param format [Symbol] the format name
-        # @return [Module, nil] the adapter loader or nil
         def adapter_loader_for(format)
           registered_formats.dig(format, :adapter_loader)
         end
 
-        # Get the adapter options for a format
-        #
-        # @param format [Symbol] the format name
-        # @return [Hash, nil] { available: [...], default: :name } or nil
         def adapter_options_for(format)
           registered_formats.dig(format, :adapter_options)
         end
 
-        # Get the castable type for a format
-        #
-        # @param format [Symbol] the format name
-        # @return [Class, nil] the castable type or nil
         def castable_type_for(format)
           registered_formats.dig(format, :castable_type)
         end
 
-        # Get all registered format names
-        #
-        # @return [Array<Symbol>]
         def formats
           registered_formats.keys
         end
 
-        # Get all key-value format names (non-XML formats)
-        #
-        # @return [Array<Symbol>]
         def key_value_formats
           registered_formats.select { |_, info| info[:key_value] }.keys
         end
 
-        # Check if a format is a key-value format
-        #
-        # @param format [Symbol] the format name
-        # @return [Boolean]
         def key_value?(format)
           registered_formats.dig(format, :key_value) == true
         end
 
-        # Get format-specific error types
-        #
-        # @param format [Symbol] the format name
-        # @return [Array<Class>, nil] error types for this format
         def error_types_for(format)
           registered_formats.dig(format, :error_types)
         end
 
-        # Get all registered error types across all formats
-        #
-        # @return [Array<Class>]
         def all_error_types
           registered_formats.values.filter_map do |info|
             info[:error_types]
           end.flatten.compact
         end
 
-        # Get registration info for a format
-        #
-        # @param format [Symbol] the format name
-        # @return [Hash, nil] the registration info or nil if not found
         def info(format)
           registered_formats[format]
         end
 
-        # Get all registered formats with their details
-        #
-        # @return [Hash{Symbol => Hash}]
         def all
           registered_formats.dup
         end
 
-        # Reset the registry (primarily for testing)
-        #
-        # @return [void]
         def reset!
           @registered_formats = nil
         end
 
         private
 
-        # Get the internal registry hash
-        #
-        # @return [Hash]
         def registered_formats
           @registered_formats ||= {}
         end
 
-        # Define adapter getter/setter methods on Configuration class
-        # for a dynamically registered format.
-        #
-        # @param format [Symbol] the format name
-        # @param adapter_options [Hash, nil] { available: [...], default: :name }
         def define_configuration_adapter_methods(format, adapter_options)
           cfg = ::Lutaml::Model::Configuration
-          return if cfg.method_defined?(:"#{format}_adapter")
+          return if cfg.method_defined?(:"#{format}_adapter=")
 
-          default_adapter = adapter_options&.dig(:default)
+          adapter_options&.dig(:default)
 
+          # Adapter class getter on Configuration instance
           cfg.define_method(:"#{format}_adapter") do
-            @adapter_types[format] || default_adapter
+            AdapterResolver.adapter_for(format)
           end
 
+          # Adapter type name setter on Configuration instance
           cfg.define_method(:"#{format}_adapter=") do |adapter_type|
             set_adapter(format, adapter_type)
           end
 
+          # Aliased _type methods
           cfg.send(:alias_method, :"#{format}_adapter_type=",
                    :"#{format}_adapter=")
           cfg.send(:alias_method, :"#{format}_adapter_type",
                    :"#{format}_adapter")
         end
 
-        # Validate registration parameters
+        # Derive a symbol adapter name from an adapter class.
         #
-        # @param format [Symbol] the format name
-        # @param mapping_class [Class] the mapping class
-        # @param transformer [Class] the transformer class
-        # @raise [ArgumentError] if validation fails
+        # @param adapter_class [Class] e.g., Lutaml::Json::Adapter::StandardAdapter
+        # @return [Symbol] e.g., :standard
+        def derive_adapter_name(adapter_class)
+          name = adapter_class.name
+          return :standard unless name
+
+          # Extract the adapter type from class name: "...::StandardAdapter" → :standard
+          short = name.split("::").last
+          short = short.delete_suffix("Adapter")
+          short.downcase.to_sym
+        end
+
         def validate_registration!(format, mapping_class, transformer)
           unless format.is_a?(Symbol)
             raise ArgumentError,

data/lib/lutaml/model/mapping/listener.rb

@@ -91,13 +91,15 @@ module Lutaml
       #
       # @param args [Array] Arguments to pass to the handler block
       # @return [Object] Result of the handler invocation
-      def call(*)
+      # rubocop:disable Style/ArgumentsForwarding -- anonymous * requires Ruby 3.2+
+      def call(*args)
         if simple?
           raise NoHandlerError,
                 "Cannot call simple listener #{id.inspect}"
         end
 
-        @handler.call(*)
+        @handler.call(*args)
+        # rubocop:enable Style/ArgumentsForwarding
       end
 
       # Error raised when attempting to invoke a simple listener as a complex one.