ohm 0.0.7 → 0.0.9

data/README.markdown

@@ -1,5 +1,5 @@
-Ohm
-===
+Ohm ॐ
+=====
 
 Object-hash mapping library for Redis.
 
@@ -23,6 +23,8 @@ Usage
       set :participants
       list :comments
 
+      index :name
+
       def validate
         assert_present :name
       end
@@ -31,11 +33,11 @@ Usage
     event = Event.create(:name => "Ruby Tuesday")
     event.participants << "Michel Martens"
     event.participants << "Damian Janowski"
-    event.participants      #=> ["Damian Janowski", "Michel Martens"]
+    event.participants.all #=> ["Damian Janowski", "Michel Martens"]
 
     event.comments << "Very interesting event!"
     event.comments << "Agree"
-    event.comments          #=> ["Very interesting event!", "Agree"]
+    event.comments.all #=> ["Very interesting event!", "Agree"]
 
     another_event = Event.new
     another_event.valid?    #=> false

data/lib/ohm.rb

@@ -1,19 +1,33 @@
+require "base64"
 require File.join(File.dirname(__FILE__), "ohm", "redis")
 require File.join(File.dirname(__FILE__), "ohm", "validations")
 
 module Ohm
+
+  # Provides access to the redis database. This is shared accross all models and instances.
   def redis
     @redis
   end
 
-  def connect(*attrs)
-    @redis = Ohm::Redis.new(*attrs)
+  # Connect to a redis database.
+  #
+  # @param options [Hash] options to create a message with.
+  # @option options [#to_s] :host ('127.0.0.1') Host of the redis database.
+  # @option options [#to_s] :port (6379) Port number.
+  # @option options [#to_s] :db (0) Database number.
+  # @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)
+    @redis = Ohm::Redis.new(*options)
   end
 
+  # Clear the database.
   def flush
     @redis.flushdb
   end
 
+  # Join the parameters with ":" to create a key.
   def key(*args)
     args.join(":")
   end
@@ -21,42 +35,93 @@ module Ohm
   module_function :key, :connect, :flush, :redis
 
   module Attributes
-    class Collection < Array
+    class Collection
+      include Enumerable
+
       attr_accessor :key, :db
 
       def initialize(db, key)
         self.db = db
         self.key = key
-        super(retrieve)
+      end
+
+      def each(&block)
+        all.each(&block)
+      end
+
+      def all(model = nil)
+        model ? raw.collect { |id| model[id] } : raw
       end
     end
 
+    # Represents a Redis list.
+    #
+    # @example Use a list attribute.
+    #
+    #   class Event < Ohm::Model
+    #     attribute :name
+    #     list :participants
+    #   end
+    #
+    #   event = Event.create :name => "Redis Meeting"
+    #   event.participants << "Albert"
+    #   event.participants << "Benoit"
+    #   event.participants.all #=> ["Albert", "Benoit"]
     class List < Collection
-      def retrieve
-        db.list(key)
-      end
 
+      # @param value [#to_s] Pushes value to the list.
       def << value
-        super(value) if db.rpush(key, value)
+        db.rpush(key, value)
+      end
+
+    private
+
+      def raw
+        db.list(key)
       end
     end
 
+    # Represents a Redis set.
+    #
+    # @example Use a set attribute.
+    #
+    #   class Company < Ohm::Model
+    #     attribute :name
+    #     set :employees
+    #   end
+    #
+    #   company = Company.create :name => "Redis Co."
+    #   company.employees << "Albert"
+    #   company.employees << "Benoit"
+    #   company.employees.all #=> ["Albert", "Benoit"]
+    #   company.include?("Albert") #=> true
     class Set < Collection
-      def retrieve
-        db.smembers(key).sort
-      end
 
+      # @param value [#to_s] Adds value to the list.
       def << value
-        super(value) if db.sadd(key, value)
+        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)
-        super(value) if db.srem(key, value)
+        db.srem(key, value)
       end
 
       def include?(value)
         db.sismember(key, value)
       end
+
+    private
+
+      def raw
+        db.smembers(key).sort
+      end
     end
   end
 
@@ -64,6 +129,13 @@ module Ohm
     module Validations
       include Ohm::Validations
 
+      # Validates that the attribute or array of attributes are unique. For this,
+      # an index of the same kind must exist.
+      #
+      # @overload assert_unique :name
+      #   Validates that the name attribute is unique.
+      # @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])
@@ -76,10 +148,15 @@ module Ohm
 
     @@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
 
