Class: Lutaml::Store::PackageStore

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

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(definition) ⇒ PackageStore

Returns a new instance of PackageStore.



9
10
11
12
13
14
15
16
17
 
# File 'lib/lutaml/store/package_store.rb', line 9

def initialize(definition)
  @definition = definition
  @db = DatabaseStore.new(
    adapter: :memory,
    models: definition.database_store_models
  )
  @assets = {}
  @metadata = nil
end

Instance Attribute Details

#assets ⇒ Object (readonly)

Returns the value of attribute assets.



7
8
9
 
# File 'lib/lutaml/store/package_store.rb', line 7

def assets
  @assets
end

#definition ⇒ Object (readonly)

Returns the value of attribute definition.



7
8
9
 
# File 'lib/lutaml/store/package_store.rb', line 7

def definition
  @definition
end

#metadata ⇒ Object

Returns the value of attribute metadata.



6
7
8
 
# File 'lib/lutaml/store/package_store.rb', line 6

def metadata
  @metadata
end

Class Method Details

.load(definition, path, transport: :directory, format: nil) ⇒ Object

── Load / Save ──



21
22
23
24
25
 
# File 'lib/lutaml/store/package_store.rb', line 21

def self.load(definition, path, transport: :directory, format: nil)
  store = new(definition)
  PackageTransport.resolve(transport).read(path, store, format: format)
  store
end

Instance Method Details

#add_asset(path, content) ⇒ Object 



73
74
75
 
# File 'lib/lutaml/store/package_store.rb', line 73

def add_asset(path, content)
  @assets[path] = content
end

#add_model(model_instance) ⇒ Object

── Model CRUD ──



34
35
36
 
# File 'lib/lutaml/store/package_store.rb', line 34

def add_model(model_instance)
  @db.save(model_instance)
end

#add_models(model_instances) ⇒ Object 



38
39
40
 
# File 'lib/lutaml/store/package_store.rb', line 38

def add_models(model_instances)
  model_instances.each { |m| add_model(m) }
end

#asset(path) ⇒ Object

── Assets ──



69
70
71
 
# File 'lib/lutaml/store/package_store.rb', line 69

def asset(path)
  @assets[path]
end

#asset_paths ⇒ Object 



77
78
79
 
# File 'lib/lutaml/store/package_store.rb', line 77

def asset_paths
  @assets.keys
end

#clear_all ⇒ Object 



99
100
101
102
103
 
# File 'lib/lutaml/store/package_store.rb', line 99

def clear_all
  definition.model_classes.each { |mc| clear_models(mc) }
  clear_assets
  @metadata = nil
end

#clear_assets ⇒ Object 



95
96
97
 
# File 'lib/lutaml/store/package_store.rb', line 95

def clear_assets
  @assets.clear
end

#clear_models(model_class) ⇒ Object

── Bulk ──



87
88
89
90
91
92
93
 
# File 'lib/lutaml/store/package_store.rb', line 87

def clear_models(model_class)
  @db.all(model: model_class).each do |m|
    entry = definition.entry_for(model_class)
    key = m.public_send(entry.key)
    @db.destroy(model: model_class, **{ entry.key => key })
  end
end

#fetch_model(model_class, key) ⇒ Object 



42
43
44
45
 
# File 'lib/lutaml/store/package_store.rb', line 42

def fetch_model(model_class, key)
  entry = definition.entry_for(model_class)
  @db.fetch(model: model_class, **{ entry.key => key })
end

#model_count(model_class) ⇒ Object 



51
52
53
 
# File 'lib/lutaml/store/package_store.rb', line 51

def model_count(model_class)
  @db.count(model: model_class)
end

#model_exists?(model_class, key) ⇒ Boolean

Returns:

  • (Boolean) 


55
56
57
58
 
# File 'lib/lutaml/store/package_store.rb', line 55

def model_exists?(model_class, key)
  entry = definition.entry_for(model_class)
  @db.exists?(model: model_class, **{ entry.key => key })
end

#models_for(model_class) ⇒ Object 



47
48
49
 
# File 'lib/lutaml/store/package_store.rb', line 47

def models_for(model_class)
  @db.all(model: model_class)
end

#remove_asset(path) ⇒ Object 



81
82
83
 
# File 'lib/lutaml/store/package_store.rb', line 81

def remove_asset(path)
  @assets.delete(path)
end

#remove_model(model_class, key) ⇒ Object 



60
61
62
63
 
# File 'lib/lutaml/store/package_store.rb', line 60

def remove_model(model_class, key)
  entry = definition.entry_for(model_class)
  @db.destroy(model: model_class, **{ entry.key => key })
end

#save(path, transport: :directory, format: nil, formats: {}) ⇒ Object 



27
28
29
30
 
# File 'lib/lutaml/store/package_store.rb', line 27

def save(path, transport: :directory, format: nil, formats: {})
  resolved_formats = resolve_formats(format, formats)
  PackageTransport.resolve(transport).write(path, self, formats: resolved_formats)
end

#stats ⇒ Object

── Stats ──



107
108
109
110
111
112
113
114
115
116
117
 
# File 'lib/lutaml/store/package_store.rb', line 107

def stats
  model_stats = definition.model_classes
                          .map { |mc| [mc.name, model_count(mc)] }
                          .to_h
  {
    package: definition.name,
    models: model_stats,
    assets: @assets.size,
    metadata: @metadata ? true : false
  }
end