ohm 0.0.31 → 0.0.32

data/README.markdown

@@ -106,13 +106,13 @@ when you retrieve the value.
 
 A `set` in Redis is an unordered list, with an external behavior similar
 to that of Ruby arrays, but optimized for faster membership lookups.
-It's used internaly by Ohm to keep track of the instances of each model
+It's used internally by Ohm to keep track of the instances of each model
 and for generating and maintaining indexes.
 
 ### list
 
-A `list` is like an array in Ruby. It's perfectly suited for queues and
-for keeping elements in order.
+A `list` is like an array in Ruby. It's perfectly suited for queues
+and for keeping elements in order.
 
 ### counter
 
@@ -122,16 +122,45 @@ the value, but you can not assign it. In the example above, we used a
 counter attribute for tracking votes. As the incr and decr operations
 are atomic, you can rest assured a vote won't be counted twice.
 
+Persistence strategy
+--------------------
+
+The attributes declared with `attribute` are only persisted after
+calling `save`. If the object is in an invalid state, no value is sent
+to Redis (see the section on **Validations** below).
+
+Operations on attributes of type `list`, `set` and `counter` are
+possible only after the object is created (when it has an assigned
+`id`). Any operation on these kinds of attributes is performed
+immediately, without running the object validations. This design yields
+better performance than running the validations on each operation or
+buffering the operations and waiting for a call to `save`.
+
+For most use cases, this pattern doesn't represent a problem.
+If you need to check for validity before operating on lists, sets or
+counters, you can use this pattern:
+
+    if event.valid?
+      event.comments << "Great event!"
+    end
+
+If you are saving the object, this will suffice:
+
+    if event.save
+      event.comments << "Wonderful event!"
+    end
+
+
 Associations
 ------------
 
 Ohm lets you use collections (lists and sets) to represent associations.
-For this, you only need to provide a second paramenter when declaring a
+For this, you only need to provide a second parameter when declaring a
 list or a set:
 
     set :attendees, Person
 
-After this, everytime you refer to `event.attendees` you will be talking
+After this, every time you refer to `event.attendees` you will be talking
 about instances of the model `Person`. If you want to get the raw values
 of the set, you can use `event.attendees.raw`.
 

data/lib/ohm.rb

@@ -183,6 +183,8 @@ module Ohm
         db.rpush(key, value)
       end
 
+      alias push <<
+
       # @return [String] Return and remove the last element of the list.
       def pop
         db.rpop(key)
@@ -353,16 +355,6 @@ module Ohm
       end
     end
 
-    class RedefinitionError < Error
-      def initialize(att)
-        @att = att
-      end
-
-      def message
-        "Cannot redefine #{@att.inspect}"
-      end
-    end
-
     @@attributes = Hash.new { |hash, key| hash[key] = [] }
     @@collections = Hash.new { |hash, key| hash[key] = [] }
     @@counters = Hash.new { |hash, key| hash[key] = [] }
@@ -379,8 +371,6 @@ module Ohm
     #
     # @param name [Symbol] Name of the attribute.
     def self.attribute(name)
-      raise RedefinitionError, name if attributes.include?(name)
-
       define_method(name) do
         read_local(name)
       end
@@ -389,7 +379,7 @@ module Ohm
         write_local(name, value)
       end
 
-      attributes << name
+      attributes << name unless attributes.include?(name)
     end
 
     # Defines a counter attribute for the model. This attribute can't be assigned, only incremented
@@ -397,13 +387,11 @@ module Ohm
     #
     # @param name [Symbol] Name of the counter.
     def self.counter(name)
-      raise RedefinitionError, name if counters.include?(name)
-
       define_method(name) do
         read_local(name).to_i
       end
 
-      counters << name
+      counters << name unless counters.include?(name)
     end
 
     # Defines a list attribute for the model. It can be accessed only after the model instance
@@ -411,10 +399,8 @@ module Ohm
     #
     # @param name [Symbol] Name of the list.
     def self.list(name, model = nil)
-      raise RedefinitionError, name if collections.include?(name)
-
       attr_list_reader(name, model)
-      collections << name
+      collections << name unless collections.include?(name)
     end
 
     # Defines a set attribute for the model. It can be accessed only after the model instance
@@ -423,10 +409,8 @@ module Ohm
     #
     # @param name [Symbol] Name of the set.
     def self.set(name, model = nil)
-      raise RedefinitionError, name if collections.include?(name)
-
       attr_set_reader(name, model)
-      collections << name
+      collections << name unless collections.include?(name)
     end
 
     # Creates an index (a set) that will be used for finding instances.
@@ -445,9 +429,7 @@ module Ohm
     #
     # @param name [Symbol] Name of the attribute to be indexed.
     def self.index(att)
-      raise RedefinitionError, att if indices.include?(att)
-
-      indices << att
+      indices << att unless indices.include?(att)
     end
 
     def self.attr_list_reader(name, model = nil)
@@ -602,7 +584,7 @@ module Ohm
       false
     end
 
