Class: Lutaml::Store::CompositeModelHandler

Inherits:
Object
  • Object
show all
Defined in:
lib/lutaml/store/composite_model_handler.rb

Defined Under Namespace

Classes: Reference

Instance Method Summary collapse

Constructor Details

#initialize(registry, store, model_store = nil, serializer:) ⇒ CompositeModelHandler

Returns a new instance of CompositeModelHandler.



8
9
10
11
12
13
 
# File 'lib/lutaml/store/composite_model_handler.rb', line 8

def initialize(registry, store, model_store = nil, serializer:)
  @registry = registry
  @store = store
  @model_store = model_store
  @serializer = serializer
end

Instance Method Details

#delete_composite_models(model) ⇒ Object 



72
73
74
75
76
77
78
79
80
 
# File 'lib/lutaml/store/composite_model_handler.rb', line 72

def delete_composite_models(model)
  composite_models = @registry.find_composite_models(model)

  composite_models.each_value do |composite_info|
    registration = composite_info[:registration]
    storage_key = registration.generate_storage_key(composite_info[:model])
    @store.delete(storage_key)
  end
end

#process_composite_models(model) ⇒ Object 



15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
 
# File 'lib/lutaml/store/composite_model_handler.rb', line 15

def process_composite_models(model)
  composite_models = @registry.find_composite_models(model)
  stored_composites = {}

  composite_models.each do |attr_path, composite_info|
    nested_model = composite_info[:model]
    registration = composite_info[:registration]

    storage_key = registration.generate_storage_key(nested_model)
    serialized_data = @serializer.serialize(nested_model)
    @store.set(storage_key, serialized_data)

    stored_composites[attr_path] = Reference.new(
      storage_key: storage_key.to_s,
      model_class: nested_model.class.name,
      key_value: composite_info[:key_value]
    )
  end

  stored_composites
end

#restore_composite_models(model, composite_references = nil) ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
 
# File 'lib/lutaml/store/composite_model_handler.rb', line 37

def restore_composite_models(model, composite_references = nil)
  return model unless composite_references

  restored_model = model.dup

  composite_references.each do |attr_path, reference_info|
    ref = if reference_info.is_a?(Hash)
            Reference.new(**reference_info.transform_keys(&:to_sym).slice(
              :storage_key, :model_class, :key_value
            ))
          else
            reference_info
          end
    nested_model = restore_nested_model(ref)
    next unless nested_model

    set_nested_attribute(restored_model, attr_path, nested_model)
  end

  restored_model
end

#update_composite_models(model, updates) ⇒ Object 



59
60
61
62
63
64
65
66
67
68
69
70
 
# File 'lib/lutaml/store/composite_model_handler.rb', line 59

def update_composite_models(model, updates)
  composite_updates = extract_composite_updates(updates)
  return if composite_updates.empty?

  composite_updates.each do |attr_path, update_value|
    if attr_path.include?(".")
      update_nested_composite(model, attr_path, update_value)
    else
      update_direct_composite(model, attr_path, update_value)
    end
  end
end