ohm 0.1.0.rc5 → 0.1.0.rc6

data/Rakefile

@@ -20,22 +20,11 @@ desc "Stop the Redis server"
 task :stop do
   if File.exists?(REDIS_PID)
     system "kill #{File.read(REDIS_PID)}"
-    system "rm #{REDIS_PID}"
   end
 end
 
 task :test do
-  require File.expand_path(File.join(File.dirname(__FILE__), "test", "test_helper"))
+  require File.expand_path("./test/helper", File.dirname(__FILE__))
 
-  Dir["test/**/*_test.rb"].each_with_index do |file, index|
-    ENV["REDIS_URL"] = "redis://127.0.0.1:6379/#{index}"
-
-    fork do
-      load file
-    end
-
-    exit $?.exitstatus unless $?.success?
-  end
-
-  Process.waitall
+  Cutest.run(Dir["test/*_test.rb"])
 end

data/lib/ohm.rb

@@ -2,6 +2,7 @@
 
 require "base64"
 require "redis"
+require "nest"
 
 require File.join(File.dirname(__FILE__), "ohm", "pattern")
 require File.join(File.dirname(__FILE__), "ohm", "validations")
@@ -11,15 +12,15 @@ require File.join(File.dirname(__FILE__), "ohm", "key")
 module Ohm
 
   # Provides access to the Redis database. This is shared accross all models and instances.
-  def redis
+  def self.redis
     threaded[:redis] ||= connection(*options)
   end
 
-  def redis=(connection)
+  def self.redis=(connection)
     threaded[:redis] = connection
   end
 
-  def threaded
+  def self.threaded
     Thread.current[:ohm] ||= {}
   end
 
@@ -32,31 +33,29 @@ module Ohm
   # @option options [#to_s] :timeout (0) Database timeout in seconds.
   # @example Connect to a database in port 6380.
   #   Ohm.connect(:port => 6380)
-  def connect(*options)
+  def self.connect(*options)
     self.redis = nil
     @options = options
   end
 
   # Return a connection to Redis.
   #
-  # This is a wapper around Redis.new(options)
-  def connection(*options)
-    Redis.new(*options)
+  # This is a wapper around Redis.connect(options)
+  def self.connection(*options)
+    Redis.connect(*options)
   end
 
-  def options
+  def self.options
     @options = [] unless defined? @options
     @options
   end
 
   # Clear the database.
-  def flush
+  def self.flush
     redis.flushdb
   end
 
-  module_function :connect, :connection, :flush, :redis, :redis=, :options, :threaded
-
-  Error = Class.new(StandardError)
+  class Error < StandardError; end
 
   class Model
 
@@ -106,20 +105,14 @@ module Ohm
         self << model
       end
 
-      def first(options = {})
-        if options[:by]
-          sort_by(options.delete(:by), options.merge(:limit => 1)).first
-        else
-          model[key.first(options)]
-        end
-      end
+      def sort(_options = {})
+        return [] unless key.exists
 
-      def [](index)
-        model[key[index]]
-      end
+        options = _options.dup
+        options[:start] ||= 0
+        options[:limit] = [options[:start], options[:limit]] if options[:limit]
 
-      def sort(*args)
-        key.sort(*args).map(&model)
+        key.sort(options).map(&model)
       end
 
       # Sort the model instances by the given attribute.
@@ -132,11 +125,14 @@ module Ohm
       #   user = User.all.sort_by(:name, :order => "ALPHA").first
       #   user.name == "A"
       #   # => true
-      def sort_by(att, options = {})
-        options.merge!(:by => model.key("*->#{att}"))
+      def sort_by(att, _options = {})
+        return [] unless key.exists
+
+        options = _options.dup
+        options.merge!(:by => model.key["*->#{att}"])
 
         if options[:get]
-          key.sort(options.merge(:get => model.key("*->#{options[:get]}")))
+          key.sort(options.merge(:get => model.key["*->#{options[:get]}"]))
         else
           sort(options)
         end
@@ -146,14 +142,11 @@ module Ohm
         key.del
       end
 
