memstore 1.1.0 → 1.2.0

data/README.md

@@ -29,10 +29,10 @@ $ gem install memstore
 ## Usage
 
 - [Basics](#basics)
-- [Objects vs. Hashes](#objects-vs-hashes)
-- [Adding Items](#adding-items)
-- [Retrieving Items](#retrieving-items)
-- [Deleting Items](#deleting-items)
+  - [Objects vs. Hashes](#objects-vs-hashes)
+  - [Adding Items](#adding-items)
+  - [Retrieving Items](#retrieving-items)
+  - [Deleting Items](#deleting-items)
 - [Search Queries](#search-queries)
 - [Serialization](#serialization)
   - [Binary](#binary)
@@ -40,6 +40,7 @@ $ gem install memstore
   - [YAML](#yaml)
   - [JSON](#json)
   - [MessagePack](#messagepack)
+  - [Concurrent Access](#concurrent-access)
 
 ### Basics
 
@@ -68,7 +69,7 @@ store = MemStore.new(:id, { ... }) # to use custom key
 
 The collection must be a hash that correctly maps the used key to each item.
 
-### Objects vs. Hashes
+#### Objects vs. Hashes
 
 MemStore comes in two flavors: `ObjectStore` and `HashStore`.
 
@@ -90,7 +91,7 @@ store = MemStore::HashStore.new
 
 If no key attribute is specified, `HashStore` will also use `Object#hash`.
 
-### Adding Items
+#### Adding Items
 
 `items` provides direct access to the internal items hash.
 
@@ -123,7 +124,7 @@ store << a << b << c
 # => store
 ```
 
-### Retrieving Items
+#### Retrieving Items
 
 `length` (or `size`) returns the current number of items:
 
@@ -152,7 +153,7 @@ store[1..3, 6]
 # => [a, b, c, f]
 ```
 
-### Deleting Items
+#### Deleting Items
 
 `delete_items` (or `delete_item`) deletes items by reference and returns them.  
 This is considered the default use case and therefore also available as `delete`.
@@ -187,17 +188,17 @@ store.delete_keys(5..7, 9)
 
 The following methods are available to query the data store:
 
-- `find_all` (also available as `find`)
+- `find_all` (alias `find`)
 - `find_any`
 - `find_one`
 - `find_not_all`
 - `find_none`
-- `first_all` (also available as `first`)
+- `first_all` (alias `first`)
 - `first_any`
 - `first_one`
 - `first_not_all`
 - `first_none`
-- `count_all` (also available as `count`)
+- `count_all` (alias `count`)
 - `count_any`
 - `count_one`
 - `count_not_all`
@@ -221,7 +222,7 @@ In other words:
 
 - `all` means `condition && condition && ...`.
 - `any` means `condition || condition || ...`.
-- `one` means `condition ^ condition ^ ...` (XOR).
+- `one` means `condition ^ condition ^ ...`.
 - `not all` means `!(condition && condition && ...)` or `!condition || !condition || ...`.
 - `none` means `!(condition || condition || ...)` or `!condition && !condition && ...`.
 
@@ -405,6 +406,27 @@ store[1]
 # => { "id" => 1 }
 ```
 
+#### Concurrent Access
+
+To support concurrent access, e.g. when multiple threads or processes read and write the same data store file, there’s a `with_file` equivalent of `from_file` and `to_file`.
+
+`with_file` takes a file (name) and a block. It then obtains an exclusive lock on that file, restores a data store from it or creates a new one, invokes the block with the data store and finally saves the data store back to the file. Optionally, key and/or items can be specified for when the data store is created instead of restored.
+
+```ruby
+MemStore.with_file(file, key, items) do |store|
+  # create, read, update, delete
+end
+```
+
+`MemStore.with_file` is a shortcut to `MemStore::ObjectStore.with_file`.
+
+`HashStore` offers a locking version of all its serialization methods:
+
+- `with_file` by default,
+- `with_yaml_file` when `memstore/yaml` is included,
+- `with_json_file` when `memstore/json` is included,
+- `with_msgpack_file` when `memstore/msgpack` is included.
+
 ## Contributing
 
 1. Fork it on [GitHub](https://github.com/sklppr/memstore).

data/lib/memstore.rb

@@ -1,4 +1,9 @@
+# encoding: utf-8
+
 require "memstore/version"
+require "memstore/objectstore"
+require "memstore/hashstore"
+require "memstore/queries"
 
 module MemStore
 
@@ -14,197 +19,8 @@ module MemStore
     ObjectStore.from_file(file)
   end
 
-  class ObjectStore
-
-    def initialize(key=nil, items={})
-      @key = key || :hash
-      @items = items
-    end
-
-    attr_accessor :items
-
-    def insert(*items)
-      items.each { |item| @items[key(item)] = item }
-      self
-    end
-    alias_method :<<, :insert
-    
-    def length
-      @items.length
-    end
-    alias_method :size, :length
-    alias_method :count, :length
-
-    def [](*keys)
-      return @items[keys.first] if keys.length == 1 && !keys.first.is_a?(Range)
-      keys.inject [] do |items, key|
-        if key.is_a?(Range) then key.inject(items) { |i, k| i << @items[k] }
-        else items << @items[key] end
-      end
-    end
-
-    def all
-      @items.values
-    end
-
-    def delete_items(*items)
-      return @items.delete(key(items.first)) if items.length == 1
-      items.collect { |item| @items.delete(key(item)) }
-    end
-    alias_method :delete_item, :delete_items
-    alias_method :delete, :delete_items
-
-    def delete_keys(*keys)
-      return @items.delete(keys.first) if keys.length == 1 && !keys.first.is_a?(Range)
-      keys.inject [] do |items, key|
-        if key.is_a?(Range) then key.inject(items) { |i, k| i << @items.delete(k) }
-        else items << @items.delete(key) end
-      end
-    end
-    alias_method :delete_key, :delete_keys
-  
-    def find_all(conditions={}, &block)
-      all.select { |item| instance_exec(item, conditions, block, &FIND_ALL) }
-    end
-    alias_method :find, :find_all
-
-    def find_any(conditions={}, &block)
-      all.select { |item| instance_exec(item, conditions, block, &FIND_ANY) }
-    end
-
-    def find_one(conditions={}, &block)
-      all.select { |item| instance_exec(item, conditions, block, &FIND_ONE) }
-    end
-
-    def find_not_all(conditions={}, &block)
-      all.reject { |item| instance_exec(item, conditions, block, &FIND_ALL) }
-    end
-
-    def find_none(conditions={}, &block)
-      all.select { |item| instance_exec(item, conditions, block, &FIND_NONE) }
-    end
-
-    def first_all(conditions={}, &block)
-      all.detect { |item| instance_exec(item, conditions, block, &FIND_ALL) }
-    end
-    alias_method :first, :first_all
-
-    def first_any(conditions={}, &block)
-      all.detect { |item| instance_exec(item, conditions, block, &FIND_ANY) }
-    end
-
-    def first_one(conditions={}, &block)
-      all.detect { |item| instance_exec(item, conditions, block, &FIND_ONE) }
-    end
-
-    def first_not_all(conditions={}, &block)
-      all.detect { |item| !instance_exec(item, conditions, block, &FIND_ALL) }
-    end
-
-    def first_none(conditions={}, &block)
-      all.detect { |item| instance_exec(item, conditions, block, &FIND_NONE) }
-    end
-
-    def count_all(conditions={}, &block)
-      all.count { |item| instance_exec(item, conditions, block, &FIND_ALL) }
-    end
-    alias_method :count, :count_all
-
-    def count_any(conditions={}, &block)
-      all.count { |item| instance_exec(item, conditions, block, &FIND_ANY) }
-    end
-
-    def count_one(conditions={}, &block)
-      all.count { |item| instance_exec(item, conditions, block, &FIND_ONE) }
-    end
-
-    def count_not_all(conditions={}, &block)
-      all.count { |item| !instance_exec(item, conditions, block, &FIND_ALL) }
-    end
-
-    def count_none(conditions={}, &block)
-      all.count { |item| instance_exec(item, conditions, block, &FIND_NONE) }
-    end
-
-    def self.from_binary(binary)
-      begin Marshal.load(binary) rescue nil end
-    end
-
-    def self.from_file(file)
-      begin self.from_binary(IO.read(file)) rescue nil end
-    end
-
-    def to_binary
-      Marshal.dump(self)
-    end
-
-    def to_file(file)
-      IO.write(file, self.to_binary)
-    end
-
-    private
-  
-    FIND_ALL = Proc.new do |item, conditions, block|
-        conditions.all? { |attribute, condition| condition === attr(item, attribute) } &&
-          if block then !!block.call(item) else true end
-      end
-  
-    FIND_ANY = Proc.new do |item, conditions, block|
-        conditions.any? { |attribute, condition| condition === attr(item, attribute) } ||
-          if block then !!block.call(item) else false end
-      end
-
-    FIND_NONE = Proc.new do |item, conditions, block|
-        conditions.none? { |attribute, condition| condition === attr(item, attribute) } &&
-          if block then !!block.call(item) else true end
-      end
-
-    FIND_ONE = Proc.new do |item, conditions, block|
-        conditions.one? { |attribute, condition| condition === attr(item, attribute) } ||
-          if block then !!block.call(item) else false end
-      end
-
-    def key(item)
-      item.send(@key)
-    end
-
-    def attr(item, attribute)
-      item.send(attribute)
-    end
-
-  end
-
-  class HashStore < ObjectStore
-
-    def self.from_hash(hash)
-      begin
-        key = hash[:key] || hash["key"]
-        items = hash[:items] || hash["items"]
-        return nil if key.nil? || items.nil?
-        self.new(key, items)
-      rescue
-        nil
-      end
-    end
-
-    def initialize(key=nil, items={})
-      @key, @items = key, items
-    end
-
-    def to_hash
-      { key: @key, items: @items }
-    end
-
-    private
-
-    def key(item)
-      if @key.nil? then item.hash else item[@key] end
-    end
-
-    def attr(item, attribute)
-      item[attribute]
-    end
-
+  def self.with_file(file, key=nil, items={}, &block)
+    ObjectStore.with_file(file, key, items, &block)
   end
 
 end

data/lib/memstore/hashstore.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+module MemStore
+
+  class HashStore < ObjectStore
+
+    def self.from_hash(hash)
+      begin
+
+        if hash.has_key?(:key) then key = hash[:key]
+        elsif hash.has_key? "key" then key = hash["key"]
+        else return nil end
+
+        if hash.has_key?(:items) then items = hash[:items]
+        elsif hash.has_key? "items" then items = hash["items"]
+        else return nil end
+
+        if items.is_a?(Hash) then self.new(key, items) else self.new(key) end
+
+      rescue
+        nil
+      end
+    end
+
+    def initialize(key=nil, items={})
+      @key, @items = key, items
+    end
+
+    def to_hash
+      { key: @key, items: @items }
+    end
+
+    private
+
+    def key(item)
+      if @key.nil? then item.hash else item[@key] end
+    end
+
+    def attr(item, attribute)
+      item[attribute]
+    end
+
+  end
+
+end

data/lib/memstore/json.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require "json"
 
 module MemStore
@@ -13,11 +15,15 @@ module MemStore
     end
 
     def self.from_json(json)
-      begin self.from_hash(JSON.parse(json)) rescue nil end
+      self.from_hash(JSON.parse(json)) rescue nil
     end
     
     def self.from_json_file(file)
-      begin self.from_json(IO.read(file)) rescue nil end
+      self.from_json(IO.read(file)) rescue nil
+    end
+
+    def self.with_json_file(file, key=nil, items={}, &block)
+      self.run_with_file(:from_json_file, :to_json_file, file, key, items, &block)
     end
 
   end

data/lib/memstore/msgpack.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require "msgpack"
 
 module MemStore
@@ -13,11 +15,15 @@ module MemStore
     end
 
     def self.from_msgpack(msgpack)
-      begin self.from_hash(MessagePack.unpack(msgpack)) rescue nil end
+      self.from_hash(MessagePack.unpack(msgpack)) rescue nil
     end
     
     def self.from_msgpack_file(file)
-      begin self.from_msgpack(IO.read(file)) rescue nil end
+      self.from_msgpack(IO.read(file)) rescue nil
+    end
+
+    def self.with_msgpack_file(file, key=nil, items={}, &block)
+      self.run_with_file(:from_msgpack_file, :to_msgpack_file, file, key, items, &block)
     end
 
   end

data/lib/memstore/objectstore.rb

@@ -0,0 +1,98 @@
+# encoding: utf-8
+
+module MemStore
+
+  class ObjectStore
+
+    def initialize(key=nil, items={})
+      @key = key || :hash
+      @items = items
+    end
+
+    attr_accessor :items
+
+    def insert(*items)
+      items.each { |item| @items[key(item)] = item }
+      self
+    end
+    alias_method :<<, :insert
+    
+    def length
+      @items.length
+    end
+    alias_method :size, :length
+    alias_method :count, :length
+
+    def [](*keys)
+      return @items[keys.first] if keys.length == 1 && !keys.first.is_a?(Range)
+      keys.inject [] do |items, key|
+        if key.is_a?(Range) then key.inject(items) { |i, k| i << @items[k] }
+        else items << @items[key] end
+      end
+    end
+
+    def all
+      @items.values
+    end
+
+    def delete_items(*items)
+      return @items.delete(key(items.first)) if items.length == 1
+      items.collect { |item| @items.delete(key(item)) }
+    end
+    alias_method :delete_item, :delete_items
+    alias_method :delete, :delete_items
+
+    def delete_keys(*keys)
+      return @items.delete(keys.first) if keys.length == 1 && !keys.first.is_a?(Range)
+      keys.inject [] do |items, key|
+        if key.is_a?(Range) then key.inject(items) { |i, k| i << @items.delete(k) }
+        else items << @items.delete(key) end
+      end
+    end
+    alias_method :delete_key, :delete_keys
+
+    def self.from_binary(binary)
+      restored = Marshal.load(binary) rescue nil
+      if restored.kind_of?(ObjectStore) || restored.kind_of?(HashStore) then restored else nil end
+    end
+
+    def self.from_file(file)
+      self.from_binary(IO.read(file)) rescue nil
+    end
+
+    def to_binary
+      Marshal.dump(self)
+    end
+
+    def to_file(file)
+      IO.write(file, self.to_binary)
+    end
+
+    def self.with_file(file, key=nil, items={}, &block)
+      self.run_with_file(:from_file, :to_file, file, key, items, &block)
+    end
+
+    private
+
+    def key(item)
+      item.send(@key)
+    end
+
+    def attr(item, attribute)
+      item.send(attribute)
+    end
+
+    def self.run_with_file(from_file_method, to_file_method, file, key=nil, items={}, &block)
+      File.open(file) do |file|
+        file.flock(File::LOCK_EX)
+        store = self.send(from_file_method, file) || self.new(key, items)
+        result = block.call(store)
+        store.send(to_file_method, file)
+        file.flock(File::LOCK_UN)
+        result
+      end
+    end
+
+  end
+  
+end

data/lib/memstore/queries.rb

@@ -0,0 +1,94 @@
+# encoding: utf-8
+
+module MemStore
+
+  class ObjectStore
+
+    def find_all(conditions={}, &block)
+      all.select { |item| instance_exec(item, conditions, block, &FIND_ALL) }
+    end
+    alias_method :find, :find_all
+
+    def find_any(conditions={}, &block)
+      all.select { |item| instance_exec(item, conditions, block, &FIND_ANY) }
+    end
+
+    def find_one(conditions={}, &block)
+      all.select { |item| instance_exec(item, conditions, block, &FIND_ONE) }
+    end
+
+    def find_not_all(conditions={}, &block)
+      all.reject { |item| instance_exec(item, conditions, block, &FIND_ALL) }
+    end
+
+    def find_none(conditions={}, &block)
+      all.select { |item| instance_exec(item, conditions, block, &FIND_NONE) }
+    end
+
+    def first_all(conditions={}, &block)
+      all.detect { |item| instance_exec(item, conditions, block, &FIND_ALL) }
+    end
+    alias_method :first, :first_all
+
+    def first_any(conditions={}, &block)
+      all.detect { |item| instance_exec(item, conditions, block, &FIND_ANY) }
+    end
+
+    def first_one(conditions={}, &block)
+      all.detect { |item| instance_exec(item, conditions, block, &FIND_ONE) }
+    end
+
+    def first_not_all(conditions={}, &block)
+      all.detect { |item| !instance_exec(item, conditions, block, &FIND_ALL) }
+    end
+
+    def first_none(conditions={}, &block)
+      all.detect { |item| instance_exec(item, conditions, block, &FIND_NONE) }
+    end
+
+    def count_all(conditions={}, &block)
+      all.count { |item| instance_exec(item, conditions, block, &FIND_ALL) }
+    end
+    alias_method :count, :count_all
+
+    def count_any(conditions={}, &block)
+      all.count { |item| instance_exec(item, conditions, block, &FIND_ANY) }
+    end
+
+    def count_one(conditions={}, &block)
+      all.count { |item| instance_exec(item, conditions, block, &FIND_ONE) }
+    end
+
+    def count_not_all(conditions={}, &block)
+      all.count { |item| !instance_exec(item, conditions, block, &FIND_ALL) }
+    end
+
+    def count_none(conditions={}, &block)
+      all.count { |item| instance_exec(item, conditions, block, &FIND_NONE) }
+    end
+
+    private
+  
+    FIND_ALL = Proc.new do |item, conditions, block|
+        conditions.all? { |attribute, condition| condition === attr(item, attribute) } &&
+          if block then !!block.call(item) else true end
+      end
+  
+    FIND_ANY = Proc.new do |item, conditions, block|
+        conditions.any? { |attribute, condition| condition === attr(item, attribute) } ||
+          if block then !!block.call(item) else false end
+      end
+
+    FIND_NONE = Proc.new do |item, conditions, block|
+        conditions.none? { |attribute, condition| condition === attr(item, attribute) } &&
+          if block then !!block.call(item) else true end
+      end
+
+    FIND_ONE = Proc.new do |item, conditions, block|
+        conditions.one? { |attribute, condition| condition === attr(item, attribute) } ||
+          if block then !!block.call(item) else false end
+      end
+
+  end
+  
+end

data/lib/memstore/version.rb

@@ -1,3 +1,3 @@
 module MemStore
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/lib/memstore/yaml.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 require "yaml"
 
 module MemStore
@@ -13,11 +15,19 @@ module MemStore
     end
 
     def self.from_yaml(yaml)
-      begin self.from_hash(YAML.load(yaml)) rescue nil end
+      begin
+        self.from_hash(YAML.load(yaml))
+      rescue StandardError, Psych::SyntaxError
+        nil
+      end
     end
     
     def self.from_yaml_file(file)
-      begin self.from_yaml(IO.read(file)) rescue nil end
+      self.from_yaml(IO.read(file)) rescue nil
+    end
+
+    def self.with_yaml_file(file, key=nil, items={}, &block)
+      self.run_with_file(:from_yaml_file, :to_yaml_file, file, key, items, &block)
     end
 
   end

data/spec/hashstore_spec.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+
+require "minitest/autorun"
+require "tempfile"
+require "memstore"
+
+describe MemStore::HashStore do
+
+  before do
+    @store = MemStore::HashStore.new(:id)
+    10.times { |i| @store << { id: i } }
+  end
+
+  it "can be instantiated with items" do
+    h = { a: 1, b: 2, c: 3 }
+    store = MemStore::HashStore.new(nil, h)
+    store.items.must_equal h
+  end
+
+  it "indexes items by Object#hash by default" do
+    h = {}
+    store = MemStore::HashStore.new.insert(h)
+    store.items[h.hash].must_equal h
+  end
+
+  it "indexes items using a custom key" do
+    @store.items[0].must_equal @store.all.first
+  end
+
+  it "can be converted to and from binary" do
+    restored = MemStore::HashStore.from_binary(@store.to_binary)
+    restored.must_be_instance_of MemStore::HashStore
+    restored.items.must_equal @store.items
+    restored.instance_variable_get(:@key).must_equal @store.instance_variable_get(:@key)
+  end
+
+  it "can be serialized to and deserialized from a binary file" do
+    tmp = Tempfile.new("memstore")
+    @store.to_file(tmp)
+    restored = MemStore::HashStore.from_file(tmp)
+    restored.must_be_instance_of MemStore::HashStore
+    restored.items.must_equal @store.items
+    restored.instance_variable_get(:@key).must_equal @store.instance_variable_get(:@key)
+    tmp.unlink
+  end
+
+  it "can be converted to and from a hash" do
+    restored = MemStore::HashStore.from_hash(@store.to_hash)
+    restored.items.must_equal @store.items
+    restored.instance_variable_get(:@key).must_equal @store.instance_variable_get(:@key)
+  end
+
+  it "returns nil when conversion from hash fails" do
+    MemStore::HashStore.from_hash(nil).must_equal nil
+    MemStore::HashStore.from_hash({}).must_equal nil
+  end
+
+end

data/spec/{memstore_json_spec.rb → json_spec.rb}

@@ -28,4 +28,23 @@ describe MemStore::HashStore do
     tmp.unlink
   end
 
+  it "returns nil when conversion from JSON fails" do
+    MemStore::HashStore.from_json(nil).must_equal nil
+    MemStore::HashStore.from_json(Marshal.dump(Object.new)).must_equal nil
+  end
+
+  it "supports concurrent access to a single JSON file" do
+    tmp = Tempfile.new("memstore")
+    fork do
+      MemStore::HashStore.with_json_file(tmp, "id") { |store| store.insert({"id"=>"1"}, {"id"=>"3"}) }
+    end
+    fork do
+      MemStore::HashStore.with_json_file(tmp, "id") { |store| store.insert({"id"=>"2"}, {"id"=>"4"}) }
+    end
+    sleep 0.1
+    restored = MemStore::HashStore.from_json_file(tmp)
+    restored.items.must_equal({"1"=>{"id"=>"1"}, "2"=>{"id"=>"2"}, "3"=>{"id"=>"3"}, "4"=>{"id"=>"4"}})
+    tmp.unlink
+  end
+
 end

data/spec/{memstore_msgpack_spec.rb → msgpack_spec.rb}

@@ -28,4 +28,23 @@ describe MemStore::HashStore do
     tmp.unlink
   end
 
+  it "returns nil when conversion from MessagePack fails" do
+    MemStore::HashStore.from_msgpack(nil).must_equal nil
+    MemStore::HashStore.from_msgpack(Marshal.dump(Object.new)).must_equal nil
+  end
+
+  it "supports concurrent access to a single MessagePack file" do
+    tmp = Tempfile.new("memstore")
+    fork do
+      MemStore::HashStore.with_msgpack_file(tmp, "id") { |store| store.insert({"id"=>1}, {"id"=>3}) }
+    end
+    fork do
+      MemStore::HashStore.with_msgpack_file(tmp, "id") { |store| store.insert({"id"=>2}, {"id"=>4}) }
+    end
+    sleep 0.1
+    restored = MemStore::HashStore.from_msgpack_file(tmp)
+    restored.items.must_equal({1=>{"id"=>1}, 2=>{"id"=>2}, 3=>{"id"=>3}, 4=>{"id"=>4}})
+    tmp.unlink
+  end
+
 end

data/spec/objectstore_spec.rb

@@ -0,0 +1,113 @@
+# encoding: utf-8
+
+require "minitest/autorun"
+require "tempfile"
+require "memstore"
+
+describe MemStore::ObjectStore do
+  
+  before do
+    @store = MemStore::ObjectStore.new(:to_i)
+    10.times { |i| @store << i.to_f }
+  end
+
+  it "can be instantiated with items" do
+    h = { a: 1, b: 2, c: 3 }
+    store = MemStore::ObjectStore.new(nil, h)
+    store.items.must_equal h
+  end
+
+  it "is the default when instantiating MemStore" do
+    MemStore.new.must_be_instance_of MemStore::ObjectStore
+  end
+
+  it "indexes items by Object#hash by default" do
+    o = Object.new
+    store = MemStore::ObjectStore.new.insert(o)
+    store.items[o.hash].must_equal o
+  end
+
+  it "indexes items using a custom key" do
+    @store.items[0].must_equal 0.0
+  end
+
+  it "returns the overall number of items" do
+    @store.length.must_equal 10
+  end
+
+  it "returns a single item by itself" do
+    @store[3].must_equal 3.0
+  end
+
+  it "returns multiple items as an array" do
+    @store[3, 4, 5, 6].must_equal [3.0, 4.0, 5.0, 6.0]
+  end
+
+  it "returns multiple items using a Range as an array" do
+    @store[0..9].must_equal @store.all
+  end
+
+  it "deletes a single item by reference and returns it by itself" do
+    @store.delete_item(3.0).must_equal 3.0
+  end
+
+  it "deletes multiple items by reference and returns them" do
+    @store.delete_items(3.0, 4.0, 5.0, 6.0).must_equal [3.0, 4.0, 5.0, 6.0]
+    @store.all.must_equal [0.0, 1.0, 2.0, 7.0, 8.0, 9.0]
+  end
+
+  it "deletes a single item by key and returns it by itself" do
+    @store.delete_key(3).must_equal 3.0
+  end
+
+  it "deletes multiple items by key and returns them as an array" do
+    @store.delete_keys(3, 4, 5, 6).must_equal [3.0, 4.0, 5.0, 6.0]
+    @store.all.must_equal [0.0, 1.0, 2.0, 7.0, 8.0, 9.0]
+  end
+
+  it "deletes multiple items by key using a Range and returns them as an array" do
+    @store.delete_keys(3..6).must_equal [3.0, 4.0, 5.0, 6.0]
+    @store.all.must_equal [0.0, 1.0, 2.0, 7.0, 8.0, 9.0]
+  end
+
+  it "can be converted to and from binary" do
+    restored = MemStore::ObjectStore.from_binary(@store.to_binary)
+    restored.must_be_instance_of MemStore::ObjectStore
+    restored.items.must_equal @store.items
+    restored.instance_variable_get(:@key).must_equal @store.instance_variable_get(:@key)
+  end
+
+  it "returns nil when conversion from binary fails" do
+    MemStore::ObjectStore.from_binary(nil).must_equal nil
+    MemStore::ObjectStore.from_binary(Marshal.dump(Object.new)).must_equal nil
+  end
+
+  it "can be serialized to and deserialized from a binary file" do
+    tmp = Tempfile.new("memstore")
+    @store.to_file(tmp)
+    restored = MemStore::ObjectStore.from_file(tmp)
+    restored.must_be_instance_of MemStore::ObjectStore
+    restored.items.must_equal @store.items
+    restored.instance_variable_get(:@key).must_equal @store.instance_variable_get(:@key)
+    tmp.unlink
+  end
+
+  it "returns nil when deserialization from binary file fails" do
+    MemStore::ObjectStore.from_file("does_not_exist").must_equal nil
+  end
+
+  it "supports concurrent access to a single binary file" do
+    tmp = Tempfile.new("memstore")
+    fork do
+      MemStore.with_file(tmp, :to_i) { |store| store.insert(1.0, 3.0) }
+    end
+    fork do
+      MemStore.with_file(tmp, :to_i) { |store| store.insert(2.0, 4.0) }
+    end
+    sleep 0.1
+    restored = MemStore.from_file(tmp)
+    restored.items.must_equal({1=>1.0, 2=>2.0, 3=>3.0, 4=>4.0})
+    tmp.unlink
+  end
+
+end

data/spec/queries_spec.rb

@@ -0,0 +1,107 @@
+require "minitest/autorun"
+require "tempfile"
+
+class Dummy
+
+  attr_accessor :id, :name, :child
+  
+  def initialize(id, name=nil, child=nil)
+    @id, @name, @child = id, name, child
+  end
+
+  def ==(obj)
+    obj.is_a?(Dummy) &&
+    obj.id == @id &&
+    obj.name == @name &&
+    obj.child == @child
+  end
+
+end
+
+describe MemStore::ObjectStore do
+
+  before do
+    @store = MemStore::ObjectStore.new
+    strings = %w(foo moo boo faa maa baa foa moa boa lao)
+    classes = [String, Array]
+    10.times do |i|
+      @store << Dummy.new(i, strings[i], classes[i%2].new)
+    end
+  end
+
+  it "finds all items fulfilling all conditions" do
+    matches = @store.find_all(id: 3..7, child: String)
+    matches.collect{ |m| m.id }.must_equal [4, 6]
+  end
+
+  it "finds all items fulfilling at least one condition" do
+    matches = @store.find_any(id: 3..7, child: String)
+    matches.collect{ |m| m.id }.must_equal [0, 2, 3, 4, 5, 6, 7, 8]
+  end
+
+  it "finds all items fulfilling exactly one condition" do
+    matches = @store.find_one(name: /o/, child: String)
+    matches.collect{ |m| m.id }.must_equal [1, 4, 7, 9]
+  end
+
+  it "finds all items violating at least one condition" do
+    matches = @store.find_not_all(name: /o/, child: String)
+    matches.collect{ |m| m.id }.must_equal [1, 3, 4, 5, 7, 9]
+  end
+
+  it "finds all items violating all conditions" do
+    matches = @store.find_none(name: /o/, child: String)
+    matches.collect{ |m| m.id }.must_equal [3, 5]
+  end
+
+  it "finds the first item fulfilling all conditions" do
+    match = @store.first_all(id: 3..7, child: String)
+    match.id.must_equal 4
+  end
+
+  it "finds the first item fulfilling at least one condition" do
+    match = @store.first_any(id: 3..7, child: String)
+    match.id.must_equal 0
+  end
+
+  it "finds the first item fulfilling exactly one condition" do
+    match = @store.first_one(name: /o/, child: String)
+    match.id.must_equal 1
+  end
+
+  it "finds the first item violating at least one condition" do
+    match = @store.first_not_all(name: /o/, child: String)
+    match.id.must_equal 1
+  end
+
+  it "finds the first item violating all conditions" do
+    match = @store.first_none(name: /o/, child: String)
+    match.id.must_equal 3
+  end
+
+  it "counts all items fulfilling all conditions" do
+    count = @store.count_all(id: 3..7, child: String)
+    count.must_equal [4, 6].length
+  end
+
+  it "counts all items fulfilling at least one condition" do
+    count = @store.count_any(id: 3..7, child: String)
+    count.must_equal [0, 2, 3, 4, 5, 6, 7, 8].length
+  end
+
+  it "counts all items fulfilling exactly one condition" do
+    count = @store.count_one(name: /o/, child: String)
+    count.must_equal [1, 4, 7, 9].length
+  end
+
+  it "counts all items violating at least one condition" do
+    count = @store.count_not_all(name: /o/, child: String)
+    count.must_equal [1, 3, 4, 5, 7, 9].length
+  end
+
+  it "counts all items violating all conditions" do
+    count = @store.count_none(name: /o/, child: String)
+    count.must_equal [3, 5].length
+  end
+
+end

data/spec/{memstore_yaml_spec.rb → yaml_spec.rb}

@@ -28,4 +28,23 @@ describe MemStore::HashStore do
     tmp.unlink
   end
 
+  it "returns nil when conversion from YAML fails" do
+    MemStore::HashStore.from_yaml(nil).must_equal nil
+    MemStore::HashStore.from_yaml(Marshal.dump(Object.new)).must_equal nil
+  end
+
+  it "supports concurrent access to a single YAML file" do
+    tmp = Tempfile.new("memstore")
+    fork do
+      MemStore::HashStore.with_yaml_file(tmp, :id) { |store| store.insert({id: 1}, {id: 3}) }
+    end
+    fork do
+      MemStore::HashStore.with_yaml_file(tmp, :id) { |store| store.insert({id: 2}, {id: 4}) }
+    end
+    sleep 0.1
+    restored = MemStore::HashStore.from_yaml_file(tmp)
+    restored.items.must_equal({1=>{id: 1}, 2=>{id: 2}, 3=>{id: 3}, 4=>{id: 4}})
+    tmp.unlink
+  end
+
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memstore
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -25,15 +25,20 @@ files:
 - README.md
 - Rakefile
 - lib/memstore.rb
+- lib/memstore/hashstore.rb
 - lib/memstore/json.rb
 - lib/memstore/msgpack.rb
+- lib/memstore/objectstore.rb
+- lib/memstore/queries.rb
 - lib/memstore/version.rb
 - lib/memstore/yaml.rb
 - memstore.gemspec
-- spec/memstore_json_spec.rb
-- spec/memstore_msgpack_spec.rb
-- spec/memstore_spec.rb
-- spec/memstore_yaml_spec.rb
+- spec/hashstore_spec.rb
+- spec/json_spec.rb
+- spec/msgpack_spec.rb
+- spec/objectstore_spec.rb
+- spec/queries_spec.rb
+- spec/yaml_spec.rb
 homepage: https://github.com/sklppr/memstore
 licenses: []
 post_install_message: 
@@ -59,7 +64,9 @@ signing_key:
 specification_version: 3
 summary: A simple, in-memory data store.
 test_files:
-- spec/memstore_json_spec.rb
-- spec/memstore_msgpack_spec.rb
-- spec/memstore_spec.rb
-- spec/memstore_yaml_spec.rb
+- spec/hashstore_spec.rb
+- spec/json_spec.rb
+- spec/msgpack_spec.rb
+- spec/objectstore_spec.rb
+- spec/queries_spec.rb
+- spec/yaml_spec.rb

data/spec/memstore_spec.rb

@@ -1,268 +0,0 @@
-# encoding: utf-8
-
-require "minitest/autorun"
-require "tempfile"
-require "memstore"
-
-class Dummy
-
-  attr_accessor :id, :name, :child
-  
-  def initialize(id, name=nil, child=nil)
-    @id, @name, @child = id, name, child
-  end
-
-  def ==(obj)
-    obj.is_a?(Dummy) &&
-    obj.id == @id &&
-    obj.name == @name &&
-    obj.child == @child
-  end
-
-end
-
-describe MemStore::ObjectStore do
-  
-  it "can be instantiated with items" do
-    h = { a: 1, b: 2, c: 3 }
-    store = MemStore::ObjectStore.new(nil, h)
-    store.items.must_equal h
-  end
-
-  it "is the default when instantiating MemStore" do
-      MemStore.new.must_be_instance_of MemStore::ObjectStore
-    end
-
-  it "indexes items by Object#hash by default" do
-    o = Object.new
-    store = MemStore::ObjectStore.new.insert(o)
-    store.items[o.hash].must_equal o
-  end
-
-  it "indexes items using a custom key" do
-    o = Dummy.new("custom key")
-    store = MemStore::ObjectStore.new(:id).insert(o)
-    store.items[o.id].must_equal o
-  end
-
-  it "can be converted to and from binary" do
-    o = Dummy.new("custom key")
-    store = MemStore::ObjectStore.new(:id).insert(o)
-    restored = MemStore::ObjectStore.from_binary(store.to_binary)
-    restored.must_be_instance_of MemStore::ObjectStore
-    restored.items.must_equal store.items
-    restored.instance_variable_get(:@key).must_equal :id
-  end
-
-  it "returns nil when conversion from binary fails" do
-    MemStore::ObjectStore.from_binary(nil).must_equal nil
-  end
-
-  it "can be serialized to and deserialized from a binary file" do
-    tmp = Tempfile.new("memstore")
-    o = Dummy.new("custom key")
-    store = MemStore::ObjectStore.new(:id).insert(o)
-    store.to_file(tmp)
-    restored = MemStore::ObjectStore.from_file(tmp)
-    restored.must_be_instance_of MemStore::ObjectStore
-    restored.items.must_equal store.items
-    restored.instance_variable_get(:@key).must_equal :id
-    tmp.unlink
-  end
-
-  it "returns nil when deserialization from binary file fails" do
-    MemStore::ObjectStore.from_file("does_not_exist").must_equal nil
-  end
-
-end
-
-describe MemStore::HashStore do
-
-  it "can be instantiated with items" do
-    h = { a: 1, b: 2, c: 3 }
-    store = MemStore::HashStore.new(nil, h)
-    store.items.must_equal h
-  end
-
-  it "indexes items by Object#hash by default" do
-    h = {}
-    store = MemStore::HashStore.new.insert(h)
-    store.items[h.hash].must_equal h
-  end
-
-  it "indexes items using a custom key" do
-    h = { id: "custom key" }
-    store = MemStore::HashStore.new(:id).insert(h)
-    store.items[h[:id]].must_equal h
-  end
-
-  it "can be converted to and from binary" do
-    store = MemStore::HashStore.new(:id).insert({ id: "custom key" })
-    restored = MemStore::HashStore.from_binary(store.to_binary)
-    restored.must_be_instance_of MemStore::HashStore
-    restored.items.must_equal store.items
-    restored.instance_variable_get(:@key).must_equal :id
-  end
-
-  it "can be serialized to and deserialized from a binary file" do
-    tmp = Tempfile.new("memstore")
-    store = MemStore::HashStore.new(:id).insert({ id: "custom key" })
-    store.to_file(tmp)
-    restored = MemStore::HashStore.from_file(tmp)
-    restored.must_be_instance_of MemStore::HashStore
-    restored.items.must_equal store.items
-    restored.instance_variable_get(:@key).must_equal :id
-    tmp.unlink
-  end
-
-  it "can be converted to and from a hash" do
-    store = MemStore::HashStore.new(:id)
-    10.times { |i| store << { id: i } }
-    restored = MemStore::HashStore.from_hash(store.to_hash)
-    restored.items.must_equal store.items
-    restored.instance_variable_get(:@key).must_equal :id
-  end
-
-  it "returns nil when conversion from hash fails" do
-    MemStore::HashStore.from_hash(nil).must_equal nil
-    MemStore::HashStore.from_hash({}).must_equal nil
-  end
-
-end
-
-describe MemStore do
-
-  before do
-    @store = MemStore.new(:to_i)
-    # Use float as objects and integer as key
-    10.times { |i| @store << i.to_f }
-  end
-
-  it "returns the overall number of items" do
-    @store.length.must_equal 10
-  end
-
-  it "returns a single item by itself" do
-    @store[3].must_equal 3.0
-  end
-
-  it "returns multiple items as an array" do
-    @store[3, 4, 5, 6].must_equal [3.0, 4.0, 5.0, 6.0]
-  end
-
-  it "returns multiple items using a Range as an array" do
-    @store[0..9].must_equal @store.all
-  end
-
-  it "deletes a single item by reference and returns it by itself" do
-    @store.delete_item(3.0).must_equal 3.0
-  end
-
-  it "deletes multiple items by reference and returns them" do
-    @store.delete_items(3.0, 4.0, 5.0, 6.0).must_equal [3.0, 4.0, 5.0, 6.0]
-    @store.all.must_equal [0.0, 1.0, 2.0, 7.0, 8.0, 9.0]
-  end
-
-  it "deletes a single item by key and returns it by itself" do
-    @store.delete_key(3).must_equal 3.0
-  end
-
-  it "deletes multiple items by key and returns them as an array" do
-    @store.delete_keys(3, 4, 5, 6).must_equal [3.0, 4.0, 5.0, 6.0]
-    @store.all.must_equal [0.0, 1.0, 2.0, 7.0, 8.0, 9.0]
-  end
-
-  it "deletes multiple items by key using a Range and returns them as an array" do
-    @store.delete_keys(3..6).must_equal [3.0, 4.0, 5.0, 6.0]
-    @store.all.must_equal [0.0, 1.0, 2.0, 7.0, 8.0, 9.0]
-  end
-
-end
-
-describe MemStore do
-
-  before do
-    @store = MemStore.new
-    strings = %w(foo moo boo faa maa baa foa moa boa lao)
-    classes = [String, Array]
-    10.times do |i|
-      @store << Dummy.new(i, strings[i], classes[i%2].new)
-    end
-  end
-
-  it "finds all items fulfilling all conditions" do
-    matches = @store.find_all(id: 3..7, child: String)
-    matches.collect{ |m| m.id }.must_equal [4, 6]
-  end
-
-  it "finds all items fulfilling at least one condition" do
-    matches = @store.find_any(id: 3..7, child: String)
-    matches.collect{ |m| m.id }.must_equal [0, 2, 3, 4, 5, 6, 7, 8]
-  end
-
-  it "finds all items fulfilling exactly one condition" do
-    matches = @store.find_one(name: /o/, child: String)
-    matches.collect{ |m| m.id }.must_equal [1, 4, 7, 9]
-  end
-
-  it "finds all items violating at least one condition" do
-    matches = @store.find_not_all(name: /o/, child: String)
-    matches.collect{ |m| m.id }.must_equal [1, 3, 4, 5, 7, 9]
-  end
-
-  it "finds all items violating all conditions" do
-    matches = @store.find_none(name: /o/, child: String)
-    matches.collect{ |m| m.id }.must_equal [3, 5]
-  end
-
-  it "finds the first item fulfilling all conditions" do
-    match = @store.first_all(id: 3..7, child: String)
-    match.id.must_equal 4
-  end
-
-  it "finds the first item fulfilling at least one condition" do
-    match = @store.first_any(id: 3..7, child: String)
-    match.id.must_equal 0
-  end
-
-  it "finds the first item fulfilling exactly one condition" do
-    match = @store.first_one(name: /o/, child: String)
-    match.id.must_equal 1
-  end
-
-  it "finds the first item violating at least one condition" do
-    match = @store.first_not_all(name: /o/, child: String)
-    match.id.must_equal 1
-  end
-
-  it "finds the first item violating all conditions" do
-    match = @store.first_none(name: /o/, child: String)
-    match.id.must_equal 3
-  end
-
-  it "counts all items fulfilling all conditions" do
-    count = @store.count_all(id: 3..7, child: String)
-    count.must_equal [4, 6].length
-  end
-
-  it "counts all items fulfilling at least one condition" do
-    count = @store.count_any(id: 3..7, child: String)
-    count.must_equal [0, 2, 3, 4, 5, 6, 7, 8].length
-  end
-
-  it "counts all items fulfilling exactly one condition" do
-    count = @store.count_one(name: /o/, child: String)
-    count.must_equal [1, 4, 7, 9].length
-  end
-
-  it "counts all items violating at least one condition" do
-    count = @store.count_not_all(name: /o/, child: String)
-    count.must_equal [1, 3, 4, 5, 7, 9].length
-  end
-
-  it "counts all items violating all conditions" do
-    count = @store.count_none(name: /o/, child: String)
-    count.must_equal [3, 5].length
-  end
-
-end