ohm 0.0.34 → 0.0.35

data/lib/ohm.rb

@@ -1,14 +1,15 @@
 # encoding: UTF-8
 
 require "base64"
-require File.join(File.dirname(__FILE__), "ohm", "redis")
+require "redis"
+
 require File.join(File.dirname(__FILE__), "ohm", "validations")
 require File.join(File.dirname(__FILE__), "ohm", "compat-1.8.6")
 require File.join(File.dirname(__FILE__), "ohm", "key")
 require File.join(File.dirname(__FILE__), "ohm", "collection")
 
 module Ohm
-  VERSION = "0.0.34"
+  VERSION = "0.0.35"
 
   # Provides access to the Redis database. This is shared accross all models and instances.
   def redis
@@ -39,9 +40,9 @@ module Ohm
 
   # Return a connection to Redis.
   #
-  # This is a wapper around Ohm::Redis.new(options)
+  # This is a wapper around Redis.new(options)
   def connection(*options)
-    Ohm::Redis.new(*options)
+    Redis.new(*options)
   end
 
   def options
@@ -53,7 +54,6 @@ module Ohm
     redis.flushdb
   end
 
-  # Join the parameters with ":" to create a key.
   def key(*args)
     Key[*args]
   end
@@ -63,15 +63,47 @@ module Ohm
   Error = Class.new(StandardError)
 
   class Model
+
+    # Wraps a model name for lazy evaluation.
+    class Wrapper < BasicObject
+      def initialize(name, &block)
+        @name = name
+        @caller = ::Kernel.caller[2]
+        @block = block
+
+        class << self
+          def method_missing(method_id, *args)
+            ::Kernel.raise ::NoMethodError, "You tried to call #{@name}##{method_id}, but #{@name} is not defined on #{@caller}"
+          end
+        end
+      end
+
+      def self.wrap(object)
+        object.class == self ? object : new(object.inspect) { object }
+      end
+
+      def unwrap
+        @block.call
+      end
+
+      def class
+        Wrapper
+      end
+
+      def inspect
+        "<Wrapper for #{@name} (in #{@caller})>"
+      end
+    end
+
     class Collection
       include Enumerable
 
       attr :raw
       attr :model
 
-      def initialize(key, model, db = model.db)
-        @raw = self.class::Raw.new(key, db)
-        @model = model
+      def initialize(key, model, db = nil)
+        @model = model.unwrap
+        @raw = self.class::Raw.new(key, db || @model.db)
       end
 
       def <<(model)
@@ -197,7 +229,7 @@ module Ohm
       def apply(operation, hash, glue)
         target = key.volatile.group(glue).append(*keys(hash))
         model.db.send(operation, target, *target.sub_keys)
-        Set.new(target, model)
+        Set.new(target, Wrapper.wrap(model))
       end
 
       # Transform a hash of attribute/values into an array of keys.
@@ -240,7 +272,7 @@ module Ohm
     class Index < Set
       def apply(operation, hash, glue)
         if hash.keys.size == 1
-          return Set.new(keys(hash).first, model)
+          return Set.new(keys(hash).first, Wrapper.wrap(model))
         else
           super
         end
@@ -390,6 +422,8 @@ module Ohm
     #
     # @see Ohm::Model::collection
     def self.reference(name, model)
+      model = Wrapper.wrap(model)
+
       reader = :"#{name}_id"
       writer = :"#{name}_id="
 
@@ -397,7 +431,7 @@ module Ohm
       index reader
 
       define_memoized_method(name) do
-        model[send(reader)]
+        model.unwrap[send(reader)]
       end
 
       define_method(:"#{name}=") do |value|
@@ -451,7 +485,8 @@ module Ohm
     # @param model     [Constant] Model where the reference is defined.
     # @param reference [Symbol]   Reference as defined in the associated model.
     def self.collection(name, model, reference = to_reference)
-      define_method(name) { model.find(:"#{reference}_id" => send(:id)) }
+      model = Wrapper.wrap(model)
+      define_method(name) { model.unwrap.find(:"#{reference}_id" => send(:id)) }
     end
 
     def self.to_reference
@@ -460,6 +495,7 @@ module Ohm
 
     def self.attr_collection_reader(name, type, model)
       if model
