remodel 0.1.0

data/.gitignore

@@ -0,0 +1,2 @@
+dump.rdb
+pkg/*

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Tim Lossen -- http://tim.lossen.de
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,103 @@
+# remodel your storage layer
+
+use [redis](http://github.com/antirez/redis) instead of mysql to store your application data.
+
+remodel (= redis model) is an ActiveRecord-like mapping layer which offers familiar syntax 
+like `has_many`, `has_one` etc. to build your domain model in ruby.
+
+
+## why redis?
+
+redis offers in-memory read and write performance — on the order of 10K to 100K 
+operations per second, comparable to [memcached](http://memcached.org/) — plus asynchronous
+persistence to disk. for example, on my macbook (2 ghz):
+
+	$ redis-benchmark -d 100 -r 10000 -q
+	SET: 13864.27 requests per second
+	GET: 18152.17 requests per second
+	INCR: 17006.80 requests per second
+	LPUSH: 17243.99 requests per second
+	LPOP: 18706.54 requests per second
+
+
+
+## how to get started
+
+1. install [redis](http://github.com/antirez/redis) and ezras excellent
+[redis-rb](http://github.com/ezmobius/redis-rb) ruby client:
+
+		$ brew install redis
+		$ gem install redis
+
+2. install the super-fast [yajl](http://github.com/lloyd/yajl) json parser
+plus ruby bindings:
+
+		$ brew install yajl
+		$ gem install yajl-ruby
+
+3. start redis:
+
+		$ redis-server
+
+4. now the tests should run successfully:
+
+		$ rake
+		Started
+		.................................................................
+		Finished in 0.063041 seconds.
+		65 tests, 103 assertions, 0 failures, 0 errors
+
+
+## example
+
+define your domain model [like this](http://github.com/tlossen/remodel/blob/master/example/book.rb):
+
+	class Book < Remodel::Entity
+	  has_many :chapters, :class => 'Chapter', :reverse => :book
+	  property :title, :class => 'String'
+	  property :year, :class => 'Integer'
+	end
+
+	class Chapter < Remodel::Entity
+	  has_one :book, :class => Book, :reverse => :chapters
+	  property :title, :class => String
+	end
+	
+now you can do:
+
+	>> require 'example/book'
+	=> true
+	>> book = Book.create :title => 'Moby Dick', :year => 1851
+	=> #<Book(b:3) title: "Moby Dick", year: 1851>
+	>> chapter = book.chapters.create :title => 'Ishmael'
+	=> #<Chapter(c:4) title: "Ishmael">
+	>> chapter.book
+	=> #<Book(b:3) title: "Moby Dick", year: 1851>
+
+
+## inspired by
+
+* [how to redis](http://www.paperplanes.de/2009/10/30/how_to_redis.html)
+&mdash; good overview of different mapping options by [mattmatt](http://github.com/mattmatt).
+* [hurl](http://github.com/defunkt/hurl) &mdash; basically i started with
+defunkts [Hurl::Model](http://github.com/defunkt/hurl/blob/master/models/model.rb).
+* [ohm](http://github.com/soveran/ohm) &mdash; object-hash mapping for redis. 
+somewhat similar, but instead of serializing to json, stores each attribute under a separate key.
+
+
+## todo
+
+* documentation ([rocco](http://github.com/rtomayko/rocco))
+* benchmarks
+* `delete`
+* `find_by`
+
+
+## status
+
+alpha. play around at your own risk :)
+
+
+## license
+
+[MIT](http://github.com/tlossen/remodel/raw/master/LICENSE), baby!

data/Rakefile

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "remodel"
+    gem.summary = "a minimal ORM (object-redis-mapper)"
+    gem.description = "build your domain model in ruby, persist your objects to redis."
+    gem.email = "tim@lossen.de"
+    gem.homepage = "http://github.com/tlossen/remodel"
+    gem.authors = ["Tim Lossen"]
+    gem.files.include('lib/**/*.rb')
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/redis-monitor.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+# http://gist.github.com/267149 (mathias meyer)
+
+require 'socket'
+host = ARGV[0] || 'localhost'
+port = ARGV[1] || '6379'
+
+trap(:INT) {
+  exit
+}
+
+puts "Connecting to #{host}:#{port}"
+begin
+  sock = TCPSocket.new(host, port)
+  sock.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1
+
+  sock.write("monitor\r\n")
+
+  while line = sock.gets
+    puts line
+  end
+rescue Errno::ECONNREFUSED
+  puts "Connection refused"
+end