-    # Lock the object before ejecuting the block, and release it once the block is done.
+    # Lock the object before executing the block, and release it once the block is done.
     def mutex
       lock!
       yield
@@ -761,9 +743,18 @@ module Ohm
     end
 
     # Lock the object so no other instances can modify it.
+    # This method implements the design pattern for locks
+    # described at: http://code.google.com/p/redis/wiki/SetnxCommand
+    #
     # @see Model#mutex
     def lock!
-      lock = db.setnx(key(:_lock), 1) until lock == 1
+      until db.setnx(key(:_lock), lock_timeout)
+        next unless lock = db.get(key(:_lock))
+        sleep(0.5) and next unless lock_expired?(lock)
+
+        break unless lock = db.getset(key(:_lock), lock_timeout)
+        break if lock_expired?(lock)
+      end
     end
 
     # Release the lock.
@@ -771,5 +762,13 @@ module Ohm
     def unlock!
       db.del(key(:_lock))
     end
+
+    def lock_timeout
+      Time.now.to_f + 1
+    end
+
+    def lock_expired? lock
+      lock.to_f < Time.now.to_f
+    end
   end
 end

data/lib/ohm/redis.rb

@@ -7,19 +7,19 @@
 # http://github.com/ezmobius/redis-rb/
 require 'socket'
 
-begin
-  if (RUBY_VERSION >= '1.9')
-    require 'timeout'
-    RedisTimer = Timeout
-  else
-    require 'system_timer'
-    RedisTimer = SystemTimer
+module Ohm
+  begin
+    if (RUBY_VERSION >= '1.9')
+      require 'timeout'
+      RedisTimer = Timeout
+    else
+      require 'system_timer'
+      RedisTimer = SystemTimer
+    end
+  rescue LoadError
+    RedisTimer = nil
   end
-rescue LoadError
-  RedisTimer = nil
-end
 
-module Ohm
   class Redis
     class ProtocolError < RuntimeError
       def initialize(reply_type)
@@ -42,6 +42,7 @@ module Ohm
       :smove => true,
       :srem => true,
       :zadd => true,
+      :zincrby => true,
       :zrem => true,
       :zscore => true
     }
@@ -136,13 +137,13 @@ module Ohm
       # socket instead will be supported anyway.
       if @timeout != 0 and RedisTimer
         begin
-          @sock = TCPSocket.new(host, port, 0)
+          @sock = TCPSocket.new(host, port)
         rescue Timeout::Error
           @sock = nil
           raise Timeout::Error, "Timeout connecting to the server"
         end
       else
-        @sock = TCPSocket.new(host, port, 0)
+        @sock = TCPSocket.new(host, port)
       end
 
       @sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
@@ -184,7 +185,7 @@ module Ohm
     def call_command(argv)
       connect unless connected?
       raw_call_command(argv.dup)
-    rescue Errno::ECONNRESET, Errno::EPIPE
+    rescue Errno::ECONNRESET, Errno::EPIPE, Errno::ECONNABORTED
       if reconnect
         raw_call_command(argv.dup)
       else

data/test/indices_test.rb

@@ -165,4 +165,37 @@ class IndicesTest < Test::Unit::TestCase
       assert_equal [user], User.find(:update => "CORRECTED - UPDATE 2-Suspected US missile strike kills 5 in Pakistan")
     end
   end
+
+  context "New indices" do
+    should "populate a new index when the model is saved" do
+      class Event < Ohm::Model
+        attribute :name
+      end
+
+      foo = Event.create(:name => "Foo")
+
+      assert_raise(Ohm::Model::IndexNotFound) { Event.find(:name => "Foo") }
+
+      class Event < Ohm::Model
+        index :name
+      end
+
+      # Find works correctly once the index is added.
+      assert_nothing_raised { Event.find(:name => "Foo") }
+
+      # The index was added after foo was created.
+      assert Event.find(:name => "Foo").empty?
+
+      bar = Event.create(:name => "Bar")
+
+      # Bar was indexed properly.
+      assert_equal bar, Event.find(:name => "Bar").first
+
+      # Saving all the objects populates the indices.
+      Event.all.each { |e| e.save }
+
+      # Now foo is indexed.
+      assert_equal foo, Event.find(:name => "Foo").first
+    end
+  end
 end

data/test/model_test.rb

@@ -99,8 +99,8 @@ class TestRedis < Test::Unit::TestCase
   end
 
   context "Model definition" do
-    should "raise if an attribute is redefined" do
-      assert_raise Ohm::Model::RedefinitionError do
+    should "not raise if an attribute is redefined" do
+      assert_nothing_raised do
         class RedefinedModel < Ohm::Model
           attribute :name
           attribute :name
@@ -108,8 +108,8 @@ class TestRedis < Test::Unit::TestCase
       end
     end
 
-    should "raise if a counter is redefined" do
-      assert_raise Ohm::Model::RedefinitionError do
+    should "not raise if a counter is redefined" do
+      assert_nothing_raised do
         class RedefinedModel < Ohm::Model
           counter :age
           counter :age
