remodel 0.3.1 → 0.4.0

data/VERSION

@@ -1 +1 @@
-0.3.1
+0.4.0

data/lib/remodel/caching_context.rb

@@ -0,0 +1,62 @@
+# encoding: UTF-8
+module Remodel
+
+  class CachingContext
+
+    # use Remodel.create_context instead
+    class << self
+      private :new
+    end
+
+    def initialize(context)
+      @context = context
+      @cache = {}
+    end
+
+    def key
+      @context.key
+    end
+
+    def hget(field)
+      @cache[field] = @context.hget(field) unless @cache.has_key?(field)
+      @cache[field]
+    end
+
+    def hmget(*fields)
+      load(fields - @cache.keys)
+      @cache.values_at(*fields)
+    end
+
+    def hset(field, value)
+      value = value.to_s if value
+      @cache[field] = value
+      @context.hset(field, value)
+    end
+
+    def hincrby(field, value)
+      result = @context.hincrby(field, value)
+      @cache[field] = result.to_s
+      result
+    end
+
+    def hdel(field)
+      @cache[field] = nil
+      @context.hdel(field)
+    end
+
+    def inspect
+      "\#<#{self.class.name}(#{@context.inspect})>"
+    end
+
+  private
+
+    def load(fields)
+      return if fields.empty?
+      fields.zip(@context.hmget(*fields)).each do |field, value|
+        @cache[field] = value
+      end
+    end
+
+  end
+
+end

data/lib/remodel/context.rb

@@ -0,0 +1,41 @@
+module Remodel
+
+  class Context
+
+    # use Remodel.create_context instead
+    class << self
+      private :new
+    end
+
+    attr_reader :key
+
+    def initialize(key)
+      @key = key
+    end
+
+    def hget(field)
+      Remodel.redis.hget(@key, field)
+    end
+
+    def hmget(*fields)
+      Remodel.redis.hmget(@key, *fields)
+    end
+
+    def hset(field, value)
+      Remodel.redis.hset(@key, field, value)
+    end
+
+    def hincrby(field, value)
+      Remodel.redis.hincrby(@key, field, value)
+    end
+
+    def hdel(field)
+      Remodel.redis.hdel(@key, field)
+    end
+
+    def inspect
+      "\#<#{self.class.name}(#{@key})>"
+    end
+  end
+
+end

data/lib/remodel/entity.rb

@@ -19,7 +19,7 @@ module Remodel
 
     def save
       @key = next_key unless @key
-      Remodel.redis.hset(@context, @key, to_json)
+      @context.hset(@key, to_json)
       self
     end
 
@@ -41,9 +41,9 @@ module Remodel
 
     def delete
       raise EntityNotSaved unless @key
-      Remodel.redis.hdel(@context, @key)
+      @context.hdel(@key)
       self.class.associations.each do |name|
-        Remodel.redis.hdel(@context, "#{@key}_#{name}")
+        @context.hdel("#{@key}_#{name}")
       end
     end
 
@@ -57,7 +57,7 @@ module Remodel
 
     def inspect
       properties = attributes.map { |name, value| "#{name}: #{value.inspect}" }.join(', ')
-      "\#<#{self.class.name}(#{context}, #{id}) #{properties}>"
+      "\#<#{self.class.name}(#{context.key}, #{id}) #{properties}>"
     end
 
     def self.create(context, attributes = {})
@@ -112,7 +112,7 @@ module Remodel
           instance_variable_get(var)
         else
           clazz = Class[options[:class]]
-          value_key = Remodel.redis.hget(self.context, "#{key}_#{name}")
+          value_key = self.context.hget("#{key}_#{name}")
           value = value_key && clazz.find(self.context, value_key) rescue nil
           instance_variable_set(var, value)
         end
@@ -126,10 +126,10 @@ module Remodel
       define_method("_#{name}=") do |value|
         if value
           instance_variable_set(var, value)
-          Remodel.redis.hset(self.context, "#{key}_#{name}", value.key)
+          self.context.hset("#{key}_#{name}", value.key)
         else
           remove_instance_variable(var) if instance_variable_defined? var
-          Remodel.redis.hdel(self.context, "#{key}_#{name}")
+          self.context.hdel("#{key}_#{name}")
         end
       end; private "_#{name}="
 
@@ -166,12 +166,12 @@ module Remodel
     end
 
     def self.fetch(context, key)
-      Remodel.redis.hget(context, key) || raise(EntityNotFound, "no #{name} with key #{key} in context #{context}")
+      context.hget(key) || raise(EntityNotFound, "no #{name} with key #{key} in context #{context}")
     end
 
     # Each entity has its own sequence to generate unique ids.
     def next_key
-      id = Remodel.redis.hincrby(@context, "#{self.class.key_prefix}", 1)
+      id = @context.hincrby("#{self.class.key_prefix}", 1)
       "#{self.class.key_prefix}#{id}"
     end
 

