memstore 1.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Sebastian Klepper
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,391 @@
+# MemStore
+
+*A simple in-memory data store.*
+
+MemStore is a simple in-memory data store that supports adding, retrieving and deleting items as well as complex search queries and easy serialization.
+
+It’s not in any way supposed to be a “real” database. However, it can replace a database in small applications or prototypes.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem "memstore"
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install memstore
+
+## Usage
+
+- [Basics](#basics)
+- [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)
+  - [Hash](#hash)
+  - [YAML](#yaml)
+  - [JSON](#json)
+  - [MessagePack](#messagepack)
+
+### Basics
+
+Creating a data store is utterly simple:
+
+```ruby
+mb = MemStore.new
+```
+
+By default, objects are indexed using `Object#hash`.
+
+If a different property should be used, it can be specified like this:
+
+```ruby
+mb = MemStore.new(:id)
+```
+
+The property needs to be truly unique for all objects since it’s used as a hash key internally.
+
+An items collection can also be provided on creation:
+
+```ruby
+mb = MemStore.new(nil, { ... }) # to use Object.hash as key
+mb = 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
+
+MemStore comes in two flavors: `ObjectStore` and `HashStore`.
+
+They’re basically the same, but `ObjectStore` accesses items through `item.attribute` while `HashStore` accesses items through `item[attribute]`.
+
+`ObjectStore` is the default variant:
+
+```ruby
+mb = MemStore.new
+# is equal to
+mb = MemStore::ObjectStore.new
+```
+
+`HashStore` needs to be created explicitly:
+
+```ruby
+mb = MemStore::HashStore.new
+```
+
+If no key attribute is specified, `HashStore` will also use `Object#hash`.
+
+### Adding Items
+
+`items` provides direct access to the internal items hash.
+
+```ruby
+mb.items
+# => {}
+mb.items = { 1 => a, 2 => b, 3 => c }
+# => { 1 => a, 2 => b, 3 => c }
+```
+
+`insert` adds one or multiple items and returns the data store itself:
+
+```ruby
+mb.insert(a, b, c)
+# => mb
+```
+
+Since it returns the data store, items can be added right after instantiation:
+
+```ruby
+mb = MemStore.new.insert(a, b, c)
+# => mb
+```
+
+MemStore also supports the shovel operator `<<` for adding items.  
+Only one item can be added at a time but it’s chainable:
+
+```ruby
+mb << a << b << c
+# => mb
+```
+
+### Retrieving Items
+
+`size` returns the current number of items:
+
+```ruby
+mb.size
+# => 3
+```
+
+The bracket operator `[]` is used to look up items by their key.  
+If a single key is given, a single item will be returned.  
+If multiple keys are given, an array of items will be returned with `nil` when there is no item for a key.
+
+```ruby
+mb[1]
+# => a
+mb[1, 2, 3]
+# => [a, b, c]
+```
+
+Ranges are also supported and can even be combined with single keys:
+
+```ruby
+mb[1..3]
+# => [a, b, c]
+mb[1..3, 6]
+# => [a, b, c, f]
+```
+
+### 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`.
+
+If one item is given, it is deleted and returned.  
+If multiple items are given, they are deleted and returned as an array.
+
+```ruby
+mb.delete_item(a)
+# => a
+mb.delete_items(b, c, d)
+# => [b, c, d]
+mb.delete(e, f, g)
+# => [e, f, g]
+```
+
+This is considered the default use case and therefore also available as `delete`.
+
+`delete_keys` (or `delete_key`) deletes items by key and returns them.  
+Again, one or multiple items can be deleted at a time and even ranges are handled.
+
+```ruby
+mb.delete_key(1)
+# => a
+mb.delete_keys(2, 3, 4)
+# => [b, c, d]
+mb.delete_keys(5..7, 9)
+# => [e, f, g, i]
+```
+
+### Search Queries
+
+The following methods are available to query the data store:
+
+- `find_all` (`find`)
+- `find_any`
+- `find_one`
+- `find_not_all`
+- `find_none`
+- `first_all` (`first`)
+- `first_any`
+- `first_one`
+- `first_not_all`
+- `first_none`
+
+The first part indicates what is returned:
+
+- `find_*` returns all matches.
+- `first_*` returns the first match.
+
+The second part indicates how conditions are evaluated:
+
+- `*_all` matches items *fulfilling all* conditions.
+- `*_any` matches items *fulfilling at least one* condition.
+- `*_one` matches items *fulfilling exactly one* condition.
+- `*_not_all` matches items *violating at least one* condition.
+- `*_none` matches items *violating all* conditions.
+
+In other words:
+
+- `all` means `condition && condition && ...`
+- `any` means `condition || condition || ...`
+- `one` means `condition ^ condition ^ ...` (XOR)
+- `not all` means `!(condition && condition && ...)` or `!condition || !condition || ...`
+- `none` means `!(condition || condition || ...)` or `!condition && !condition && ...`
+
+For convenience, `find` is aliased to `find_all` and `first` to `first_all`.
+
+All variants take a `conditions` hash and an optional block.
+
+The hash maps attributes names to conditions that should be tested.  
+Conditions are evaluated using the `===` operator and can be virtually anything:
+
+```ruby
+mb.find(name: "Fred", age: 25)
+mb.find(name: /red/i, age: 10..30)
+mb.find(child: MyClass)
+mb.find(child: -> child { child.valid? })
+```
+
+Additional types can be used in conditions by supporting the `===` operator. For example:
+
+```ruby
+class Array
+	def ===(obj)
+		self.include?(obj)
+	end
+end
+
+mb.find age: [23, 25, 27]
+```
+
+The block is invoked with every item and can do more complex tests.  
+Its return value is interpreted as a boolean value:
+
+```ruby
+mb.find { |item| item.age - item.child.age > 20 }
+```
+
+In addition to the evaluation logic, the arrays returned by all variants of `find` can be merged:
+
+```ruby
+mb.find(...) | mb.find(...) | mb.find(...)
+```
+
+Note that the pipe operator `|` already eliminates duplicates:
+
+```ruby
+[a, b, c] | [c, d, e]
+# => [a, b, c, d, e]
+# which is equal to
+([a, b, c] + [c, d, e]).uniq
+```
+
+### Serialization
+
+#### Binary
+
+The data store can easily be serialized and restored in binary format:
+
+```ruby
+mb.to_file("datastore.bin")
+# => number of bytes written
+MemStore.from_file("datastore.bin")
+# => instance of ObjectStore or HashStore
+```
+
+MemStore will automatically restore the correct class (`ObjectStore`/`HashStore`), key and items.
+
+#### Hash
+
+`HashStore` can be converted to and from a hash:
+
+```ruby
+h = mb.to_hash
+# => { key: ..., items: { ... } }
+MemStore::HashStore.from_hash(h)
+# => instance of HashStore
+```
+
+#### YAML
+
+`memstore/yaml` enables serialization of `HashStore` to and from [YAML](http://yaml.org/):
+
+```ruby
+require "memstore/yaml" # requires "yaml"
+
+mb.to_yaml
+# => YAML string
+mb.to_yaml_file(file)
+# => number of bytes written
+MemStore::HashStore.from_yaml(yaml)
+# => instance of HashStore
+MemStore::HashStore.from_yaml_file(file)
+# => instance of HashStore
+```
+
+De/serialization is seamless since YAML can handle symbols and non-string keys (i.e. Psych converts them correctly).
+
+#### JSON
+
+`memstore/json` enables serialization of `HashStore` to and from [JSON](http://www.json.org/):
+
+```ruby
+require "memstore/json" # requires "json"
+
+mb.to_json
+# => JSON string
+mb.to_json_file(file)
+# => number of bytes written
+MemStore::HashStore.from_json(json)
+# => instance of HashStore
+MemStore::HashStore.from_json_file(file)
+# => instance of HashStore
+```
+
+**Important:** Symbols will be converted to strings and JSON only allows string keys.
+
+```ruby
+mb = MemStore::HashStore.new(:id)
+mb << { id: 1 }
+mb.to_hash
+# => { :key => :id, :items => { 1 => { :id => 1 } } }
+mb = MemStore::HashStore.from_json(mb.to_json)
+mb.to_hash
+# => { :key => "id", :items => { "1" => { "id" => 1 } } }
+```
+
+The following style ensures consistent access before and after serialization:
+
+```ruby
+mb = MemStore::HashStore.new("id")
+mb << { "id" => "1" }
+mb["1"]
+# => { "id" => "1" }
+```
+
+#### MessagePack
+
+`memstore/msgpack` enables serialization of `HashStore` to and from [MessagePack](http://msgpack.org/):
+
+```ruby
+require "memstore/msgpack" # requires "msgpack"
+
+mb.to_msgpack
+# => MessagePack binary format
+mb.to_msgpack_file(file)
+# => number of bytes written
+MemStore::HashStore.from_msgpack(msgpack)
+# => instance of HashStore
+MemStore::HashStore.from_msgpack_file(file)
+# => instance of HashStore
+```
+
+**Important:** Symbols will be converted to strings but non-string keys are allowed.
+
+```ruby
+mb = MemStore::HashStore.new(:id)
+mb << { id: 1 }
+mb.to_hash
+# => { :key => :id, :items => { 1 => { :id => 1 } } }
+mb = MemStore::HashStore.from_msgpack(mb.to_msgpack)
+mb.to_hash
+# => { :key => "id", :items => { 1 => { "id" => 1 } } }
+```
+
+The following style ensures consistent access before and after serialization:
+
+```ruby
+mb = MemStore::HashStore.new("id")
+mb << { "id" => 1 }
+mb[1]
+# => { "id" => 1 }
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch: `git checkout -b my-new-feature`
+3. Commit your changes: `git commit -am 'Add some feature'`
+4. Push to the branch: `git push origin my-new-feature`
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new :default do |t|
+	t.pattern = "spec/**/*_spec.rb"
+end

data/lib/memstore.rb

@@ -0,0 +1,164 @@
+require "memstore/version"
+
+module MemStore
+
+  def self.new(key=nil)
+    ObjectStore.new(key)
+  end
+
+  def self.from_file(file)
+    Marshal.load IO.read(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 size
+      @items.length
+    end
+
+    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 to_file(file)
+      IO.write file, Marshal.dump(self)
+    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)
+      self.new(hash[:key] || hash["key"], hash[:items] || hash["items"])
+    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

@@ -0,0 +1,25 @@
+require "json"
+
+module MemStore
+
+  class HashStore
+    
+    def to_json
+      self.to_hash.to_json
+    end
+    
+    def to_json_file(file)
+      IO.write file, self.to_json
+    end
+
+    def self.from_json(json)
+      self.from_hash JSON.parse(json)
+    end
+    
+    def self.from_json_file(file)
+      self.from_json IO.read(file)
+    end
+
+  end
+
+end

data/lib/memstore/msgpack.rb

@@ -0,0 +1,25 @@
+require "msgpack"
+
+module MemStore
+
+  class HashStore
+
+    def to_msgpack
+      self.to_hash.to_msgpack
+    end
+    
+    def to_msgpack_file(file)
+      IO.write file, self.to_msgpack
+    end
+
+    def self.from_msgpack(msgpack)
+      self.from_hash MessagePack.unpack(msgpack)
+    end
+    
+    def self.from_msgpack_file(file)
+      self.from_msgpack IO.read(file)
+    end
+
+  end
+
+end

data/lib/memstore/version.rb

@@ -0,0 +1,3 @@
+module MemStore
+  VERSION = "1.0.0"
+end

data/lib/memstore/yaml.rb

@@ -0,0 +1,25 @@
+require "yaml"
+
+module MemStore
+
+  class HashStore
+    
+    def to_yaml
+      self.to_hash.to_yaml
+    end
+    
+    def to_yaml_file(file)
+      IO.write file, self.to_yaml
+    end
+
+    def self.from_yaml(yaml)
+      self.from_hash YAML.load(yaml)
+    end
+    
+    def self.from_yaml_file(file)
+      self.from_yaml IO.read(file)
+    end
+
+  end
+
+end

data/memstore.gemspec

@@ -0,0 +1,18 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "memstore/version"
+
+Gem::Specification.new do |gem|
+  gem.name          = "memstore"
+  gem.version       = MemStore::VERSION
+  gem.summary       = %q{A simple, in-memory data store.}
+  gem.description   = %q{MemStore is a simple in-memory data store that supports adding, retrieving and deleting items as well as complex search queries and easy serialization.}
+  gem.authors       = ["Sebastian Klepper"]
+  gem.email         = ["sk@sebastianklepper.com"]
+  gem.homepage      = "https://github.com/sklppr/memstore"
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+end

data/spec/memstore_json_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require "minitest/autorun"
+require "tempfile"
+require "memstore"
+require "memstore/json"
+
+describe MemStore::HashStore do
+	
+	before do
+		@key = "id"
+		@mb = MemStore::HashStore.new(@key)
+		10.times { |i| @mb << { "id" => i.to_s } }
+	end
+
+	it "can be converted to and from JSON" do
+		restored = MemStore::HashStore.from_json(@mb.to_json)
+		restored.items.must_equal @mb.items
+		restored.instance_variable_get(:@key).must_equal @key
+	end
+
+	it "can be serialized to and deserialized from a JSON file" do
+		tmp = Tempfile.new("memstore_json")
+		@mb.to_json_file(tmp)
+		restored = MemStore::HashStore.from_json_file(tmp)
+		restored.items.must_equal @mb.items
+		restored.instance_variable_get(:@key).must_equal @key
+		tmp.unlink
+	end
+
+end

data/spec/memstore_msgpack_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require "minitest/autorun"
+require "tempfile"
+require "memstore"
+require "memstore/msgpack"
+
+describe MemStore::HashStore do
+	
+	before do
+		@key = "id"
+		@mb = MemStore::HashStore.new(@key)
+		10.times { |i| @mb << { "id" => i } }
+	end
+
+	it "can be converted to and from MessagePack" do
+		restored = MemStore::HashStore.from_msgpack(@mb.to_msgpack)
+		restored.items.must_equal @mb.items
+		restored.instance_variable_get(:@key).must_equal @key
+	end
+
+	it "can be serialized to and deserialized from a MessagePack file" do
+		tmp = Tempfile.new("memstore_json")
+		@mb.to_msgpack_file(tmp)
+		restored = MemStore::HashStore.from_msgpack_file(tmp)
+		restored.items.must_equal @mb.items
+		restored.instance_variable_get(:@key).must_equal @key
+		tmp.unlink
+	end
+
+end

data/spec/memstore_spec.rb

@@ -0,0 +1,192 @@
+# encoding: utf-8
+
+require "minitest/autorun"
+require "tempfile"
+require "memstore"
+
+describe MemStore::ObjectStore do
+	
+	it "can be instantiated with items" do
+		h = { a: 1, b: 2, c: 3 }
+		mb = MemStore::ObjectStore.new(nil, h)
+		mb.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
+		mb = MemStore::ObjectStore.new.insert(o)
+		mb.items[o.hash].must_equal o
+	end
+
+	it "indexes items using a custom key" do
+		o = Struct.new(:id).new(id: "custom key")
+		mb = MemStore::ObjectStore.new(:id).insert(o)
+		mb.items[o.id].must_equal o
+	end
+
+	it "can be serialized and deserialized" do
+		tmp = Tempfile.new("memstore")
+		MemStore::ObjectStore.new.to_file tmp
+		MemStore.from_file(tmp).must_be_instance_of MemStore::ObjectStore
+		tmp.unlink
+	end
+
+end
+
+describe MemStore::HashStore do
+
+	it "can be instantiated with items" do
+		h = { a: 1, b: 2, c: 3 }
+		mb = MemStore::HashStore.new(nil, h)
+		mb.items.must_equal h
+	end
+
+	it "indexes items by Object#hash by default" do
+		h = {}
+		mb = MemStore::HashStore.new.insert(h)
+		mb.items[h.hash].must_equal h
+	end
+
+	it "indexes items using a custom key" do
+		h = { id: "custom key" }
+		mb = MemStore::HashStore.new(:id).insert(h)
+		mb.items[h[:id]].must_equal h
+	end
+
+	it "can be serialized and deserialized" do
+		tmp = Tempfile.new("memstore")
+		MemStore::HashStore.new.to_file tmp
+		MemStore.from_file(tmp).must_be_instance_of MemStore::HashStore
+		tmp.unlink
+	end
+
+	it "can be converted to and from a hash" do
+		mb = MemStore::HashStore.new(:id)
+		10.times { |i| mb << { id: i } }
+		restored = MemStore::HashStore.from_hash(mb.to_hash)
+		restored.items.must_equal mb.items
+		restored.instance_variable_get(:@key).must_equal :id
+	end
+
+end
+
+describe MemStore do
+
+	before do
+		@mb = MemStore.new(:to_i)
+		# Use float as objects and integer as key
+		10.times { |i| @mb << i.to_f }
+	end
+
+	it "returns a single item by itself" do
+		@mb[3].must_equal 3.0
+	end
+
+	it "returns multiple items as an array" do
+		@mb[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
+		@mb[0..9].must_equal @mb.all
+	end
+
+	it "deletes a single item by reference and returns it by itself" do
+		@mb.delete_item(3.0).must_equal 3.0
+	end
+
+	it "deletes multiple items by reference and returns them" do
+		@mb.delete_items(3.0, 4.0, 5.0, 6.0).must_equal [3.0, 4.0, 5.0, 6.0]
+		@mb.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
+		@mb.delete_key(3).must_equal 3.0
+	end
+
+	it "deletes multiple items by key and returns them as an array" do
+		@mb.delete_keys(3, 4, 5, 6).must_equal [3.0, 4.0, 5.0, 6.0]
+		@mb.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
+		@mb.delete_keys(3..6).must_equal [3.0, 4.0, 5.0, 6.0]
+		@mb.all.must_equal [0.0, 1.0, 2.0, 7.0, 8.0, 9.0]
+	end
+
+	it "can be serialized and deserialized" do
+		tmp = Tempfile.new("memstore")
+		@mb.to_file tmp
+		MemStore.from_file(tmp).items.must_equal @mb.items
+		tmp.unlink
+	end
+
+end
+
+Dummy = Struct.new(:id, :name, :child)
+
+describe MemStore do
+
+	before do
+		@mb = MemStore.new
+		strings = %w(foo moo boo faa maa baa foa moa boa lao)
+		classes = [String, Array]
+		10.times do |i|
+			@mb << Dummy.new(i, strings[i], classes[i%2].new)
+		end
+	end
+
+	it "finds all items fulfilling all conditions" do
+		matches = @mb.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 = @mb.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 = @mb.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 = @mb.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 = @mb.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 = @mb.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 = @mb.first_any(id: 3..7, child: String)
+		match.id.must_equal 0
+	end
+
+	it "finds the first item fulfilling exactly one condition" do
+		match = @mb.first_one(name: /o/, child: String)
+		match.id.must_equal 1
+	end
+
+	it "finds the first item violating at least one condition" do
+		match = @mb.first_not_all(name: /o/, child: String)
+		match.id.must_equal 1
+	end
+
+	it "finds the first item violating all conditions" do
+		match = @mb.first_none(name: /o/, child: String)
+		match.id.must_equal 3
+	end
+
+end

data/spec/memstore_yaml_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require "minitest/autorun"
+require "tempfile"
+require "memstore"
+require "memstore/yaml"
+
+describe MemStore::HashStore do
+	
+	before do
+		@key = :id
+		@mb = MemStore::HashStore.new(@key)
+		10.times { |i| @mb << { id: i } }
+	end
+
+	it "can be converted to and from YAML" do
+		restored = MemStore::HashStore.from_yaml(@mb.to_yaml)
+		restored.items.must_equal @mb.items
+		restored.instance_variable_get(:@key).must_equal @key
+	end
+
+	it "can be serialized to and deserialized from a YAML file" do
+		tmp = Tempfile.new("memstore_yaml")
+		@mb.to_yaml_file(tmp)
+		restored = MemStore::HashStore.from_yaml_file(tmp)
+		restored.items.must_equal @mb.items
+		restored.instance_variable_get(:@key).must_equal @key
+		tmp.unlink
+	end
+
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification
+name: memstore
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Sebastian Klepper
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-19 00:00:00.000000000 Z
+dependencies: []
+description: MemStore is a simple in-memory data store that supports adding, retrieving
+  and deleting items as well as complex search queries and easy serialization.
+email:
+- sk@sebastianklepper.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/memstore.rb
+- lib/memstore/json.rb
+- lib/memstore/msgpack.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
+homepage: https://github.com/sklppr/memstore
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+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