+        model = Wrapper.wrap(model)
         define_memoized_method(name) { Ohm::Model::const_get(type).new(key(name), model, db) }
       else
         define_memoized_method(name) { Ohm::const_get(type).new(key(name), db) }
@@ -482,7 +518,7 @@ module Ohm
     end
 
     def self.all
-      @all ||= Ohm::Model::Index.new(key(:all), self)
+      @all ||= Ohm::Model::Index.new(key(:all), Wrapper.wrap(self))
     end
 
     def self.attributes
@@ -659,35 +695,20 @@ module Ohm
       self.class.key(id, *args)
     end
 
-    # Use MSET if possible, SET otherwise.
-    def write
-      db.support_mset? ?
-        write_with_mset :
-        write_with_set
-    end
-
-    # Write attributes using SET
-    # This method will be removed once MSET becomes standard.
-    def write_with_set
-      attributes.each do |att|
-        value = send(att)
-        value.to_s.empty? ?
-          db.set(key(att), value) :
-          db.del(key(att))
-      end
-    end
-
     # Write attributes using MSET
-    # This is the preferred method, and will be the only option
-    # available once MSET becomes standard.
-    def write_with_mset
+    def write
       unless attributes.empty?
         rems, adds = attributes.map { |a| [key(a), send(a)] }.partition { |t| t.last.to_s.empty? }
+
         db.del(*rems.flatten.compact) unless rems.empty?
-        db.mset(adds.flatten)         unless adds.empty?
+        db.mapped_mset(adds.flatten)  unless adds.empty?
       end
     end
 
+    def self.const_missing(name)
+      Wrapper.new(name) { const_get(name) }
+    end
+
   private
 
     # Provides access to the Redis database. This is shared accross all models and instances.
@@ -759,6 +780,7 @@ module Ohm
     def delete_from_indices
       db.smembers(key(:_indices)).each do |index|
         db.srem(index, id)
+        db.srem(key(:_indices), index)
       end
     end
 
@@ -771,7 +793,12 @@ module Ohm
     end
 
     def read_remote(att)
-      db.get(key(att)) unless new?
+      unless new?
+        value = db.get(key(att))
+        value.respond_to?(:force_encoding) ?
+          value.force_encoding("UTF-8") :
+          value
+      end
     end
 
     def read_locals(attrs)

data/lib/ohm/collection.rb

@@ -124,7 +124,7 @@ module Ohm
 
     # @return [Array] Elements of the list.
     def all
-      db.list(key)
+      db.lrange(key, 0, -1)
     end
 
     # @return [Integer] Returns the number of elements in the list.

data/lib/ohm/compat-1.8.6.rb

@@ -14,7 +14,7 @@ unless "".respond_to?(:lines)
   end
 end
 
-unless Object.new.respond_to?(:tap)
+unless respond_to?(:tap)
   class Object
     def tap
       yield(self)
@@ -22,3 +22,18 @@ unless Object.new.respond_to?(:tap)
     end
   end
 end
+
+module Ohm
+  if defined?(BasicObject)
+    BasicObject = ::BasicObject
+  elsif defined?(BlankSlate)
+    BasicObject = ::BlankSlate
+  else
+
+    # If neither BasicObject (Ruby 1.9) nor BlankSlate (typically provided by Builder)
+    # are present, define our simple implementation inside the Ohm module.
+    class BasicObject
+      instance_methods.each { |meth| undef_method(meth) unless meth =~ /\A(__|instance_eval)/ }
+    end
+  end
+end

data/test/benchmarks.rb

@@ -7,55 +7,33 @@ Ohm.flush
 
 class Event < Ohm::Model
   attribute :name
-  set :attendees
+  attribute :location
+
+  index :name
+  index :location
 
   def validate
     assert_present :name
+    assert_present :location
   end
 end
 
-event = Event.create(:name => "Ruby Tuesday")
-array = []
-
-benchmark "add to set with ohm redis" do
-  Ohm.redis.sadd("foo", 1)
-end
-
-benchmark "add to set with ohm" do
-  event.attendees << 1
-end
-
-Ohm.redis.sadd("bar", 1)
-Ohm.redis.sadd("bar", 2)
-
-benchmark "retrieve a set of two members with ohm redis" do
-  Ohm.redis.sadd("bar", 3)
-  Ohm.redis.srem("bar", 3)
-  Ohm.redis.smembers("bar")
-end
-
-Ohm.redis.del("Event:#{event.id}:attendees")
-
-event.attendees << 1
-event.attendees << 2
+i = 0
 
