ohm 0.0.26 → 0.0.27

data/README.markdown

@@ -12,6 +12,12 @@ Ohm is a library for storing objects in
 database. It includes an extensible list of validations and has very
 good performance.
 
+Community
+---------
+
+Join the mailing list: [http://groups.google.com/group/ohm-ruby](http://groups.google.com/group/ohm-ruby)
+
+Meet us on IRC: [#ohm](irc://chat.freenode.net/#ohm) on [freenode.net](http://freenode.net/)
 
 Getting started
 ---------------
@@ -157,9 +163,9 @@ An index is a set that's handled automatically by Ohm. For any index declared,
 Ohm maintains different sets of objects ids for quick lookups.
 
 For example, in the example above, the index on the name attribute will
-allow for searches like Event.find(:name, "some value").
+allow for searches like Event.find(name: "some value").
 
-Note that the `assert_unique` validation and the methods `find`, `search` and `filter` need a
+Note that the `assert_unique` validation and the methods `find` and `except` need a
 corresponding index in order to work.
 
 ### Finding
@@ -169,27 +175,22 @@ You can find a collection of records with the `find` method:
     # This returns a collection of users with the username "Albert"
     User.find(username: "Albert")
 
-### Searching and filtering
+### Filtering results
 
-    # This returns a collection of users with usernames "Albert" or "Benoit"
-    User.search(username: ["Albert", "Benoit"]) do |search_results|
-      @users = search_results.all
-    end
+    # Find all users from Argentina
+    User.find(country: "Argentina")
 
-    # This returns a collection of users with usernames "Albert" or "Benoit",
-    # but only those with the account enabled.
-    User.search(username: ["Albert", "Benoit"]) do |search_results|
-      search_results.filter(account: "enabled") do |filter_results|
-        @users = filter_results.all
-      end
-    end
+    # Find all activated users from Argentina
+    User.find(country: "Argentina", status: "activated")
+
+    # Find all users from Argentina, except those with a suspended account.
+    User.find(country: "Argentina").except(status: "suspended")
+
+Note that calling these methods results in new sets being created
+on the fly. This is important so that you can perform further operations
+before reading the items to the client.
 
-Important: note that both `search` and `filter` yield the results
-to a block. This is important because the set of results is stored
-for the duration of the block (to allow for chaining of searches and
-filters), but is deleted once the block ends. The `.all` is necessary
-for retrieving the actual instances, as keeping a reference to a set
-that is going to be deleted would only return empty sets.
+For more information, see (SINTERSTORE)[http://code.google.com/p/redis/wiki/SinterstoreCommand] and (SDIFFSTORE)[http://code.google.com/p/redis/wiki/SdiffstoreCommand].
 
 Validations
 -----------

data/Thorfile

@@ -0,0 +1,27 @@
+# encoding: UTF-8
+
+class Ohm < Thor
+  desc "doc", "Generate YARD documentation"
+  method_options :open => false
+  def doc
+    require "yard"
+
+    opts = ["--protected", "--title", "Ohm – Object-hash mapping library for Redis"]
+
+    YARD::CLI::Yardoc.run(*opts)
+
+    system "open doc/index.html" if options[:open]
+  end
+
+  desc "deploy", "Deploy documentation"
+  def deploy
+    system "rsync -az doc/* ohm.keyvalue.org:deploys/ohm.keyvalue.org/"
+  end
+
+  desc "test", "Run all tests"
+  def test
+    Dir["test/**/*_test.rb"].each do |file|
+      load file
+    end
+  end
+end

data/lib/ohm.rb

@@ -74,11 +74,14 @@ module Ohm
       # @option options [#to_s] :order (ASC) Sorting order, which can be ASC or DESC.
       # @option options [Integer] :limit (all) Number of items to return.
       # @option options [Integer] :start (0) An offset from where the limit will be applied.
+      #
       # @example Get the first ten users sorted alphabetically by name:
-      #   @event.attendees.sort(User, :by => :name, :order => "ALPHA", :limit => 10)
+      #
+      #   @event.attendees.sort(:by => :name, :order => "ALPHA", :limit => 10)
       #
       # @example Get five posts sorted by number of votes and starting from the number 5 (zero based):
-      #   @blog.posts.sort(Post, :by => :votes, :start => 5, :limit => 10")
+      #
+      #   @blog.posts.sort(:by => :votes, :start => 5, :limit => 10")
       def sort(options = {})
         return [] if empty?
         options[:start] ||= 0
@@ -94,8 +97,9 @@ module Ohm
       #   User.create :name => "B"
       #   User.create :name => "A"
       #
-      #   user = User.all.sort_by :name, :order => "ALPHA"
-      #   user.name == "A" #=> true
+      #   user = User.all.sort_by(:name, :order => "ALPHA").first
+      #   user.name == "A"
+      #   # => true
       def sort_by(att, options = {})
         sort(options.merge(:by => model.key("*", att)))
       end
@@ -128,6 +132,29 @@ module Ohm
         size.zero?
       end
 
+      # Clears the values in the collection.
+      def clear
+        db.del(key)
+        self
+      end
+
+      # Appends the given values to the collection.
+      def concat(values)
+        values.each { |value| self << value }
+        self
+      end
+
+      # Replaces the collection with the passed values.
+      def replace(values)
+        clear
+        concat(values)
+      end
+
+      # @param value [Ohm::Model#id] Adds the id of the object if it's an Ohm::Model.
+      def add(model)
+        self << model.id
+      end
+
     private
 
       def instantiate(raw)
@@ -180,6 +207,10 @@ module Ohm
         db.llen(key)
       end
 
+      def include?(value)
+        raw.include?(value)
+      end
+
       def inspect
         "#<List: #{raw.inspect}>"
       end
@@ -206,13 +237,6 @@ module Ohm
         db.sadd(key, value)
       end
 
-      # @param value [Ohm::Model#id] Adds the id of the object if it's an Ohm::Model.
-      def add model
-        raise ArgumentError unless model.kind_of?(Ohm::Model)
-        raise ArgumentError unless model.id
-        self << model.id
-      end
-
       def delete(value)
         db.srem(key, value)
       end
@@ -230,70 +254,63 @@ module Ohm
         db.scard(key)
       end
 
+      def inspect
+        "#<Set: #{raw.inspect}>"
+      end
+
       # Returns an intersection with the sets generated from the passed hash.
       #
-      # @see Ohm::Model.filter
-      # @yield [results] Results of the filtering. Beware that the set of results is deleted from Redis when the block ends.
+      # @see Ohm::Model.find
       # @example
-      #   Event.filter(public: true) do |filter_results|
-      #     @events = filter_results.all
-      #   end
+      #   @events = Event.find(public: true)
       #
-      #   # You can also combine search and filter
-      #   Event.search(day: "2009-09-11") do |search_results|
-      #     search_results.filter(public: true) do |filter_results|
-      #       @events = filter_results.all
-      #     end
-      #   end
-      def filter(hash, &block)
-        raise ArgumentError, "filter expects a block" unless block_given?
-        apply(:sinterstore, keys(hash).push(key), &block)
-      end
-
-      # Returns a union with the sets generated from the passed hash.
+      #   # You can combine the result with sort and other set operations:
+      #   @events.sort_by(:name)
+      def find(hash)
+        apply(:sinterstore, hash, "+")
+      end
+
+      # Returns the difference between the receiver and the passed sets.
       #
-      # @see Ohm::Model.search
-      # @yield [results] Results of the search. Beware that the set of results is deleted from Redis when the block ends.
       # @example
-      #   Event.search(day: "2009-09-11") do |search_results|
-      #     events = search_results.all
-      #   end
-      def search(hash, &block)
-        raise ArgumentError, "search expects a block" unless block_given?
-        apply(:sunionstore, keys(hash), &block)
+      #   @events = Event.find(public: true).except(status: "sold_out")
+      def except(hash)
+        apply(:sdiffstore, hash, "-")
       end
 
-      def delete!
-        db.del(key)
-      end
+    private
 
-      # Apply a redis operation on a collection of sets. Note that
-      # the resulting set is removed inmediatly after use.
-      def apply(operation, source, &block)
-        target = source.uniq.join("+")
-        db.send(operation, target, *source)
-        set = self.class.new(db, target, model)
-        block.call(set)
-        set.delete! if source.size > 1
+      # Apply a redis operation on a collection of sets.
+      def apply(operation, hash, glue)
+        indices = keys(hash).unshift(key).uniq
+        target = indices.join(glue)
+        db.send(operation, target, *indices)
+        self.class.new(db, target, model)
       end
 
-      def inspect
-        "#<Set: #{raw.inspect}>"
-      end
-
-    private
-
       # Transform a hash of attribute/values into an array of keys.
       def keys(hash)
         hash.inject([]) do |acc, t|
           acc + Array(t[1]).map do |v|
-            model.key(t[0], model.encode(v))
+            model.index_key_for(t[0], v)
           end
         end
       end
     end
+
+    class Index < Set
+      def inspect
+        "#<Index: #{raw.inspect}>"
+      end
+
+      def clear
+        raise Ohm::Model::CannotDeleteIndex
+      end
+    end
   end
 
+  Error = Class.new(StandardError)
+
   class Model
     module Validations
       include Ohm::Validations
@@ -307,20 +324,44 @@ module Ohm
       #   Validates that the :street and :city pair is unique.
       def assert_unique(attrs)
         result = db.sinter(*Array(attrs).map { |att| index_key_for(att, send(att)) })
-        assert(result.empty? || result.include?(id.to_s), [attrs, :not_unique])
+        assert result.empty? || !new? && result.include?(id.to_s), [attrs, :not_unique]
       end
     end
 
     include Validations
 
-    ModelIsNew = Class.new(StandardError)
+    class MissingID < Error
+      def message
+        "You tried to perform an operation that needs the model ID, but it's not present."
+      end
+    end
+
+    class CannotDeleteIndex < Error
+      def message
+        "You tried to delete an internal index used by Ohm."
+      end
+    end
+
+    class IndexNotFound < Error
+      def initialize(att)
+        @att = att
+      end
+
+      def message
+        "Index #{@att.inspect} not found."
+      end
+    end
 
     @@attributes = Hash.new { |hash, key| hash[key] = [] }
     @@collections = Hash.new { |hash, key| hash[key] = [] }
     @@counters = Hash.new { |hash, key| hash[key] = [] }
     @@indices = Hash.new { |hash, key| hash[key] = [] }
 
-    attr_accessor :id
+    attr_writer :id
+
+    def id
+      @id or raise MissingID
+    end
 
     # Defines a string attribute for the model. This attribute will be persisted by Redis
     # as a string. Any value stored here will be retrieved in its string representation.
@@ -381,7 +422,7 @@ module Ohm
     #   end
     #
     #   # Now this is possible:
-    #   User.find :email, "ohm@example.com"
+    #   User.find email: "ohm@example.com"
     #
     # @param name [Symbol] Name of the attribute to be indexed.
     def self.index(att)
@@ -411,7 +452,7 @@ module Ohm
     end
 
     def self.all
-      @all ||= Attributes::Set.new(db, key(:all), self)
+      @all ||= Attributes::Index.new(db, key(:all), self)
     end
 
     def self.attributes
@@ -436,38 +477,16 @@ module Ohm
       model
     end
 
-    # Find all the records matching the specified attribute-value pair.
-    #
-    # @example
-    #   Event.find(:starts_on, Date.today)
-    def self.find(attrs, value)
-      Attributes::Set.new(db, key(attrs, encode(value)), self)
-    end
-
     # Search across multiple indices and return the intersection of the sets.
     #
     # @example Finds all the user events for the supplied days
     #   event1 = Event.create day: "2009-09-09", author: "Albert"
     #   event2 = Event.create day: "2009-09-09", author: "Benoit"
     #   event3 = Event.create day: "2009-09-10", author: "Albert"
-    #   Event.filter(author: "Albert", day: "2009-09-09") do |events|
-    #     assert_equal [event1], events
-    #   end
-    def self.filter(hash, &block)
-      self.all.filter(hash, &block)
-    end
-
-    # Search across multiple indices and return the union of the sets.
     #
-    # @example Finds all the events for the supplied days
-    #   event1 = Event.create day: "2009-09-09"
-    #   event2 = Event.create day: "2009-09-10"
-    #   event3 = Event.create day: "2009-09-11"
-    #   Event.search(day: ["2009-09-09", "2009-09-10", "2009-09-011"]) do |events|
-    #     assert_equal [event1, event2, event3], events
-    #   end
-    def self.search(hash, &block)
-      self.all.search(hash, &block)
+    #   assert_equal [event1], Event.find(author: "Albert", day: "2009-09-09")
+    def self.find(hash)
+      all.find(hash)
     end
 
     def self.encode(value)
@@ -480,7 +499,7 @@ module Ohm
     end
 
     def new?
-      !id
+      !@id
     end
 
     def create
@@ -524,19 +543,19 @@ module Ohm
       self
     end
 
-    # Increment the attribute denoted by :att.
+    # Increment the counter denoted by :att.
     #
     # @param att [Symbol] Attribute to increment.
     def incr(att)
-      raise ArgumentError unless counters.include?(att)
+      raise ArgumentError, "#{att.inspect} is not a counter." unless counters.include?(att)
       write_local(att, db.incr(key(att)))
     end
 
-    # Decrement the attribute denoted by :att.
+    # Decrement the counter denoted by :att.
     #
     # @param att [Symbol] Attribute to decrement.
     def decr(att)
-      raise ArgumentError unless counters.include?(att)
+      raise ArgumentError, "#{att.inspect} is not a counter." unless counters.include?(att)
       write_local(att, db.decr(key(att)))
     end
 
@@ -558,7 +577,7 @@ module Ohm
 
     def ==(other)
       other.kind_of?(self.class) && other.key == key
-    rescue ModelIsNew
+    rescue MissingID
       false
     end
 
@@ -574,20 +593,19 @@ module Ohm
       everything = (attributes + collections + counters).map do |att|
         value = begin
                   send(att)
-                rescue ModelIsNew
+                rescue MissingID
                   nil
                 end
 
         [att, value.inspect]
       end
 
-      "#<#{self.class}:#{id || "?"} #{everything.map {|e| e.join("=") }.join(" ")}>"
+      "#<#{self.class}:#{new? ? "?" : id} #{everything.map {|e| e.join("=") }.join(" ")}>"
     end
 
   protected
 
     def key(*args)
-      raise ModelIsNew if new?
       self.class.key(id, *args)
     end
 
@@ -610,7 +628,7 @@ module Ohm
     end
 
     def initialize_id
-      self.id = db.incr(self.class.key("id"))
+      self.id = db.incr(self.class.key("id")).to_s
     end
 
     def db
@@ -673,7 +691,7 @@ module Ohm
     end
 
     def read_remote(att)
-      id && db.get(key(att))
+      db.get(key(att)) unless new?
     end
 
     def write_remote(att, value)
@@ -694,8 +712,13 @@ module Ohm
       end
     end
 
+    def self.index_key_for(att, value)
+      raise IndexNotFound, att unless indices.include?(att)
+      key(att, encode(value))
+    end
+
     def index_key_for(att, value)
-      self.class.key(att, self.class.encode(value))
+      self.class.index_key_for(att, value)
     end
 
     # Lock the object so no other instances can modify it.

data/test/indices_test.rb

@@ -9,6 +9,7 @@ class IndicesTest < Test::Unit::TestCase
     attribute :email
     attribute :update
     attribute :activation_code
+    attribute :sandunga
 
     index :email
     index :email_provider
@@ -38,30 +39,46 @@ class IndicesTest < Test::Unit::TestCase
     end
 
     should "be able to find by the given attribute" do
-      assert_equal @user1, User.find(:email, "foo").first
+      assert_equal @user1, User.find(:email => "foo").first
+    end
+
+    should "raise if the field is not indexed" do
+      assert_raises(Ohm::Model::IndexNotFound) do
+        User.find(:sandunga => "foo")
+      end
     end
 
     should "return nil if no results are found" do
-      assert User.find(:email, "foobar").empty?
-      assert_equal nil, User.find(:email, "foobar").first
+      assert User.find(:email => "foobar").empty?
+      assert_equal nil, User.find(:email => "foobar").first
     end
 
     should "update indices when changing attribute values" do
       @user1.email = "baz"
       @user1.save
 
-      assert_equal [], User.find(:email, "foo")
-      assert_equal [@user1], User.find(:email, "baz")
+      assert_equal [], User.find(:email => "foo")
+      assert_equal [@user1], User.find(:email => "baz")
     end
 
     should "remove from the index after deleting" do
       @user2.delete
 
-      assert_equal [], User.find(:email, "bar")
+      assert_equal [], User.find(:email => "bar")
     end
 
     should "work with attributes that contain spaces" do
-      assert_equal [@user3], User.find(:email, "baz qux")
+      assert_equal [@user3], User.find(:email => "baz qux")
+    end
+
+    should "not allow to manually clear an index" do
+      assert_raise Ohm::Model::CannotDeleteIndex do
+        User.find(:email => "bar").clear
+      end
+
+      assert_raise Ohm::Model::CannotDeleteIndex do
+        User.find(:email => "bar").find(:email => "baz").clear
+      end
     end
   end
 
@@ -73,12 +90,12 @@ class IndicesTest < Test::Unit::TestCase
     end
 
     should "allow indexing by an arbitrary attribute" do
-      assert_equal [@user1, @user2], User.find(:email_provider, "gmail.com").to_a.sort_by { |u| u.id }
-      assert_equal [@user3], User.find(:email_provider, "yahoo.com")
+      assert_equal [@user1, @user2], User.find(:email_provider => "gmail.com").to_a.sort_by { |u| u.id }
+      assert_equal [@user3], User.find(:email_provider => "yahoo.com")
     end
 
     should "allow indexing by an attribute that is lazily set" do
-      assert_equal [@user1], User.find(:activation_code, "user:1").to_a
+      assert_equal [@user1], User.find(:activation_code => "user:1").to_a
     end
   end
 
@@ -97,7 +114,7 @@ class IndicesTest < Test::Unit::TestCase
     end
 
     should "index each item" do
-      assert_equal [@user1, @user2], User.find(:working_days, "Mon").to_a.sort_by { |u| u.id }
+      assert_equal [@user1, @user2], User.find(:working_days => "Mon").to_a.sort_by { |u| u.id }
     end
 
     # TODO If we deal with Ohm collections, the updates are atomic but the reindexing never happens.
@@ -105,11 +122,11 @@ class IndicesTest < Test::Unit::TestCase
     should "remove the indices when the object changes" do
       @user2.working_days.delete "Mon"
       @user2.save
-      assert_equal [@user1], User.find(:working_days, "Mon")
+      assert_equal [@user1], User.find(:working_days => "Mon")
     end
   end
 
-  context "Intersection and and union" do
+  context "Intersection and difference" do
     class Event < Ohm::Model
       attr_writer :days
 
@@ -123,40 +140,29 @@ class IndicesTest < Test::Unit::TestCase
     end
 
     setup do
-      @event1 = Event.create(:timeline => 1)
-      @event2 = Event.create(:timeline => 1)
-      @event3 = Event.create(:timeline => 2)
-      @event1.days = [1, 2]
-      @event2.days = [2, 3]
-      @event3.days = [3, 4]
-      @event1.save
-      @event2.save
-      @event3.save
+      @event1 = Event.create(:timeline => 1).update(:days => [1, 2])
+      @event2 = Event.create(:timeline => 1).update(:days => [2, 3])
+      @event3 = Event.create(:timeline => 2).update(:days => [3, 4])
     end
 
     should "intersect multiple sets of results" do
-      Event.filter(:timeline => 1, :days => [1, 2]) do |set|
-        assert_equal [@event1], set
-      end
+      assert_equal [@event1], Event.find(:timeline => 1, :days => [1, 2])
+      assert_equal [@event1], Event.find(:timeline => 1).find(:days => [1, 2])
     end
 
-    should "group multiple sets of results" do
-      Event.search(:days => [1, 2]) do |set|
-        assert_equal [@event1, @event2], set
-      end
+    should "compute the difference between sets" do
+      assert_equal [@event2], Event.find(:timeline => 1).except(:days => 1)
     end
 
-    should "combine intersections and unions" do
-      Event.search(:days => [1, 2, 3]) do |events|
-        events.filter(:timeline => 1) do |result|
-          assert_equal [@event1, @event2], result
-        end
+    should "raise if the argument is not an index" do
+      assert_raises(Ohm::Model::IndexNotFound) do
+        Event.find(:timeline => 1).except(:not_an_index => 1)
       end
     end
 
     should "work with strings that generate a new line when encoded" do
       user = User.create(:email => "foo@bar", :update => "CORRECTED - UPDATE 2-Suspected US missile strike kills 5 in Pakistan")
-      assert_equal [user], User.find(:update, "CORRECTED - UPDATE 2-Suspected US missile strike kills 5 in Pakistan")
+      assert_equal [user], User.find(:update => "CORRECTED - UPDATE 2-Suspected US missile strike kills 5 in Pakistan")
     end
   end
 end

data/test/model_test.rb

@@ -6,6 +6,7 @@ require "ostruct"
 class Post < Ohm::Model
   attribute :body
   list :comments
+  list :related, Post
 end
 
 class User < Ohm::Model
@@ -15,10 +16,15 @@ end
 
 class Person < Ohm::Model
   attribute :name
+  index :initial
 
   def validate
     assert_present :name
   end
+
+  def initial
+    name[0, 1].upcase
+  end
 end
 
 class Event < Ohm::Model
@@ -44,9 +50,13 @@ class TestRedis < Test::Unit::TestCase
 
   context "An event created from a hash of attributes" do
     should "assign an id and save the object" do
+      Ohm.flush
+
       event1 = Event.create(:name => "Ruby Tuesday")
       event2 = Event.create(:name => "Ruby Meetup")
-      assert_equal event1.id + 1, event2.id
+
+      assert_equal "1", event1.id
+      assert_equal "2", event2.id
     end
 
     should "return the unsaved object if validation fails" do
@@ -144,14 +154,19 @@ class TestRedis < Test::Unit::TestCase
 
   context "Creating a new model" do
     should "assign a new id to the event" do
+      Ohm.flush
+
       event1 = Event.new
       event1.create
 
       event2 = Event.new
       event2.create
 
-      assert event1.id
-      assert_equal event1.id + 1, event2.id
+      assert !event1.new?
+      assert !event2.new?
+
+      assert_equal "1", event1.id
+      assert_equal "2", event2.id
     end
   end
 
@@ -265,6 +280,8 @@ class TestRedis < Test::Unit::TestCase
 
   context "Loading attributes" do
     setup do
+      Ohm.flush
+
       event = Event.new
       event.name = "Ruby Tuesday"
       @id = event.create.id
@@ -291,7 +308,7 @@ class TestRedis < Test::Unit::TestCase
     end
 
     should "not be available if the model is new" do
-      assert_raise Ohm::Model::ModelIsNew do
+      assert_raise Ohm::Model::MissingID do
         @event.attendees << 1
       end
     end
@@ -338,6 +355,34 @@ class TestRedis < Test::Unit::TestCase
       @event.attendees << "3"
       assert_equal 3, @event.attendees.size
     end
+
+    should "empty the set" do
+      @event.create
+      @event.attendees << "1"
+
+      @event.attendees.clear
+
+      assert @event.attendees.empty?
+    end
+
+    should "replace the values in the set" do
+      @event.create
+      @event.attendees << "1"
+
+      @event.attendees.replace(["2", "3"])
+
+      assert_equal ["2", "3"], @event.attendees.raw.sort
+    end
+
+    should "filter elements" do
+      @event.create
+      @event.attendees.add(Person.create(:name => "Albert"))
+      @event.attendees.add(Person.create(:name => "Marie"))
+
+      assert_equal ["1"], @event.attendees.find(:initial => "A").raw
+      assert_equal ["2"], @event.attendees.find(:initial => "M").raw
+      assert_equal [],    @event.attendees.find(:initial => "Z").raw
+    end
   end
 
   context "Attributes of type List" do
@@ -408,6 +453,34 @@ class TestRedis < Test::Unit::TestCase
       assert_equal "2", @post.comments.pop
       assert @post.comments.empty?
     end
+
+    should "empty the list" do
+      @post.comments.unshift "1"
+      @post.comments.clear
+
+      assert @post.comments.empty?
+    end
+
+    should "replace the values in the list" do
+      @post.comments.replace(["1", "2"])
+
+      assert_equal ["1", "2"], @post.comments.raw
+    end
+
+    should "add models" do
+      @post.related.add(Post.create(:body => "Hello"))
+
+      assert_equal ["2"], @post.related.raw
+    end
+
+    should "find elements in the list" do
+      another_post = Post.create
+
+      @post.related.add(another_post)
+
+      assert  @post.related.include?(another_post.id)
+      assert !@post.related.include?("-1")
+    end
   end
 
   context "Applying arbitrary transformations" do

data/test/validations_test.rb

@@ -22,13 +22,13 @@ class ValidationsTest < Test::Unit::TestCase
     context "That must have a present name" do
       should "not be created if the name is never assigned" do
         @event.create
-        assert_nil @event.id
+        assert @event.new?
       end
 
       should "not be created if the name assigned is empty" do
         @event.name = ""
         @event.create
-        assert_nil @event.id
+        assert @event.new?
       end
 
       should "be created if the name assigned is not empty" do
@@ -41,7 +41,7 @@ class ValidationsTest < Test::Unit::TestCase
         should "not be created if the name doesn't match /^\w+$/" do
           @event.name = "hello-world"
           @event.create
-          assert_nil @event.id
+          assert @event.new?
         end
       end
     end
@@ -56,7 +56,7 @@ class ValidationsTest < Test::Unit::TestCase
         @event.place = "bar"
         @event.create
 
-        assert_nil @event.id
+        assert @event.new?
         assert_equal [[:capacity, :not_numeric]], @event.errors
       end
 
@@ -70,7 +70,7 @@ class ValidationsTest < Test::Unit::TestCase
         @event.capacity = "baz"
         @event.create
 
-        assert_nil @event.id
+        assert @event.new?
         assert_equal [[:capacity, :not_numeric]], @event.errors
       end
 
@@ -98,7 +98,7 @@ class ValidationsTest < Test::Unit::TestCase
         @event.name = "foo"
         @event.create
 
-        assert_nil @event.id
+        assert @event.new?
         assert_equal [[:name, :not_unique]], @event.errors
       end
     end
@@ -114,7 +114,7 @@ class ValidationsTest < Test::Unit::TestCase
         @event.place = "bar"
         @event.create
 
-        assert_nil @event.id
+        assert @event.new?
         assert_equal [[[:name, :place], :not_unique]], @event.errors
 
         @event.place = "baz"
@@ -123,6 +123,18 @@ class ValidationsTest < Test::Unit::TestCase
         assert @event.valid?
       end
     end
+
+    context "That defines a unique validation on a non indexed attribute" do
+      should "raise ArgumentError" do
+        def @event.validate
+          assert_unique :capacity
+        end
+
+        assert_raises(Ohm::Model::IndexNotFound) do
+          @event.valid?
+        end
+      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.26
+  version: 0.0.27
 platform: ruby
 authors: 
 - Michel Martens
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-26 00:00:00 -03:00
+date: 2009-11-19 00:00:00 -03:00
 default_executable: 
 dependencies: []
 
@@ -31,6 +31,7 @@ files:
 - README.markdown
 - LICENSE
 - Rakefile
+- Thorfile
 - test/all_tests.rb
 - test/benchmarks.rb
 - test/connection_test.rb
@@ -39,7 +40,6 @@ files:
 - test/model_test.rb
 - test/mutex_test.rb
 - test/redis_test.rb
-- test/search_test.rb
 - test/test_helper.rb
 - test/validations_test.rb
 - test/test.conf

data/test/search_test.rb

@@ -1,42 +0,0 @@
-require File.join(File.dirname(__FILE__), "test_helper")
-
-class SearchTest < Test::Unit::TestCase
-  setup do
-    Ohm.flush
-  end
-
-  class Lane < Ohm::Model
-    attribute :lane_type
-
-    index :lane_type
-
-    def to_s
-      lane_type.capitalize
-    end
-
-    def validate
-      assert_unique :lane_type
-    end
-
-    def error_messages
-      errors.present do |e|
-        e.on [:lane_type, :not_unique], "The lane type #{lane_type} is already in use"
-      end
-    end
-  end
-
-  context "A model with an indexed attribute" do
-    setup do
-      @results = []
-      @subresults = []
-      Lane.search(:lane_type => "email") { |sr| @results << sr.size }
-      Lane.create(:lane_type => "email")
-      Lane.search(:lane_type => "email") { |sr| @results << sr.size }
-      Lane.search(:lane_type => "email") { |sr| @results << sr.size }
-    end
-
-    should "be able to find by the given attribute" do
-      assert_equal [0, 1, 1], @results
-    end
-  end
-end