data/lib/remodel/has_many.rb

@@ -56,12 +56,12 @@ module Remodel
     end
 
     def _store
-      Remodel.redis.hset(@this.context, @key, JSON.generate(self.map(&:key)))
+      @this.context.hset(@key, JSON.generate(self.map(&:key)))
     end
 
     def _fetch(clazz, context, key)
-      keys = JSON.parse(Remodel.redis.hget(context, key) || '[]').uniq
-      values = keys.empty? ? [] : Remodel.redis.hmget(context, *keys)
+      keys = JSON.parse(context.hget(key) || '[]').uniq
+      values = keys.empty? ? [] : context.hmget(*keys)
       keys.zip(values).map do |key, json|
         clazz.restore(context, key, json) if json
       end.compact

data/lib/remodel.rb

@@ -24,6 +24,8 @@ end
 require File.join(File.dirname(__FILE__), 'remodel', 'mapper')
 require File.join(File.dirname(__FILE__), 'remodel', 'has_many')
 require File.join(File.dirname(__FILE__), 'remodel', 'entity')
+require File.join(File.dirname(__FILE__), 'remodel', 'context')
+require File.join(File.dirname(__FILE__), 'remodel', 'caching_context')
 
 
 module Remodel
@@ -46,6 +48,12 @@ module Remodel
   def self.redis=(redis)
     @redis = redis
   end
+
+  def self.create_context(key, options = {})
+    context = Context.send(:new, key)
+    context = CachingContext.send(:new, context) if options[:caching]
+    context
+  end
   
   # Returns the mapper defined for a given class, or the identity mapper.
   def self.mapper_for(clazz)

data/test/helper.rb

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'test/unit'
 require 'shoulda'
+require 'mocha'
 
 require File.dirname(__FILE__) + '/../lib/remodel.rb'
 
@@ -10,4 +11,8 @@ class Test::Unit::TestCase
     Remodel.redis
   end
   
+  def context
+    @context ||= Remodel.create_context('test')
+  end
+  
 end

data/test/test_caching_context.rb

@@ -0,0 +1,116 @@
+# encoding: UTF-8
+require 'helper'
+
+class Remodel::CachingContext
+  attr_accessor :cache
+  class << self
+    public :new
+  end
+end
+
+class TestCachingContext < Test::Unit::TestCase
+
+  context "CachingContext" do
+    setup do
+      @cache = Remodel::CachingContext.new(context)
+    end
+
+    context 'hget' do
+      should "fetch and cache value" do
+        context.expects(:hget).with('x').returns('33')
+        assert_equal '33', @cache.hget('x')
+        assert_equal '33', @cache.cache['x']
+      end
+
+      should "return cached value" do
+        @cache.cache['x'] = '42'
+        context.expects(:hget).never
+        assert_equal '42', @cache.hget('x')
+      end
+
+      should "return cached nil" do
+        @cache.cache['x'] = nil
+        context.expects(:hget).never
+        assert_nil @cache.hget('x')
+      end
+    end
+
+    context 'hmget' do
+      should "fetch and cache values" do
+        context.expects(:hmget).with('x', 'y', 'z').returns %w[4 5 6]
+        assert_equal %w[4 5 6], @cache.hmget('x', 'y', 'z')
+        assert_equal %w[4 5 6], @cache.cache.values_at('x', 'y', 'z')
+      end
+
+      should 'only fetch uncached values' do
+        @cache.cache['y'] = '5'
+        context.expects(:hmget).with('x', 'z').returns %w[4 6]
+        assert_equal %w[4 5 6], @cache.hmget('x', 'y', 'z')
+        assert_equal %w[4 5 6], @cache.cache.values_at('x', 'y', 'z')
+      end
+
+      should 'not fetch cached nil values' do
+        @cache.cache['y'] = nil
+        context.expects(:hmget).with('x', 'z').returns %w[4 6]
+        assert_equal ['4', nil, '6'], @cache.hmget('x', 'y', 'z')
+        assert_equal ['4', nil, '6'], @cache.cache.values_at('x', 'y', 'z')
+      end
+
+      should 'not call redis if all values are cached' do
+        @cache.cache['x'] = '4'
+        @cache.cache['y'] = '5'
+        @cache.cache['z'] = '6'
+        context.expects(:hmget).never
+        assert_equal %w[4 5 6], @cache.hmget('x', 'y', 'z')
+      end
+    end
+
+    context 'hset' do
+      should 'store value in redis' do
+        context.expects(:hset).with('x', '21')
+        @cache.hset('x', 21)
+      end
+
+      should 'cache value as string' do
+        context.expects(:hset).with('x', '21')
+        @cache.hset('x', 21)
+        assert_equal '21', @cache.cache['x']
+      end
+
+      should 'cache nil' do
+        context.expects(:hset).with('x', nil)
+        @cache.hset('x', nil)
+        assert_nil @cache.cache['x']
+        assert @cache.cache.has_key?('x')
+      end
+    end
+
+    context 'hincrby' do
+      should 'increment value in redis' do
+        context.expects(:hincrby).with('i', 1).returns(3)
+        assert_equal 3, @cache.hincrby('i', 1)
+      end
+
+      should 'cache result as string' do
+        context.expects(:hincrby).with('i', 1).returns(3)
+        @cache.hincrby('i', 1)
+        assert_equal '3', @cache.cache['i']
+      end
+    end
+
+    context 'hdel' do
+      should 'delete field in redis' do
+        context.expects(:hdel).with('x')
+        @cache.hdel('x')
+      end
+
+      should 'cache nil for field' do
+        context.expects(:hdel).with('x')
+        @cache.hdel('x')
+        assert_nil @cache.cache['x']
+        assert @cache.cache.has_key?('x')
+      end
+    end
+  end
+
+end

