ohm 0.0.2 → 0.0.3

data/lib/ohm.rb

@@ -1,48 +1,14 @@
 require "rubygems"
 require "redis"
+require File.join(File.dirname(__FILE__), "ohm", "validations")
 
 module Ohm
-  module Validations
-    def valid?
-      errors.clear
-      validate
-      errors.empty?
-    end
-
-    def validate
-    end
-
-    def errors
-      @errors ||= []
-    end
-
-  private
-
-    def assert_format(att, format)
-      if assert_present(att)
-        assert attribute(att).match(format), [att, :format]
-      end
-    end
-
-    def assert_present(att)
-      if assert_not_nil(att)
-        assert attribute(att).any?, [att, :empty]
-      end
-    end
-
-    def assert_not_nil(att)
-      assert attribute(att), [att, :nil]
-    end
-
-    def assert(value, error)
-      value or errors.push(error) && false
-    end
-
-    def attribute(att)
-      instance_variable_get("@#{att}")
-    end
+  def key(*args)
+    args.join(":")
   end
 
+  module_function :key
+
   module Attributes
     class Collection < Array
       attr_accessor :key, :db
@@ -84,18 +50,34 @@ module Ohm
   end
 
   class Model
+    module Validations
+      include Ohm::Validations
+
+      def assert_unique(attrs)
+        index_key = index_key_for(attrs, read_locals(attrs))
+        assert(db.set_count(index_key).zero? || db.set_member?(index_key, id), [attrs, :not_unique])
+      end
+    end
+
     include Validations
 
     ModelIsNew = Class.new(StandardError)
 
     @@attributes = Hash.new { |hash, key| hash[key] = [] }
     @@collections = Hash.new { |hash, key| hash[key] = [] }
+    @@indices = Hash.new { |hash, key| hash[key] = [] }
 
     attr_accessor :id
 
     def self.attribute(name)
-      attr_writer(name)
-      attr_value_reader(name)
+      define_method(name) do
+        read_local(name)
+      end
+
+      define_method(:"#{name}=") do |value|
+        write_local(name, value)
+      end
+
       attributes << name
     end
 
@@ -109,13 +91,8 @@ module Ohm
       collections << name
     end
 
-    # TODO Encapsulate access to db?
-    def self.attr_value_reader(name)
-      class_eval <<-EOS
-        def #{name}
-          @#{name} ||= db[key("#{name}")]
-        end
-      EOS
+    def self.index(attrs)
+      indices << attrs
     end
 
     def self.attr_list_reader(name)
@@ -139,9 +116,7 @@ module Ohm
     end
 
     def self.all
-      filter(:all).map do |id|
-        new(:id => id)
-      end
+      filter(:all)
     end
 
     def self.attributes
@@ -152,11 +127,24 @@ module Ohm
       @@collections[self]
     end
 
+    def self.indices
+      @@indices[self]
+    end
+
     def self.create(*args)
       new(*args).create
     end
 
+    # TODO Add a method that receives several arguments and returns a
+    # string with the values separated by colons.
+    def self.find(attribute, value)
+      # filter("#{attribute}:#{value}")
+      filter(Ohm.key(attribute, value))
+    end
+
     def initialize(attrs = {})
+      @_attributes = Hash.new {|hash,key| hash[key] = read_remote(key) }
+
       attrs.each do |key, value|
         send(:"#{key}=", value)
       end
@@ -166,15 +154,18 @@ module Ohm
       return unless valid?
       initialize_id
       create_model_membership
+      add_to_indices
       save!
     end
 
     def save
       return unless valid?
+      update_indices
       save!
     end
 
     def delete
+      delete_from_indices
       delete_attributes(collections)
       delete_attributes(attributes)
       delete_model_membership
@@ -189,6 +180,23 @@ module Ohm
       self.class.collections
     end
 
+    def indices
+      self.class.indices
+    end
+
+    def ==(other)
+      other.key == key
+    rescue ModelIsNew
+      false
+    end
+
+  protected
+
+    def key(*args)
+      raise ModelIsNew unless id
+      self.class.key(id, *args)
+    end
+
   private
 
     def self.db
