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.

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 Method Summary collapse

Class Method Details

.adapter_class_for(format) ⇒ Object 



85
86
87
 
# File 'lib/lutaml/model/format_registry.rb', line 85

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

.adapter_loader_for(format) ⇒ Object 



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

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

.adapter_options_for(format) ⇒ Object 



93
94
95
 
# File 'lib/lutaml/model/format_registry.rb', line 93

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

.all ⇒ Object 



135
136
137
 
# File 'lib/lutaml/model/format_registry.rb', line 135

def all
  registered_formats.dup
end

.all_error_types ⇒ Object 



125
126
127
128
129
 
# File 'lib/lutaml/model/format_registry.rb', line 125

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

.castable_type_for(format) ⇒ Object 



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

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

.error_types_for(format) ⇒ Object 



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

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

.formats ⇒ Object 



101
102
103
 
# File 'lib/lutaml/model/format_registry.rb', line 101

def formats
  registered_formats.keys
end

.info(format) ⇒ Object 



131
132
133
 
# File 'lib/lutaml/model/format_registry.rb', line 131

def info(format)
  registered_formats[format]
end

.key_value?(format) ⇒ Boolean

Returns:

  • (Boolean) 


109
110
111
 
# File 'lib/lutaml/model/format_registry.rb', line 109

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

.key_value_formats ⇒ Object 



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

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

.mappings_class_for(format) ⇒ Object 



77
78
79
 
# File 'lib/lutaml/model/format_registry.rb', line 77

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

.rdf?(format) ⇒ Boolean

Returns:

  • (Boolean) 


117
118
119
 
# File 'lib/lutaml/model/format_registry.rb', line 117

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

.rdf_formats ⇒ Object 



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

def rdf_formats
  registered_formats.select { |_, info| info[:rdf] }.keys
end

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

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 selectable formats)

  • transformer (Class) —

    the transformer class for serialization

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

    optional module with load_adapter_file and class_for

  • castable_type (Class, nil) (defaults to: nil) —

    the castable type class

  • key_value (Boolean) (defaults to: nil) —

    whether this is a key-value format

  • error_types (Array<String, Class>) (defaults to: nil) —

    error types for this format

  • adapter_options (Hash, nil) (defaults to: nil) —

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



24
25
26
27
28
29
30
31
32
33
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
 
# File 'lib/lutaml/model/format_registry.rb', line 24

def register(format, mapping_class:, adapter_class:, transformer:,
             adapter_loader: nil, castable_type: nil, key_value: nil,
             rdf: 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,
    rdf: rdf,
    error_types: error_types,
    adapter_options: adapter_options,
    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)

  ::Lutaml::Model::Attribute.format_specific_warn_names.push(:"to_#{format}")

  # 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

  # Define adapter type accessor methods on Config module
  ::Lutaml::Model::Config.define_adapter_type_methods(format)

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

  registered_formats[format]
end

.registered?(format) ⇒ Boolean

Returns:

  • (Boolean) 


73
74
75
 
# File 'lib/lutaml/model/format_registry.rb', line 73

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

.reset! ⇒ Object 



139
140
141
 
# File 'lib/lutaml/model/format_registry.rb', line 139

def reset!
  @registered_formats = nil
end

.transformer_for(format) ⇒ Object 



81
82
83
 
# File 'lib/lutaml/model/format_registry.rb', line 81

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

.unregister(format) ⇒ Object 



69
70
71
 
# File 'lib/lutaml/model/format_registry.rb', line 69

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