Class: Smith::PersistenceAdapters::Memory

Inherits:
Object
  • Object
show all
Defined in:
lib/smith/persistence_adapters/memory.rb

Overview

In-process Hash adapter. Thread-safe via Monitor. No I/O, no transient errors. Designed for tests and quick smoke runs.

Tracks TTL via stamped expiry times so it behaves consistently with other adapters’ TTL semantics. Implements ‘store_versioned` via the monitor, enabling optimistic-locking tests without Redis.

Auto-selected by Smith.persistence_adapter when both Smith.config.persistence_adapter is nil AND Smith.config.test_mode is true (typically set in spec_helper.rb).

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Memory

Returns a new instance of Memory.



18
19
20
21
22
 
# File 'lib/smith/persistence_adapters/memory.rb', line 18

def initialize
  @store = {}
  @heartbeats = {}
  @monitor = Monitor.new
end

Instance Method Details

#clear! ⇒ Object 



92
93
94
 
# File 'lib/smith/persistence_adapters/memory.rb', line 92

def clear!
  @monitor.synchronize { @store.clear }
end

#delete(key) ⇒ Object 



44
45
46
47
48
49
 
# File 'lib/smith/persistence_adapters/memory.rb', line 44

def delete(key)
  @monitor.synchronize do
    @store.delete(key)
    @heartbeats.delete(key)
  end
end

#fetch(key) ⇒ Object 



30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/smith/persistence_adapters/memory.rb', line 30

def fetch(key)
  @monitor.synchronize do
    entry = @store[key]
    next nil if entry.nil?

    if entry[:expires_at] && entry[:expires_at] < Time.now.utc
      @store.delete(key)
      next nil
    end

    entry[:payload]
  end
end

#last_heartbeat(key) ⇒ Object 



57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/smith/persistence_adapters/memory.rb', line 57

def last_heartbeat(key)
  @monitor.synchronize do
    entry = @heartbeats[key]
    next nil if entry.nil?

    if entry[:expires_at] && entry[:expires_at] < Time.now.utc
      @heartbeats.delete(key)
      next nil
    end

    entry[:at]
  end
end

#record_heartbeat(key, ttl: Smith.config.persistence_ttl) ⇒ Object 



51
52
53
54
55
 
# File 'lib/smith/persistence_adapters/memory.rb', line 51

def record_heartbeat(key, ttl: Smith.config.persistence_ttl)
  @monitor.synchronize do
    @heartbeats[key] = { at: Time.now.utc, expires_at: ttl ? Time.now.utc + ttl : nil }
  end
end

#store(key, payload, ttl: Smith.config.persistence_ttl) ⇒ Object 



24
25
26
27
28
 
# File 'lib/smith/persistence_adapters/memory.rb', line 24

def store(key, payload, ttl: Smith.config.persistence_ttl)
  @monitor.synchronize do
    @store[key] = { payload: payload, expires_at: ttl ? Time.now.utc + ttl : nil }
  end
end

#store_versioned(key, payload, expected_version:, ttl: Smith.config.persistence_ttl) ⇒ Object

Optimistic locking via Monitor-synchronized version compare. Raises Smith::PersistenceVersionConflict when the stored payload’s version differs from expected_version. The version is read from the payload’s JSON ‘persistence_version` field (same shape Redis and ActiveRecord stores use, so the contract is consistent across all versioned adapters).



77
78
79
80
81
82
83
84
85
86
87
88
89
90
 
# File 'lib/smith/persistence_adapters/memory.rb', line 77

def store_versioned(key, payload, expected_version:, ttl: Smith.config.persistence_ttl)
  @monitor.synchronize do
    entry = @store[key]
    if entry
      current_version = parse_version(entry[:payload])
      if current_version != expected_version
        raise Smith::PersistenceVersionConflict.new(
          key: key, expected: expected_version, actual: current_version
        )
      end
    end
    @store[key] = { payload: payload, expires_at: ttl ? Time.now.utc + ttl : nil }
  end
end