@@ -196,11 +204,13 @@ module Ohm
     end
 
     def self.key(*args)
-      args.unshift(self).join(":")
+      Ohm.key(*args.unshift(self))
     end
 
     def self.filter(name)
-      db.set_members(key(name))
+      db.set_members(key(name)).map do |id|
+        new(:id => id)
+      end
     end
 
     def self.exists?(id)
@@ -215,11 +225,6 @@ module Ohm
       self.class.db
     end
 
-    def key(*args)
-      raise ModelIsNew unless id
-      self.class.key(id, *args)
-    end
-
     def delete_attributes(atts)
       atts.each do |att|
         db.delete(key(att))
@@ -235,8 +240,57 @@ module Ohm
     end
 
     def save!
-      attributes.each { |att| db[key(att)] = send(att) }
+      attributes.each { |att| write_remote(att, send(att)) }
       self
     end
+
+    def update_indices
+      delete_from_indices
+      add_to_indices
+    end
+
+    def add_to_indices
+      indices.each do |attrs|
+        db.set_add(index_key_for(attrs, read_locals(attrs)), id)
+      end
+    end
+
+    def delete_from_indices
+      indices.each do |attrs|
+        db.set_delete(index_key_for(attrs, read_remotes(attrs)), id)
+      end
+    end
+
+    def read_local(att)
+      @_attributes[att]
+    end
+
+    def write_local(att, value)
+      @_attributes[att] = value
+    end
+
+    def read_remote(att)
+      id && db[key(att)]
+    end
+
+    def write_remote(att, value)
+      db[key(att)] = value
+    end
+
+    def read_locals(attrs)
+      attrs.map do |att|
+        read_local(att)
+      end
+    end
+
+    def read_remotes(attrs)
+      attrs.map do |att|
+        read_remote(att)
+      end
+    end
+
+    def index_key_for(attrs, values)
+      self.class.key *(attrs + values)
+    end
   end
 end

data/lib/ohm/validations.rb

@@ -0,0 +1,38 @@
+module Ohm
+  module Validations
+    def valid?
+      errors.clear
+      validate
+      errors.empty?
+    end
+
+    def validate
+    end
+
+    def errors
+      @errors ||= []
+    end
+
+  protected
+
+    def assert_format(att, format)
+      if assert_present(att)
+        assert send(att).match(format), [att, :format]
+      end
+    end
+
+    def assert_present(att)
+      if assert_not_nil(att)
+        assert send(att).any?, [att, :empty]
+      end
+    end
+
+    def assert_not_nil(att)
+      assert send(att), [att, :nil]
+    end
+
+    def assert(value, error)
+      value or errors.push(error) && false
+    end
+  end
+end

data/test/benchmarks.rb

@@ -29,4 +29,24 @@ benchmark "ruby array push" do
   array.push(1)
 end
 
-run 10000
+$redis.set_add("bar", 1)
+$redis.set_add("bar", 2)
+
+benchmark "retrieve a set of two members" do
+  $redis.set_members("bar")
+end
+
+benchmark "retrieve membership status and set count" do
+  $redis.set_count("bar")
+  $redis.set_member?("bar", "1")
+end
+
+benchmark "retrieve set count" do
+  $redis.set_count("bar").zero?
+end
+
+benchmark "retrieve membership status" do
+  $redis.set_member?("bar", "1")
+end
+
+run 20_000

data/test/db/redis.pid

@@ -1 +1 @@
-6416
+26947

data/test/indices_test.rb

