sohm 0.9.0 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a233394733ef9467944e0803a078e296f14f5a9b
-  data.tar.gz: 7c9f2a402a570e18428590d81d4dcf146c2b3f7f
+  metadata.gz: a2d4f419606a66335e7a44d8440732b4179a068f
+  data.tar.gz: 6565464772af7ad624fb92268cac9ede60f70b44
 SHA512:
-  metadata.gz: c7397fe0d14eea5851e5b7037590fcc24063a0dbe5dcdd31fccdd3dfff2fec88dd313274f4d233a5c6a73d1d25aaebb1146f8889bfa86139482f77009f08d966
-  data.tar.gz: 407951baa343da76d535067e72ac31defa8ab0c763f5d76f283bf4bab99474b415a6894f68b61d58c0a197d7706496cfb5af099d59ea7763fd582d391c676847
+  metadata.gz: 6336ecb58d5112f896f673730c58b9810731342bf88183bebae05cef484a7eb377a9ffff95978211122889d6be61d0820bebc2d6c134d8c97a007e9e501aaf3d
+  data.tar.gz: f6c0592a5f52e04352121bc9975b30b45ac13c6e677a4b27a43f1032df8bc1c92aa1123d83e03ca7f41a269c02bd50679e44e675df8f54bdc1619cee2f9cb370

data/lib/sohm.rb

@@ -40,6 +40,7 @@ module Sohm
   class MissingID < Error; end
   class IndexNotFound < Error; end
   class CasViolation < Error; end
+  class NotSupported < Error; end
 
   # Instead of monkey patching Kernel or trying to be clever, it's
   # best to confine all the helper methods in a Utils module.
@@ -416,61 +417,6 @@ module Sohm
       @model = model
     end
 
-    # Chain new fiters on an existing set.
-    #
-    # Example:
-    #
-    #   set = User.find(:name => "John")
-    #   set.find(:age => 30)
-    #
-    def find(dict)
-      MultiSet.new(
-        namespace, model, Command[:sinterstore, key, *model.filters(dict)]
-      )
-    end
-
-    # Reduce the set using any number of filters.
-    #
-    # Example:
-    #
-    #   set = User.find(:name => "John")
-    #   set.except(:country => "US")
-    #
-    #   # You can also do it in one line.
-    #   User.find(:name => "John").except(:country => "US")
-    #
-    def except(dict)
-      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:
-    #
-    #   set = User.find(:name => "John")
-    #   set.union(:name => "Jane")
-    #
-    #   # You can also do it in one line.
-    #   User.find(:name => "John").union(:name => "Jane")
-    #
-    def union(dict)
-      MultiSet.new(namespace, model, key).union(dict)
-    end
-
   private
     def execute
       yield key
@@ -511,128 +457,6 @@ module Sohm
     end
   end
 
