ohm 0.0.18 → 0.0.19

data/README.markdown

@@ -135,6 +135,21 @@ with an attribute name, which will determine the sorting order. Both
 methods receive an options hash which is explained in the documentation
 for {Ohm::Attributes::Collection#sort}.
 
+Adding instances of `Person` to the attendees hash is done with the
+`add` method:
+
+    @event.attendees.add(Person.create(name: "Albert"))
+
+    # And now...
+    @event.attendees.each do |person|
+      # ...do what you want with this person.
+    end
+
+Just to clarify: when you add items to a set with `<<`, Ohm inserts
+whatever you send without checking it. When you use `add`, it assumes
+it's an instance of some `Ohm::Model` and stores its id.
+
+
 Indexes
 -------
 
@@ -144,14 +159,9 @@ 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").
 
-You can also declare an index on multiple colums, like this:
-
-    index [:name, :company]
-
 Note that the `find` method and the `assert_unique` validation need a
 corresponding index to exist.
 
-
 Validations
 -----------
 
@@ -183,43 +193,28 @@ to false.
 Checks that the given field is not nil or empty. The error code for this
 assertion is :not_present.
 
-    def assert_present(att, error = [att, :not_present])
-      assert(!send(att).to_s.empty?, error)
-    end
+    assert_present :name
 
 ### assert_format
 
 Checks that the given field matches the provided format. The error code
 for this assertion is :format.
 
-    def assert_format(att, format, error = [att, :format])
-      if assert_present(att, error)
-        assert(send(att).to_s.match(format), error)
-      end
-    end
+    assert_format :username, /^\w+$/
 
 ### assert_numeric
 
 Checks that the given field holds a number as a Fixnum or as a string
 representation. The error code for this assertion is :not_numeric.
 
-    def assert_numeric(att, error = [att, :not_numeric])
-      if assert_present(att, error)
-        assert_format(att, /^\d+$/, error)
-      end
-    end
+    assert_numeric :votes
 
 ### assert_unique
 
 Validates that the attribute or array of attributes are unique.
-For this, an index of the same kind must exist. The error code is
-:not_unique.
-
-    def assert_unique(attrs)
-      index_key = index_key_for(Array(attrs), read_locals(Array(attrs)))
-      assert(db.scard(index_key).zero? || db.sismember(index_key, id), [Array(attrs), :not_unique])
-    end
+For this, an index of the same kind must exist. The error code is :not_unique.
 
+    assert_unique :email
 
 Errors
 ------

data/lib/ohm.rb

@@ -81,7 +81,8 @@ module Ohm
         return [] if empty?
         options[:start] ||= 0
         options[:limit] = [options[:start], options[:limit]] if options[:limit]
-        instantiate(db.sort(key, options))
+        result = db.sort(key, options)
+        options[:get] ? result : instantiate(result)
       end
 
       # Sort the model instances by the given attribute.
@@ -222,6 +223,57 @@ module Ohm
       def size
         db.scard(key)
       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.
+      # @example
+      #   Event.search(day: "2009-09-11") do |search_results|
+      #     events = search_results.all
+      #   end
+      def filter(hash, &block)
+        apply(:sinterstore, keys(hash).push(key), &block)
+      end
+
+      # Returns a union with the sets generated from the passed hash.
+      #
+      # @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|
+      #     search_results.filter(public: true) do |filter_results|
+      #       events = filter_results.all
+      #     end
+      #   end
+      def search(hash, &block)
+        apply(:sunionstore, keys(hash), &block)
+      end
+
+      def delete!
+        db.del(key)
+      end
+
+      # 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.join(operation)
+        db.send(operation, target, *source)
+        set = self.class.new(db, target, model)
+        block.call(set)
+        set.delete!
+      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))
+          end
+        end
+      end
     end
   end
 
@@ -237,8 +289,8 @@ module Ohm
       # @overload assert_unique [:street, :city]
       #   Validates that the :street and :city pair is unique.
       def assert_unique(attrs)
-        index_key = index_key_for(Array(attrs), read_locals(Array(attrs)))
-        assert(db.scard(index_key).zero? || db.sismember(index_key, id), [Array(attrs), :not_unique])
+        result = db.sinter(*Array(attrs).map { |att| index_key_for(att, send(att)) })
+        assert(result.empty? || result.include?(id.to_s), [attrs, :not_unique])
       end
     end
 
@@ -305,9 +357,6 @@ module Ohm
     # If you want to find a model instance by some attribute value, then an index for that
     # attribute must exist.
     #
-    # Each index declaration creates an index. It can be either an index on one particular attribute,
-    # or an index accross many attributes.
-    #
     # @example
     #   class User < Ohm::Model
     #     attribute :email
@@ -317,12 +366,9 @@ module Ohm
     #   # Now this is possible:
     #   User.find :email, "ohm@example.com"
     #
-    # @overload index :name
-    #   Creates an index for the name attribute.
-    # @overload index [:street, :city]
-    #   Creates a composite index for street and city.
-    def self.index(attrs)
-      indices << Array(attrs)
+    # @param name [Symbol] Name of the attribute to be indexed.
+    def self.index(att)
+      indices << att
     end
 
     def self.attr_list_reader(name, model = nil)
@@ -369,18 +415,42 @@ module Ohm
       model
     end
 
-    def self.find(attribute, value)
-      Attributes::Set.new(db, key(attribute, encode(value)), self)
+    # 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
 
-    def self.encode(value)
-      Base64.encode64(value.to_s).chomp
+    # 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)
     end
 
-    def self.encode_each(values)
-      values.collect do |value|
-        encode(value)
-      end
+    def self.encode(value)
+      Base64.encode64(value.to_s).gsub("\n", "")
     end
 
     def initialize(attrs = {})