data/test/test_entity.rb

@@ -13,23 +13,23 @@ class TestEntity < Test::Unit::TestCase
 
   context "new" do
     should "set properties" do
-      foo = Foo.new('cx', :x => 1, :y => 2)
+      foo = Foo.new(context, :x => 1, :y => 2)
       assert_equal 1, foo.x
       assert_equal 2, foo.y
     end
 
     should "ignore undefined properties" do
-      foo = Foo.new('cx', :z => 3)
+      foo = Foo.new(context, :z => 3)
       assert foo.instance_eval { !@attributes.key? :z }
     end
 
     should "not set the key" do
-      foo = Foo.new('cx', :x => 23)
+      foo = Foo.new(context, :x => 23)
       assert_equal nil, foo.key
     end
 
     should "not set the id" do
-      foo = Foo.new('cx', :x => 23)
+      foo = Foo.new(context, :x => 23)
       assert_equal nil, foo.id
     end
   end
@@ -40,37 +40,37 @@ class TestEntity < Test::Unit::TestCase
     end
 
     should "work without attributes" do
-      foo = Foo.create('cx')
+      foo = Foo.create(context)
       assert foo.is_a?(Foo)
     end
 
     should "give the entity a key based on the class name" do
-      assert_equal 'f1', Foo.create('cx').key
-      assert_equal 'b1', Bar.create('cx').key
-      assert_equal 'b2', Bar.create('cx').key
+      assert_equal 'f1', Foo.create(context).key
+      assert_equal 'b1', Bar.create(context).key
+      assert_equal 'b2', Bar.create(context).key
     end
 
     should "give the entity an id which is unique per entity class" do
-      assert_equal 1, Foo.create('cx').id
-      assert_equal 1, Bar.create('cx').id
-      assert_equal 2, Bar.create('cx').id
+      assert_equal 1, Foo.create(context).id
+      assert_equal 1, Bar.create(context).id
+      assert_equal 2, Bar.create(context).id
     end
 
     should "store the entity under its key" do
-      foo = Foo.create('cx', :x => 'hello', :y => false)
-      assert redis.hexists('cx', foo.key)
+      foo = Foo.create(context, :x => 'hello', :y => false)
+      assert redis.hexists(context.key, foo.key)
     end
 
     should "store all properties" do
-      foo = Foo.create('cx', :x => 'hello', :y => false)
+      foo = Foo.create(context, :x => 'hello', :y => false)
       foo.reload
       assert_equal 'hello', foo.x
       assert_equal false, foo.y
     end
 
     should "not store the key as a property" do
-      foo = Foo.create('cx', :x => 'hello', :y => false)
-      assert !(/f1/ =~ redis.hget('cx', foo.key))
+      foo = Foo.create(context, :x => 'hello', :y => false)
+      assert !(/f1/ =~ redis.hget(context.key, foo.key))
     end
   end
 
@@ -80,18 +80,18 @@ class TestEntity < Test::Unit::TestCase
     end
 
     should "give the entity a key, if necessary" do
-      foo = Foo.new('cx').save
+      foo = Foo.new(context).save
       assert foo.key
     end
 
     should "store the entity under its key" do
-      foo = Foo.new('cx', :x => 'hello', :y => false)
+      foo = Foo.new(context, :x => 'hello', :y => false)
       foo.save
-      assert redis.hexists(foo.context, foo.key)
+      assert redis.hexists(context.key, foo.key)
     end
 
     should "store all properties" do
-      foo = Foo.new('cx', :x => 'hello', :y => false)
+      foo = Foo.new(context, :x => 'hello', :y => false)
       foo.save
       foo.reload
       assert_equal 'hello', foo.x
@@ -101,11 +101,11 @@ class TestEntity < Test::Unit::TestCase
 
   context "reload" do
     setup do
-      @foo = Foo.create('cx', :x => 'hello', :y => true)
+      @foo = Foo.create(context, :x => 'hello', :y => true)
     end
 
     should "reload all properties" do