-benchmark "retrieve a set of two members with ohm" do
-  event.attendees << 3
-  event.attendees.delete(3)
-  event.attendees
+benchmark "Create Events" do
+  Event.create(:name => "Redis Meetup #{i}", :location => "London #{i}")
 end
 
-benchmark "retrieve membership status and set count" do
-  Ohm.redis.scard("bar")
-  Ohm.redis.sismember("bar", "1")
+benchmark "Find by indexed attribute" do
+  Event.find(:name => "Redis Meetup #{i}").first
 end
 
-benchmark "retrieve set count" do
-  Ohm.redis.scard("bar").zero?
+benchmark "Mass update" do
+  Event[1].update(:name => "Redis Meetup II")
 end
 
-benchmark "retrieve membership status" do
-  Ohm.redis.sismember("bar", "1")
+benchmark "Load events" do
+  Event[1].name
 end
 
-run 10_000
+run 5000

data/test/model_test.rb

@@ -41,6 +41,10 @@ class Event < Ohm::Model
 end
 
 class TestRedis < Test::Unit::TestCase
+  setup do
+    Ohm.flush
+  end
+
   context "An event initialized with a hash of attributes" do
     should "assign the passed attributes" do
       event = Event.new(:name => "Ruby Tuesday")
@@ -50,8 +54,6 @@ 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")
 
@@ -218,8 +220,6 @@ 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
 
@@ -259,20 +259,18 @@ class TestRedis < Test::Unit::TestCase
   end
 
   context "Delete" do
-    class ModelToBeDeleted < Ohm::Model
-      attribute :name
-      set :foos
-      list :bars
-    end
+    should "delete an existing model" do
+      class ModelToBeDeleted < Ohm::Model
+        attribute :name
+        set :foos
+        list :bars
+      end
 
-    setup do
       @model = ModelToBeDeleted.create(:name => "Lorem")
 
       @model.foos << "foo"
       @model.bars << "bar"
-    end
 
-    should "delete an existing model" do
       id = @model.id
 
       @model.delete
@@ -280,10 +278,27 @@ class TestRedis < Test::Unit::TestCase
       assert_nil Ohm.redis.get(ModelToBeDeleted.key(id))
       assert_nil Ohm.redis.get(ModelToBeDeleted.key(id, :name))
       assert_equal Array.new, Ohm.redis.smembers(ModelToBeDeleted.key(id, :foos))
-      assert_equal Array.new, Ohm.redis.list(ModelToBeDeleted.key(id, :bars))
+      assert_equal Array.new, Ohm.redis.lrange(ModelToBeDeleted.key(id, :bars), 0, -1)
 
       assert ModelToBeDeleted.all.empty?
     end
+
+    should "be no leftover keys" do
+      class ::Foo < Ohm::Model
+        attribute :name
+        index :name
+      end
+
+      assert_equal [], Ohm.redis.keys("*")
+
+      Foo.create(:name => "Bar")
+
+      assert_equal ["Foo:1:_indices", "Foo:1:name", "Foo:all", "Foo:id", "Foo:name:QmFy"], Ohm.redis.keys("*").sort
+
+      Foo[1].delete
+
+      assert_equal ["Foo:id"], Ohm.redis.keys("*")
+    end
   end
 
   context "Listing" do
@@ -305,7 +320,6 @@ class TestRedis < Test::Unit::TestCase
 
   context "Sorting" do
     should "sort all" do
-      Ohm.flush
       Person.create :name => "D"
       Person.create :name => "C"
       Person.create :name => "B"
@@ -315,26 +329,22 @@ class TestRedis < Test::Unit::TestCase
     end
 
     should "return an empty array if there are no elements to sort" do
-      Ohm.flush
       assert_equal [], Person.all.sort_by(:name)
     end
 
     should "return the first element sorted by id when using first" do
-      Ohm.flush
       Person.create :name => "A"
       Person.create :name => "B"
       assert_equal "A", Person.all.first.name
     end
 
     should "return the first element sorted by name if first receives a sorting option" do
-      Ohm.flush
       Person.create :name => "B"
       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"
 
