Class: Textus::Protocol::StoreEngine

Inherits:
Object
  • Object
show all
Defined in:
lib/textus/protocol/store_engine.rb,
lib/textus/protocol/store_engine/put.rb,
lib/textus/protocol/store_engine/move.rb,
lib/textus/protocol/store_engine/delete.rb,
lib/textus/protocol/store_engine/pipeline.rb

Defined Under Namespace

Modules: Delete, Move, Pipeline, Put

Instance Method Summary collapse

Constructor Details

#initialize(file_system:, manifest:, layout:, store:, event_emitter: nil, schemas: nil) ⇒ StoreEngine

Returns a new instance of StoreEngine.



4
5
6
7
8
9
10
11
 
# File 'lib/textus/protocol/store_engine.rb', line 4

def initialize(file_system:, manifest:, layout:, store:, event_emitter: nil, schemas: nil)
  @file_system = file_system
  @manifest = manifest
  @layout = layout
  @store = store
  @event_emitter = event_emitter
  @schemas = schemas
end

Instance Method Details

#delete(key:, call:, if_etag: nil) ⇒ Object 



60
61
62
63
64
65
66
 
# File 'lib/textus/protocol/store_engine.rb', line 60

def delete(key:, call:, if_etag: nil)
  deps = Pipeline::DeleteDeps.new(
    file_system: @file_system, manifest: @manifest, store: @store,
    layout: @layout, event_emitter: @event_emitter, call:
  )
  Delete.call(key, if_etag:, deps:)
end

#exists?(key:) ⇒ Boolean

Returns:

  • (Boolean) 


27
28
29
30
 
# File 'lib/textus/protocol/store_engine.rb', line 27

def exists?(key:)
  path = resolve(key:).path
  path && @file_system.exists?(path)
end

#list(prefix: nil, lane: nil, q: nil, schema: nil) ⇒ Object 



32
33
34
35
36
37
38
39
40
41
 
# File 'lib/textus/protocol/store_engine.rb', line 32

def list(prefix: nil, lane: nil, q: nil, schema: nil)
  if @store.entry_index && (q || schema)
    rows = @store.entry_index.search(query: q, schema:, lane:, prefix:)
    (rows || []).map { |r| { "key" => r["key"], "lane" => r["lane"] } }
  else
    rows = @manifest.resolver.enumerate(prefix:)
    rows = rows.select { |r| r[:manifest_entry].lane == lane } if lane
    rows.map { |r| { "key" => r[:key], "lane" => r[:manifest_entry].lane } }
  end
end

#mentry_for(key:) ⇒ Object 



44
 
# File 'lib/textus/protocol/store_engine.rb', line 44

def mentry_for(key:)= resolve(key:).entry

#move(from_key:, to_key:, call:, if_etag: nil, dry_run: false) ⇒ Object 



68
69
70
71
72
73
74
 
# File 'lib/textus/protocol/store_engine.rb', line 68

def move(from_key:, to_key:, call:, if_etag: nil, dry_run: false)
  deps = Pipeline::MoveDeps.new(
    file_system: @file_system, manifest: @manifest, store: @store,
    layout: @layout, event_emitter: @event_emitter, reader: self, call:
  )
  Move.call(from_key:, to_key:, if_etag:, dry_run:, deps:)
end

#put(key:, meta:, body:, content:, call:, if_etag: nil, format: nil) ⇒ Object 



46
47
48
49
50
51
52
53
54
55
56
57
58
 
# File 'lib/textus/protocol/store_engine.rb', line 46

def put(key:, meta:, body:, content:, call:, if_etag: nil, format: nil)
  result = resolve(key:)
  payload = Value::Payload.new(meta: meta || {}, body:, content:)
  deps = build_deps(reader: nil, call:)

  if format
    fmt_mod = Textus::Protocol::Format.for(format)
    path = result.path.sub(/\.[^.]+$/, "") + fmt_mod.nested_ext(result.remaining.last)
    Put.call(key, mentry: result.entry, path:, payload:, if_etag:, deps:, fmt: format)
  else
    Put.call(key, mentry: result.entry, path: result.path, payload:, if_etag:, deps:)
  end
end

#read(key:) ⇒ Object 



13
14
15
16
17
18
19
20
21
22
23
24
25
 
# File 'lib/textus/protocol/store_engine.rb', line 13

def read(key:)
  result = resolve(key:)
  path = result.path
  return nil unless path && @file_system.exists?(path)

  raw = @file_system.read(path)
  parsed = Format.for(result.entry.format).parse(raw, path:)
  Envelope.build(key:, mentry: result.entry, path:,
                 meta: parsed["_meta"] || {},
                 body: parsed["body"] || "",
                 content: parsed["content"],
                 etag: Value::Etag.for_file(path))
end

#resolve(key:) ⇒ Object 



43
 
# File 'lib/textus/protocol/store_engine.rb', line 43

def resolve(key:)   = @manifest.resolver.resolve(key)