-      redis.hset @foo.context, @foo.key, %q({"x":23,"y":"adios"})
+      redis.hset(context.key, @foo.key, %q({"x":23,"y":"adios"}))
       @foo.reload
       assert_equal 23, @foo.x
       assert_equal 'adios', @foo.y
@@ -124,19 +124,19 @@ class TestEntity < Test::Unit::TestCase
     end
 
     should "raise EntityNotFound if the entity does not exist any more" do
-      redis.hdel @foo.context, @foo.key
+      redis.hdel(context.key, @foo.key)
       assert_raise(Remodel::EntityNotFound) { @foo.reload }
     end
 
     should "raise EntityNotSaved if the entity was never saved" do
-      assert_raise(Remodel::EntityNotSaved) { Foo.new('cx').reload }
+      assert_raise(Remodel::EntityNotSaved) { Foo.new(context).reload }
     end
   end
 
   context "update" do
     setup do
       redis.flushdb
-      @foo = Foo.create('cx', :x => 'Tim', :y => true)
+      @foo = Foo.create(context, :x => 'Tim', :y => true)
     end
 
     should "set the given properties" do
@@ -155,7 +155,7 @@ class TestEntity < Test::Unit::TestCase
 
   context "to_json" do
     should "serialize to json" do
-      foo = Foo.new('cx', :x => 42, :y => true)
+      foo = Foo.new(context, :x => 42, :y => true)
       assert_match /"x":42/, foo.to_json
       assert_match /"y":true/, foo.to_json
     end
@@ -163,7 +163,7 @@ class TestEntity < Test::Unit::TestCase
 
   context "as_json" do
     should "serialize into a hash" do
-      foo = Foo.create('cx', :x => 42, :y => true)
+      foo = Foo.create(context, :x => 42, :y => true)
       expected = { :id => foo.id, :x => 42, :y => true }
       assert_equal expected, foo.as_json
     end
@@ -172,7 +172,7 @@ class TestEntity < Test::Unit::TestCase
   context "#set_key_prefix" do
     should "use the given key prefix" do
       class Custom < Remodel::Entity; set_key_prefix 'my'; end
-      assert_match /^my\d+$/, Custom.create('cx').key
+      assert_match /^my\d+$/, Custom.create(context).key
     end
 
     should "ensure that the prefix is letters only" do
@@ -185,8 +185,8 @@ class TestEntity < Test::Unit::TestCase
   context "#find" do
     setup do
       redis.flushdb
-      @foo = Foo.create('cx', :x => 'hello', :y => 123)
-      Foo.create('cx', :x => 'hallo', :y => 124)
+      @foo = Foo.create(context, :x => 'hello', :y => 123)
+      Foo.create(context, :x => 'hallo', :y => 124)
     end
 
     should "find and load an entity by key" do
@@ -202,17 +202,17 @@ class TestEntity < Test::Unit::TestCase
     end
 
     should "reject a key which does not exist" do
-      assert_raise(Remodel::EntityNotFound) { Foo.find('cx', 'x66') }
+      assert_raise(Remodel::EntityNotFound) { Foo.find(context, 'x66') }
     end
 
     should "reject an id which does not exist" do
-      assert_raise(Remodel::EntityNotFound) { Foo.find('cx', 66) }
+      assert_raise(Remodel::EntityNotFound) { Foo.find(context, 66) }
     end
   end
 
   context "properties" do
     should "have property x" do
-      foo = Foo.new('cx')
+      foo = Foo.new(context)
       foo.x = 23
       assert_equal 23, foo.x
       foo.x += 10
@@ -220,45 +220,45 @@ class TestEntity < Test::Unit::TestCase
     end
 
     should "not have property z" do
-      foo = Foo.new('cx')
+      foo = Foo.new(context)
       assert_raise(NoMethodError) { foo.z }
       assert_raise(NoMethodError) { foo.z = 42 }
     end
 
     context "types" do
       should "work with nil" do
-        foo = Foo.create('cx', :x => nil)
+        foo = Foo.create(context, :x => nil)
         assert_equal nil, foo.reload.x
       end
 
       should "work with booleans" do
-        foo = Foo.create('cx', :x => false)
+        foo = Foo.create(context, :x => false)
         assert_equal false, foo.reload.x
       end
 
       should "work with integers" do
-        foo = Foo.create('cx', :x => -42)
+        foo = Foo.create(context, :x => -42)
         assert_equal -42, foo.reload.x
       end
 
       should "work with floats" do
-        foo = Foo.create('cx', :x => 3.141)
+        foo = Foo.create(context, :x => 3.141)
         assert_equal 3.141, foo.reload.x
       end
 
       should "work with strings" do
-        foo = Foo.create('cx', :x => 'hello')
+        foo = Foo.create(context, :x => 'hello')
         assert_equal 'hello', foo.reload.x
       end
 
       should "work with lists" do
-        foo = Foo.create('cx', :x => [1, 2, 3])
+        foo = Foo.create(context, :x => [1, 2, 3])
         assert_equal [1, 2, 3], foo.reload.x
       end
 
       should "work with hashes" do
         hash = { 'a' => 17, 'b' => 'test' }