data/example/book.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + "/../lib/remodel"
+
+class Book < Remodel::Entity
+  has_many :chapters, :class => 'Chapter', :reverse => :book
+  property :title, :class => 'String'
+  property :year, :class => 'Integer'
+end
+
+class Chapter < Remodel::Entity
+  has_one :book, :class => Book, :reverse => :chapters
+  property :title, :class => String
+end
+

data/lib/remodel.rb

@@ -0,0 +1,279 @@
+require 'rubygems'
+require 'redis'
+require 'yajl'
+
+module Remodel
+
+  class Error < ::StandardError; end
+  class EntityNotFound < Error; end
+  class EntityNotSaved < Error; end
+  class InvalidKeyPrefix < Error; end
+  class InvalidType < Error; end
+  
+  class Mapper
+    def initialize(clazz = nil, pack_method = nil, unpack_method = nil)
+      @clazz = clazz
+      @pack_method = pack_method
+      @unpack_method = unpack_method
+    end
+    
+    def pack(value)
+      return nil if value.nil?
+      raise(InvalidType, "#{value.inspect} is not a #{@clazz}") if @clazz && !value.is_a?(@clazz)
+      @pack_method ? value.send(@pack_method) : value
+    end
+    
+    def unpack(value)
+      return nil if value.nil?
+      @unpack_method ? @clazz.send(@unpack_method, value) : value
+    end
+  end
+  
+  class HasMany < Array
+    def initialize(this, clazz, key, reverse = nil)
+      super fetch(clazz, key)
+      @this, @clazz, @key, @reverse = this, clazz, key, reverse
+    end
+    
+    def create(attributes = {})
+      add(@clazz.create(attributes))
+    end
+    
+    def add(entity)
+      add_to_reverse_association_of(entity) if @reverse
+      _add(entity)
+    end
+
+  private
+  
+    def _add(entity)
+      self << entity
+      Remodel.redis.rpush(@key, entity.key)
+      entity
+    end
+    
+    def _remove(entity)
+      delete_if { |x| x.key = entity.key }
+      Remodel.redis.lrem(@key, 0, entity.key)
+    end
+    
+    def add_to_reverse_association_of(entity)
+      if entity.send(@reverse).is_a? HasMany
+        entity.send(@reverse).send(:_add, @this)
+      else
+        entity.send("_#{@reverse}=", @this)
+      end
+    end
+  
+    def fetch(clazz, key)
+      keys = Remodel.redis.lrange(key, 0, -1)
+      values = keys.empty? ? [] : Remodel.redis.mget(keys)
+      keys.zip(values).map do |key, json|
+        clazz.restore(key, json) if json
+      end.compact
+    end
+  end
+  
+  class Entity
+    attr_accessor :key
+    
+    def initialize(attributes = {}, key = nil)
+      @attributes = {}
+      @key = key
+      attributes.each do |name, value|
+        send("#{name}=", value) if respond_to? "#{name}="
+      end
+    end
+    
+    def save
+      @key = self.class.next_key unless @key
+      Remodel.redis.set(@key, to_json)
+      self
+    end
+    
+    def reload
+      raise EntityNotSaved unless @key
+      initialize(self.class.parse(self.class.fetch(@key)), @key)
+      instance_variables.each do |var|
+        remove_instance_variable(var) if var =~ /^@association_/
+      end
+      self
+    end
+
+    def to_json
+      Yajl::Encoder.encode(self.class.pack(@attributes))
+    end
+    
+    def inspect
+      properties = @attributes.map { |name, value| "#{name}: #{value.inspect}" }.join(', ')
+      "\#<#{self.class.name}(#{key}) #{properties}>"
+    end
+
+    def self.create(attributes = {})
+      new(attributes).save
+    end
+  
+    def self.find(key)
+      restore(key, fetch(key))
+    end
+
+    def self.restore(key, json)
+      new(parse(json), key)
+    end
+    
+  protected
+
+    def self.set_key_prefix(prefix)
+      raise(InvalidKeyPrefix, prefix) unless prefix =~ /^[a-z]+$/
+      @key_prefix = prefix
+    end
+
+    def self.property(name, options = {})
+      name = name.to_sym
+      mapper[name] = Remodel.mapper_for(options[:class])
+      define_method(name) { @attributes[name] }
+      define_method("#{name}=") { |value| @attributes[name] = value }
+    end
+    
+    def self.has_many(name, options)
+      var = "@association_#{name}".to_sym
+      
+      define_method(name) do
+        if instance_variable_defined? var
+          instance_variable_get(var)
+        else
+          clazz = Remodel.find_class(options[:class])
+          instance_variable_set(var, HasMany.new(self, clazz, "#{key}:#{name}", options[:reverse]))
+        end
+      end
+    end
+    
+    def self.has_one(name, options)
+      var = "@association_#{name}".to_sym
+      
+      define_method(name) do
+        if instance_variable_defined? var
+          instance_variable_get(var)
+        else
+          clazz = Remodel.find_class(options[:class])
+          value_key = Remodel.redis.get("#{key}:#{name}")
+          instance_variable_set(var, clazz.find(value_key)) if value_key
+        end
+      end
+      
+      define_method("#{name}=") do |value|
+        send("_reverse_association_of_#{name}=", value) if options[:reverse]
+        send("_#{name}=", value)
+      end
+      
+      define_method("_#{name}=") do |value|
+        if value
+          instance_variable_set(var, value)
+          Remodel.redis.set("#{key}:#{name}", value.key)
+        else
+          remove_instance_variable(var) if instance_variable_defined? var
+          Remodel.redis.del("#{key}:#{name}")
+        end
+      end
+      
+      private "_#{name}="
+
+      if options[:reverse]
+        define_method("_reverse_association_of_#{name}=") do |value|
+          if value
+            association = value.send("#{options[:reverse]}")
+            if association.is_a? HasMany
+              association.send("_add", self)
+            else
+              value.send("_#{options[:reverse]}=", self)
+            end
+          else
+            if old_value = send(name)
+              association = old_value.send("#{options[:reverse]}")
+              if association.is_a? HasMany
+                association.send("_remove", self)
+              else
+                old_value.send("_#{options[:reverse]}=", nil)
+              end
+            end
+          end
+        end
+        
+        private "_reverse_association_of_#{name}="
+      end
+    end
+    
+  private
+  
+    def self.fetch(key)
+      Remodel.redis.get(key) || raise(EntityNotFound, "no #{name} with key #{key}")
+    end
+  
+    def self.next_key
+      counter = Remodel.redis.incr("#{key_prefix}:seq")
+      "#{key_prefix}:#{counter}"
+    end
+  
+    def self.key_prefix
+      @key_prefix ||= name.split('::').last[0,1].downcase
+    end
+    
+    def self.parse(json)
+      unpack(Yajl::Parser.parse(json))
+    end
+  
+    def self.pack(attributes)
+      result = {}
+      attributes.each do |name, value|
+        result[name] = mapper[name].pack(value)
+      end
+      result
+    end
+    
+    def self.unpack(attributes)
+      result = {}
+      attributes.each do |name, value|
+        name = name.to_sym
+        result[name] = mapper[name].unpack(value)
+      end
+      result
+    end
+    
+    def self.mapper
+      @mapper ||= {}
+    end
+  end
+  
+  def self.redis=(redis)
+    @redis = redis
+  end
+
+  def self.redis
+    @redis ||= Redis.new
+  end
+  
+private
+
+  # converts String, Symbol or Class into Class
+  def self.find_class(clazz)
+    return nil unless clazz
+    clazz.to_s.split('::').inject(Kernel) { |mod, name| mod.const_get(name) }
+  end
+
+  def self.mapper_for(clazz)
+    mapper_by_class[find_class(clazz)]
+  end
+  
+  def self.mapper_by_class
+    @mapper_by_class ||= Hash.new(Mapper.new).merge(
+      String => Mapper.new(String),
+      Integer => Mapper.new(Integer),
+      Float => Mapper.new(Float),
+      Array => Mapper.new(Array),
+      Hash => Mapper.new(Hash),
+      Date => Mapper.new(Date, :to_s, :parse),
+      Time => Mapper.new(Time, :to_i, :at)
+    )
+  end
+  
+end