+    # 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.
+    #
+    # @param name [Symbol] Name of the attribute.
     def self.attribute(name)
       define_method(name) do
         read_local(name)
@@ -92,16 +169,58 @@ module Ohm
       attributes << name
     end
 
+    # Defines a counter attribute for the model. This attribute can't be assigned, only incremented
+    # or decremented. It will be zero by default.
+    #
+    # @param name [Symbol] Name of the counter.
+    def self.counter(name)
+      define_method(name) do
+        read_local(name).to_i
+      end
+
+      counters << name
+    end
+
+    # Defines a list attribute for the model. It can be accessed only after the model instance
+    # is created.
+    #
+    # @param name [Symbol] Name of the list.
     def self.list(name)
       attr_list_reader(name)
       collections << name
     end
 
+    # Defines a set attribute for the model. It can be accessed only after the model instance
+    # is created. Sets are recommended when insertion and retrival order is irrelevant, and
+    # operations like union, join, and membership checks are important.
+    #
+    # @param name [Symbol] Name of the set.
     def self.set(name)
       attr_set_reader(name)
       collections << name
     end
 
+    # Creates an index (a set) that will be used for finding instances.
+    #
+    # 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
+    #     index :email
+    #   end
+    #
+    #   # 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)
     end
@@ -134,6 +253,10 @@ module Ohm
       @@attributes[self]
     end
 
+    def self.counters
+      @@counters[self]
+    end
+
     def self.collections
       @@collections[self]
     end
@@ -143,11 +266,23 @@ module Ohm
     end
 
     def self.create(*args)
-      new(*args).create
+      model = new(*args)
+      model.create
+      model
     end
 
     def self.find(attribute, value)
-      filter(Ohm.key(attribute, value))
+      filter(Ohm.key(attribute, encode(value)))
+    end
+
+    def self.encode(value)
+      Base64.encode64(value.to_s).chomp
+    end
+
+    def self.encode_each(values)
+      values.collect do |value|
+        encode(value)
+      end
     end
 
     def initialize(attrs = {})
@@ -179,16 +314,37 @@ module Ohm
 
     def delete
       delete_from_indices
-      delete_attributes(collections)
       delete_attributes(attributes)
+      delete_attributes(counters)
+      delete_attributes(collections)
       delete_model_membership
       self
     end
 
+    # Increment the attribute denoted by :att.
+    #
+    # @param att [Symbol] Attribute to increment.
+    def incr(att)
+      raise ArgumentError unless counters.include?(att)
+      write_local(att, db.incr(key(att)))
+    end
+
+    # Decrement the attribute denoted by :att.
+    #
+    # @param att [Symbol] Attribute to decrement.
+    def decr(att)
+      raise ArgumentError unless counters.include?(att)
+      write_local(att, db.decr(key(att)))
+    end
+
     def attributes
       self.class.attributes
     end
 
+    def counters
+      self.class.counters
+    end
+
     def collections
       self.class.collections
     end
@@ -303,7 +459,7 @@ module Ohm
     end
 
     def index_key_for(attrs, values)
-      self.class.key *(attrs + values)
+      self.class.key *(attrs + self.class.encode_each(values))
     end
   end
 end

data/lib/ohm/redis.rb

@@ -157,9 +157,12 @@ module Ohm
     def call_command(argv)
       connect unless connected?
       raw_call_command(argv.dup)
-    rescue Errno::ECONNRESET
-      reconnect
-      raw_call_command(argv.dup)
+    rescue Errno::ECONNRESET, Errno::EPIPE
+      if reconnect
+        raw_call_command(argv.dup)
+      else
+        raise Errno::ECONNRESET
+      end
     end
 
     def raw_call_command(argv)

data/lib/ohm/validations.rb

@@ -72,20 +72,20 @@ module Ohm
 
   protected
 
-    def assert_format(att, format)
-      if assert_present(att)
-        assert send(att).match(format), [att, :format]
+    def assert_format(att, format, error = [att, :format])
+      if assert_present(att, error)
+        assert(send(att).to_s.match(format), error)
       end
     end
 
-    def assert_present(att)
-      if assert_not_nil(att)
-        assert !send(att).empty?, [att, :empty]
-      end
+    def assert_present(att, error = [att, :not_present])
+      assert(!send(att).to_s.empty?, error)
     end
 
-    def assert_not_nil(att)
-      assert send(att), [att, :nil]
+    def assert_numeric(att, error = [att, :not_numeric])
+      if assert_present(att, error)
+        assert_format(att, /^\d+$/, error)
+      end
     end
 
     def assert(value, error)

