memstore 1.0.0 → 1.0.1

data/README.md

@@ -10,15 +10,21 @@ It’s not in any way supposed to be a “real” database. However, it can repl
 
 Add this line to your application's Gemfile:
 
-    gem "memstore"
+```ruby
+gem "memstore"
+```
 
 And then execute:
 
-    $ bundle
+```sh
+$ bundle
+```
 
 Or install it yourself as:
 
-    $ gem install memstore
+```sh
+$ gem install memstore
+```
 
 ## Usage
 
@@ -40,7 +46,7 @@ Or install it yourself as:
 Creating a data store is utterly simple:
 
 ```ruby
-mb = MemStore.new
+store = MemStore.new
 ```
 
 By default, objects are indexed using `Object#hash`.
@@ -48,7 +54,7 @@ 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)
+store = MemStore.new(:id)
 ```
 
 The property needs to be truly unique for all objects since it’s used as a hash key internally.
@@ -56,8 +62,8 @@ The property needs to be truly unique for all objects since it’s used as a has
 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
+store = MemStore.new(nil, { ... }) # to use Object.hash as key
+store = MemStore.new(:id, { ... }) # to use custom key
 ```
 
 The collection must be a hash that correctly maps the used key to each item.
@@ -71,15 +77,15 @@ They’re basically the same, but `ObjectStore` accesses items through `item.att
 `ObjectStore` is the default variant:
 
 ```ruby
-mb = MemStore.new
+store = MemStore.new
 # is equal to
-mb = MemStore::ObjectStore.new
+store = MemStore::ObjectStore.new
 ```
 
 `HashStore` needs to be created explicitly:
 
 ```ruby
-mb = MemStore::HashStore.new
+store = MemStore::HashStore.new
 ```
 
 If no key attribute is specified, `HashStore` will also use `Object#hash`.
@@ -89,32 +95,32 @@ If no key attribute is specified, `HashStore` will also use `Object#hash`.
 `items` provides direct access to the internal items hash.
 
 ```ruby
-mb.items
+store.items
 # => {}
-mb.items = { 1 => a, 2 => b, 3 => c }
+store.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
+store.insert(a, b, c)
+# => store
 ```
 
 Since it returns the data store, items can be added right after instantiation:
 
 ```ruby
-mb = MemStore.new.insert(a, b, c)
-# => mb
+store = MemStore.new.insert(a, b, c)
+# => store
 ```
 
 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
+store << a << b << c
+# => store
 ```
 
 ### Retrieving Items
@@ -122,7 +128,7 @@ mb << a << b << c
 `size` returns the current number of items:
 
 ```ruby
-mb.size
+store.size
 # => 3
 ```
 
@@ -131,18 +137,18 @@ 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]
+store[1]
 # => a
-mb[1, 2, 3]
+store[1, 2, 3]
 # => [a, b, c]
 ```
 
 Ranges are also supported and can even be combined with single keys:
 
 ```ruby
-mb[1..3]
+store[1..3]
 # => [a, b, c]
-mb[1..3, 6]
+store[1..3, 6]
 # => [a, b, c, f]
 ```
 
@@ -155,25 +161,25 @@ 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)
+store.delete_item(a)
 # => a
-mb.delete_items(b, c, d)
+store.delete_items(b, c, d)
 # => [b, c, d]
-mb.delete(e, f, g)
+store.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.
+Again, one or multiple items can be deleted at a time and even ranges are accepted.
 
 ```ruby
-mb.delete_key(1)
+store.delete_key(1)
 # => a
-mb.delete_keys(2, 3, 4)
+store.delete_keys(2, 3, 4)
 # => [b, c, d]
-mb.delete_keys(5..7, 9)
+store.delete_keys(5..7, 9)
 # => [e, f, g, i]
 ```
 