-      def concat(models)
-        models.each { |model| add(model) }
-        self
-      end
-
       def replace(models)
-        clear
-        concat(models)
+        model.db.multi do
+          clear
+          models.each { |model| add(model) }
+        end
       end
 
       def empty?
@@ -204,38 +197,8 @@ module Ohm
         apply(:sdiffstore, key, source, target)
       end
 
-      def sort(options = {})
-        return [] unless key.exists
-
-        options[:start] ||= 0
-        options[:limit] = [options[:start], options[:limit]] if options[:limit]
-
-        key.sort(options).map(&model)
-      end
-
-      # Sort the model instances by the given attribute.
-      #
-      # @example Sorting elements by name:
-      #
-      #   User.create :name => "B"
-      #   User.create :name => "A"
-      #
-      #   user = User.all.sort_by(:name, :order => "ALPHA").first
-      #   user.name == "A"
-      #   # => true
-      def sort_by(att, options = {})
-        return [] unless key.exists
-
-        options.merge!(:by => model.key["*->#{att}"])
-
-        if options[:get]
-          key.sort(options.merge(:get => model.key["*->#{options[:get]}"]))
-        else
-          sort(options)
-        end
-      end
-
-      def first(options = {})
+      def first(_options = {})
+        options = _options.dup
         options.merge!(:limit => 1)
 
         if options[:by]
@@ -314,13 +277,11 @@ module Ohm
       end
 
       def pop
-        id = key.rpop
-        model[id] if id
+        model[key.rpop]
       end
 
       def shift
-        id = key.lpop
-        model[id] if id
+        model[key.lpop]
       end
 
       def unshift(model)
@@ -570,7 +531,7 @@ module Ohm
     end
 
     def self.[](id)
-      new(:id => id) if exists?(id)
+      new(:id => id) if id && exists?(id)
     end
 
     def self.to_proc
@@ -675,7 +636,7 @@ module Ohm
     # @param att [Symbol] Attribute to increment.
     def incr(att, count = 1)
       raise ArgumentError, "#{att.inspect} is not a counter." unless counters.include?(att)
-      write_local(att, db.hincrby(key, att, count))
+      write_local(att, key.hincrby(att, count))
     end
 
     # Decrement the counter denoted by :att.
@@ -807,13 +768,13 @@ module Ohm
         atts = (attributes + counters).inject([]) { |ret, att|
           value = send(att).to_s
 
-          ret.push(att, value)  if not value.empty?
+          ret.push(att, value) if not value.empty?
           ret
         }
 
         db.multi do
-          db.del(key)
-          db.hmset(key, *atts.flatten)  if atts.any?
+          key.del
+          key.hmset(*atts.flatten) if atts.any?
         end
       end
     end
@@ -822,9 +783,9 @@ module Ohm
       write_local(att, value)
 
       if value.to_s.empty?
-        db.hdel(key, att)
+        key.hdel(att)
       else
-        db.hset(key, att, value)
+        key.hset(att, value)
       end
     end
 
@@ -856,11 +817,11 @@ module Ohm
     end
 
     def self.exists?(id)
-      db.sismember(key[:all], id)
+      key[:all].sismember(id)
     end
 
     def initialize_id
-      self.id = db.incr(self.class.key[:id]).to_s
+      @id ||= self.class.key[:id].incr.to_s
     end
 
     def db
@@ -876,7 +837,7 @@ module Ohm
     end
 
     def delete_model_membership
-      db.del(key)
+      key.del
       self.class.all.delete(self)
     end
 
@@ -903,16 +864,16 @@ module Ohm
 
     def add_to_index(att, value = send(att))
       index = index_key_for(att, value)
-      db.sadd(index, id)
-      db.sadd(key[:_indices], index)
+      index.sadd(id)
+      key[:_indices].sadd(index)
     end
 
     def delete_from_indices
-      db.smembers(key[:_indices]).each do |index|
+      key[:_indices].smembers.each do |index|
         db.srem(index, id)
       end
 
-      db.del(key[:_indices])
+      key[:_indices].del
     end
 
     def read_local(att)
