ohm 1.3.2 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a0015a7962f27903ee712ca027655b3f01722f64
-  data.tar.gz: 06c1b5a4101dae29fbabd19d6804a0eafbb3ccd3
+  metadata.gz: c8fb32b51fcb6f8e322f0cdf25638936febbe980
+  data.tar.gz: 37875da64dde8f61fef65909900a9889cbf5a3c9
 SHA512:
-  metadata.gz: 6ea9f1a1f47e0863607e97f6c6d3e5c2673a355fadca8baa88f30636028b404a08dce69a26d9489272896abd734ccdcd3535eebe4807ae740a8a4b37a6b8a8b0
-  data.tar.gz: 88ee32f78b6ce100d028ecfc1dfe5d61e4e9ec6933c0261df4828d4c63835108aba23b30ea69259717e0cae5f06df8aa31ac1aadc0f1200d8d2bac255a9c249e
+  metadata.gz: 94ad5d4c99d9f85212f0902627aa27836bcd23a61f22cef7bcd40b6e8b855656dfcb68dc274128825a04b4f4b46a6b0c6bc4dd9d678326374f18acc51d9e5f10
+  data.tar.gz: 6a8007f49f2e2fac0c06d22323659b9b7ec987c6a5c87fda67e77b6e181f5160f4d78db0d5ebf6b1fa38c8cd34a9833b1f9ae0ec21063e05cb8b87b37bf85e96

data/CHANGELOG

@@ -1,4 +1,4 @@
-(unreleased)
+1.3.2
 
 - Fetching a batch of objects is now done in batches of 1000 objects at
   a time. If you are iterating over large collections, this change should

data/README.md

@@ -443,8 +443,7 @@ lookups.
 In the `Event` example, the index on the name attribute will
 allow for searches like `Event.find(:name => "some value")`.
 