@@ -221,10 +227,10 @@ 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? })
+store.find(name: "Fred", age: 25)
+store.find(name: /red/i, age: 10..30)
+store.find(child: MyClass)
+store.find(child: -> child { child.valid? })
 ```
 
 Additional types can be used in conditions by supporting the `===` operator. For example:
@@ -236,20 +242,20 @@ class Array
 	end
 end
 
-mb.find age: [23, 25, 27]
+store.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 }
+store.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(...)
+store.find(...) | store.find(...) | store.find(...)
 ```
 
 Note that the pipe operator `|` already eliminates duplicates:
@@ -263,28 +269,43 @@ Note that the pipe operator `|` already eliminates duplicates:
 
 ### Serialization
 
+MemStore support various ways of de-/serializing the data store.
+
+- `ObjectStore` supports binary format.
+- `HashStore` supports binary format, hash, [YAML](http://yaml.org/), [JSON](http://www.json.org/) and [MessagePack](http://msgpack.org/).
+
+**Important:** When file IO or deserialization fails, all variants of `from_*` return `nil`.
+
+The following style ensures that there will be a (correctly configured) data store:
+
+```ruby
+store = MemStore.from_file(file) || MemStore::HashStore(key, items)
+```
+
 #### Binary
 
-The data store can easily be serialized and restored in binary format:
+Both `ObjectStore` and `HashStore` can easily be serialized to and from binary format:
 
 ```ruby
-mb.to_file("datastore.bin")
+store.to_binary
+# => binary string
+store.to_file(file)
 # => number of bytes written
-MemStore.from_file("datastore.bin")
-# => instance of ObjectStore or HashStore
+MemStore.from_binary(binary)
+# => instance of ObjectStore or HashStore or nil
+MemStore.from_file(file)
+# => instance of ObjectStore or HashStore or nil
 ```
 
-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
+store.to_hash
 # => { key: ..., items: { ... } }
-MemStore::HashStore.from_hash(h)
-# => instance of HashStore
+MemStore::HashStore.from_hash(hash)
+# => instance of HashStore or nil
 ```
 
 #### YAML
@@ -294,14 +315,14 @@ MemStore::HashStore.from_hash(h)
 ```ruby
 require "memstore/yaml" # requires "yaml"
 
-mb.to_yaml
+store.to_yaml
 # => YAML string
-mb.to_yaml_file(file)
+store.to_yaml_file(file)
 # => number of bytes written
 MemStore::HashStore.from_yaml(yaml)
-# => instance of HashStore
+# => instance of HashStore or nil
 MemStore::HashStore.from_yaml_file(file)
-# => instance of HashStore
+# => instance of HashStore or nil
 ```
 
 De/serialization is seamless since YAML can handle symbols and non-string keys (i.e. Psych converts them correctly).
@@ -313,34 +334,34 @@ De/serialization is seamless since YAML can handle symbols and non-string keys (
 ```ruby
 require "memstore/json" # requires "json"
 
-mb.to_json
+store.to_json
 # => JSON string
-mb.to_json_file(file)
+store.to_json_file(file)
 # => number of bytes written
 MemStore::HashStore.from_json(json)
-# => instance of HashStore
+# => instance of HashStore or nil
 MemStore::HashStore.from_json_file(file)
-# => instance of HashStore
+# => instance of HashStore or nil
 ```
 
 **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
+store = MemStore::HashStore.new(:id)
+store << { id: 1 }
+store.to_hash
 # => { :key => :id, :items => { 1 => { :id => 1 } } }
-mb = MemStore::HashStore.from_json(mb.to_json)
-mb.to_hash
+store = MemStore::HashStore.from_json(store.to_json)
+store.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"]
+store = MemStore::HashStore.new("id")
+store << { "id" => "1" }
+store["1"]
 # => { "id" => "1" }
 ```
 
@@ -351,41 +372,47 @@ mb["1"]
 ```ruby
 require "memstore/msgpack" # requires "msgpack"
 
-mb.to_msgpack
+store.to_msgpack
 # => MessagePack binary format
-mb.to_msgpack_file(file)
+store.to_msgpack_file(file)
 # => number of bytes written
 MemStore::HashStore.from_msgpack(msgpack)
-# => instance of HashStore
+# => instance of HashStore or nil
 MemStore::HashStore.from_msgpack_file(file)
-# => instance of HashStore
+# => instance of HashStore or nil
 ```
 
 **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
+store = MemStore::HashStore.new(:id)
+store << { id: 1 }
+store.to_hash
 # => { :key => :id, :items => { 1 => { :id => 1 } } }
-mb = MemStore::HashStore.from_msgpack(mb.to_msgpack)
-mb.to_hash
+store = MemStore::HashStore.from_msgpack(store.to_msgpack)
+store.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]
+store = MemStore::HashStore.new("id")
+store << { "id" => 1 }
+store[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
+1. Fork it on [GitHub](https://github.com/sklppr/memstore).
+2. Create a feature branch containing your changes:
+
+    ```sh
+    $ git checkout -b feature/my-new-feature
+    # code, code, code
+    $ git commit -am "Add some feature"
+    $ git push origin feature/my-new-feature
+    ```
+
+3. Create a Pull Request on [GitHub](https://github.com/sklppr/memstore).

data/lib/memstore.rb

@@ -2,12 +2,16 @@ require "memstore/version"
 
 module MemStore
 
-  def self.new(key=nil)
-    ObjectStore.new(key)
+  def self.new(key=nil, items={})
+    ObjectStore.new(key, items)
+  end
+
+  def self.from_binary(binary)
+    begin Marshal.load(binary) rescue nil end
   end
 
   def self.from_file(file)
-    Marshal.load IO.read(file)
+    begin self.from_binary(IO.read(file)) rescue nil end
   end
 
   class ObjectStore
@@ -32,7 +36,7 @@ module MemStore
     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] }
+        if key.is_a?(Range) then key.inject(items) { |i, k| i << @items[k] }
         else items << @items[key] end
       end
     end
@@ -51,7 +55,7 @@ module MemStore
     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) }