-  # Anytime you filter a set with more than one requirement, you
-  # internally use a `MultiSet`. `MultiSet` is a bit slower than just
-  # a `Set` because it has to `SINTERSTORE` all the keys prior to
-  # retrieving the members, size, etc.
-  #
-  # Example:
-  #
-  #   User.all.kind_of?(Sohm::Set)
-  #   # => true
-  #
-  #   User.find(:name => "John").kind_of?(Sohm::Set)
-  #   # => true
-  #
-  #   User.find(:name => "John", :age => 30).kind_of?(Sohm::MultiSet)
-  #   # => true
-  #
-  class MultiSet < BasicSet
-    attr :namespace
-    attr :model
-    attr :command
-
-    def initialize(namespace, model, command)
-      @namespace = namespace
-      @model = model
-      @command = command
-    end
-
-    # Chain new fiters on an existing set.
-    #
-    # Example:
-    #
-    #   set = User.find(:name => "John", :age => 30)
-    #   set.find(:status => 'pending')
-    #
-    def find(dict)
-      MultiSet.new(
-        namespace, model, Command[:sinterstore, command, intersected(dict)]
-      )
-    end
-
-    # Reduce the set using any number of filters.
-    #
-    # Example:
-    #
-    #   set = User.find(:name => "John")
-    #   set.except(:country => "US")
-    #
-    #   # You can also do it in one line.
-    #   User.find(:name => "John").except(:country => "US")
-    #
-    def except(dict)
-      MultiSet.new(
-        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
-
-    # Do a union to the existing set using any number of filters.
-    #
-    # Example:
-    #
-    #   set = User.find(:name => "John")
-    #   set.union(:name => "Jane")
-    #
-    #   # You can also do it in one line.
-    #   User.find(:name => "John").union(:name => "Jane")
-    #
-    def union(dict)
-      MultiSet.new(
-        namespace, model, Command[:sunionstore, command, intersected(dict)]
-      )
-    end
-
-  private
-    def redis
-      model.redis
-    end
-
-    def intersected(dict)
-      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.
-      # redis will be where all the commands are executed against.
-      response = command.call(namespace[:tmp], redis)
-
-      begin
-
-        # At this point, we have the final aggregated set, which we yield
-        # to the caller. the caller can do all the normal set operations,
-        # i.e. SCARD, SMEMBERS, etc.
-        yield response
-
-      ensure
-
-        # We have to make sure we clean up the temporary keys to avoid
-        # memory leaks and the unintended explosion of memory usage.
-        command.clean
-      end
-    end
-  end
-
   # The base class for all your models. In order to better understand
   # it, here is a semi-realtime explanation of the details involved
   # when creating a User instance.
@@ -655,33 +479,6 @@ module Sohm
   #   u.incr :points
   #   u.posts.add(Post.create)
   #
-  # When you execute `User.create(...)`, you run the following Redis
-  # commands:
-  #
-  #   # Generate an ID
-  #   INCR User:id
-  #
-  #   # Add the newly generated ID, (let's assume the ID is 1).
-  #   SADD User:all 1
-  #
-  #   # Store the unique index
-  #   HSET User:uniques:email foo@bar.com 1
-  #
-  #   # Store the name index
-  #   SADD User:indices:name:John 1
-  #
-  #   # Store the HASH
-  #   HMSET User:1 name John email foo@bar.com
-  #
-  # Next we increment points:
-  #
-  #   HINCR User:1:_counters points 1
-  #
-  # And then we add a Post to the `posts` set.
-  # (For brevity, let's assume the Post created has an ID of 1).
-  #
-  #   SADD User:1:posts 1
-  #
   class Model
     def self.redis=(redis)
       @redis = redis
@@ -788,16 +585,16 @@ module Sohm
     #   User.find(:tag => "python").include?(u)
     #   # => true
     #
-    #   User.find(:tag => ["ruby", "python"]).include?(u)
-    #   # => true
-    #
+    # Due to restrictions in Codis, we only support single-index query.
+    # If you want to query based on multiple fields, you can make an
+    # index based on all the fields.
     def self.find(dict)
       keys = filters(dict)
 
       if keys.size == 1
         Sohm::Set.new(keys.first, key, self)
       else
-        Sohm::MultiSet.new(key, self, Command.new(:sinterstore, *keys))
+        raise NotSupported
       end
     end
 
@@ -1101,17 +898,9 @@ module Sohm
     # Access the ID used to store this model. The ID is used together
     # with the name of the class in order to form the Redis key.
     #
-    # Example:
-    #
-    #   class User < Sohm::Model; end
-    #
-    #   u = User.create
-    #   u.id
-    #   # => 1
-    #
-    #   u.key
-    #   # => User:1
-    #
+    # Different from ohm, id must be provided by the user in sohm,
+    # if you want to use auto-generated id, you can include Sohm::AutoId
+    # module.
     def id
       raise MissingID if not defined?(@id)
       @id
@@ -1207,6 +996,18 @@ module Sohm
       @serial_attributes
     end
 
+    def counters
+      hash = {}
+      self.class.counters.each do |name|
+        hash[name] = 0
+      end
+      return hash if new?
+      redis.call("HGETALL", key[:_counters]).each_slice(2).each do |pair|
+        hash[pair[0].to_sym] = pair[1].to_i
+      end
+      hash
+    end
+
     # Export the ID of the model. The approach of Ohm is to
     # whitelist public attributes, as opposed to exporting each
     # (possibly sensitive) attribute.

data/sohm.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name = "sohm"
-  s.version = "0.9.0"
+  s.version = "0.10.0"
   s.summary = %{Slim ohm for twemproxy-like system}
   s.description = %Q{Slim ohm is a forked ohm that works with twemproxy-like redis system, only a limited set of features in ohm is supported}
   s.authors = ["Xuejie Xiao"]

data/test/indices.rb

@@ -56,16 +56,6 @@ test "avoid intersections with the all collection" do
   assert_equal "User:_indices:email:foo", User.find(:email => "foo").key
 end
 
-test "cleanup the temporary key after use" do
-  assert User.find(:email => "foo", :activation_code => "bar").to_a
-
-  assert Sohm.redis.call("KEYS", "User:temp:*").empty?
-end
-
-test "allow multiple chained finds" do
-  assert 1 == User.find(:email => "foo").find(:activation_code => "bar").find(:update => "baz").size
-end
-
 test "return nil if no results are found" do
   assert User.find(:email => "foobar").empty?
   assert nil == User.find(:email => "foobar").first

data/test/json.rb

@@ -45,16 +45,6 @@ test "exports a set to json" do
   assert_equal expected, Programmer.all.to_json
 end
 
-test "exports a multiset to json" do
-  Programmer.create(language: "Ruby")
-  Programmer.create(language: "Python")
-
-  expected = [{ id: "1", language: "Ruby" }, { id: "2", language: "Python"}].to_json
-  result   = Programmer.find(language: "Ruby").union(language: "Python").to_json
-
-  assert_equal expected, result
-end
-
 test "exports a list to json" do
   venue = Venue.create(name: "Foo")
 

data/test/model.rb

@@ -410,12 +410,6 @@ test "finding by one entry in the enumerable" do |entry|
   assert Entry.find(:tag => "baz").include?(entry)
 end
 
-test "finding by multiple entries in the enumerable" do |entry|
-  assert Entry.find(:tag => ["foo", "bar"]).include?(entry)
-  assert Entry.find(:tag => ["bar", "baz"]).include?(entry)
-  assert Entry.find(:tag => ["baz", "oof"]).empty?
-end
-
 # Attributes of type Set
 setup do
   @person1 = Person.create(:name => "Albert")
@@ -426,16 +420,6 @@ setup do
   @event.name = "Ruby Tuesday"
 end
 
-test "filter elements" do
-  @event.save
-  @event.attendees.add(@person1)
-  @event.attendees.add(@person2)
-
-  assert [@person1] == @event.attendees.find(:initial => "A").to_a
-  assert [@person2] == @event.attendees.find(:initial => "B").to_a
-  assert [] == @event.attendees.find(:initial => "Z").to_a
-end
-
 test "delete elements" do
   @event.save
   @event.attendees.add(@person1)

data/test/set.rb

@@ -26,16 +26,3 @@ test '#exists? returns true if the given id is included in the set' do
 
   assert user.posts.exists?(post.id)
 end
-
-test "#ids returns an array with the ids" do
-  user_ids = [
-    User.create(name: "John").id,
-    User.create(name: "Jane").id
-  ]
-
-  assert_equal user_ids, User.all.ids
-
-  result = User.find(name: "John").union(name: "Jane")
-
-  assert_equal user_ids, result.ids
-end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sohm
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
 platform: ruby
 authors:
 - Xuejie Xiao
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-27 00:00:00.000000000 Z
+date: 2015-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redic
@@ -81,17 +81,6 @@ files:
 - CHANGELOG.md
 - LICENSE
 - README.md
-- benchmarks/common.rb
-- benchmarks/create.rb
-- benchmarks/delete.rb
-- examples/activity-feed.rb
-- examples/chaining.rb
-- examples/json-hash.rb
-- examples/one-to-many.rb
-- examples/philosophy.rb
-- examples/redis-logging.txt
-- examples/slug.rb
-- examples/tagging.rb
 - lib/sohm.rb
 - lib/sohm/auto_id.rb
 - lib/sohm/command.rb
@@ -106,7 +95,6 @@ files:
 - test/core.rb
 - test/counters.rb
 - test/enumerable.rb
-- test/filtering.rb
 - test/hash_key.rb
 - test/helper.rb
 - test/indices.rb

data/benchmarks/common.rb

@@ -1,33 +0,0 @@
-require "bench"
-require_relative "../lib/ohm"
-
-Ohm.redis = Redic.new("redis://127.0.0.1:6379/15")
-Ohm.flush
-
-class Event < Ohm::Model
-  attribute :name
-  attribute :location
-
-  index :name
-  index :location
-
-  def validate
-    assert_present :name
-    assert_present :location
-  end
-end
-
-class Sequence
-  def initialize
-    @value = 0
-  end
-
-  def succ!
-    Thread.exclusive { @value += 1 }
-  end
-
-  def self.[](name)
-    @@sequences ||= Hash.new { |hash, key| hash[key] = Sequence.new }
-    @@sequences[name]
-  end
-end

data/benchmarks/create.rb

@@ -1,21 +0,0 @@
-require_relative "common"
-
-benchmark "Create Events" do
-  i = Sequence[:events].succ!
-
-  Event.create(:name => "Redis Meetup #{i}", :location => "London #{i}")
-end
-
-benchmark "Find by indexed attribute" do
-  Event.find(:name => "Redis Meetup 1").first
-end
-
-benchmark "Mass update" do
-  Event[1].update(:name => "Redis Meetup II")
-end
-
-benchmark "Load events" do
-  Event[1].name
-end
-
-run 5000

data/benchmarks/delete.rb

@@ -1,13 +0,0 @@
-require_relative "common"
-
-1000.times do |i|
-  Event.create(:name => "Redis Meetup #{i}", :location => "At my place")
-end
-
-benchmark "Delete event" do
-  Event.all.each do |event|
-    event.delete
-  end
-end
-
-run 1

data/examples/activity-feed.rb

@@ -1,162 +0,0 @@
-### Building an activity feed
-
-#### Common solutions using a relational design
-
-# When faced with this application requirement, the most common approach by
-# far have been to create an *activities* table, and rows in this table would
-# reference a *user*. Activities would typically be generated for each
-# follower (or friend) when a certain user performs an action, like posting a
-# new status update.
-
-#### Problems
-
-# The biggest issue with this design, is that the *activities* table will
-# quickly get very huge, at which point you would need to shard it on
-# *user_id*. Also, inserting thousands of entries per second would quickly
-# bring your database to its knees.
-
-#### Ohm Solution
-
-# As always we need to require `Ohm`.
-require "ohm"
-
-# We create a `User` class, with a `set` for all the other users he
-# would be `following`, and another `set` for all his `followers`.
-class User < Ohm::Model
-  set :followers, User
-  set :following, User
-
-  # Because a `User` literally has a `list` of activities, using a Redis
-  # `list` to model the activities would be a good choice. We default to
-  # getting the first 100 activities, and use
-  # [lrange](http://code.google.com/p/redis/wiki/LrangeCommand) directly.
-  def activities(start = 0, limit = 100)
-    key[:activities].lrange(start, start + limit)
-  end
-
-  # Broadcasting a message to all the `followers` of a user would simply
-  # be prepending the message for each if his `followers`. We also use
-  # the Redis command
-  # [lpush](http://code.google.com/p/redis/wiki/RpushCommand) directly.
-  def broadcast(str)
-    followers.each do |user|
-      user.key[:activities].lpush(str)
-    end
-  end
-
-  # Given that *Jane* wants to follow *John*, we simply do the following
-  # steps:
-  #
-  # 1. *John* is added to *Jane*'s `following` list.
-  # 2. *Jane* is added to *John*'s `followers` list.
-  def follow(other)
-    following << other
-    other.followers << self
-  end
-end
-
-
-#### Testing
-
-# We'll use cutest for our testing framework.
-require "cutest"
-
-# The database is flushed before each test.
-prepare { Ohm.flush }
-
-# We define two users, `john` and `jane`, and yield them so all
-# other tests are given access to these 2 users.
-setup do
-  john = User.create
-  jane = User.create
-
-  [john, jane]
-end
-
-# Let's verify our model for `follow`. When `jane` follows `john`,
-# the following conditions should hold:
-#
-# 1. The followers list of `john` is comprised *only* of `jane`.
-# 2. The list of users `jane` is following is comprised *only* of `john`.
-test "jane following john" do |john, jane|
-  jane.follow(john)
-
-  assert [john] == jane.following.to_a
-  assert [jane] == john.followers.to_a
-end
-
-# Broadcasting a message should simply notify all the followers of the
-# `broadcaster`.
-test "john broadcasting a message" do |john, jane|
-  jane.follow(john)
-  john.broadcast("Learning about Redis and Ohm")
-
-  assert jane.activities.include?("Learning about Redis and Ohm")
-end
-
-#### Total Denormalization: Adding HTML
-
-# This may be a real edge case design decision, but for some scenarios this
-# may work. The beauty of this solution is that you only have to generate the
-# output once, and successive refreshes of the end user will help you save
-# some CPU cycles.
-#
-# This example of course assumes that the code that generates this does all
-# the conditional checks (possibly changing the point of view like *Me:*
-# instead of *John says:*).
-test "broadcasting the html directly" do |john, jane|
-  jane.follow(john)
-
-  snippet = '<a href="/1">John</a> says: How\'s it going ' +
-            '<a href="/user/2">jane</a>?'
-
-  john.broadcast(snippet)
-
-  assert jane.activities.include?(snippet)
-end
-
-#### Saving Space
-
-# In most cases, users don't really care about keeping their entire activity
-# history. This application requirement would be fairly trivial to implement.
-
-# Let's reopen our `User` class and define a new broadcast method.
-class User
-  # We define a constant where we set the maximum number of activity entries.
-  MAX = 10
-
-  # Using `MAX` as the reference, we check if the number of activities exceeds
-  # `MAX`, and use
-  # [ltrim](http://code.google.com/p/redis/wiki/LtrimCommand) to truncate
-  # the activities.
-  def broadcast(str)
-    followers.each do |user|
-      user.key[:activities].lpush(str)
-
-      if user.key[:activities].llen > MAX
-        user.key[:activities].ltrim(0, MAX - 1)
-      end
-    end
-  end
-end
-
-# Now let's verify that this new behavior is enforced.
-test "pushing 11 activities maintains the list to 10" do |john, jane|
-  jane.follow(john)
-
-  11.times { john.broadcast("Flooding your feed!") }
-
-  assert 10 == jane.activities.size
-end
-
-
-#### Conclusion
-
-# As you can see, choosing a more straightforward approach (in this case,
-# actually having a list per user, instead of maintaining a separate
-# `activities` table) will greatly simplify the design of your system.
-#
-# As a final note, keep in mind that the Ohm solution would still need
-# sharding for large datasets, but that would be again trivial to implement
-# using [redis-rb](http://github.com/ezmobius/redis-rb)'s distributed support
-# and sharding it against the *user_id*.