@@ -0,0 +1,36 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class IndicesTest < Test::Unit::TestCase
+  class User < Ohm::Model
+    attribute :email
+
+    index [:email]
+  end
+
+  context "A model with an indexed attribute" do
+    setup do
+      $redis.flush_db
+
+      @user1 = User.create(:email => "foo")
+      @user2 = User.create(:email => "bar")
+    end
+
+    should "be able to find by the given attribute" do
+      assert_equal [@user1], User.find(:email, "foo").to_a
+    end
+
+    should "update indices when changing attribute values" do
+      @user1.email = "baz"
+      @user1.save
+
+      assert_equal [], User.find(:email, "foo").to_a
+      assert_equal [@user1], User.find(:email, "baz").to_a
+    end
+
+    should "remove from the index after deleting" do
+      @user2.delete
+
+      assert_equal [], User.find(:email, "bar").to_a
+    end
+  end
+end

data/test/model_test.rb

@@ -241,4 +241,21 @@ class TestRedis < Test::Unit::TestCase
       assert_equal ["1", "2", "3"], Post[@post.id].comments
     end
   end
+
+  context "Comparison" do
+    setup do
+      @user = User.create(:email => "foo")
+    end
+
+    should "be comparable to other instances" do
+      assert_equal @user, User[@user.id]
+
+      assert_not_equal @user, User.create
+      assert_not_equal User.new, User.new
+    end
+
+    should "not be comparable to instances of other models" do
+      assert_not_equal @user, Event.create(:name => "Ruby Tuesday")
+    end
+  end
 end

data/test/validations_test.rb

@@ -3,6 +3,10 @@ require File.dirname(__FILE__) + '/test_helper'
 class ValidationsTest < Test::Unit::TestCase
   class Event < Ohm::Model
     attribute :name
+    attribute :place
+
+    index [:name]
+    index [:name, :place]
 
     def validate
       assert_format(:name, /^\w+$/)
@@ -40,6 +44,42 @@ class ValidationsTest < Test::Unit::TestCase
         end
       end
     end
+
+    context "That must have a unique name" do
+      should "fail when the value already exists" do
+        def @event.validate
+          assert_unique [:name]
+        end
+
+        Event.create(:name => "foo")
+        @event.name = "foo"
+        @event.create
+
+        assert_nil @event.id
+        assert_equal [[[:name], :not_unique]], @event.errors
+      end
+    end
+
+    context "That must have a unique name scoped by place" do
+      should "fail when the value already exists" do
+        def @event.validate
+          assert_unique [:name, :place]
+        end
+
+        Event.create(:name => "foo", :place => "bar")
+        @event.name = "foo"
+        @event.place = "bar"
+        @event.create
+
+        assert_nil @event.id
+        assert_equal [[[:name, :place], :not_unique]], @event.errors
+
+        @event.place = "baz"
+        @event.create
+
+        assert @event.valid?
+      end
+    end
   end
 
   context "An existing model with a valid name" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ohm
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors: 
 - Michel Martens, Damian Janowski
@@ -31,6 +31,7 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/ohm/validations.rb
 - lib/ohm.rb
 - README.markdown
 - LICENSE
@@ -39,15 +40,13 @@ files:
 - test/benchmarks.rb
 - test/db/dump.rdb
 - test/db/redis.pid
+- test/indices_test.rb
 - test/model_test.rb
-- test/references_test.rb
 - test/test.conf
 - test/test_helper.rb
 - test/validations_test.rb
 has_rdoc: false
 homepage: http://github.com/soveran/ohm
-licenses: []
-
 post_install_message: 
 rdoc_options: []
 
@@ -68,7 +67,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.2
+rubygems_version: 1.3.1
 signing_key: 
 specification_version: 2
 summary: Object-hash mapping library for Redis.

data/test/references_test.rb

@@ -1,29 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-module Ohm
-  class Reference
-    attr :model, :id
-
-    def initialize(model, id)
-    end
-
-    def self.marshal_load(*args)
-      1
-    end
-  end
-end
-
-class ReferencesTest < Test::Unit::TestCase
-  class Referee < Ohm::Model
-  end
-
-  test "dump" do
-    model = Referee.new.create
-
-    ref = Ohm::Reference.new(Referee, 1)
-
-    $redis["foo"] = ref
-
-    #assert_equal Referee[1], $redis["foo"]
-  end
-end