+        if key.is_a?(Range) then key.inject(items) { |i, k| i << @items.delete(k) }
         else items << @items.delete(key) end
       end
     end
@@ -99,8 +103,12 @@ module MemStore
       all.detect { |item| instance_exec(item, conditions, block, &FIND_NONE) }
     end
 
+    def to_binary
+      Marshal.dump(self)
+    end
+
     def to_file(file)
-      IO.write file, Marshal.dump(self)
+      IO.write(file, self.to_binary)
     end
 
     private
@@ -138,7 +146,14 @@ module MemStore
   class HashStore < ObjectStore
 
     def self.from_hash(hash)
-      self.new(hash[:key] || hash["key"], hash[:items] || hash["items"])
+      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={})

data/lib/memstore/json.rb

@@ -9,15 +9,15 @@ module MemStore
     end
     
     def to_json_file(file)
-      IO.write file, self.to_json
+      IO.write(file, self.to_json)
     end
 
     def self.from_json(json)
-      self.from_hash JSON.parse(json)
+      begin self.from_hash(JSON.parse(json)) rescue nil end
     end
     
     def self.from_json_file(file)
-      self.from_json IO.read(file)
+      begin self.from_json(IO.read(file)) rescue nil end
     end
 
   end

data/lib/memstore/msgpack.rb

@@ -9,15 +9,15 @@ module MemStore
     end
     
     def to_msgpack_file(file)
-      IO.write file, self.to_msgpack
+      IO.write(file, self.to_msgpack)
     end
 
     def self.from_msgpack(msgpack)
-      self.from_hash MessagePack.unpack(msgpack)
+      begin self.from_hash(MessagePack.unpack(msgpack)) rescue nil end
     end
     
     def self.from_msgpack_file(file)