data/test/db/redis.pid

@@ -1 +1 @@
-36980
+65913

data/test/errors_test.rb

@@ -31,11 +31,11 @@ class ErrorsTest < Test::Unit::TestCase
       values = []
 
       @model.errors.present do |e|
-        e.on [:name, :nil] do
+        e.on [:name, :not_present] do
           values << 1
         end
 
-        e.on [:account, :empty] do
+        e.on [:account, :not_present] do
           values << 2
         end
 
@@ -65,8 +65,8 @@ class ErrorsTest < Test::Unit::TestCase
 
     should "accept multiple matches for an error" do
       values = @model.errors.present do |e|
-        e.on [:name, :nil], "A"
-        e.on [:account, :empty] do
+        e.on [:name, :not_present], "A"
+        e.on [:account, :not_present] do
           "B"
         end
         e.on :terrible_error, "C"
@@ -85,8 +85,8 @@ class ErrorsTest < Test::Unit::TestCase
 
     should "take a custom presenter" do
       values = @model.errors.present(MyPresenter) do |e|
-        e.on([:name, :nil]) { "A" }
-        e.on([:account, :empty]) { "B" }
+        e.on([:name, :not_present]) { "A" }
+        e.on([:account, :not_present]) { "B" }
         e.on(:terrible_error) { "C" }
       end
 

data/test/indices_test.rb

@@ -9,10 +9,11 @@ class IndicesTest < Test::Unit::TestCase
 
   context "A model with an indexed attribute" do
     setup do
-      Ohm.redis.flushdb
+      Ohm.flush
 
       @user1 = User.create(:email => "foo")
       @user2 = User.create(:email => "bar")
+      @user3 = User.create(:email => "baz qux")
     end
 
     should "be able to find by the given attribute" do
@@ -32,5 +33,9 @@ class IndicesTest < Test::Unit::TestCase
 
       assert_equal [], User.find(:email, "bar")
     end
+
+    should "work with attributes that contain spaces" do
+      assert_equal [@user3], User.find(:email, "baz qux")
+    end
   end
 end

data/test/model_test.rb

@@ -2,6 +2,7 @@ require File.join(File.dirname(__FILE__), "test_helper")
 
 class Event < Ohm::Model
   attribute :name
+  counter :votes
   set :attendees
 end
 
@@ -14,6 +15,14 @@ class Post < Ohm::Model
   list :comments
 end
 
+class Person < Ohm::Model
+  attribute :name
+
+  def validate
+    assert_present :name
+  end
+end
+
 class TestRedis < Test::Unit::TestCase
   context "An event initialized with a hash of attributes" do
     should "assign the passed attributes" do
@@ -28,6 +37,10 @@ class TestRedis < Test::Unit::TestCase
       event2 = Event.create(:name => "Ruby Meetup")
       assert_equal event1.id + 1, event2.id
     end
+
+    should "return the unsaved object if validation fails" do
+      assert Person.create(:name => nil).kind_of?(Person)
+    end
   end
 
   context "Finding an event" do
@@ -189,19 +202,14 @@ class TestRedis < Test::Unit::TestCase
       end
     end
 
-    should "return an array if the model exists" do
-      @event.create
-      assert @event.attendees.kind_of?(Array)
-    end
-
     should "remove an element if sent :delete" do
       @event.create
       @event.attendees << "1"
       @event.attendees << "2"
       @event.attendees << "3"
-      assert_equal ["1", "2", "3"], @event.attendees
+      assert_equal ["1", "2", "3"], @event.attendees.all
       @event.attendees.delete("2")
-      assert_equal ["1", "3"], Event[@event.id].attendees
+      assert_equal ["1", "3"], Event[@event.id].attendees.all
     end
 
     should "return true if the set includes some member" do
@@ -212,6 +220,22 @@ class TestRedis < Test::Unit::TestCase
       assert @event.attendees.include?("2")
       assert_equal false, @event.attendees.include?("4")
     end
+
+    should "return instances of the passed model if the call to all includes a class" do
+      @event.create
+      @person = Person.create :name => "albert"
+      @event.attendees << @person.id
+
+      assert_equal [@person], @event.attendees.all(Person)
+    end
+
+    should "insert the model instance id instead of the object if using add" do
+      @event.create
+      @person = Person.create :name => "albert"
+      @event.attendees.add(@person)
+
+      assert_equal [@person.id.to_s], @event.attendees.all
+    end
   end
 
   context "Attributes of type List" do