@@ -925,7 +886,7 @@ module Ohm
 
     def read_remote(att)
       unless new?
-        value = db.hget(key, att)
+        value = key.hget(att)
         value.respond_to?(:force_encoding) ?
           value.force_encoding("UTF-8") :
           value
@@ -959,27 +920,23 @@ module Ohm
     #
     # @see Model#mutex
     def lock!
-      until db.setnx(key[:_lock], lock_timeout)
-        next unless lock = db.get(key[:_lock])
-        sleep(0.5) and next unless lock_expired?(lock)
+      until key[:_lock].setnx(Time.now.to_f + 0.5)
+        next unless timestamp = key[:_lock].get
+        sleep(0.1) and next unless lock_expired?(timestamp)
 
-        break unless lock = db.getset(key[:_lock], lock_timeout)
-        break if lock_expired?(lock)
+        break unless timestamp = key[:_lock].getset(Time.now.to_f + 0.5)
+        break if lock_expired?(timestamp)
       end
     end
 
     # Release the lock.
     # @see Model#mutex
     def unlock!
-      db.del(key[:_lock])
-    end
-
-    def lock_timeout
-      Time.now.to_f + 1
+      key[:_lock].del
     end
 
-    def lock_expired? lock
-      lock.to_f < Time.now.to_f
+    def lock_expired? timestamp
+      timestamp.to_f < Time.now.to_f
     end
   end
 end

data/lib/ohm/key.rb

@@ -1,44 +1,17 @@
 module Ohm
 
   # Represents a key in Redis.
-  class Key < String
-    attr :redis
-
-    def initialize(name, redis = nil)
-      @redis = redis
-      super(name.to_s)
-    end
-
-    def [](key)
-      self.class.new("#{self}:#{key}", @redis)
-    end
-
+  class Key < Nest
     def volatile
-      self.index("~") == 0 ? self : self.class.new("~", @redis)[self]
+      self.index("~") == 0 ? self : self.class.new("~", redis)[self]
     end
 
     def +(other)
-      self.class.new("#{self}+#{other}", @redis)
+      self.class.new("#{self}+#{other}", redis)
     end
 
     def -(other)
-      self.class.new("#{self}-#{other}", @redis)
-    end
-
-    [:append, :blpop, :brpop, :decr, :decrby, :del, :exists, :expire,
-    :expireat, :get, :getset, :hdel, :hexists, :hget, :hgetall,
-    :hincrby, :hkeys, :hlen, :hmget, :hmset, :hset, :hvals, :incr,
-    :incrby, :lindex, :llen, :lpop, :lpush, :lrange, :lrem, :lset,
-    :ltrim, :move, :rename, :renamenx, :rpop, :rpoplpush, :rpush,
-    :sadd, :scard, :sdiff, :sdiffstore, :set, :setex, :setnx, :sinter,
-    :sinterstore, :sismember, :smembers, :smove, :sort, :spop,
-    :srandmember, :srem, :substr, :sunion, :sunionstore, :ttl, :type,
-    :zadd, :zcard, :zincrby, :zinterstore, :zrange, :zrangebyscore,
-    :zrank, :zrem, :zremrangebyrank, :zremrangebyscore, :zrevrange,
-    :zrevrank, :zscore, :zunionstore].each do |meth|
-      define_method(meth) do |*args|
-        redis.send(meth, self, *args)
-      end
+      self.class.new("#{self}-#{other}", redis)
     end
   end
 end

data/lib/ohm/version.rb

@@ -1,5 +1,5 @@
 # encoding: UTF-8
 
 module Ohm
-  VERSION = "0.1.0.rc5"
+  VERSION = "0.1.0.rc6"
 end

data/test/1.8.6_test.rb

@@ -1,25 +1,25 @@
-require File.expand_path(File.join(File.dirname(__FILE__), "test_helper"))
+# encoding: UTF-8
 
-class TestString < Test::Unit::TestCase
-  context "String#lines" do
-    should "return the parts when separated with \\n" do
-      assert_equal ["a\n", "b\n", "c\n"], "a\nb\nc\n".lines.to_a
-    end
+require File.expand_path("./helper", File.dirname(__FILE__))
 
