remodel 0.1.4 → 0.3.0

data/README.md

@@ -5,6 +5,10 @@ use [redis](http://github.com/antirez/redis) instead of mysql to store your appl
 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.
 
+entities are serialized to json and stored as fields in a redis hash. using different hashes
+(called 'contexts' in remodel), you can easily separate data belonging to multiple users, 
+for example.
+
 
 ## why redis?
 
@@ -23,7 +27,7 @@ persistence to disk. for example, on my macbook (2 ghz):
 
 ## how to get started
 
-1. install [redis](http://github.com/antirez/redis) and ezras excellent
+1. install [redis](http://github.com/antirez/redis) and the
 [redis-rb](http://github.com/ezmobius/redis-rb) ruby client:
 
 		$ brew install redis
@@ -49,6 +53,7 @@ define your domain model [like this](http://github.com/tlossen/remodel/blob/mast
 	  has_many :chapters, :class => 'Chapter', :reverse => :book
 	  property :title, :class => 'String'
 	  property :year, :class => 'Integer'
+	  property :author, :class => 'String', :default => '(anonymous)'
 	end
 
 	class Chapter < Remodel::Entity
@@ -58,15 +63,20 @@ define your domain model [like this](http://github.com/tlossen/remodel/blob/mast
 	
 now you can do:
 
-	>> require 'example/book'
+	>> require './example/book'
 	=> true
-	>> book = Book.create :title => 'Moby Dick', :year => 1851
-	=> #<Book(b:3) title: "Moby Dick", year: 1851>
+	>> book = Book.create 'shelf', :title => 'Moby Dick', :year => 1851
+	=> #<Book(shelf, 1) title: "Moby Dick", year: 1851, author: "(anonymous)"> 
 	>> chapter = book.chapters.create :title => 'Ishmael'
-	=> #<Chapter(c:4) title: "Ishmael">
+	=> #<Chapter(shelf, 1) title: "Ishmael"> 
 	>> chapter.book
-	=> #<Book(b:3) title: "Moby Dick", year: 1851>
+	=> #<Book(shelf, 1) title: "Moby Dick", year: 1851, author: "(anonymous)"> 
+
+all entities have been created in the redis hash 'shelf' we have used as context:
 
+	>> Remodel.redis.hgetall 'shelf'
+	=> {"b"=>"1", "b1"=>"{\"title\":\"Moby Dick\",\"year\":1851}", "c"=>"1", 
+	   "c1"=>"{\"title\":\"Ishmael\"}", "c1_book"=>"b1", "b1_chapters"=>"[\"c1\"]"}
 
 ## inspired by
 
@@ -81,16 +91,15 @@ somewhat similar, but instead of serializing to json, stores each attribute unde
 ## todo
 
 * better docs
-* `find_by`
 * make serializer (json, messagepack, marshal ...) configurable
-* benchmarks
 
 
 ## status
 
-still pretty alpha &mdash; play around at your own risk :)
+it has some rough edges, but i have successfully been using remodel in production since summer 2010.
+
 
 
 ## license
 
-[MIT](http://github.com/tlossen/remodel/raw/master/LICENSE), baby!
+[MIT](http://github.com/tlossen/remodel/raw/master/LICENSE)

data/Rakefile

@@ -5,8 +5,8 @@ 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.summary = "remodel variant which uses hashes"
+    gem.description = "persist your objects to redis hashes."
     gem.email = "tim@lossen.de"
     gem.homepage = "http://github.com/tlossen/remodel"
     gem.authors = ["Tim Lossen"]

data/VERSION

@@ -1 +1 @@
-0.1.4
+0.3.0

data/example/book.rb

@@ -4,6 +4,7 @@ class Book < Remodel::Entity
   has_many :chapters, :class => 'Chapter', :reverse => :book
   property :title, :class => 'String'
   property :year, :class => 'Integer'
+  property :author, :class => 'String', :default => '(anonymous)'
 end
 
 class Chapter < Remodel::Entity

data/lib/remodel/entity.rb

@@ -2,24 +2,24 @@ module Remodel
 
   # The superclass of all persistent remodel entities.
   class Entity
-    attr_accessor :key
+    attr_accessor :context, :key
 
-    def initialize(attributes = {}, key = nil)
+    def initialize(context, attributes = {}, key = nil)
+      @context = context
       @attributes = {}
       @key = key
-      attributes = self.class.default_values.merge(attributes) if key.nil?
       attributes.each do |name, value|
         send("#{name}=", value) if respond_to? "#{name}="
       end
     end
 
     def id
-      key && key.split(':').last.to_i
+      key && key.match(/\d+/)[0].to_i
     end
 
     def save
-      @key = self.class.next_key unless @key
-      Remodel.redis.set(@key, to_json)
+      @key = next_key unless @key
+      Remodel.redis.hset(@context, @key, to_json)
       self
     end
 
@@ -30,20 +30,25 @@ module Remodel
 
     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_/
+      attributes = self.class.parse(self.class.fetch(@context, @key))
+      initialize(@context, attributes, @key)
+      self.class.associations.each do |name|
+        var = "@#{name}".to_sym
+        remove_instance_variable(var) if instance_variable_defined? var
       end
       self
     end
 
     def delete
       raise EntityNotSaved unless @key
-      Remodel.redis.del(@key)
+      Remodel.redis.hdel(@context, @key)
+      self.class.associations.each do |name|
+        Remodel.redis.hdel(@context, "#{@key}_#{name}")
+      end
     end
 
     def as_json
-      { :id => id }.merge(@attributes)
+      { :id => id }.merge(attributes)
     end
 
     def to_json
@@ -51,29 +56,21 @@ module Remodel
     end
 
     def inspect
-      properties = @attributes.map { |name, value| "#{name}: #{value.inspect}" }.join(', ')
-      "\#<#{self.class.name}(#{id}) #{properties}>"
-    end
-
-    def self.create(attributes = {})
-      new(attributes).save
+      properties = attributes.map { |name, value| "#{name}: #{value.inspect}" }.join(', ')
+      "\#<#{self.class.name}(#{context}, #{id}) #{properties}>"
     end
 
-    def self.find(key)
-      key = "#{key_prefix}:#{key}" if key.kind_of? Integer
-      restore(key, fetch(key))
+    def self.create(context, attributes = {})
+      new(context, attributes).save
     end
 
-    def self.all
-      keys = Remodel.redis.keys("#{key_prefix}:*").select { |k| k =~ /:[0-9]+$/ }
-      values = keys.empty? ? [] : Remodel.redis.mget(keys)
-      keys.zip(values).map do |key, json|
-        restore(key, json) if json
-      end.compact
+    def self.find(context, key)
+      key = "#{key_prefix}#{key}" if key.kind_of? Integer
+      restore(context, key, fetch(context, key))
     end
 
-    def self.restore(key, json)
-      new(parse(json), key)
+    def self.restore(context, key, json)
+      new(context, parse(json), key)
     end
 
   protected # --- DSL for subclasses ---
@@ -86,34 +83,37 @@ module Remodel
     def self.property(name, options = {})
       name = name.to_sym
       mapper[name] = Remodel.mapper_for(options[:class])
-      default_values[name] = options[:default] if options.has_key?(:default)
-      define_method(name) { @attributes[name] }
+      default_value = options[:default]
+      define_method(name) { @attributes[name].nil? ? self.class.copy_of(default_value) : @attributes[name] }
       define_method("#{name}=") { |value| @attributes[name] = value }
     end
 
     def self.has_many(name, options)
-      var = "@association_#{name}".to_sym
+      associations.push(name)
+      var = "@#{name}".to_sym
 
       define_method(name) do
         if instance_variable_defined? var
           instance_variable_get(var)
         else
           clazz = Class[options[:class]]
-          instance_variable_set(var, HasMany.new(self, clazz, "#{key}:#{name}", options[:reverse]))
+          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
+      associations.push(name)
+      var = "@#{name}".to_sym
 
       define_method(name) do
         if instance_variable_defined? var
           instance_variable_get(var)
         else
           clazz = Class[options[:class]]
-          value_key = Remodel.redis.get("#{key}:#{name}")
-          instance_variable_set(var, clazz.find(value_key)) if value_key
+          value_key = Remodel.redis.hget(self.context, "#{key}_#{name}")
+          value = value_key && clazz.find(self.context, value_key) rescue nil
+          instance_variable_set(var, value)
         end
       end
 
@@ -125,10 +125,10 @@ module Remodel
       define_method("_#{name}=") do |value|
         if value
           instance_variable_set(var, value)
-          Remodel.redis.set("#{key}:#{name}", value.key)
+          Remodel.redis.hset(self.context, "#{key}_#{name}", value.key)
         else
           remove_instance_variable(var) if instance_variable_defined? var
-          Remodel.redis.del("#{key}:#{name}")
+          Remodel.redis.hdel(self.context, "#{key}_#{name}")
         end
       end; private "_#{name}="
 
@@ -156,14 +156,22 @@ module Remodel
 
   private # --- Helper methods ---
 
-    def self.fetch(key)
-      Remodel.redis.get(key) || raise(EntityNotFound, "no #{name} with key #{key}")
+    def attributes
+      result = {}
+      self.class.mapper.keys.each do |name|
+        result[name] = send(name)
+      end
+      result
+    end
+
+    def self.fetch(context, key)
+      Remodel.redis.hget(context, key) || raise(EntityNotFound, "no #{name} with key #{key} in context #{context}")
     end
 
     # Each entity has its own sequence to generate unique ids.
-    def self.next_key
-      id = Remodel.redis.incr("#{key_prefix}:seq")
-      "#{key_prefix}:#{id}"
+    def next_key
+      id = Remodel.redis.hincrby(@context, "#{self.class.key_prefix}", 1)
+      "#{self.class.key_prefix}#{id}"
     end
 
     # Default key prefix is the first letter of the class name, in lowercase.
@@ -187,7 +195,7 @@ module Remodel
       result = {}
       attributes.each do |name, value|
         name = name.to_sym
-        result[name] = mapper[name].unpack(value)
+        result[name] = mapper[name].unpack(value) if mapper[name]
       end
       result
     end
@@ -197,8 +205,12 @@ module Remodel
       @mapper ||= {}
     end
 
-    def self.default_values
-      @default_values ||= {}
+    def self.associations
+      @associations ||= []
+    end
+
+    def self.copy_of(value)
+      value.is_a?(Array) || value.is_a?(Hash) ? value.dup : value
     end
 
   end

data/lib/remodel/has_many.rb

@@ -3,12 +3,12 @@ module Remodel
   # Represents the many-end of a many-to-one or many-to-many association.
   class HasMany < Array
     def initialize(this, clazz, key, reverse = nil)
-      super _fetch(clazz, key)
+      super _fetch(clazz, this.context, key)
       @this, @clazz, @key, @reverse = this, clazz, key, reverse
     end
 
     def create(attributes = {})
-      add(@clazz.create(attributes))
+      add(@clazz.create(@this.context, attributes))
     end
 
     def find(id)
@@ -29,13 +29,13 @@ module Remodel
 
     def _add(entity)
       self << entity
-      Remodel.redis.rpush(@key, entity.key)
+      _store
       entity
     end
 
     def _remove(entity)
       delete_if { |x| x.key == entity.key }
-      Remodel.redis.lrem(@key, 0, entity.key)
+      _store
       entity
     end
 
@@ -55,11 +55,15 @@ module Remodel
       end
     end
 
-    def _fetch(clazz, key)
-      keys = Remodel.redis.lrange(key, 0, -1)
-      values = keys.empty? ? [] : Remodel.redis.mget(keys)
+    def _store
+      Remodel.redis.hset(@this.context, @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.zip(values).map do |key, json|
-        clazz.restore(key, json) if json
+        clazz.restore(context, key, json) if json
       end.compact
     end
   end

data/lib/remodel.rb

@@ -34,6 +34,7 @@ module Remodel
   class EntityNotSaved < Error; end
   class InvalidKeyPrefix < Error; end
   class InvalidType < Error; end
+  class MissingContext < Error; end
 
   # By default, the redis server is expected to listen at `localhost:6379`.
   # Otherwise you will have to set `Remodel.redis` to a suitably initialized
@@ -45,7 +46,7 @@ module Remodel
   def self.redis=(redis)
     @redis = redis
   end
-
+  
   # Returns the mapper defined for a given class, or the identity mapper.
   def self.mapper_for(clazz)
     mapper_by_class[Class[clazz]]

data/test/helper.rb

@@ -9,5 +9,5 @@ class Test::Unit::TestCase
   def redis
     Remodel.redis
   end
-
+  
 end