Class: Newman::Recorder

Inherits:
Object
  • Object
show all
Includes:
Enumerable
Defined in:
lib/newman/recorder.rb

Instance Method Summary collapse

Constructor Details

#initialize(column, store) ⇒ Recorder

To initialize a ‘Newman::Recorder` object, a `column` key and `store` object must be provided, i.e.

store     = Newman::Store.new("sample.store")
recorder  = Newman::Recorder.new(:subscribers, store)

However, in most cases you should not instantiate a ‘Newman::Recorder` directly, and instead should make use of `Newman::Store#[]` which is syntactic sugar for the same operation.

The first time a particular ‘column` key is referenced, two mapping is created for the column in the underlying data store: one which keeps track of the autoincrementing ids, and one that keeps track of the data stored within the column. It’s fine to treat these mappings as implementation details, but we treat them as part of Newman’s external interface because backwards-incompatible changes to them will result in possible data store corruption.



37
38
39
40
41
42
43
44
45
 
# File 'lib/newman/recorder.rb', line 37

def initialize(column, store)
  self.column = column
  self.store  = store

  store.write do |data|
    data[:identifiers][column] ||= 0
    data[:columns][column]     ||= {}
  end
end

Instance Method Details

#create(contents) ⇒ Object

‘Newman::Recorder#create` store an arbitrary Ruby object in the data store and returns a `Newman::Record` object which has fields for the `column` key, record `id`, and record `contents`. This method automatically generates new ids, starting with `id=1` for the first record and then incrementing sequentially.



69
70
71
72
73
74
75
76
77
 
# File 'lib/newman/recorder.rb', line 69

def create(contents)
  store.write do |data| 
    id = (data[:identifiers][column] += 1)
    
    data[:columns][column][id] = contents 

    Record.new(column, id, contents)
  end
end

#destroy(id) ⇒ Object

‘Newman::Recorder#destroy` looks up a record by `id` and then removes it from the data store. This method returns `true` whether or not a record was actually destroyed, which is a somewhat useless behavior and may need to be fixed in a future version of Newman. Patches welcome!



111
112
113
114
115
116
117
 
# File 'lib/newman/recorder.rb', line 111

def destroy(id)
  store.write do |data|
    data[:columns][column].delete(id)
  end

  true
end

#each ⇒ Object

‘Newman::Recorder#each` iterates over all records stored in the column, yielding a `Newman::Record` object for each one. Because `Enumerable` is mixed into `Newman::Recorder`, all enumerable methods that get called on a recorder object end up making calls to this method.



53
54
55
56
57
58
59
 
# File 'lib/newman/recorder.rb', line 53

def each
  store.read do |data|
    data[:columns][column].each do |id, contents| 
      yield(Record.new(column, id, contents)) 
    end
  end
end

#read(id) ⇒ Object

‘Newman::Recorder#read` looks up a record by `id` and returns a `Newman::Record` object.



84
85
86
87
88
 
# File 'lib/newman/recorder.rb', line 84

def read(id)
  store.read do |data|
    Record.new(column, id, data[:columns][column][id])
  end
end

#update(id) ⇒ Object

‘Newman::Recorder#update` looks up a record by `id` and yields its contents. The record contents are then replaced with the return value of the provided block.



96
97
98
99
100
101
102
 
# File 'lib/newman/recorder.rb', line 96

def update(id)
  store.write do |data|
    data[:columns][column][id] = yield(data[:columns][column][id])

    Record.new(column, id, data[:columns][column][id])
  end
end