-        foo = Foo.create('cx', :x => hash)
+        foo = Foo.create(context, :x => hash)
         assert_equal hash, foo.reload.x
       end
     end
@@ -266,8 +266,8 @@ class TestEntity < Test::Unit::TestCase
 
   context "#restore" do
     should "restore an entity from json" do
-      before = Foo.create('cx', :x => 42, :y => true)
-      after = Foo.restore(before.context, before.key, before.to_json)
+      before = Foo.create(context, :x => 42, :y => true)
+      after = Foo.restore(context, before.key, before.to_json)
       assert_equal before.key, after.key
       assert_equal before.x, after.x
       assert_equal before.y, after.y

data/test/test_entity_defaults.rb

@@ -10,35 +10,35 @@ class TestEntityDefaults < Test::Unit::TestCase
 
   context "[default values]" do
     should "be returned for missing properties" do
-      bar = Bar.new('cx')
+      bar = Bar.new(context)
       assert_equal 123, bar.simple
     end
 
     should "be returned for properties that are nil" do
-      bar = Bar.new('cx', :simple => 'cool')
+      bar = Bar.new(context, :simple => 'cool')
       bar.simple = nil
       assert_equal 123, bar.simple
     end
 
     should "not be returned for given properties" do
-      bar = Bar.new('cx', :simple => 'cool')
+      bar = Bar.new(context, :simple => 'cool')
       assert_equal 'cool', bar.simple
     end
 
     should "not be stored" do
-      bar = Bar.create('cx')
-      assert !(/123/ =~ redis.hget('cx', bar.key))
+      bar = Bar.create(context)
+      assert !(/123/ =~ redis.hget(context, bar.key))
     end
 
     should "be returned by as_json" do
-      bar = Bar.new('cx')
+      bar = Bar.new(context)
       assert_equal 123, bar.as_json[:simple]
     end
   end
 
   context "[collections]" do
     setup do
-      @bar, @baz = Bar.new('cx'), Bar.new('cx')
+      @bar, @baz = Bar.new(context), Bar.new(context)
     end
 
     should "not share arrays" do

data/test/test_entity_delete.rb

@@ -19,27 +19,27 @@ class TestEntityDelete < Test::Unit::TestCase
   context "delete" do
     setup do
       redis.flushdb
-      @group = Group.create('cx', :name => 'ruby user group')
+      @group = Group.create(context, :name => 'ruby user group')
       @tim = @group.members.create(:name => 'Tim')
       @group.members.create(:name => 'Ben')
-      @room = Room.create(:name => 'some office')
+      @room = Room.create(context, :name => 'some office')
       @group.room = @room
       @group.reload
     end
 
     should "ensure that the entity is persistent" do
-      assert_raise(Remodel::EntityNotSaved) { Group.new('cx').delete }
+      assert_raise(Remodel::EntityNotSaved) { Group.new(context).delete }
     end
 
     should "delete the given entity" do
       @group.delete
-      assert_nil redis.hget(@group.context, @group.key)
+      assert_nil redis.hget(context.key, @group.key)
     end
 
     should "delete any associations in redis" do
       @group.delete
-      assert_nil redis.hget(@group.context, "#{@group.key}_members")
-      assert_nil redis.hget(@group.context, "#{@group.key}_room")
+      assert_nil redis.hget(context.key, "#{@group.key}_members")
+      assert_nil redis.hget(context.key, "#{@group.key}_room")
     end
 
     context "has_one" do

data/test/test_entity_shortnames.rb

@@ -8,25 +8,25 @@ class TestEntityShortnames < Test::Unit::TestCase
 
   context "[short names]" do
     setup do
-      @bar = Bar.create('cx', :foo => 42)
+      @bar = Bar.create(context, :foo => 42)
     end
-    
+
     should "be used when storing properties" do
-      serialized = redis.hget('cx', @bar.key)
+      serialized = redis.hget(context.key, @bar.key)
       assert !serialized.match(/foo/)
       assert serialized.match(/z/)
     end
-    
+
     should "work in roundtrip" do
       @bar.reload
       assert_equal 42, @bar.foo
     end
-    
+
     should "not be used in as_json" do
       assert !@bar.as_json.has_key?(:z)
       assert @bar.as_json.has_key?(:foo)
     end
-    
+
     should "not be used in inspect" do
       assert !@bar.inspect.match(/z/)
       assert @bar.inspect.match(/foo/)

data/test/test_many_to_many.rb

@@ -14,19 +14,19 @@ class TestManyToMany < Test::Unit::TestCase
 
   context "both associations" do
     should "be empty by default" do
-      assert_equal [], Person.new('cx').groups
-      assert_equal [], Group.new('cx').members
+      assert_equal [], Person.new(context).groups
+      assert_equal [], Group.new(context).members
     end
 
     context "create" do
       should "add a new group to both associations" do