@@ -344,8 +354,6 @@ class TestRedis < Test::Unit::TestCase
 
   context "Loading attributes" do
     setup do
-      Ohm.flush
-
       event = Event.new
       event.name = "Ruby Tuesday"
       @id = event.create.id
@@ -367,8 +375,6 @@ class TestRedis < Test::Unit::TestCase
 
   context "Attributes of type Set" do
     setup do
-      Ohm.flush
-
       @person1 = Person.create(:name => "Albert")
       @person2 = Person.create(:name => "Bertrand")
       @person3 = Person.create(:name => "Charles")
@@ -450,8 +456,6 @@ class TestRedis < Test::Unit::TestCase
 
   context "Attributes of type List" do
     setup do
-      Ohm.flush
-
       @post = Post.new
       @post.body = "Hello world!"
       @post.create
@@ -585,13 +589,19 @@ class TestRedis < Test::Unit::TestCase
       end
     end
 
-    class Calendar < Ohm::Model
+    class ::Calendar < Ohm::Model
       list :holidays, lambda { |v| Date.parse(v) }
       list :subscribers, lambda { |id| MyActiveRecordModel.find(id) }
+      list :appointments, Appointment
+    end
+
+    class ::Appointment < Ohm::Model
+      attribute :text
     end
 
     setup do
       @calendar = Calendar.create
+
       @calendar.holidays.raw << "2009-05-25"
       @calendar.holidays.raw << "2009-07-09"
 
@@ -604,6 +614,12 @@ class TestRedis < Test::Unit::TestCase
       assert_equal ["1"], @calendar.subscribers.raw.all
       assert_equal [MyActiveRecordModel.find(1)], @calendar.subscribers.all
     end
+
+    should "work with models too" do
+      @calendar.appointments.add(Appointment.create(:text => "Meet with Bertrand"))
+
+      assert_equal [Appointment[1]], Calendar[1].appointments.sort
+    end
   end
 
   context "Sorting lists and sets" do
@@ -715,6 +731,18 @@ class TestRedis < Test::Unit::TestCase
       counter :visits
       set :friends
       list :comments
+
+      def foo
+        bar.foo
+      end
+
+      def baz
+        bar.new.foo
+      end
+
+      def bar
+        SomeMissingConstant
+      end
     end
 
     should "provide a meaningful inspect" do
@@ -730,9 +758,26 @@ class TestRedis < Test::Unit::TestCase
 
       assert_equal %Q{#<Bar:#{bar.id} name="Albert" friends=#<Set: ["1", "2"]> comments=#<List: ["A"]> visits=1>}, Bar[bar.id].inspect
     end
+
+    def assert_wrapper_exception(&block)
+      begin
+        block.call
+      rescue NoMethodError => exception_raised
+      end
+
+      assert_match /You tried to call SomeMissingConstant#\w+, but SomeMissingConstant is not defined on #{__FILE__}:\d+:in `bar'/, exception_raised.message
+    end
+
+    should "inform about a miscatch by Wrapper when calling class methods" do
+      assert_wrapper_exception { Bar.new.baz }
+    end
+
+    should "inform about a miscatch by Wrapper when calling instance methods" do
+      assert_wrapper_exception { Bar.new.foo }
+    end
   end
 
-  context "Overwritting write" do
+  context "Overwriting write" do
     class ::Baz < Ohm::Model
       attribute :name
 
@@ -756,6 +801,16 @@ class TestRedis < Test::Unit::TestCase
     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
@@ -813,6 +868,7 @@ class TestRedis < Test::Unit::TestCase
     context "a collection of other objects" do
       setup do
         @note = Note.create(:content => "Interesting stuff", :source => @post)
+        @comment = Comment.create(:note => @note)
       end
 
       should "return a set of notes" do
@@ -820,6 +876,17 @@ class TestRedis < Test::Unit::TestCase
         assert_equal @note, @post.notes.first
       end
 
+      should "return a set of comments" do
+        assert_equal @comment, @note.comments.first
+      end
+
+      should "return a list of ratings" do
+        @rating = Rating.create(:value => 5)
+        @note.ratings << @rating
+
+        assert_equal @rating, @note.ratings.first
+      end
+
       should "default to the current class name" do
         @editor = Editor.create(:name => "Albert", :post => @post)