@@ -533,14 +603,30 @@ module Ohm
     end
 
     def add_to_indices
-      indices.each do |attrs|
-        db.sadd(index_key_for(attrs, read_locals(attrs)), id)
+      indices.each do |att|
+        next add_to_index(att) unless collection?(send(att))
+        send(att).each { |value| add_to_index(att, value) }
       end
     end
 
+    def collection?(value)
+      self.class.collection?(value)
+    end
+
+    def self.collection?(value)
+      value.kind_of?(Enumerable) &&
+      value.kind_of?(String) == false
+    end
+
+    def add_to_index(att, value = send(att))
+      index = index_key_for(att, value)
+      db.sadd(index, id)
+      db.sadd(key(:_indices), index)
+    end
+
     def delete_from_indices
-      indices.each do |attrs|
-        db.srem(index_key_for(attrs, read_remotes(attrs)), id)
+      db.smembers(key(:_indices)).each do |index|
+        db.srem(index, id)
       end
     end
 
@@ -572,8 +658,8 @@ module Ohm
       end
     end
 
-    def index_key_for(attrs, values)
-      self.class.key *(attrs + self.class.encode_each(values))
+    def index_key_for(att, value)
+      self.class.key(att, self.class.encode(value))
     end
 
     # Lock the object so no other instances can modify it.

data/test/connection_test.rb

@@ -25,7 +25,7 @@ class ConnectionTest < Test::Unit::TestCase
     threads << Thread.new do
       conn1 = Ohm.redis
     end
-    
+
     threads << Thread.new do
       conn2 = Ohm.redis
     end

data/test/indices_test.rb

@@ -1,21 +1,30 @@
 require File.join(File.dirname(__FILE__), "test_helper")
 
 class IndicesTest < Test::Unit::TestCase
+  setup do
+    Ohm.flush
+  end
+
   class User < Ohm::Model
     attribute :email
+    attribute :update
 
     index :email
     index :email_provider
+    index :working_days
+    index :update
 
     def email_provider
       email.split("@").last
     end
+
+    def working_days
+      @working_days ||= []
+    end
   end
 
   context "A model with an indexed attribute" do
     setup do
-      Ohm.flush
-
       @user1 = User.create(:email => "foo")
       @user2 = User.create(:email => "bar")
       @user3 = User.create(:email => "baz qux")
@@ -51,8 +60,6 @@ class IndicesTest < Test::Unit::TestCase
 
   context "Indexing arbitrary attributes" do
     setup do
-      Ohm.flush
-
       @user1 = User.create(:email => "foo@gmail.com")
       @user2 = User.create(:email => "bar@gmail.com")
       @user3 = User.create(:email => "bazqux@yahoo.com")
@@ -63,4 +70,82 @@ class IndicesTest < Test::Unit::TestCase
       assert_equal [@user3], User.find(:email_provider, "yahoo.com")
     end
   end
+
+  context "Indexing enumerables" do
+    setup do
+      @user1 = User.create(:email => "foo@gmail.com")
+      @user2 = User.create(:email => "bar@gmail.com")
+
+      @user1.working_days << "Mon"
+      @user1.working_days << "Tue"
+      @user2.working_days << "Mon"
+      @user2.working_days << "Wed"
+
+      @user1.save
+      @user2.save
+    end
+
+    should "index each item" do
+      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.
+    # One solution may be to reindex after inserts or deletes in collection.
+    should "remove the indices when the object changes" do
+      @user2.working_days.delete "Mon"
+      @user2.save
+      assert_equal [@user1], User.find(:working_days, "Mon")
+    end
+  end
+
+  context "Intersection and and union" do
+    class Event < Ohm::Model
+      attr_writer :days
+
+      attribute :timeline
+      index :timeline
+      index :days
+
+      def days
+        @days ||= []
+      end
+    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
+    end
+
+    should "intersect multiple sets of results" do
+      Event.filter(timeline: 1, days: [1, 2]) do |set|
+        assert_equal [@event1], set
+      end
+    end
+
+    should "group multiple sets of results" do
+      Event.search(days: [1, 2]) do |set|
+        assert_equal [@event1, @event2], set
+      end
+    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
+      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")
+    end
+  end
 end

data/test/model_test.rb

@@ -221,6 +221,14 @@ class TestRedis < Test::Unit::TestCase
       Person.create :name => "A"
       assert_equal "A", Person.all.first(:by => :name, :order => "ALPHA").name
     end
+
+    should "return attribute values when the get parameter is specified" do
+      Ohm.flush
+      Person.create :name => "B"
+      Person.create :name => "A"
+
+      assert_equal "A", Person.all.sort_by(:name, get: "Person:*:name", order: "ALPHA").first
+    end
   end
 
   context "Loading attributes" do

data/test/validations_test.rb

@@ -7,7 +7,7 @@ class ValidationsTest < Test::Unit::TestCase
     attribute :capacity
 
     index :name
-    index [:name, :place]
+    index :place
 
     def validate
       assert_format(:name, /^\w+$/)
@@ -99,12 +99,12 @@ class ValidationsTest < Test::Unit::TestCase
         @event.create
 
         assert_nil @event.id
-        assert_equal [[[:name], :not_unique]], @event.errors
+        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
+      should "fail when the value already exists for a scoped attribute" do
         def @event.validate
           assert_unique [:name, :place]
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ohm
 version: !ruby/object:Gem::Version 
-  version: 0.0.18
+  version: 0.0.19
 platform: ruby
 authors: 
 - Michel Martens
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-07 00:00:00 -03:00
+date: 2009-09-15 00:00:00 -03:00
 default_executable: 
 dependencies: []