-        tim = Person.create('cx', :name => 'tim')
+        tim = Person.create(context, :name => 'tim')
         rugb = tim.groups.create :name => 'rug-b'
         assert_equal [tim], rugb.members
       end
 
       should "add a new person to both associations" do
-        rugb = Group.create('cx', :name => 'rug-b')
+        rugb = Group.create(context, :name => 'rug-b')
         tim = rugb.members.create :name => 'tim'
         assert_equal [rugb], tim.groups
       end
@@ -34,8 +34,8 @@ class TestManyToMany < Test::Unit::TestCase
 
     context "add" do
       setup do
-        @tim = Person.create('cx', :name => 'tim')
-        @rugb = Group.create('cx', :name => 'rug-b')
+        @tim = Person.create(context, :name => 'tim')
+        @rugb = Group.create(context, :name => 'rug-b')
       end
 
       should "add a new group to both associations" do
@@ -53,7 +53,7 @@ class TestManyToMany < Test::Unit::TestCase
 
     context "remove" do
       setup do
-        @tim = Person.create('cx', :name => 'tim')
+        @tim = Person.create(context, :name => 'tim')
         @rugb = @tim.groups.create(:name => 'rug-b')
         @erlang = @tim.groups.create(:name => 'erlang')
         @aws = @tim.groups.create(:name => 'aws')

data/test/test_many_to_one.rb

@@ -16,29 +16,29 @@ class TestManyToOne < Test::Unit::TestCase
   context "has_many" do
     context "association" do
       should "exist" do
-        assert Puzzle.create('cx').respond_to?(:pieces)
+        assert Puzzle.create(context).respond_to?(:pieces)
       end
 
       should "return an empty list by default" do
-        assert_equal [], Puzzle.create('cx').pieces
+        assert_equal [], Puzzle.create(context).pieces
       end
       
       should "return any existing children" do
-        puzzle = Puzzle.create('cx')
-        red_piece = Piece.create('cx', :color => 'red')
-        blue_piece = Piece.create('cx', :color => 'blue')
+        puzzle = Puzzle.create(context)
+        red_piece = Piece.create(context, :color => 'red')
+        blue_piece = Piece.create(context, :color => 'blue')
         value = JSON.generate([red_piece.key, blue_piece.key])
-        redis.hset 'cx', "#{puzzle.key}_pieces", value
+        redis.hset(context.key, "#{puzzle.key}_pieces", value)
         assert_equal 2, puzzle.pieces.size
         assert_equal Piece, puzzle.pieces[0].class
         assert_equal 'red', puzzle.pieces[0].color
       end
 
       should "not return any child multiple times" do
-        puzzle = Puzzle.create('cx')
-        red_piece = Piece.create('cx', :color => 'red')
+        puzzle = Puzzle.create(context)
+        red_piece = Piece.create(context, :color => 'red')
         value = JSON.generate([red_piece.key, red_piece.key])
-        redis.hset 'cx', "#{puzzle.key}_pieces", value
+        redis.hset(context.key, "#{puzzle.key}_pieces", value)
         assert_equal 1, puzzle.pieces.size
         assert_equal Piece, puzzle.pieces[0].class
         assert_equal 'red', puzzle.pieces[0].color
@@ -46,17 +46,17 @@ class TestManyToOne < Test::Unit::TestCase
 
       context "create" do
         should "have a create method" do
-          assert Puzzle.create('cx').pieces.respond_to?(:create)
+          assert Puzzle.create(context).pieces.respond_to?(:create)
         end
 
         should "work without attributes" do
-          puzzle = Puzzle.create('cx')
+          puzzle = Puzzle.create(context)
           piece = puzzle.pieces.create
           assert piece.is_a?(Piece)
         end
 
         should "create and store a new child" do
-          puzzle = Puzzle.create('cx')
+          puzzle = Puzzle.create(context)
           puzzle.pieces.create :color => 'green'
           assert_equal 1, puzzle.pieces.size
           puzzle.reload
@@ -66,7 +66,7 @@ class TestManyToOne < Test::Unit::TestCase
         end
 
         should "associate the created child with self" do
-          puzzle = Puzzle.create('cx', :topic => 'provence')
+          puzzle = Puzzle.create(context, :topic => 'provence')
           piece = puzzle.pieces.create :color => 'green'
           assert_equal 'provence', piece.puzzle.topic
         end
@@ -74,8 +74,8 @@ class TestManyToOne < Test::Unit::TestCase
 
       context "add" do
         should "add the given entity to the association" do
-          puzzle = Puzzle.create('cx')
-          piece = Piece.create('cx', :color => 'white')
+          puzzle = Puzzle.create(context)
+          piece = Piece.create(context, :color => 'white')
           puzzle.pieces.add piece
           assert_equal 1, puzzle.pieces.size
           puzzle.reload