@@ -117,8 +117,8 @@ class TestRedis < Test::Unit::TestCase
       end
     end
 
-    should "raise if a list is redefined" do
-      assert_raise Ohm::Model::RedefinitionError do
+    should "not raise if a list is redefined" do
+      assert_nothing_raised do
         class RedefinedModel < Ohm::Model
           list :todo
           list :todo
@@ -126,8 +126,8 @@ class TestRedis < Test::Unit::TestCase
       end
     end
 
-    should "raise if a set is redefined" do
-      assert_raise Ohm::Model::RedefinitionError do
+    should "not raise if a set is redefined" do
+      assert_nothing_raised do
         class RedefinedModel < Ohm::Model
           set :friends
           set :friends
@@ -135,8 +135,8 @@ class TestRedis < Test::Unit::TestCase
       end
     end
 
-    should "raise if a collection is redefined" do
-      assert_raise Ohm::Model::RedefinitionError do
+    should "not raise if a collection is redefined" do
+      assert_nothing_raised do
         class RedefinedModel < Ohm::Model
           list :toys
           set :toys
@@ -144,8 +144,8 @@ class TestRedis < Test::Unit::TestCase
       end
     end
 
-    should "raise if a index is redefined" do
-      assert_raise Ohm::Model::RedefinitionError do
+    should "not raise if a index is redefined" do
+      assert_nothing_raised do
         class RedefinedModel < Ohm::Model
           attribute :color
           index :color
@@ -453,6 +453,13 @@ class TestRedis < Test::Unit::TestCase
       assert @post.comments.all.kind_of?(Array)
     end
 
+    should "append elements with push" do
+      @post.comments.push "1"
+      @post.comments << "2"
+
+      assert_equal ["1", "2"], @post.comments.all
+    end
+
     should "keep the inserting order" do
       @post.comments << "1"
       @post.comments << "2"

data/test/mutex_test.rb

@@ -32,5 +32,58 @@ class TestMutex < Test::Unit::TestCase
       p2.join
       assert t2 > t1
     end
+
+    should "allow an instance to lock a record if the previous lock is expired" do
+      @p1.send(:lock!)
+      @p2.mutex do
+        assert true
+      end
+    end
+
+    should "work if two clients are fighting for the lock" do
+      @p1.send(:lock!)
+      @p3 = Person[1]
+      @p4 = Person[1]
+
+      assert_nothing_raised do
+        p1 = Thread.new { @p1.mutex {} }
+        p2 = Thread.new { @p2.mutex {} }
+        p3 = Thread.new { @p3.mutex {} }
+        p4 = Thread.new { @p4.mutex {} }
+        p1.join
+        p2.join
+        p3.join
+        p4.join
+      end
+    end
+
+    should "yield the right result after a lock fight" do
+      class Candidate < Ohm::Model
+        attribute :name
+        counter :votes
+      end
+
+      @candidate = Candidate.create :name => "Foo"
+      @candidate.send(:lock!)
+
+      threads = []
+
+      n = 10
+      m = 9
+
+      n.times do |i|
+        threads << Thread.new do
+          m.times do |i|
+            @candidate.mutex do
+              sleep 0.1
+              @candidate.incr(:votes)
+            end
+          end
+        end
+      end
+
+      threads.each { |t| t.join }
+      assert_equal n * m, @candidate.votes
+    end
   end
 end

data/test/redis_test.rb

@@ -386,6 +386,23 @@ class RedisTest < Test::Unit::TestCase
       end
     end
 
+    should "increment by a certain amount the score of a zset ZINCRBY" do
+      assert_equal 0, @r.zcard("league")
+
+      @r.zincrby "league", 1, "foo"
+      assert_equal "1", @r.zscore("league", "foo")
+
+      assert_equal 1, @r.zcard("league")
+
+      @r.zincrby "league", 10, "foo"
+      assert_equal "11", @r.zscore("league", "foo")
+
+      @r.set "bar", "2"
+      assert_raises do
+        @r.zincrby "bar", 2, "baz"
+      end
+    end
+
     should "provide info" do
       %w(last_save_time redis_version total_connections_received connected_clients total_commands_processed connected_slaves uptime_in_seconds used_memory uptime_in_days changes_since_last_save).each do |x|
         assert @r.info.keys.include?(x)

data/test/test_helper.rb

@@ -8,5 +8,5 @@ end
 require "contest"
 require File.dirname(__FILE__) + "/../lib/ohm"
 
-Ohm.connect(:port => 6381)
+Ohm.connect(:port => 6381, :db => 1, :timeout => 3)
 Ohm.flush

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ohm
 version: !ruby/object:Gem::Version 
-  version: 0.0.31
+  version: 0.0.32
 platform: ruby
 authors: 
 - Michel Martens
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-26 00:00:00 -03:00
+date: 2010-01-13 00:00:00 -03:00
 default_executable: 
 dependencies: []