ohm 2.0.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d404b17a73aaa3f8e44ef1973cc2c2281bfdeb7
-  data.tar.gz: 5e59ffee49a2bee96c3417cc0763f31552bf06ff
+  metadata.gz: 879b753fd8424a547c5cf83753b2f4d7dd817a14
+  data.tar.gz: fab1f4b6971328047ed17e37d589ebc47c32d082
 SHA512:
-  metadata.gz: 849b95d5ebfc61b136be8351b6c0887e6c2961c78bb086204c39a1110524efd02fe94d48c5ed05c123c326567aa70ffbb2292e70a10d9f875307dd33e82f72e9
-  data.tar.gz: db2213eff5791aa09f02e2d79c9059d9ed4d3619f6206257bf3a69c227a2481361f179fd620ec6b07d4c21f7cb89965d6e52e7b90ab08494ef8ed067e637aa31
+  metadata.gz: 3538cccef143743083a6a31c672e4e5bacec42f743196fbcf52f1c68ca4ca3bcc3169f9633a40cdfc1633d48428c60e53e999641e252b640767d85b6b8db3117
+  data.tar.gz: b51d4ad91623b2357492837a37d1f0f03928e4a2e526849afe4cd558987089fab2a930233065d1230e6dd82c70c6c0341435c0fbbf7f9a467953480e09ec99c4

data/README.md