@@ -87,7 +87,7 @@ class TestManyToOne < Test::Unit::TestCase
 
       context "find" do
         setup do
-          @puzzle = Puzzle.create('cx')
+          @puzzle = Puzzle.create(context)
           5.times { @puzzle.pieces.create :color => 'blue' }
         end
 
@@ -106,9 +106,9 @@ class TestManyToOne < Test::Unit::TestCase
 
   context "reload" do
     should "reset has_many associations" do
-      puzzle = Puzzle.create('cx')
+      puzzle = Puzzle.create(context)
       piece = puzzle.pieces.create :color => 'black'
-      redis.hdel 'cx', "#{puzzle.key}_pieces"
+      redis.hdel(context.key, "#{puzzle.key}_pieces")
       puzzle.reload
       assert_equal [], puzzle.pieces
     end

data/test/test_mappers.rb

@@ -15,7 +15,7 @@ class TestMappers < Test::Unit::TestCase
 
   context "create" do
     setup do
-      @item = Item.create('cx', :time => Time.at(1234567890), :date => Date.parse("1972-06-16"))
+      @item = Item.create(context, :time => Time.at(1234567890), :date => Date.parse("1972-06-16"))
     end
 
     should "store unmapped values" do
@@ -35,13 +35,13 @@ class TestMappers < Test::Unit::TestCase
     end
 
     should "serialize mapped values correctly" do
-      json = redis.hget(@item.context, @item.key)
+      json = redis.hget(context.key, @item.key)
       assert_match /1234567890/, json
       assert_match /"1972-06-16"/, json
     end
 
     should "handle nil values" do
-      item = Item.create('cx')
+      item = Item.create(context)
       assert_nil item.boolean
       assert_nil item.string
       assert_nil item.integer
@@ -53,14 +53,14 @@ class TestMappers < Test::Unit::TestCase
     end
 
     should "reject invalid types" do
-      assert_raise(Remodel::InvalidType) { Item.create('cx', :boolean => 'hello') }
-      assert_raise(Remodel::InvalidType) { Item.create('cx', :string => true) }
-      assert_raise(Remodel::InvalidType) { Item.create('cx', :integer => 33.5) }
-      assert_raise(Remodel::InvalidType) { Item.create('cx', :float => 5) }
-      assert_raise(Remodel::InvalidType) { Item.create('cx', :array => {}) }
-      assert_raise(Remodel::InvalidType) { Item.create('cx', :hash => []) }
-      assert_raise(Remodel::InvalidType) { Item.create('cx', :time => Date.new) }
-      assert_raise(Remodel::InvalidType) { Item.create('cx', :date => Time.now) }
+      assert_raise(Remodel::InvalidType) { Item.create(context, :boolean => 'hello') }
+      assert_raise(Remodel::InvalidType) { Item.create(context, :string => true) }
+      assert_raise(Remodel::InvalidType) { Item.create(context, :integer => 33.5) }
+      assert_raise(Remodel::InvalidType) { Item.create(context, :float => 5) }
+      assert_raise(Remodel::InvalidType) { Item.create(context, :array => {}) }
+      assert_raise(Remodel::InvalidType) { Item.create(context, :hash => []) }
+      assert_raise(Remodel::InvalidType) { Item.create(context, :time => Date.new) }
+      assert_raise(Remodel::InvalidType) { Item.create(context, :date => Time.now) }
     end
   end
 

data/test/test_one_to_many.rb

@@ -16,65 +16,65 @@ class TestOneToMany < Test::Unit::TestCase
   context "has_one" do
     context "association getter" do
       should "exist" do
-        assert Piece.create('cx').respond_to?(:puzzle)
+        assert Piece.create(context).respond_to?(:puzzle)
       end
 
       should "return nil by default" do
-        assert_nil Piece.create('cx').puzzle
+        assert_nil Piece.create(context).puzzle
       end
 
       should "return the associated entity" do
-        puzzle = Puzzle.create('cx', :topic => 'animals')
-        piece = Piece.create('cx')
-        redis.hset('cx', "#{piece.key}_puzzle", puzzle.key)
+        puzzle = Puzzle.create(context, :topic => 'animals')
+        piece = Piece.create(context)
+        redis.hset(context.key, "#{piece.key}_puzzle", puzzle.key)
         assert_equal 'animals', piece.puzzle.topic
       end
     end
 
     context "association setter" do
       should "exist" do
-        assert Piece.create('cx').respond_to?(:'puzzle=')
+        assert Piece.create(context).respond_to?(:'puzzle=')
       end
 
       should "store the key of the associated entity" do
-        puzzle = Puzzle.create('cx')
-        piece = Piece.create('cx')
+        puzzle = Puzzle.create(context)
+        piece = Piece.create(context)
         piece.puzzle = puzzle
-        assert_equal puzzle.key, redis.hget(puzzle.context, "#{piece.key}_puzzle")
+        assert_equal puzzle.key, redis.hget(context.key, "#{piece.key}_puzzle")
       end
 
       should "add the entity to the reverse association" do
