memstore 2.0.1 → 2.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e09df24ba555d687f405c140c6ccbacaf4b42963
-  data.tar.gz: 462f77bf9be2d36d7cd98f770c59b65149fdd5e8
+  metadata.gz: b6f4cc0d74155f2d9f36ba022fd256b28891cbff
+  data.tar.gz: 63ab2ed73f4460fbb655b09992bf85fa698bea2c
 SHA512:
-  metadata.gz: 827ae9142869655c018017fe3ca335333561dc9504ab0ef46b5e0dae02b21b3b8f9c83bdad00090a6e9fc2c1ca9fc4fa289795cc1cdd5465a12680b07d037efb
-  data.tar.gz: 3c92d873c50ddbb71f8ec8a67190edc65f003a67221526ceae430ee6446fb3a3bc6a3714ee2d5b76c07448265af1862e99668eb638b8fabd3990f719d7f38ec5
+  metadata.gz: 8b1d6e1a2338a3d633d0966411daa316c46359c3f064fb64d47393a3262b4f98c1bd8b4682aff70a5df3ea568583bd33249d1ce6e1b2d2a3ea87585a3ce1c6f0
+  data.tar.gz: b2ae3c5fdb102a6e24e1b97f41ca6dcb0dc66b8ff84b159132f1a9a9e44e0db2f39b0b899dfcc58bde5918d0b02e825a121ec89650face919303a28441f8fcfc

data/README.md

@@ -83,6 +83,8 @@ For convenience, there are aliases for the `*_all` variants:
 - `count` is an alias of `count_all`
 - `delete` is an alias of `delete_all`
 
+### Conditions
+
 All methods take a hash of conditions and/or a block.
 
 The hash is expected to map attributes (see [Customization](#customization)) to conditions.  
@@ -119,6 +121,8 @@ refine Array do
 end
 ```
 
+### Block
+
 The block is invoked with the item *after* the conditions are evaluated.
 
 ```ruby
@@ -126,19 +130,75 @@ store.find(age: 25) { |item| item.age - item.child.age > 20 }
 # is equivalent to item.age == 25 && item.age - item.child.age > 20
 ```
 
-In addition to the query logic, you can merge the arrays returned by `find_*`:
+### Operators
+
+Since all queries return arrays, you can use set operations.  
+This can be especially useful to avoid overly complex queries.
+
+Assume queries with these results:
 
 ```ruby
-store.find_all(...) | store.find_any(...) | store.find_none(...)
+store.find_any(...)
+# => [a, b, c, d, e]
+store.find_all(...)
+# => [a, b, c]
+store.find_none()
+# => [b, c, e]
 ```
 
-Note that the pipe operator `|` already eliminates duplicates:
+Combine results using the union operator `|`:
 
 ```ruby
-[a, b, c] | [c, d, e]
-# => [a, b, c, d, e]
+store.find_all(...) | store.find_none(...)
+# => [a, b, c, e]
+```
+
+Restrict results using the intersection operator `&`:
+
+```ruby
+store.find_any(...) & store.find_none(...)
+# => [a, d]
 ```
 
+Note that both operators exclude duplicates and preserve order.
+
+## Map & Reduce
+
+MemStore provides a `map` method which is a shortcut to `store.all.map`:
+
+```ruby
+store.map { |item| "#{item.name} (#{item.age})" }
+# => ["Peter (23)", "Paul (42)", "Mary (33)"]
+```
+
+Since the result is an array, you can directly call `reduce` on it:
+
+```ruby
+store.map { |item| item.name.length }.reduce { |sum, n| sum + n }
+# => 13
+```
+
+If you simply want to grab a certain attribute from each item, you can use `collect` instead:
+
+```ruby
+store.collect(:age)
+# is equivalent to
+store.map { |item| item.age }
+```
+
+This automatically uses the correct access method for attributes (see [Customization](#customization)).
+
+It also returns an array so you can directly chain `reduce`:
+
+```ruby
+store.collect(:age)
+# => [23, 42, 33]
+store.collect(:age).reduce(:+)
+# => 98
+```
+
+*Of course, you can also use `items` or `all` to directly work with a hash or array of items.*
+
 ## Customization
 
 ### Default Behavior
@@ -169,7 +229,7 @@ store.find("age" => 42, "name" => "John")
 # calls item.age and item.name to retrieve attributes
 ```
 
-*Note that using Strings will result in a performance penalty because `Object#send` expects Symbols.*
+*Note that using strings will result in a performance penalty because `Object#send` expects symbols.*
 
 ### Custom Key
 
@@ -200,14 +260,14 @@ store.find(age: 42, name: "John")
 # calls item[:age] and item[:name] to retrieve attributes
 ```
 
-If you provide a Symbol or String, it will be treated as a method name.  
-*Note that providing a String will result in a performance penalty because `Object#send` expects Symbols.*
+If you provide a symbol or string, it will be treated as a method name.  
+*Note that providing a string will result in a performance penalty because `Object#send` expects symbols.*
 
 To access an attribute, MemStore will call the according method on your item and pass the requested attribute to it.  
 This means `key` and attributes in the conditions hash must be whatever your method expects:
 
 ```ruby
-# assuming that items have a method `get` that expects a String:
+# assuming that items have a method `get` that expects a string:
 store = MemStore.new(key: "id", access: :get)
 store << item
 # calls item.get("id") to retrieve key
@@ -260,7 +320,7 @@ end
 # lambda:
 store = MemStore.new(access: -> item, attribute { special_accessor(item, attribute) })
 # Proc:
-store = MemStore.new(access: Proc.new { |item| special_accessor(item, attribute) })
+store = MemStore.new(access: Proc.new { |item, attribute| special_accessor(item, attribute) })
 # Method:
 store = MemStore.new(access: method(:special_accessor))
 ```

data/lib/memstore/core.rb

@@ -126,4 +126,22 @@ class MemStore
     keys.collect { |key| @items.delete(key) }
   end
 
+  # Collects values of given attribute from all items.
+  #
+  # attribute - name of attribute to be collected (symbol or string)
+  #
+  # Returns an array of attribute values of each item.
+  def collect(attribute)
+    all.collect { |item| access_attribute(item, attribute) }
+  end
+
+  # Maps given block to all items.
+  #
+  # block - block to invoke with each item
+  #
+  # Returns an array of results from each block invocation.
+  def map(&block)
+    all.map(&block)
+  end
+
 end

data/lib/memstore/version.rb

@@ -1,3 +1,3 @@
 class MemStore
-  VERSION = "2.0.1"
+  VERSION = "2.0.2"
 end

data/spec/core_methods_spec.rb

@@ -64,4 +64,12 @@ describe MemStore do
     @store.all.must_equal([0.0, 1.0, 2.0, 7.0, 8.0, 9.0])
   end
 
+  it "collects attribute values using the specified access method" do
+    @store.collect(:to_i).must_equal(@store.all.map { |n| n.to_i })
+  end
+
+  it "provides a shortcut to invoke map on all items" do
+    @store.map { |n| n.to_i }.must_equal(@store.all.map { |n| n.to_i })
+  end
+
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: memstore
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.0.2
 platform: ruby
 authors:
 - Sebastian Klepper
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-12-18 00:00:00.000000000 Z
+date: 2014-11-01 00:00:00.000000000 Z
 dependencies: []
 description: MemStore is a simple in-memory data store that supports complex search
   queries.
@@ -52,7 +52,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: A simple in-memory data store.