-Note that the {Ohm::Model::Validations#assert_unique assert_unique}
-validation and the methods {Ohm::Model::Set#find find} and
+Note that the methods {Ohm::Model::Set#find find} and
 {Ohm::Model::Set#except except} need a corresponding index in order to work.
 
 ### Finding records
@@ -462,8 +461,11 @@ User.find(:username => "Albert")
 # Find all users from Argentina
 User.find(:country => "Argentina")
 
-# Find all activated users from Argentina
-User.find(:country => "Argentina", :status => "activated")
+# Find all active users from Argentina
+User.find(:country => "Argentina", :status => "active")
+
+# Find all active users from Argentina and Uruguay
+User.find(status: "active").combine(country: ["Argentina", "Uruguay"])
 
 # Find all users from Argentina, except those with a suspended account.
 User.find(:country => "Argentina").except(:status => "suspended")

data/examples/chaining.rb

@@ -21,7 +21,7 @@ require "ohm"
 #     end
 #
 class User < Ohm::Model
-  collection :orders, Order
+  collection :orders, :Order
 end
 
 # The product for our purposes will only contain a name.
@@ -41,8 +41,8 @@ class Order < Ohm::Model
   attribute :state
   index :state
 
-  reference :user, User
-  reference :product, Product
+  reference :user, :User
+  reference :product, :Product
 end
 
 ##### Testing what we have so far.
@@ -58,15 +58,26 @@ prepare { Ohm.flush }
 setup do
   @user = User.create
 
-  @ipod = Product.create(:name => "iPod")
-  @ipad = Product.create(:name => "iPad")
+  @ipod = Product.create(name: "iPod")
+  @ipad = Product.create(name: "iPad")
 
-  @pending =    Order.create(:user => @user, :state => "pending",
-                             :product => @ipod)
-  @authorized = Order.create(:user => @user, :state => "authorized",
-                             :product => @ipad)
-  @captured =   Order.create(:user => @user, :state => "captured",
-                             :product => @ipad)
+  @pending = Order.create(
+    user: @user,
+    state: "pending",
+    product: @ipod
+  )
+
+  @authorized = Order.create(
+    user: @user,
+    state: "authorized",
+    product:  @ipad
+  )
+
+  @captured = Order.create(
+    user: @user,
+    state: "captured",
+    product:  @ipad
+  )
 end
 
 # Now let's try and grab all pending orders, and also pending
@@ -74,31 +85,23 @@ end
 test "finding pending orders" do
   assert @user.orders.find(state: "pending").include?(@pending)
 
-  assert @user.orders.find(:state => "pending",
-                           :product_id => @ipod.id).include?(@pending)
+  assert @user.orders.find(state: "pending",
+                           product_id: @ipod.id).include?(@pending)
 
-  assert @user.orders.find(:state => "pending",
-                           :product_id => @ipad.id).empty?
+  assert @user.orders.find(state: "pending", product_id: @ipad.id).empty?
 end
 
-# Now we try and find captured and authorized orders. The tricky part
-# is trying to find an order that is either *captured* or *authorized*,
-# since `Ohm` as of this writing doesn't support unions in its
-# finder syntax.
+# Now we try and find captured and authorized orders.
+# Since now `Ohm` supports unions in its finder syntax,
+# it's really easy to do so.
 test "finding authorized and/or captured orders" do
-  assert @user.orders.find(:state => "authorized").include?(@authorized)
-  assert @user.orders.find(:state => "captured").include?(@captured)
+  assert @user.orders.find(state: "authorized").include?(@authorized)
+  assert @user.orders.find(state: "captured").include?(@captured)
 
-  assert @user.orders.find(:state => ["authorized", "captured"]).empty?
+  auth_or_capt =  @user.orders.find(state: "authorized").union(state: "captured")
 
-  auth_or_capt = @user.orders.key.volatile[:auth_or_capt]
-  auth_or_capt.sunionstore(
-    @user.orders.find(:state => "authorized").key,
-    @user.orders.find(:state => "captured").key
-  )
-
-  assert auth_or_capt.smembers.include?(@authorized.id)
-  assert auth_or_capt.smembers.include?(@captured.id)
+  assert auth_or_capt.include?(@authorized)
+  assert auth_or_capt.include?(@captured)
 end
 
 #### Creating shortcuts
@@ -106,11 +109,11 @@ end
 # You can of course define methods to make that code more readable.
 class User < Ohm::Model
   def authorized_orders
-    orders.find(:state => "authorized")
+    orders.find(state: "authorized")
   end
 
   def captured_orders
-    orders.find(:state => "captured")
+    orders.find(state: "captured")
   end
 end
 
@@ -125,29 +128,33 @@ end
 
 #### Chaining Kung-Fu
 
-# The `Ohm::Model::Set` takes a *Redis* key and a *class monad*
-# for its arguments.
+# The `Ohm::Set` takes a *Redis* key, a *namespace* and
+# an *Ohm model* for its arguments.
 #
-# We can simply subclass it and define the monad to always be an
-# `Order` so we don't have to manually set it everytime.
-class UserOrders < Ohm::Model::Set
+# We can simply subclass it and define the arguments
+# so we don't have to manually set them everytime.
+class UserOrders < Ohm::Set
+  attr :model
+
   def initialize(key)
-    super key, Ohm::Model::Wrapper.wrap(Order)
+    @model = Order
+
+    super(key, key, @model)
   end
 
   # Here is the crux of the chaining pattern. Instead of
-  # just doing a straight up `find(:state => "pending")`, we return
+  # just doing a straight up `find(state: "pending")`, we return
   # `UserOrders` again.
   def pending
-    self.class.new(model.index_key_for(:state, "pending"))
+    self.class.new(model.key[:indices][:state]["pending"])
   end
 
   def authorized
-    self.class.new(model.index_key_for(:state, "authorized"))
+    self.class.new(model.key[:indices][:state]["authorized"])
   end
 
   def captured
-    self.class.new(model.index_key_for(:state, "captured"))
+    self.class.new(model.key[:indices][:state]["captured"])
   end
 
   # Now we wrap the implementation of doing an `SUNIONSTORE` and also
@@ -156,27 +163,24 @@ class UserOrders < Ohm::Model::Set
   # NOTE: `volatile` just returns the key prepended with a `~:`, so in
   # this case it would be `~:Order:accepted`.
   def accepted
-    model.key.volatile[:accepted].sunionstore(
-      authorized.key, captured.key
-    )
-
-    self.class.new(model.key.volatile[:accepted])
+    Ohm::MultiSet.new(key, @model, Ohm::Command[:sunionstore, authorized.key, captured.key])
   end
 end
 
 # Now let's re-open the `User` class and add a customized `orders` method.
 class User < Ohm::Model
   def orders
-    UserOrders.new(Order.index_key_for(:user_id, id))
+    UserOrders.new(Order.key[:indices][:user_id][id])
   end
 end
 
 # Ok! Let's put all of that chaining code to good use.
 test "finding pending orders using a chainable style" do
   assert @user.orders.pending.include?(@pending)
-  assert @user.orders.pending.find(:product_id => @ipod.id).include?(@pending)
 
-  assert @user.orders.pending.find(:product_id => @ipad.id).empty?
+  assert @user.orders.pending.find(product_id: @ipod.id).include?(@pending)
+
+  assert @user.orders.pending.find(product_id: @ipad.id).empty?
 end
 
 test "finding authorized and/or captured orders using a chainable style" do
@@ -188,8 +192,8 @@ test "finding authorized and/or captured orders using a chainable style" do
 
   accepted = @user.orders.accepted
 
-  assert accepted.find(:product_id => @ipad.id).include?(@authorized)
-  assert accepted.find(:product_id => @ipad.id).include?(@captured)
+  assert accepted.find(product_id: @ipad.id).include?(@authorized)
+  assert accepted.find(product_id: @ipad.id).include?(@captured)
 end
 
 #### Conclusion

data/lib/ohm.rb

@@ -149,7 +149,7 @@ module Ohm
           fetch(slice).each { |e| yield(e) }
         end
       else
-        Enumerator.new(self, :each)
+        to_enum
       end
     end
 
@@ -467,6 +467,20 @@ module Ohm
       MultiSet.new(namespace, model, key).except(dict)
     end
 
+    # Perform an intersection between the existent set and
+    # the new set created by the union of the passed filters.
+    #
+    # Example:
+    #
+    #   set = User.find(:status => "active")
+    #   set.combine(:name => ["John", "Jane"])
+    #   
+    #   # The result will include all users with active status
+    #   # and with names "John" or "Jane".
+    def combine(dict)
+      MultiSet.new(namespace, model, key).combine(dict)
+    end
+
     # Do a union to the existing set using any number of filters.
     #
     # Example:
@@ -598,7 +612,23 @@ module Ohm
     #
     def except(dict)
       MultiSet.new(
-        namespace, model, Command[:sdiffstore, command, intersected(dict)]
+        namespace, model, Command[:sdiffstore, command, unioned(dict)]
+      )
+    end
+
+    # Perform an intersection between the existent set and
+    # the new set created by the union of the passed filters.
+    #
+    # Example:
+    #
+    #   set = User.find(:status => "active")
+    #   set.combine(:name => ["John", "Jane"])
+    #   
+    #   # The result will include all users with active status
+    #   # and with names "John" or "Jane".
+    def combine(dict)
+      MultiSet.new(
+        namespace, model, Command[:sinterstore, command, unioned(dict)]
       )
     end
 
@@ -627,6 +657,11 @@ module Ohm
       Command[:sinterstore, *model.filters(dict)]
     end
 
+
+    def unioned(dict)
+      Command[:sunionstore, *model.filters(dict)]
+    end
+
     def execute
       # namespace[:tmp] is where all the temp keys should be stored in.
       # db will be where all the commands are executed against.

data/lib/ohm/transaction.rb

@@ -38,7 +38,7 @@ module Ohm
   #   t1.append(t2)
   #   t1.commit(redis)
   #
-  # @see http://redis.io/topic/transactions Transactions in Redis.
+  # @see http://redis.io/topics/transactions Transactions in Redis.
   class Transaction
     class Store
       class EntryAlreadyExistsError < RuntimeError

data/ohm.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "ohm"
-  s.version = "1.3.2"
+  s.version = "1.4.0"
   s.summary = %{Object-hash mapping library for Redis.}
   s.description = %Q{Ohm is a library that allows to store an object in Redis, a persistent key-value database. It includes an extensible list of validations and has very good performance.}
   s.authors = ["Michel Martens", "Damian Janowski", "Cyril David"]

data/test/filtering.rb

@@ -95,6 +95,14 @@ test "#union" do |john, jane|
   assert res.any? { |e| e.status == "inactive" }
 end
 
+test "#combine" do |john, jane|
+  res = User.find(:status => "active").combine(fname: ["John", "Jane"])
+
+  assert_equal 2, res.size
+  assert res.include?(john)
+  assert res.include?(jane)
+end
+
 # book author thing via @myobie
 scope do
   class Book < Ohm::Model
@@ -159,142 +167,3 @@ scope do
     assert_equal 2, res.size
   end
 end
-
-# test precision of filtering commands
-require "logger"
-require "stringio"
-scope do
-  class Post < Ohm::Model
-    attribute :author
-    index :author
-
-    attribute :mood
-    index :mood
-  end
-
-  setup do
-    io = StringIO.new
-
-    Post.connect(:logger => Logger.new(io))
-
-    Post.create(author: "matz", mood: "happy")
-    Post.create(author: "rich", mood: "mad")
-
-    io
-  end
-
-  def read(io)
-    io.rewind
-    io.read
-  end
-
-  test "SINTERSTORE a b" do |io|
-    Post.find(author: "matz").find(mood: "happy").to_a
-
-    # This is the simple case. We should only do one SINTERSTORE
-    # given two direct keys. Anything more and we're performing badly.
-    expected = "SINTERSTORE Post:tmp:[a-f0-9]{64} " +
-               "Post:indices:author:matz Post:indices:mood:happy"
-
-    assert(read(io) =~ Regexp.new(expected))
-  end
-
-  test "SUNIONSTORE a b" do |io|
-    Post.find(author: "matz").union(mood: "happy").to_a
-
-    # Another simple case where we must only do one operation at maximum.
-    expected = "SUNIONSTORE Post:tmp:[a-f0-9]{64} " +
-               "Post:indices:author:matz Post:indices:mood:happy"
-
-    assert(read(io) =~ Regexp.new(expected))
-  end
-
-  test "SUNIONSTORE c (SINTERSTORE a b)" do |io|
-    Post.find(author: "matz").find(mood: "happy").union(author: "rich").to_a
-
-    # For this case we need an intermediate key. This will
-    # contain the intersection of matz + happy.
-    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
-               "Post:indices:author:matz Post:indices:mood:happy"
-
-    assert(read(io) =~ Regexp.new(expected))
-
-    # The next operation is simply doing a UNION of the previously
-    # generated intermediate key and the additional single key.
-    expected = "SUNIONSTORE (Post:tmp:[a-f0-9]{64}) " +
-               "%s Post:indices:author:rich" % $1
-
-    assert(read(io) =~ Regexp.new(expected))
-  end
-
-  test "SUNIONSTORE (SINTERSTORE c d) (SINTERSTORE a b)" do |io|
-    Post.find(author: "matz").find(mood: "happy").
-         union(author: "rich", mood: "sad").to_a
-
-    # Similar to the previous case, we need to do an intermediate
-    # operation.
-    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
-               "Post:indices:author:matz Post:indices:mood:happy"
-
-    match1 = read(io).match(Regexp.new(expected))
-    assert match1
-
-    # But now, we need to also hold another intermediate key for the
-    # condition of author: rich AND mood: sad.
-    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
-               "Post:indices:author:rich Post:indices:mood:sad"
-
-    match2 = read(io).match(Regexp.new(expected))
-    assert match2
-
-    # Now we expect that it does a UNION of those two previous
-    # intermediate keys.
-    expected = sprintf(
-      "SUNIONSTORE (Post:tmp:[a-f0-9]{64}) %s %s",
-      match1[1], match2[1]
-    )
-
-    assert(read(io) =~ Regexp.new(expected))
-  end
-
-  test do |io|
-    Post.create(author: "kent", mood: "sad")
-
-    Post.find(author: "kent", mood: "sad").
-         union(author: "matz", mood: "happy").
-         except(mood: "sad", author: "rich").to_a
-
-    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
-               "Post:indices:author:kent Post:indices:mood:sad"
-
-    match1 = read(io).match(Regexp.new(expected))
-    assert match1
-
-    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
-               "Post:indices:author:matz Post:indices:mood:happy"
-
-    match2 = read(io).match(Regexp.new(expected))
-    assert match2
-
-    expected = sprintf(
-      "SUNIONSTORE (Post:tmp:[a-f0-9]{64}) %s %s",
-      match1[1], match2[1]
-    )
-
-    match3 = read(io).match(Regexp.new(expected))
-    assert match3
-
-    expected = "SINTERSTORE (Post:tmp:[a-f0-9]{64}) " +
-               "Post:indices:mood:sad Post:indices:author:rich"
-
-    match4 = read(io).match(Regexp.new(expected))
-    assert match4
-
-    expected = sprintf(
-      "SDIFFSTORE (Post:tmp:[a-f0-9]{64}) %s %s",
-      match3[1], match4[1]
-    )
-
-    assert(read(io) =~ Regexp.new(expected))
-  end
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ohm
 version: !ruby/object:Gem::Version
-  version: 1.3.2
+  version: 1.4.0
 platform: ruby
 authors:
 - Michel Martens
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-20 00:00:00.000000000 Z
+date: 2015-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -143,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: ohm
-rubygems_version: 2.0.3
+rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: Object-hash mapping library for Redis.