-        puzzle = Puzzle.create('cx')
-        piece = Piece.create('cx')
+        puzzle = Puzzle.create(context)
+        piece = Piece.create(context)
         piece.puzzle = puzzle
         assert_equal 1, puzzle.pieces.size
         assert_equal piece.id, puzzle.pieces.first.id
       end
       
       should "remove the entity from the old reverse association" do
-        puzzle = Puzzle.create('cx')
+        puzzle = Puzzle.create(context)
         piece = puzzle.pieces.create
-        new_puzzle = Puzzle.create('cx')
+        new_puzzle = Puzzle.create(context)
         piece.puzzle = new_puzzle
         assert_equal [], puzzle.reload.pieces
       end
 
       should "be settable to nil" do
-        piece = Piece.create('cx')
+        piece = Piece.create(context)
         piece.puzzle = nil
         assert_nil piece.puzzle
       end
 
       should "remove the key if set to nil" do
-        piece = Piece.create('cx')
-        piece.puzzle = Puzzle.create('cx')
+        piece = Piece.create(context)
+        piece.puzzle = Puzzle.create(context)
         piece.puzzle = nil
         assert_nil redis.hget(piece.context, "#{piece.key}_puzzle")
       end
 
       should "remove the entity from the reverse association if set to nil" do
-        puzzle = Puzzle.create('cx')
-        piece = Piece.create('cx')
+        puzzle = Puzzle.create(context)
+        piece = Piece.create(context)
         piece.puzzle = puzzle
         piece.puzzle = nil
         puzzle.reload
@@ -85,9 +85,9 @@ class TestOneToMany < Test::Unit::TestCase
 
   context "reload" do
     should "reset has_one associations" do
-      piece = Piece.create('cx', :color => 'black')
-      piece.puzzle = Puzzle.create('cx')
-      redis.hdel 'cx', "#{piece.key}_puzzle"
+      piece = Piece.create(context, :color => 'black')
+      piece.puzzle = Puzzle.create(context)
+      redis.hdel(context.key, "#{piece.key}_puzzle")
       piece.reload
       assert_nil piece.puzzle
     end

data/test/test_one_to_one.rb

@@ -14,14 +14,14 @@ class TestOneToOne < Test::Unit::TestCase
 
   context "both associations" do
     should "be nil by default" do
-      assert_equal nil, Man.new('cx').wife
-      assert_equal nil, Woman.new('cx').husband
+      assert_equal nil, Man.new(context).wife
+      assert_equal nil, Woman.new(context).husband
     end
 
     context "setter" do
       setup do
-        @bill = Man.create('cx', :name => 'Bill')
-        @mary = Woman.create('cx', :name => 'Mary')
+        @bill = Man.create(context, :name => 'Bill')
+        @mary = Woman.create(context, :name => 'Mary')
       end
 
       context "non-nil value" do

data/test/test_remodel.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+class TestRemodel < Test::Unit::TestCase
+
+  context "create_context" do
+    should "create a context" do
+      context = Remodel.create_context('foo')
+      assert_equal Remodel::Context, context.class
+      assert_equal 'foo', context.key
+    end
+
+    should "create a caching context, if specified" do
+      context = Remodel.create_context('foo', :caching => true)
+      assert_equal Remodel::CachingContext, context.class
+      assert_equal 'foo', context.key
+    end
+  end
+
+end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 3
-  - 1
-  version: 0.3.1
+  - 4
+  - 0
+  version: 0.4.0
 platform: ruby
 authors: 
 - Tim Lossen
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-06-16 00:00:00 +02:00
+date: 2011-07-05 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -36,10 +36,13 @@ files:
 - docs/remodel.html
 - example/book.rb
 - lib/remodel.rb
+- lib/remodel/caching_context.rb
+- lib/remodel/context.rb
 - lib/remodel/entity.rb
 - lib/remodel/has_many.rb
 - lib/remodel/mapper.rb
 - test/helper.rb
+- test/test_caching_context.rb
 - test/test_entity.rb
 - test/test_entity_defaults.rb
 - test/test_entity_delete.rb
@@ -50,6 +53,7 @@ files:
 - test/test_monkeypatches.rb
 - test/test_one_to_many.rb
 - test/test_one_to_one.rb
+- test/test_remodel.rb
 has_rdoc: true
 homepage: http://github.com/tlossen/remodel
 licenses: []
@@ -84,6 +88,7 @@ specification_version: 3
 summary: a minimal ORM (object-redis-mapper)
 test_files: 
 - test/helper.rb
+- test/test_caching_context.rb
 - test/test_entity.rb
 - test/test_entity_defaults.rb
 - test/test_entity_delete.rb
@@ -94,3 +99,4 @@ test_files:
 - test/test_monkeypatches.rb
 - test/test_one_to_many.rb
 - test/test_one_to_one.rb
+- test/test_remodel.rb