data/remodel.gemspec

@@ -0,0 +1,64 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{remodel}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tim Lossen"]
+  s.date = %q{2010-03-23}
+  s.default_executable = %q{redis-monitor.rb}
+  s.description = %q{build your domain model in ruby, persist your objects to redis.}
+  s.email = %q{tim@lossen.de}
+  s.executables = ["redis-monitor.rb"]
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "LICENSE",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "bin/redis-monitor.rb",
+     "example/book.rb",
+     "lib/remodel.rb",
+     "remodel.gemspec",
+     "test/helper.rb",
+     "test/test_entity.rb",
+     "test/test_many_to_many.rb",
+     "test/test_many_to_one.rb",
+     "test/test_mappers.rb",
+     "test/test_one_to_many.rb",
+     "test/test_one_to_one.rb"
+  ]
+  s.homepage = %q{http://github.com/tlossen/remodel}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{a minimal ORM (object-redis-mapper)}
+  s.test_files = [
+    "test/helper.rb",
+     "test/test_entity.rb",
+     "test/test_many_to_many.rb",
+     "test/test_many_to_one.rb",
+     "test/test_mappers.rb",
+     "test/test_one_to_many.rb",
+     "test/test_one_to_one.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/test/helper.rb

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+require File.dirname(__FILE__) + '/../lib/remodel.rb'
+
+class Test::Unit::TestCase
+  
+  def redis
+    Remodel.redis
+  end
+  
+end

data/test/test_entity.rb

@@ -0,0 +1,220 @@
+require 'helper'
+
+class Foo < Remodel::Entity
+  property :x
+  property :y
+end
+
+class Bar < Remodel::Entity; end
+
+class TestEntity < Test::Unit::TestCase
+
+  context "new" do
+    should "set properties" do
+      foo = Foo.new :x => 1, :y => 2
+      assert 1, foo.x
+      assert 2, foo.y
+    end
+    
+    should "ignore undefined properties" do
+      foo = Foo.new :z => 3
+      assert foo.instance_eval { !@attributes.key? :z }
+    end
+  end
+  
+  context "reload" do
+    setup do
+      @foo = Foo.create :x => 'hello', :y => true
+    end
+
+    should "reload all properties" do
+      redis.set @foo.key, %q({"x":23,"y":"adios"})
+      @foo.reload
+      assert_equal 23, @foo.x
+      assert_equal 'adios', @foo.y
+    end
+    
+    should "keep the key" do
+      key = @foo.key
+      @foo.reload
+      assert_equal key, @foo.key
+    end
+    
+    should "stay the same object" do
+      id = @foo.object_id
+      @foo.reload
+      assert_equal id, @foo.object_id
+    end
+    
+    should "raise EntityNotFound if the entity does not exist any more" do
+      redis.del @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.reload }
+    end
+  end
+  
+  context "create" do
+    setup do
+      redis.flushdb
+    end
+    
+    should "work without attributes" do
+      foo = Foo.create
+      assert foo.is_a?(Foo)
+    end
+    
+    should "give the entity a key based on the class name" do
+      assert_equal 'f:1', Foo.create.key
+      assert_equal 'b:1', Bar.create.key
+      assert_equal 'b:2', Bar.create.key
+    end
+    
+    should "store the entity under its key" do
+      foo = Foo.create :x => 'hello', :y => false
+      assert redis.exists(foo.key)
+    end
+    
+    should "store all properties" do
+      foo = Foo.create :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 :x => 'hello', :y => false
+      assert !(/f:1/ =~ redis.get(foo.key))
+    end    
+  end
+  
+  context "save" do
+    setup do
+      redis.flushdb
+    end
+    
+    should "give the entity a key, if necessary" do
+      foo = Foo.new.save
+      assert foo.key
+    end
+    
+    should "store the entity under its key" do
+      foo = Foo.new :x => 'hello', :y => false
+      foo.save
+      assert redis.exists(foo.key)
+    end
+
+    should "store all properties" do
+      foo = Foo.new :x => 'hello', :y => false
+      foo.save
+      foo.reload
+      assert_equal 'hello', foo.x
+      assert_equal false, foo.y
+    end
+  end
+  
+   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.key
+     end
+     
+     should "ensure that the prefix is letters only" do
+       assert_raise(Remodel::InvalidKeyPrefix) do
+         class InvalidPrefix < Remodel::Entity; set_key_prefix '666'; end
+       end
+     end
+   end
+  
+  context "find" do
+    setup do
+      redis.flushdb
+      @foo = Foo.create :x => 'hello', :y => 123
+    end
+    
+    should "load an entity from redis" do
+      foo = Foo.find(@foo.key)
+      assert_equal foo.x, @foo.x
+      assert_equal foo.y, @foo.y
+    end
+    
+    should "raise EntityNotFound if the key does not exist" do
+      assert_raise(Remodel::EntityNotFound) { Foo.find(23) }
+    end
+  end
+  
+  context "properties" do
+    should "have property x" do
+      foo = Foo.new
+      foo.x = 23
+      assert_equal 23, foo.x
+      foo.x += 10
+      assert_equal 33, foo.x
+    end
+    
+    should "not have property z" do
+      foo = Foo.new
+      assert_raise(NoMethodError) { foo.z }
+      assert_raise(NoMethodError) { foo.z = 42 }
+    end
+    
+    context "types" do
+      should "work with nil" do
+        foo = Foo.create :x => nil
+        assert_equal nil, foo.reload.x
+      end
+      
+      should "work with booleans" do
+        foo = Foo.create :x => false
+        assert_equal false, foo.reload.x
+      end
+      
+      should "work with integers" do
+        foo = Foo.create :x => -42
+        assert_equal -42, foo.reload.x
+      end
+      
+      should "work with floats" do
+        foo = Foo.create :x => 3.141
+        assert_equal 3.141, foo.reload.x
+      end
+      
+      should "work with strings" do
+        foo = Foo.create :x => 'hello'
+        assert_equal 'hello', foo.reload.x
+      end
+
+      should "work with lists" do
+        foo = Foo.create :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 :x => hash
+        assert_equal hash, foo.reload.x
+      end
+    end
+  end
+  
+  context "json" do
+    should "serialize to json" do
+      foo = Foo.new :x => 42, :y => true
+      assert_match /"x":42/, foo.to_json
+      assert_match /"y":true/, foo.to_json
+    end
+  end
+  
+  context "restore" do
+    should "restore an entity from json" do
+      before = Foo.create :x => 42, :y => true
+      after = Foo.restore(before.key, before.to_json)
+      assert_equal before.key, after.key
+      assert_equal before.x, after.x
+      assert_equal before.y, after.y
+    end
+  end
+  
+end

data/test/test_many_to_many.rb

@@ -0,0 +1,53 @@
+require 'helper'
+
+class TestManyToMany < Test::Unit::TestCase
+
+  class Person < Remodel::Entity
+    has_many :groups, :class => 'TestManyToMany::Group', :reverse => 'members'
+    property :name
+  end
+
+  class Group < Remodel::Entity
+    has_many :members, :class => 'TestManyToMany::Person', :reverse => 'groups'
+    property :name
+  end
+
+  context "both associations" do
+    should "be empty by default" do
+      assert_equal [], Person.new.groups
+      assert_equal [], Group.new.members
+    end
+    
+    context "create" do
+      should "add a new group to both associations" do
+        tim = Person.create :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 :name => 'rug-b'
+        tim = rugb.members.create :name => 'tim'
+        assert_equal [rugb], tim.groups
+      end
+    end
+    
+    context "add" do
+      setup do
+        @tim = Person.create :name => 'tim'
+        @rugb = Group.create :name => 'rug-b'
+      end
+      
+      should "add a new group to both associations" do
+        @tim.groups.add(@rugb)
+        assert_equal [@tim], @rugb.members
+      end
+      
+      should "add a new person to both associations" do
+        @rugb.members.add(@tim)
+        assert_equal [@rugb], @tim.groups
+      end
+    end
+  end
+  
+end

data/test/test_many_to_one.rb

@@ -0,0 +1,88 @@
+require 'helper'
+
+class TestManyToOne < Test::Unit::TestCase
+
+  class Puzzle < Remodel::Entity
+    has_many :pieces, :class => 'TestManyToOne::Piece', :reverse => 'puzzle'
+    property :topic
+  end
+
+  class Piece < Remodel::Entity
+    has_one :puzzle, :class => 'TestManyToOne::Puzzle'
+    property :color
+  end
+
+  context "has_many" do
+    context "association" do
+      should "exist" do
+        assert Puzzle.create.respond_to?(:pieces)
+      end
+    
+      should "return an empty list by default" do
+        assert_equal [], Puzzle.create.pieces
+      end
+    
+      should "return any existing children" do
+        puzzle = Puzzle.create
+        redis.rpush "#{puzzle.key}:pieces", Piece.create(:color => 'red').key
+        redis.rpush "#{puzzle.key}:pieces", Piece.create(:color => 'blue').key
+        assert_equal 2, puzzle.pieces.size
+        assert_equal Piece, puzzle.pieces[0].class
+        assert_equal 'red', puzzle.pieces[0].color
+      end
+    
+      context "create" do
+        should "have a create method" do
+          assert Puzzle.create.pieces.respond_to?(:create)
+        end
+        
+        should "work without attributes" do
+          puzzle = Puzzle.create
+          piece = puzzle.pieces.create
+          assert piece.is_a?(Piece)
+        end
+      
+        should "create and store a new child" do
+          puzzle = Puzzle.create
+          puzzle.pieces.create :color => 'green'
+          assert_equal 1, puzzle.pieces.size
+          puzzle.reload
+          assert_equal 1, puzzle.pieces.size
+          assert_equal Piece, puzzle.pieces[0].class
+          assert_equal 'green', puzzle.pieces[0].color
+        end
+        
+        should "associate the created child with self" do
+          puzzle = Puzzle.create :topic => 'provence'
+          piece = puzzle.pieces.create :color => 'green'
+          assert_equal 'provence', piece.puzzle.topic
+        end
+      end
+
+      context "add" do
+        should "add the given entity to the association" do
+          puzzle = Puzzle.create
+          piece = Piece.create :color => 'white'
+          puzzle.pieces.add piece
+          assert_equal 1, puzzle.pieces.size
+          puzzle.reload
+          assert_equal 1, puzzle.pieces.size
+          assert_equal Piece, puzzle.pieces[0].class
+          assert_equal 'white', puzzle.pieces[0].color
+        end
+      end
+      
+    end
+  end
+  
+  context "reload" do
+    should "reset has_many associations" do
+      puzzle = Puzzle.create
+      piece = puzzle.pieces.create :color => 'black'
+      redis.del "#{puzzle.key}:pieces"
+      puzzle.reload
+      assert_equal [], puzzle.pieces
+    end
+  end
+  
+end

data/test/test_mappers.rb

@@ -0,0 +1,64 @@
+require 'helper'
+
+class Item < Remodel::Entity
+  property :string, :class => String
+  property :integer, :class => Integer
+  property :float, :class => Float
+  property :array, :class => Array
+  property :hash, :class => Hash
+  property :time, :class => Time
+  property :date, :class => Date
+end
+
+class TestMappers < Test::Unit::TestCase
+
+  context "create" do
+    setup do
+      @item = Item.create :time => Time.at(1234567890), :date => Date.parse("1972-06-16")
+    end
+    
+    should "store unmapped values" do
+      assert_equal Time, @item.instance_eval { @attributes[:time].class }
+      assert_equal Date, @item.instance_eval { @attributes[:date].class }
+    end
+    
+    should "not change mapped values" do
+      assert_equal Time.at(1234567890), @item.time
+      assert_equal Date.parse("1972-06-16"), @item.date
+    end
+
+    should "not change mapped values after reload" do
+      @item.reload
+      assert_equal Time.at(1234567890), @item.time
+      assert_equal Date.parse("1972-06-16"), @item.date
+    end
+    
+    should "serialize mapped values correctly" do
+      json = redis.get(@item.key)
+      assert_match /1234567890/, json
+      assert_match /"1972-06-16"/, json
+    end
+    
+    should "handle nil values" do
+      item = Item.create
+      assert_nil item.string
+      assert_nil item.integer
+      assert_nil item.float
+      assert_nil item.array
+      assert_nil item.hash
+      assert_nil item.time
+      assert_nil item.date
+    end
+    
+    should "reject invalid types" do
+      assert_raise(Remodel::InvalidType) { Item.create :string => true }
+      assert_raise(Remodel::InvalidType) { Item.create :integer => 33.5 }
+      assert_raise(Remodel::InvalidType) { Item.create :float => 5 }
+      assert_raise(Remodel::InvalidType) { Item.create :array => {} }
+      assert_raise(Remodel::InvalidType) { Item.create :hash => [] }
+      assert_raise(Remodel::InvalidType) { Item.create :time => Date.new }
+      assert_raise(Remodel::InvalidType) { Item.create :date => Time.now }
+    end
+  end
+
+end

data/test/test_one_to_many.rb

@@ -0,0 +1,87 @@
+require 'helper'
+
+
+class TestOneToMany < Test::Unit::TestCase
+
+  class Piece < Remodel::Entity
+    has_one :puzzle, :class => 'TestOneToMany::Puzzle', :reverse => 'pieces'
+    property :color
+  end
+
+  class Puzzle < Remodel::Entity
+    has_many :pieces, :class => 'TestOneToMany::Piece'
+    property :topic
+  end
+
+  context "has_one" do
+    context "association getter" do
+      should "exist" do
+        assert Piece.create.respond_to?(:puzzle)
+      end
+      
+      should "return nil by default" do
+        assert_nil Piece.create.puzzle
+      end
+      
+      should "return the associated entity" do
+        puzzle = Puzzle.create :topic => 'animals'
+        piece = Piece.create
+        redis.set("#{piece.key}:puzzle", puzzle.key)
+        assert_equal 'animals', piece.puzzle.topic
+      end
+    end 
+
+    context "association setter" do
+      should "exist" do
+        assert Piece.create.respond_to?(:'puzzle=')
+      end
+
+      should "store the key of the associated entity" do
+        puzzle = Puzzle.create
+        piece = Piece.create
+        piece.puzzle = puzzle
+        assert_equal puzzle.key, redis.get("#{piece.key}:puzzle")
+      end
+      
+      should "add the entity to the reverse association" do
+        puzzle = Puzzle.create
+        piece = Piece.create
+        piece.puzzle = puzzle
+        assert_equal 1, puzzle.pieces.size
+      end
+      
+      should "be settable to nil" do
+        piece = Piece.create
+        piece.puzzle = nil
+        assert_nil piece.puzzle
+      end
+
+      should "remove the key if set to nil" do
+        piece = Piece.create
+        piece.puzzle = Puzzle.create
+        piece.puzzle = nil
+        assert_nil redis.get("#{piece.key}:puzzle")
+      end
+      
+      should "remove the entity from the reverse association if set to nil" do
+        puzzle = Puzzle.create
+        piece = Piece.create
+        piece.puzzle = puzzle
+        piece.puzzle = nil
+        puzzle.reload
+        assert_equal 0, puzzle.pieces.size
+      end
+    end
+  end
+
+  context "reload" do
+    should "reset has_one associations" do
+      piece = Piece.create :color => 'black'
+      piece.puzzle = Puzzle.create
+      redis.del "#{piece.key}:puzzle"
+      piece.reload
+      assert_nil piece.puzzle
+    end
+  end
+  
+end

data/test/test_one_to_one.rb

@@ -0,0 +1,57 @@
+require 'helper'
+
+class TestOneToOne < Test::Unit::TestCase
+
+  class Man < Remodel::Entity
+    has_one :wife, :class => 'TestOneToOne::Woman', :reverse => 'husband'
+    property :name
+  end
+
+  class Woman < Remodel::Entity
+    has_one :husband, :class => 'TestOneToOne::Man', :reverse => 'wife'
+    property :name
+  end
+
+  context "both associations" do
+    should "be nil by default" do
+      assert_equal nil, Man.new.wife
+      assert_equal nil, Woman.new.husband
+    end
+    
+    context "setter" do
+      setup do
+        @bill = Man.create :name => 'Bill'
+        @mary = Woman.create :name => 'Mary'
+      end
+      
+      context "non-nil value" do
+        should "also set husband" do
+          @bill.wife = @mary
+          assert_equal @bill, @mary.husband
+        end
+      
+        should "also set wife" do
+          @mary.husband = @bill
+          assert_equal @mary, @bill.wife
+        end
+      end
+      
+      context "nil value" do
+        setup do
+          @bill.wife = @mary
+        end
+        
+        should "also clear husband" do
+          @bill.wife = nil
+          assert_equal nil, @mary.husband
+        end
+        
+        should "also clear wife" do
+          @mary.husband = nil
+          assert_equal nil, @bill.wife
+        end
+      end
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: remodel
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Tim Lossen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-23 00:00:00 +01:00
+default_executable: redis-monitor.rb
+dependencies: []
+
+description: build your domain model in ruby, persist your objects to redis.
+email: tim@lossen.de
+executables: 
+- redis-monitor.rb
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- .gitignore
+- LICENSE
+- README.md
+- Rakefile
+- VERSION
+- bin/redis-monitor.rb
+- example/book.rb
+- lib/remodel.rb
+- remodel.gemspec
+- test/helper.rb
+- test/test_entity.rb
+- test/test_many_to_many.rb
+- test/test_many_to_one.rb
+- test/test_mappers.rb
+- test/test_one_to_many.rb
+- test/test_one_to_one.rb
+has_rdoc: true
+homepage: http://github.com/tlossen/remodel
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: a minimal ORM (object-redis-mapper)
+test_files: 
+- test/helper.rb
+- test/test_entity.rb
+- test/test_many_to_many.rb
+- test/test_many_to_one.rb
+- test/test_mappers.rb
+- test/test_one_to_many.rb
+- test/test_one_to_one.rb