@@ -23,6 +23,7 @@ These are libraries in other languages that were inspired by Ohm.
 
 * [JOhm](https://github.com/xetorthio/johm) for Java, created by xetorthio
 * [Lohm](https://github.com/slact/lua-ohm) for Lua, created by slact
+* [ohm.lua](https://github.com/amakawa/ohm.lua) for Lua, created by amakawa
 * [Nohm](https://github.com/maritz/nohm) for Node.js, created by maritz
 * [Redisco](https://github.com/iamteem/redisco) for Python, created by iamteem
 * [redis3m](https://github.com/luca3m/redis3m) for C++, created by luca3m
@@ -164,11 +165,17 @@ querying. Keep reading to find out what you can do with models.
 Attribute types
 ---------------
 
-Ohm::Model provides four attribute types: {Ohm::Model.attribute
-attribute}, {Ohm::Model.set set}, {Ohm::Model.list list}
-and {Ohm::Model.counter counter}; and two meta types:
-{Ohm::Model.reference reference} and {Ohm::Model.collection
-collection}.
+Ohm::Model provides 4 attribute types: 
+
+* {Ohm::Model.attribute attribute}, 
+* {Ohm::Model.set set}
+* {Ohm::Model.list list}
+* {Ohm::Model.counter counter}
+
+and 2 meta types:
+
+* {Ohm::Model.reference reference}
+* {Ohm::Model.collection collection}.
 
 ### attribute
 
@@ -439,8 +446,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

@@ -16,12 +16,12 @@ require "ohm"
 # A `User` has a `collection` of *orders*. Note that a collection
 # is actually just a convenience, which implemented simply will look like:
 #
-#     def orders
-#       Order.find(:user_id => self.id)
-#     end
+#   def orders
+#     Order.find(user_id: self.id)
+#   end
 #
 class User < Ohm::Model
-  collection :orders, Order
+  collection :orders, :Order
 end
 
 # The product for our purposes will only contain a name.
@@ -29,7 +29,7 @@ class Product < Ohm::Model
   attribute :name
 end
 
-# We define an `Order` with just a single `attribute` called state, and
+# We define an `Order` with just a single `attribute` called `state`, and
 # also add an `index` so we can search an order given its state.
 #
 # The `reference` to the `User` is actually required for the `collection`
@@ -58,15 +58,15 @@ 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 +74,22 @@ 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/or authorized orders.
 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?
+  results = @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 results.include?(@authorized)
+  assert results.include?(@captured)
 end
 
 #### Creating shortcuts
@@ -106,11 +97,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
 
@@ -121,62 +112,40 @@ test "finding authorized and/or captured orders" do
 end
 
 # In most cases this is fine, but if you want to have a little fun,
-# then we can play around with some chainability.
+# then we can play around with some chainability using scopes.
 
-#### Chaining Kung-Fu
+# Let's require `ohm-contrib`, which we will be using for scopes.
+require "ohm/contrib"
 
-# The `Ohm::Model::Set` takes a *Redis* key and a *class monad*
-# 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
-  def initialize(key)
-    super key, Ohm::Model::Wrapper.wrap(Order)
-  end
+# Include `Ohm::Scope` module and desired scopes.
+class Order
+  include Ohm::Scope
 
-  # Here is the crux of the chaining pattern. Instead of
-  # just doing a straight up `find(:state => "pending")`, we return
-  # `UserOrders` again.
-  def pending
-    self.class.new(model.index_key_for(:state, "pending"))
-  end
+  scope do
+    def pending
+      find(state: "pending")
+    end
 
-  def authorized
-    self.class.new(model.index_key_for(:state, "authorized"))
-  end
+    def authorized
+      find(state: "authorized")
+    end
 
-  def captured
-    self.class.new(model.index_key_for(:state, "captured"))
-  end
+    def captured
+      find(state: "captured")
+    end
 
-  # Now we wrap the implementation of doing an `SUNIONSTORE` and also
-  # make it return a `UserOrders` object.
-  #
-  # 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])
-  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))
+    def accepted
+      find(state: "authorized").union(state: "captured")
+    end
   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: @ipod.id).include?(@pending)
 
-  assert @user.orders.pending.find(:product_id => @ipad.id).empty?
+  assert @user.orders.pending.find(product_id: @ipad.id).empty?
 end
 
 test "finding authorized and/or captured orders using a chainable style" do
@@ -188,16 +157,6 @@ 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
-
-# This design pattern is something that really depends upon the situation. In
-# the example above, you can add more complicated querying on the `UserOrders`
-# class.
-#
-# The most important takeaway here is the ease of which we can weild the
-# different components of Ohm, and mold it accordingly to our preferences,
-# without having to monkey-patch anything.

data/examples/tagging.rb

@@ -156,11 +156,13 @@ class Post
 
   # For our scenario, we only need a `before_update` and `after_save`.
   # The idea for our `before_update` is to decrement the `total` of
-  # all existing tags. We use `read_remote(:tags)` to make sure that
-  # we actually get the original `tags` for a particular record.
+  # all existing tags. We use `get(:tags)` the original tags for the
+  # record and use assigned one on save.
 protected
   def before_update
-    tag(read_remote(:tags)).map(&Tag).each { |t| t.decr :total }
+    assigned_tags = tags
+    tag(get(:tags)).map(&Tag).each { |t| t.decr :total }
+    self.tags = assigned_tags
   end
 
   # And of course, we increment all new tags for a particular record
@@ -186,7 +188,8 @@ class Tag < Ohm::Model
   # though is that we need to encode the tag name, so special characters
   # and spaces won't produce an invalid key.
   def self.[](id)
-    super(encode(id)) || create(:id => encode(id))
+    encoded_id = id.encode
+    super(encoded_id) || create(:id => encoded_id)
   end
 end
 

data/lib/ohm.rb

@@ -528,6 +528,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:
@@ -666,6 +680,22 @@ module Ohm
       )
     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
+
     # Do a union to the existing set using any number of filters.
     #
     # Example:

data/ohm.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "ohm"
-  s.version = "2.0.1"
+  s.version = "2.1.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 has very good performance.}
   s.authors = ["Michel Martens", "Damian Janowski", "Cyril David"]

data/test/filtering.rb

@@ -111,6 +111,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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ohm
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 2.1.0
 platform: ruby
 authors:
 - Michel Martens
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-26 00:00:00.000000000 Z
+date: 2015-01-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redic
@@ -138,7 +138,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.