Class: Lutaml::Model::FormatRegistry

Inherits:
Object
  • Object
show all
Defined in:
lib/lutaml/model/format_registry.rb

Overview

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.

Examples:

Registering a custom format

Lutaml::Model::FormatRegistry.register(:custom,
  mapping_class: MyMapping,
  adapter_class: MyAdapter,
  transformer: MyTransformer
)

Checking if a format is registered

Lutaml::Model::FormatRegistry.registered?(:xml) #=> true

Listing all registered formats

Lutaml::Model::FormatRegistry.formats #=> [:xml, :json, :yaml, ...]

Class Method Summary collapse

Class Method Details

.adapter_class_for(format) ⇒ Class?

Get the adapter class for a format

Parameters:

  • format (Symbol) —

    the format name

Returns:

  • (Class, nil) —

    the adapter class or nil if not registered



121
122
123
 
# File 'lib/lutaml/model/format_registry.rb', line 121

def adapter_class_for(format)
  registered_formats.dig(format, :adapter_class)
end

.adapter_loader_for(format) ⇒ Module?

Get the adapter loader for a format

Parameters:

  • format (Symbol) —

    the format name

Returns:

  • (Module, nil) —

    the adapter loader or nil



129
130
131
 
# File 'lib/lutaml/model/format_registry.rb', line 129

def adapter_loader_for(format)
  registered_formats.dig(format, :adapter_loader)
end

.adapter_options_for(format) ⇒ Hash?

Get the adapter options for a format

Parameters:

  • format (Symbol) —

    the format name

Returns:

  • (Hash, nil) —

    { available: […], default: :name } or nil



137
138
139
 
# File 'lib/lutaml/model/format_registry.rb', line 137

def adapter_options_for(format)
  registered_formats.dig(format, :adapter_options)
end

.all ⇒ Hash{Symbol => Hash}

Get all registered formats with their details

Returns:



199
200
201
 
# File 'lib/lutaml/model/format_registry.rb', line 199

def all
  registered_formats.dup
end

.all_error_types ⇒ Array<Class>

Get all registered error types across all formats

Returns:

  • (Array<Class>) 


182
183
184
185
186
 
# File 'lib/lutaml/model/format_registry.rb', line 182

def all_error_types
  registered_formats.values.filter_map do |info|
    info[:error_types]
  end.flatten.compact
end

.castable_type_for(format) ⇒ Class?

Get the castable type for a format

Parameters:

  • format (Symbol) —

    the format name

Returns:

  • (Class, nil) —

    the castable type or nil



145
146
147
 
# File 'lib/lutaml/model/format_registry.rb', line 145

def castable_type_for(format)
  registered_formats.dig(format, :castable_type)
end

.error_types_for(format) ⇒ Array<Class>?

Get format-specific error types

Parameters:

  • format (Symbol) —

    the format name

Returns:

  • (Array<Class>, nil) —

    error types for this format



175
176
177
 
# File 'lib/lutaml/model/format_registry.rb', line 175

def error_types_for(format)
  registered_formats.dig(format, :error_types)
end

.formats ⇒ Array<Symbol>

Get all registered format names

Returns:

  • (Array<Symbol>) 


152
153
154
 
# File 'lib/lutaml/model/format_registry.rb', line 152

def formats
  registered_formats.keys
end

.info(format) ⇒ Hash?

Get registration info for a format

Parameters:

  • format (Symbol) —

    the format name

Returns:

  • (Hash, nil) —

    the registration info or nil if not found



192
193
194
 
# File 'lib/lutaml/model/format_registry.rb', line 192

def info(format)
  registered_formats[format]
end

.key_value?(format) ⇒ Boolean

Check if a format is a key-value format

Parameters:

  • format (Symbol) —

    the format name

Returns:

  • (Boolean) 


167
168
169
 
# File 'lib/lutaml/model/format_registry.rb', line 167

def key_value?(format)
  registered_formats.dig(format, :key_value) == true
end

.key_value_formats ⇒ Array<Symbol>

Get all key-value format names (non-XML formats)

Returns:

  • (Array<Symbol>) 


159
160
161
 
# File 'lib/lutaml/model/format_registry.rb', line 159

def key_value_formats
  registered_formats.select { |_, info| info[:key_value] }.keys
end

.mappings_class_for(format) ⇒ Class?

Get the mapping class for a format

Parameters:

  • format (Symbol) —

    the format name

Returns:

  • (Class, nil) —

    the mapping class or nil if not registered



105
106
107
 
# File 'lib/lutaml/model/format_registry.rb', line 105

def mappings_class_for(format)
  registered_formats.dig(format, :mapping_class)
end

.register(format, mapping_class:, adapter_class:, transformer:, adapter_loader: nil, castable_type: nil, key_value: nil, error_types: nil, adapter_options: nil) ⇒ Hash

Register a new format with its associated components

Parameters:

  • format (Symbol) —

    the format name (e.g., :xml, :json)

  • mapping_class (Class) —

    the mapping class for this format

  • adapter_class (Class, nil) —

    the adapter class (nil for abstract formats)

  • transformer (Class) —

    the transformer class for serialization

  • adapter_loader (Module, nil) (defaults to: nil) —

    optional module with load_adapter_file and class_for methods

Returns:

  • (Hash) —

    the registered format configuration

Raises:

  • (ArgumentError) —

    if format is invalid or required params missing



34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
 
# File 'lib/lutaml/model/format_registry.rb', line 34

def register(format, mapping_class:, adapter_class:, transformer:,
adapter_loader: nil, castable_type: nil, key_value: nil, error_types: nil, adapter_options: nil)
  validate_registration!(format, mapping_class, transformer)

  registered_formats[format] = {
    mapping_class: mapping_class,
    transformer: transformer,
    adapter_class: adapter_class,
    adapter_loader: adapter_loader,
    castable_type: castable_type,
    key_value: key_value,
    error_types: error_types,
    adapter_options: adapter_options,
    registered_at: Time.now,
  }

  ::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)
  end

  Lutaml::Model::Config.define_singleton_method(:"#{format}_adapter_type") do
    instance.adapter_for(format)
  end

  # Define adapter methods on Configuration class for this format
  define_configuration_adapter_methods(format, adapter_options)

  registered_formats[format]
end

.registered?(format) ⇒ Boolean

Check if a format is registered

Parameters:

  • format (Symbol) —

    the format to check

Returns:

  • (Boolean) 


97
98
99
 
# File 'lib/lutaml/model/format_registry.rb', line 97

def registered?(format)
  registered_formats.key?(format)
end

.reset! ⇒ void

This method returns an undefined value.

Reset the registry (primarily for testing)



206
207
208
 
# File 'lib/lutaml/model/format_registry.rb', line 206

def reset!
  @registered_formats = nil
end

.transformer_for(format) ⇒ Class?

Get the transformer for a format

Parameters:

  • format (Symbol) —

    the format name

Returns:

  • (Class, nil) —

    the transformer class or nil if not registered



113
114
115
 
# File 'lib/lutaml/model/format_registry.rb', line 113

def transformer_for(format)
  registered_formats.dig(format, :transformer)
end

.unregister(format) ⇒ Hash?

Unregister a format

Parameters:

  • format (Symbol) —

    the format to unregister

Returns:

  • (Hash, nil) —

    the removed format configuration or nil if not found



89
90
91
 
# File 'lib/lutaml/model/format_registry.rb', line 89

def unregister(format)
  registered_formats.delete(format)
end