-      self.from_msgpack IO.read(file)
+      begin self.from_msgpack(IO.read(file)) rescue nil end
     end
 
   end

data/lib/memstore/version.rb

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

data/lib/memstore/yaml.rb

@@ -9,15 +9,15 @@ module MemStore
     end
     
     def to_yaml_file(file)
-      IO.write file, self.to_yaml
+      IO.write(file, self.to_yaml)
     end
 
     def self.from_yaml(yaml)
-      self.from_hash YAML.load(yaml)
+      begin self.from_hash(YAML.load(yaml)) rescue nil end
     end
     
     def self.from_yaml_file(file)
-      self.from_yaml IO.read(file)
+      begin self.from_yaml(IO.read(file)) rescue nil end
     end
 
   end

data/spec/memstore_json_spec.rb

@@ -6,26 +6,26 @@ 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
+  
+  before do
+    @key = "id"
+    @store = MemStore::HashStore.new(@key)
+    10.times { |i| @store << { "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 converted to and from JSON" do
+    restored = MemStore::HashStore.from_json(@store.to_json)
+    restored.items.must_equal @store.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
+  it "can be serialized to and deserialized from a JSON file" do
+    tmp = Tempfile.new("memstore")
+    @store.to_json_file(tmp)
+    restored = MemStore::HashStore.from_json_file(tmp)
+    restored.items.must_equal @store.items
+    restored.instance_variable_get(:@key).must_equal @key
+    tmp.unlink
+  end
 
 end

data/spec/memstore_msgpack_spec.rb

@@ -6,26 +6,26 @@ 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
+  
+  before do
+    @key = "id"
+    @store = MemStore::HashStore.new(@key)
+    10.times { |i| @store << { "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 converted to and from MessagePack" do
+    restored = MemStore::HashStore.from_msgpack(@store.to_msgpack)
+    restored.items.must_equal @store.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
+  it "can be serialized to and deserialized from a MessagePack file" do
+    tmp = Tempfile.new("memstore")
+    @store.to_msgpack_file(tmp)
+    restored = MemStore::HashStore.from_msgpack_file(tmp)
+    restored.items.must_equal @store.items
+    restored.instance_variable_get(:@key).must_equal @key
+    tmp.unlink
+  end
 
 end

data/spec/memstore_spec.rb

@@ -4,189 +4,235 @@ 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 }
-		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
+  
+  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.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 "can be serialized to and deserialized from a binary file" 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
+  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)
+    10.times { |i| store << { id: i } }
+    restored = MemStore.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")
+    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
+    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
-		@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
+  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 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 serialized to and deserialized from a binary file" do
+    tmp = Tempfile.new("memstore")
+    @store.to_file tmp
+    MemStore.from_file(tmp).items.must_equal @store.items
+    tmp.unlink
+  end
+
+  it "returns nil when conversion from binary fails" do
+    MemStore.from_binary(nil).must_equal nil
+  end
+
+  it "returns nil when deserialization from binary file fails" do
+    MemStore.from_file("does_not_exist").must_equal nil
+  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
+  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
 
 end

data/spec/memstore_yaml_spec.rb

@@ -6,26 +6,26 @@ 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
+  
+  before do
+    @key = :id
+    @store = MemStore::HashStore.new(@key)
+    10.times { |i| @store << { 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 converted to and from YAML" do
+    restored = MemStore::HashStore.from_yaml(@store.to_yaml)
+    restored.items.must_equal @store.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
+  it "can be serialized to and deserialized from a YAML file" do
+    tmp = Tempfile.new("memstore")
+    @store.to_yaml_file(tmp)
+    restored = MemStore::HashStore.from_yaml_file(tmp)
+    restored.items.must_equal @store.items
+    restored.instance_variable_get(:@key).must_equal @key
+    tmp.unlink
+  end
 
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: memstore
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-19 00:00:00.000000000 Z
+date: 2013-02-20 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.