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 



87
88
89
 
# File 'lib/lutaml/model/format_registry.rb', line 87

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

.adapter_loader_for(format) ⇒ Object 



91
92
93
 
# File 'lib/lutaml/model/format_registry.rb', line 91

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

.adapter_options_for(format) ⇒ Object 



95
96
97
 
# File 'lib/lutaml/model/format_registry.rb', line 95

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

.all ⇒ Object 



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

def all
  registered_formats.dup
end

.all_error_types ⇒ Object 



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

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

.castable_type_for(format) ⇒ Object 



99
100
101
 
# File 'lib/lutaml/model/format_registry.rb', line 99

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

.error_types_for(format) ⇒ Object 



123
124
125
 
# File 'lib/lutaml/model/format_registry.rb', line 123

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

.formats ⇒ Object 



103
104
105
 
# File 'lib/lutaml/model/format_registry.rb', line 103

def formats
  registered_formats.keys
end

.info(format) ⇒ Object 



133
134
135
 
# File 'lib/lutaml/model/format_registry.rb', line 133

def info(format)
  registered_formats[format]
end

.key_value?(format) ⇒ Boolean

Returns:

  • (Boolean) 


111
112
113
 
# File 'lib/lutaml/model/format_registry.rb', line 111

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

.key_value_formats ⇒ Object 



107
108
109
 
# File 'lib/lutaml/model/format_registry.rb', line 107

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

.mappings_class_for(format) ⇒ Object 



79
80
81
 
# File 'lib/lutaml/model/format_registry.rb', line 79

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

.rdf?(format) ⇒ Boolean

Returns:

  • (Boolean) 


119
120
121
 
# File 'lib/lutaml/model/format_registry.rb', line 119

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

.rdf_formats ⇒ Object 



115
116
117
 
# File 'lib/lutaml/model/format_registry.rb', line 115

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, stream_methods: false) ⇒ 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
68
69
 
# 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,
             stream_methods: false)
  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::Serialize.register_stream_methods(format) if stream_methods

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


75
76
77
 
# File 'lib/lutaml/model/format_registry.rb', line 75

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

.reset! ⇒ Object 



141
142
143
 
# File 'lib/lutaml/model/format_registry.rb', line 141

def reset!
  @registered_formats = nil
end

.transformer_for(format) ⇒ Object 



83
84
85
 
# File 'lib/lutaml/model/format_registry.rb', line 83

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

.unregister(format) ⇒ Object 



71
72
73
 
# File 'lib/lutaml/model/format_registry.rb', line 71

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