@@ -222,14 +246,14 @@ class TestRedis < Test::Unit::TestCase
     end
 
     should "return an array" do
-      assert @post.comments.kind_of?(Array)
+      assert @post.comments.all.kind_of?(Array)
     end
 
     should "keep the inserting order" do
       @post.comments << "1"
       @post.comments << "2"
       @post.comments << "3"
-      assert_equal ["1", "2", "3"], @post.comments
+      assert_equal ["1", "2", "3"], @post.comments.all
     end
 
     should "keep the inserting order after saving" do
@@ -237,7 +261,45 @@ class TestRedis < Test::Unit::TestCase
       @post.comments << "2"
       @post.comments << "3"
       @post.save
-      assert_equal ["1", "2", "3"], Post[@post.id].comments
+      assert_equal ["1", "2", "3"], Post[@post.id].comments.all
+    end
+
+    should "respond to each" do
+      @post.comments << "1"
+      @post.comments << "2"
+      @post.comments << "3"
+
+      i = 1
+      @post.comments.each do |c|
+        assert_equal i, c.to_i
+        i += 1
+      end
+    end
+  end
+
+  context "Counters" do
+    setup do
+      @event = Event.create(:name => "Ruby Tuesday")
+    end
+
+    should "raise ArgumentError if the attribute is not a counter" do
+      assert_raise ArgumentError do
+        @event.incr(:name)
+      end
+    end
+
+    should "be zero if not initialized" do
+      assert_equal 0, @event.votes
+    end
+
+    should "be able to increment a counter" do
+      @event.incr(:votes)
+      assert_equal 1, @event.votes
+    end
+
+    should "be able to decrement a counter" do
+      @event.decr(:votes)
+      assert_equal -1, @event.votes
     end
   end
 

data/test/validations_test.rb

@@ -4,6 +4,7 @@ class ValidationsTest < Test::Unit::TestCase
   class Event < Ohm::Model
     attribute :name
     attribute :place
+    attribute :capacity
 
     index :name
     index [:name, :place]
@@ -45,6 +46,48 @@ class ValidationsTest < Test::Unit::TestCase
       end
     end
 
+    context "That must have a numeric attribute :capacity" do
+      should "fail when the value is nil" do
+        def @event.validate
+          assert_numeric :capacity
+        end
+
+        @event.name = "foo"
+        @event.place = "bar"
+        @event.create
+
+        assert_nil @event.id
+        assert_equal [[:capacity, :not_numeric]], @event.errors
+      end
+
+      should "fail when the value is not numeric" do
+        def @event.validate
+          assert_numeric :capacity
+        end
+
+        @event.name = "foo"
+        @event.place = "bar"
+        @event.capacity = "baz"
+        @event.create
+
+        assert_nil @event.id
+        assert_equal [[:capacity, :not_numeric]], @event.errors
+      end
+
+      should "succeed when the value is numeric" do
+        def @event.validate
+          assert_numeric :capacity
+        end
+
+        @event.name = "foo"
+        @event.place = "bar"
+        @event.capacity = 42
+        @event.create
+
+        assert_not_nil @event.id
+      end
+    end
+
     context "That must have a unique name" do
       should "fail when the value already exists" do
         def @event.validate
@@ -160,32 +203,14 @@ class ValidationsTest < Test::Unit::TestCase
       should "fail when the attribute is nil" do
         @target.validate
 
-        assert_equal [[:name, :nil]], @target.errors
+        assert_equal [[:name, :not_present]], @target.errors
       end
 
       should "fail when the attribute is empty" do
         @target.name = ""
         @target.validate
 
-        assert_equal [[:name, :empty]], @target.errors
-      end
-    end
-
-    context "assert_not_nil" do
-      should "fail when the attribute is nil" do
-        def @target.validate
-          assert_not_nil(:name)
-        end
-
-        @target.validate
-
-        assert_equal [[:name, :nil]], @target.errors
-
-        @target.errors.clear
-        @target.name = ""
-        @target.validate
-
-        assert_equal [], @target.errors
+        assert_equal [[:name, :not_present]], @target.errors
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ohm
 version: !ruby/object:Gem::Version 
-  version: 0.0.7
+  version: 0.0.9
 platform: ruby
 authors: 
 - Michel Martens
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-27 00:00:00 -03:00
+date: 2009-07-22 00:00:00 -03:00
 default_executable: 
 dependencies: []