-    should "return the parts when separated with \\r\\n" do
-      assert_equal ["a\r\n", "b\r\n", "c\r\n"], "a\r\nb\r\nc\r\n".lines.to_a
-    end
+prepare.clear
 
-    should "accept a record separator" do
-      assert_equal ["ax", "bx", "cx"], "axbxcx".lines("x").to_a
-    end
+test "String#lines should return the parts when separated with \\n" do
+  assert ["a\n", "b\n", "c\n"] == "a\nb\nc\n".lines.to_a
+end
+
+test "String#lines return the parts when separated with \\r\\n" do
+  assert ["a\r\n", "b\r\n", "c\r\n"] == "a\r\nb\r\nc\r\n".lines.to_a
+end
+
+test "String#lines accept a record separator" do
+  assert ["ax", "bx", "cx"] == "axbxcx".lines("x").to_a
+end
 
-    should "execute the passed block" do
-      lines = ["a\r\n", "b\r\n", "c\r\n"]
+test "String#lines execute the passed block" do
+  lines = ["a\r\n", "b\r\n", "c\r\n"]
 
-      "a\r\nb\r\nc\r\n".lines do |line|
-        assert_equal lines.shift, line
-      end
-    end
+  "a\r\nb\r\nc\r\n".lines do |line|
+    assert lines.shift == line
   end
 end

data/test/associations_test.rb

@@ -0,0 +1,100 @@
+# encoding: UTF-8
+
+require File.expand_path("./helper", File.dirname(__FILE__))
+
+class Person < Ohm::Model
+  attribute :name
+end
+
+class ::Note < Ohm::Model
+  attribute :content
+  reference :source, Post
+  collection :comments, Comment
+  list :ratings, Rating
+end
+
+class ::Comment < Ohm::Model
+  reference :note, Note
+end
+
+class ::Rating < Ohm::Model
+  attribute :value
+end
+
+class ::Editor < Ohm::Model
+  attribute :name
+  reference :post, Post
+end
+
+class ::Post < Ohm::Model
+  reference :author, Person
+  collection :notes, Note, :source
+  collection :editors, Editor
+end
+
+setup do
+  @post = Post.create
+end
+
+test "return an instance of Person if author_id has a valid id" do
+  @post.author_id = Person.create(:name => "Albert").id
+  @post.save
+  assert "Albert" == Post[@post.id].author.name
+end
+
+test "assign author_id if author is sent a valid instance" do
+  @post.author = Person.create(:name => "Albert")
+  @post.save
+  assert "Albert" == Post[@post.id].author.name
+end
+
+test "assign nil if nil is passed to author" do
+  @post.author = nil
+  @post.save
+  assert Post[@post.id].author.nil?
+end
+
+test "be cached in an instance variable" do
+  @author = Person.create(:name => "Albert")
+  @post.update(:author => @author)
+
+  assert @author == @post.author
+  assert @post.author.object_id == @post.author.object_id
+
+  @post.update(:author => Person.create(:name => "Bertrand"))
+
+  assert "Bertrand" == @post.author.name
+  assert @post.author.object_id == @post.author.object_id
+
+  @post.update(:author_id => Person.create(:name => "Charles").id)
+
+  assert "Charles" == @post.author.name
+end
+
+setup do
+  @post = Post.create
+  @note = Note.create(:content => "Interesting stuff", :source => @post)
+  @comment = Comment.create(:note => @note)
+end
+
+test "return a set of notes" do
+  assert @note.source == @post
+  assert @note == @post.notes.first
+end
+
+test "return a set of comments" do
+  assert @comment == @note.comments.first
+end
+
+test "return a list of ratings" do
+  @rating = Rating.create(:value => 5)
+  @note.ratings << @rating
+
+  assert @rating == @note.ratings.first
+end
+
+test "default to the current class name" do
+  @editor = Editor.create(:name => "Albert", :post => @post)
+
+  assert @editor == @post.editors.first
+end