redisrecord 0.1

data/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2009 Mauro Pompilio
+
+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.markdown

@@ -0,0 +1,69 @@
+# RedisRecord
+A "virtual" Object Relational Mapper on top of [Redis](http://redis.googlecode.com).
+
+This is a proof-of-concept. Allows you to create schema-less data structures and <br/>
+build relationships between them, using Redis as storage.
+
+## Author
+Mauro Pompilio <hackers.are.rockstars@gmail.com>
+
+## License
+MIT
+
+## Example
+		
+		class User < RedisRecord::Base
+		  database 15
+		  has_many :posts
+		end
+		
+		class Post < RedisRecord::Base
+		  database 15
+		  belongs_to :user
+		  has_many :comments
+		end
+		
+		class Comment < RedisRecord::Base
+		  database 15
+		  belongs_to :post
+		  belongs_to :user
+		end 
+		
+		>> u = User.new
+		=> #<User:0xb761c3f0 @stored_attrs=#<Set: {}>, @cached_attrs={}, @opts={}>
+		>> u.name = 'Mauro'
+		=> "Mauro"
+		>> u.age = 25
+		=> 25
+		>> u.save
+		=> [:updated_at, :age, :name, :id, :created_at]
+		>> u.whatever = {:as_many_attributes => 'as you want'}
+		=> {:as_many_attributes=>"as you want"}
+		>> u.save
+		=> [:updated_at, :whatever]
+		>> u
+		=> #<User:0xb761c3f0 @stored_attrs=#<Set: {:updated_at, :age, :name, :whatever, :id, :created_at}>, @cached_attrs={:updated_at=>"1238173522.49843", :age=>25, :name=>"Mauro", :whatever=>{:as_many_attributes=>"as you want"}, :id=>1, :created_at=>"1238173522.49808"}, @opts={}>
+		>> u = User.find(1)
+		=> #<User:0xb760a2a4 @stored_attrs=#<Set: {:updated_at, :age, :name, :whatever, :id, :created_at}>, @cached_attrs={:updated_at=>"1238173566", :age=>"25", :name=>"Mauro", :whatever=>"as_many_attributesas you want", :id=>"1", :created_at=>"1238173522.49808"}, @opts={:stored=>true}>
+		>> p = Post.new
+		=> #<Post:0xb7608210 @stored_attrs=#<Set: {}>, @cached_attrs={:user_id=>nil}, @opts={}>
+		>> p.title = 'New Post'
+		=> "New Post"
+		>> p.user_id = u.id
+		=> "1"
+		>> p.save
+		=> [:updated_at, :title, :id, :user_id, :created_at:
+		>> p2 = Post.new
+		=> #<Post:0xb75e5ad0 @stored_attrs=#<Set: {}>, @cached_attrs={:user_id=>nil}, @opts={}>
+		>> p2.title = 'Another post'
+		=> "Another post"
+		>> p2.user_id = u.id
+		=> "1"
+		>> p2.save
+		=> [:updated_at, :title, :id, :user_id, :created_at]
+		>> p.user
+		=> #<User:0xb75ce754 @stored_attrs=#<Set: {:updated_at, :age, :name, :whatever, :id, :created_at}>, @cached_attrs={:updated_at=>"1238173566", :age=>"25", :name=>"Mauro", :whatever=>"as_many_attributesas you want", :id=>"1", :created_at=>"1238173522.49808"}, @opts={:stored=>true}>
+		>> p2.user
+		=> #<User:0xb75c8480 @stored_attrs=#<Set: {:updated_at, :age, :name, :whatever, :id, :created_at}>, @cached_attrs={:updated_at=>"1238173566", :age=>"25", :name=>"Mauro", :whatever=>"as_many_attributesas you want", :id=>"1", :created_at=>"1238173522.49808"}, @opts={:stored=>true}>
+		>> u.posts
+		=> [#<Post:0xb75c20a8 @stored_attrs=#<Set: {:updated_at, :title, :id, :user_id, :created_at}>, @cached_attrs={:updated_at=>"1238173641", :title=>"New Post", :id=>"1", :user_id=>"1", :created_at=>"1238173641.17936"}, @opts={:stored=>true}>, #<Post:0xb75bdb0c @stored_attrs=#<Set: {:updated_at, :title, :id, :user_id, :created_at}>, @cached_attrs={:updated_at=>"1238173858", :title=>"Another post", :id=>"2", :user_id=>"1", :created_at=>"1238173858.82325"}, @opts={:stored=>true}>]

data/examples/demo.rb

@@ -0,0 +1,60 @@
+# = Sample file
+require 'lib/redisrecord'
+
+# example.rb demo class
+class User < RedisRecord::Model
+  database 0
+  has_many :posts
+  #has_one :moderator
+end
+
+# example.rb demo class
+class Post < RedisRecord::Model
+  database 1
+  belongs_to :user
+  has_many :comments
+  has_and_belongs_to_many :categories
+end
+
+# example.rb demo class
+class Comment < RedisRecord::Model
+  database 15
+  belongs_to :post
+  belongs_to :user
+end
+
+# example.rb demo class
+class Category < RedisRecord::Model
+  has_and_belongs_to_many :posts
+end
+
+# example.rb demo class
+class Moderator < RedisRecord::Model
+  database 15
+  belongs_to :user
+end
+
+# Example
+#p u = User.new
+#p u.name = 'Mauro'
+#p u.age = 25
+#p u.save
+#p u.whatever = {:as_many_attributes => 'as you want'}
+#p u.save
+#p u
+#p u = User.find(1)
+#p p = Post.new
+#p p.title = 'New Post'
+#p p.user_id = u.id
+#p p.save
+#p p2 = Post.new
+#p p2.title = 'Another post'
+#p p2.user_id = u.id
+#p p2.save
+#p p.user
+#p p2.user
+#p u.posts
+
+# Flush DB
+#r = Redis.new(:db => 15)
+#r.flush_db

data/examples/sphinx.conf

@@ -0,0 +1,45 @@
+#
+# Sphinx configuration file sample for RedisRecord
+#
+
+# data source definition
+source redisrecord
+{
+  type= xmlpipe2
+  xmlpipe_command= cat /tmp/redisindex.xml
+}
+
+# index definition
+index redisindex
+{
+  source= redisrecord
+  path= /tmp/redisindex
+  docinfo= extern
+  mlock= 0
+  morphology= none
+  min_word_len= 1
+  charset_type= utf-8
+  html_strip= 0
+}
+
+# indexer settings
+indexer
+{
+  mem_limit= 32M
+}
+
+# searchd settings
+searchd
+{
+  port= 3312
+  log= /tmp/searchd.log
+  query_log= /tmp/query.log
+  read_timeout= 5
+  max_children= 30
+  pid_file= /tmp/searchd.pid
+  max_matches= 1000
+  seamless_rotate= 1
+  preopen_indexes= 0
+  unlink_old= 1
+}
+# --eof--

data/examples/users.yml

@@ -0,0 +1,9 @@
+one:
+  name: "Mauro"
+  lastname: "Pompilio"
+  age: 25
+
+two:
+  name: "Ivan"
+  lastname: "Belmonte"
+  age: 30

data/lib/redisrecord.rb

@@ -0,0 +1,374 @@
+# = RedisRecord
+# A "virtual" Object Relational Mapper on top of Redis[http://redis.googlecode.com].
+#
+# This is a proof-of-concept. Allows you to create schema-less data structures and
+# build relationships between them, using Redis as storage.
+#
+# == Main repository
+# http://github.com/malditogeek/redisrecord/tree/master
+#
+# == Author
+# Mauro Pompilio <hackers.are.rockstars@gmail.com>
+#
+# == License
+# MIT
+#
+
+require 'activesupport'
+require 'redis'
+
+# = RedisRecord
+module RedisRecord
+
+  # Not found exception.
+  class RecordNotFound < Exception; end
+
+  # Duplicate attribute exception.
+  class DuplicateAttribute < Exception; end
+ 
+  # Connection to Redis.
+  class RedisConnection < Redis; end
+
+  # Base class.
+  class Model
+    attr_reader :attrs, :stored_attrs
+
+    # Redis connection
+    @@redis = RedisConnection.new(:logger => Logger.new(STDOUT))
+
+    # Reflections
+    @@reflections = {}
+
+    # Class methods
+    class << self
+
+      # Generates reflections skeleton when the RedisRecord is inherited.
+      def inherited(klass)
+        @@reflections[klass.name.to_sym] = {}
+        [:belongs_to, :has_many].each do |r|
+          @@reflections[klass.name.to_sym][r] = []
+        end
+      end
+
+      # Retrieve records. Allowed: 
+      #  * :all
+      #  * :first
+      #  * :last
+      #  * one or more IDs.
+      # 
+      # Example: 
+      #  Post.find(:last)
+      #  Post.find(1)
+      #  Post.find([1,2,3])
+      #
+      # Allowed options:
+      #  * :should_raise: If *true* raise RecordNotFound exception on missing records. Defauls is *false*.
+      def find(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {} 
+        case args.first
+          when :all
+            find_all(options)
+          when :first
+            find_first(options)
+          when :last
+            find_last(options)
+          else
+            find_from_ids(args, options)
+        end
+      end
+
+      # Sort class objects by the given attribute. Defaults are: 
+      #  * :order => 'ALPHA DESC'
+      #  * :limit => 10
+      #
+      # Example:
+      #  Post.sort_by(:updated_at) #=> Last 10 updated posts
+      #  Post.sort_by(:id, :order => 'ALPHA ASC', :limit => 5) #=> First 5 posts
+      def sort_by(attribute, options={})
+        limit  = options[:limit]  || 10
+        offset = options[:offset] || 0
+        order  = options[:order]  || 'ALPHA DESC'
+        ids = @@redis.sort("#{name}:list", 
+                           :by => "#{name}:*:#{attribute}", 
+                           :limit => [offset, limit],
+                           :order => order,
+                           :get => "#{name}:*:id")
+        find_from_ids(ids, options)
+      end
+
+      def _connection
+        @@redis
+      end
+
+      def get_lookup(attr, value)
+        _connection.get("#{name}:lookup:#{attr}:#{value}")
+      end
+
+      private # class methods
+
+      # Captures the *class* missing methods.
+      def method_missing(*args)
+        case args[0].to_s
+          when /^find_by_/
+            lookup = args[0].to_s.gsub(/^find_by_/, '')
+            find(get_lookup(lookup, args[1]))
+        end
+      end
+
+      def find_all(options)
+        all_ids = @@redis.list_range("#{name}:list", 0, -1)
+        [find_from_ids(all_ids, options)].flatten
+      end
+
+      def find_first(options)
+        first_id = @@redis.list_index("#{name}:list", 0)
+        find_from_ids(first_id, options)
+      end
+
+      def find_last(options)
+        first_id = @@redis.list_index("#{name}:list", -1)
+        find_from_ids(first_id, options)
+      end
+
+      def find_from_ids(ids, options={})
+        records = []
+        ids = [ids].flatten
+        ids.each do |id|
+          begin
+            redis_attrs = @@redis.set_members("#{name}:#{id}:attrs").to_a
+            raise if redis_attrs.empty?
+            stored_attrs = @@redis.mget(redis_attrs.map {|a| "#{name}:#{id}:#{a}"})
+            object_attrs = {}
+            redis_attrs.each_with_index {|a,i| object_attrs[a.to_sym] = stored_attrs[i]}
+            records << instantiate(object_attrs)
+          rescue
+            raise RecordNotFound.new("#{name}:#{id}") if options[:should_raise]
+            #records << nil
+          end
+        end
+        (ids.length == 1 ? records[0] : records)
+      end
+
+      # Select which database to be used.
+      #  class Post < RedisRecord
+      #    database 15
+      #  end
+      def database(db)
+        puts 'Per class database selection is DISABLED.'
+        return false
+        #_connection.call_command ['select', db]
+      end
+
+      # Returns a new object with the given attributes hash.
+      def instantiate(instance_attrs={})
+        new(instance_attrs, :stored => true)
+      end
+
+      # Belongs_to relationship initialization.
+      #  class Post < RedisRecord
+      #    belongs_to :user
+      #  end
+      def belongs_to(*klasses)
+        klasses.each do |klass|
+          add_reflection :belongs_to, klass
+
+          fkey = klass.to_s.foreign_key.to_sym
+          define_method("#{klass}") do
+            k = klass.to_s.classify.constantize
+            k.find(@cached_attrs[fkey])
+          end
+          define_method("#{klass}=") do |new_value|
+            k = klass.to_s.classify.constantize
+            if new_value.is_a?(k)
+              @cached_attrs[fkey] = new_value.id
+              k.find(new_value.id)
+            end
+          end
+        end
+      end
+
+      # Has_many relationship initialization.
+      #  class Post < RedisRecord
+      #    has_many :comments
+      #  end
+      def has_many(*klasses)
+        klasses.each do |klass|
+          add_reflection :has_many, klass
+
+          define_method("#{klass}") {
+            k = klass.to_s.classify.constantize
+            ids = @@redis.set_members("#{self.class.name}:#{@cached_attrs[:id]}:_#{klass.to_s.singularize}_ids").to_a
+            ids.empty? ? [] : [k.find(ids)].flatten
+          }
+        end
+      end
+
+      # Has_one relationship initialization.
+      #  class Post < RedisRecord
+      #    has_one :permalink
+      #  end
+      #def has_one(klass)
+      #  add_reflection :has_one, klass
+      #  define_method("#{klass}") {
+      #    k = klass.to_s.classify.constantize
+      #    k.find(@@redis["#{self.class.name}:#{@cached_attrs[:id]}:_#{klass.to_s.singularize}_id"])
+      #  }
+      #end
+
+      # Has_and_belongs_to_many relationship initialization.
+      def has_and_belongs_to_many(klass)
+        has_many klass
+        belongs_to klass.to_s.singularize
+      end
+
+      def add_reflection(reflection, klass)
+        @@reflections[self.name.to_sym][reflection] << klass
+      end
+
+    end # Class methods
+
+    # Instantiate a new object with the given *attrs* hash.
+    def initialize(attrs={},opts={})
+      @opts = opts.freeze
+
+      # Object attrs
+      @cached_attrs, @stored_attrs = {}, Set.new
+      add_attributes attrs
+      attrs.keys.each {|k| @stored_attrs << k.to_sym} if @opts[:stored]
+      add_foreign_keys_as_attributes
+    end
+
+    # Save the (non-stored) object attributes to Redis.
+    def save
+      # Autoincremental ID unless specified
+      unless @cached_attrs.include?(:id)
+        add_attribute :id, @@redis.incr("#{self.class.name}:autoincrement")
+        add_attribute :created_at, Time.now.to_f.to_s
+        add_attribute :updated_at, Time.now.to_f.to_s
+        @@redis.push_tail("#{self.class.name}:list", @cached_attrs[:id]) # List of all the class objects
+      end
+
+      # Store each @cached_attrs
+      stored = Set.new
+      (@cached_attrs.keys - @stored_attrs.to_a).each do |k|
+          stored << k 
+          @stored_attrs << k
+          @@redis.set_add("#{self.class.name}:#{id}:attrs", k.to_s)
+          @@redis.set("#{self.class.name}:#{@cached_attrs[:id]}:#{k}", @cached_attrs[k])
+      end
+
+      # updated_at
+      @@redis.set("#{self.class.name}:#{@cached_attrs[:id]}:updated_at", Time.now.to_f.to_s)
+      stored << :updated_at 
+
+      # Relationships
+      @@reflections[self.class.name.to_sym][:belongs_to].each do |klass|
+        @@redis.set_add("#{klass.to_s.camelize}:#{@cached_attrs[klass.to_s.foreign_key.to_sym]}:_#{self.class.name.underscore}_ids", @cached_attrs[:id])
+      end
+
+      return stored.to_a
+    end
+
+    def destroy
+      if @cached_attrs[:id]
+        @@redis.list_rm("#{self.class.name}:list", 0, @cached_attrs[:id])
+        @cached_attrs.keys.each do |k|
+          @@redis.delete("#{self.class.name}:#{@cached_attrs[:id]}:#{k}")
+        end
+        @@redis.delete("#{self.class.name}:#{id}:attrs")
+
+        # Reflections
+        @@reflections[self.class.name.to_sym][:belongs_to].each do |klass|
+          fkey = @cached_attrs["#{klass}_id".to_sym]
+          @@redis.set_delete("#{klass.to_s.camelize}:#{fkey}:_#{self.class.name.downcase}_ids", @cached_attrs[:id]) if fkey
+        end
+
+        @cached_attrs = {}
+      end
+    end
+
+    # Returns *true* if there are unsaved attributes.
+    #  p = Post.new(:title => 'Lorem ipsum')
+    #  p.save
+    #  p.dirty? # => false
+    #  p.body = 'Dolor sit amet'
+    #  p.dirty? # => true
+    def dirty?
+      (@cached_attrs.keys - @stored_attrs.to_a).empty? ? false : true
+    end
+
+    # Returns *true* if the object wasn't stored before
+    def new_record?
+      @opts[:stored] == true ? false : true
+    end
+
+    # Current instance attributes
+    def attributes
+      @cached_attrs.keys
+    end
+
+    # Reload from store, keeps non-stored attributes.
+    def reload
+      attrs = @@redis.set_members("#{self.class.name}:#{@cached_attrs[:id]}:attrs").map(&:to_sym)
+      attrs.each do |attr|
+        @cached_attrs[attr] = @@redis.get("#{self.class.name}:#{@cached_attrs[:id]}:#{attr}")
+      end
+      self
+    end
+
+    # Force reload from store, wipes non-stored attributes.
+    def reload!
+      @cached_attrs = {:id => @cached_attrs[:id]}
+      reload
+    end
+
+    # Set a reverse lookup by attribute.
+    def set_lookup(attr)
+      self.class._connection.set("#{self.class.name}:lookup:#{attr}:#{self.send(attr)}", self.id) if self.id
+    end
+
+    private
+
+    # Captures the *instance* missing methods and converts it into instance attributes.
+    def method_missing(*args)
+      method = args[0].to_s
+      case args.length
+        when 2
+          k, v = method.delete('=').to_sym, args[1]
+          add_attribute k, v
+      end
+    end
+
+    # Add attributes to the instance cache and define the accessor methods
+    def add_attributes(hash)
+      hash.each_pair do |k,v|
+        k = k.to_sym
+        #raise DuplicateAttribute.new("#{k}") unless (k == :id or !self.respond_to?(k))
+        if k == :id or !self.respond_to?(k)
+          @cached_attrs[k] = v
+          meta = class << self; self; end
+          meta.send(:define_method, k) { @cached_attrs[k] }
+          meta.send(:define_method, "#{k}=") do |new_value| 
+            @cached_attrs[k] = new_value.is_a?(RedisRecord::Model) ? new_value.id : new_value
+            @stored_attrs.delete(k)
+          end
+        end
+      end
+      hash
+    end
+
+    # Wraper around add_attributes
+    def add_attribute(key, value=nil)
+      add_attributes({key => value})
+    end
+
+    # Add the foreign key for the belongs_to relationships
+    def add_foreign_keys_as_attributes
+      @@reflections[self.class.name.to_sym][:belongs_to].each do |klass|
+        add_attribute klass.to_s.foreign_key.to_sym
+      end
+    end
+
+  end
+
+end

data/lib/redisrecord/extensions.rb

@@ -0,0 +1,112 @@
+# = RedisRecord extensions
+#
+# This extensions should be required manually and add the following specific funcionality:
+#
+#  * populate_from_yaml: Allows you to populate a DB from a YAML file.
+#  * Sphinx extensions:
+#    * sphinx_export: Export records to xmlpipe2-compatible XML files.
+#    * search: Sphinx query interface for RedisRecord.
+#
+require 'yaml'
+
+begin
+  require 'xml'
+rescue LoadError
+  $stderr.puts '[error] Missing gem: "libxml-ruby". Try: sudo gem install libxml-ruby'
+end
+
+begin
+  require 'riddle'
+rescue LoadError
+  $stderr.puts '[error] Missing gem: "riddle". Try: sudo gem install riddle'
+end
+
+module RedisRecord
+  class Base
+    class << self
+      # IMPORTANT: This method is part of the *RedisRecord extensions*.
+      #
+      # Accepts a YAML file as input to populate the database. 
+      #
+      # A sample YAML file can be found in the *samples* directory.
+      def populate_from_yaml(yaml_file)
+        entries = YAML::load_file(yaml_file)
+        records = []
+        entries.keys.each do |k|
+          begin
+            r = new(entries[k])
+        	  r.save 
+        	  records << r
+          rescue Exception => e 
+        	  records << nil
+          end
+        end
+        records
+      end
+
+      # IMPORTANT: This method is part of the *RedisRecord extensions*.
+      #
+      # Generates an Sphinx xmlpipe2-compatible XML file ready to be
+      # indexed.
+      #
+      # Parameters:
+      #  * records: An array of RedisRecord entries
+      #  * outfile: Output XML file path. Default is '/tmp/redisindex.xml'
+      #
+      # Depends on: *libxml-ruby* gem.
+      #
+      # A sample *sphinx.conf* file can be found in the *samples* directory.
+      def sphinx_export(records, outfile='/tmp/redisindex.xml')
+        sphinx_docset = XML::Document.new()
+        sphinx_docset.root = XML::Node.new('sphinx:docset')
+        
+        sphinx_schema = XML::Node.new('sphinx:schema')
+        records_attrs = records.map {|r| r.attrs }
+        records_attrs.flatten!.uniq!
+        [:created_at, :updated_at].each do |a|
+          records_attrs.delete(a)
+          sphinx_attr = XML::Node.new('sphinx:attr')
+          sphinx_attr.attributes['name'] = a.to_s
+          sphinx_attr.attributes['type'] = 'timestamp'
+          sphinx_schema << sphinx_attr
+        end
+
+        records_attrs.each do |a|
+          sphinx_field = XML::Node.new('sphinx:field')
+          sphinx_field.attributes['name']= a.to_s
+          sphinx_schema << sphinx_field
+        end
+        sphinx_attr = XML::Node.new('sphinx:field')
+        sphinx_attr.attributes['name'] = 'class'
+        sphinx_schema << sphinx_attr
+        
+        sphinx_docset.root << sphinx_schema
+        
+        records.each do |record| 
+          sphinx_doc = XML::Node.new('sphinx:document')
+          sphinx_doc.attributes['id'] = record.id
+          sphinx_doc << XML::Node.new('class', record.class.name)
+          record.attrs.each {|key| sphinx_doc << XML::Node.new(key, record.send(key).to_s) }
+          sphinx_docset.root << sphinx_doc 
+        end
+        
+        sphinx_docset.save(outfile)
+        sphinx_docset
+      end
+
+      # IMPORTANT: This method is part of the *RedisRecord extensions*.
+      #
+      # Sphinx client for RedisRecord. Accepts Sphinx extended[http://www.sphinxsearch.com/docs/current.html#extended-syntax] query syntax.
+      #
+      # Depends on: *riddle* gem.
+      def search(*args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        client = Riddle::Client.new
+        client.match_mode = :extended
+        q = client.query("#{args} @class #{name}")
+        ids = q[:matches].map {|r| r[:doc]}
+        find(ids)
+      end
+    end
+  end
+end

data/spec/basic_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "RedisRecord" do
+
+  before(:each) do
+    @c = Customer.new
+  end
+
+  after do
+    r = Redis.new
+    #r.select_db 15
+    r.flush_db
+  end
+
+  it "should allow to add any attribute to an instance" do
+    @c.name = 'foo'
+    @c.age  = 25
+    @c.name.should == 'foo'
+    @c.age.should == 25
+  end
+
+  it "should have an attribute accesor with the instance attributes" do
+    @c.name = 'foo'
+    @c.age  = 25
+    @c.attrs.map {|a| a.to_s }.sort.should == ['age', 'name']
+  end
+
+  it "should be 'dirty' if some of the instance attributes aren't saved" do
+    @c.name = 'foo'
+    @c.dirty?.should == true
+  end
+
+  it "should not be 'dirty' anymore once saved" do 
+    @c.name = 'foo'
+    @c.save
+    @c.dirty?.should == false
+  end
+
+  it "should be 'dirty' again after add a new attribute or update an existing one" do
+    @c.name = 'foo'
+    @c.save
+    @c.age  = 25
+    @c.dirty?.should == true
+    @c.save
+    @c.name = 'bar'
+    @c.dirty?.should == true
+  end
+
+  it "should have :id and timestamp attributes after saved" do
+    @c.name = 'foo'
+    saved_attributes = @c.save
+    saved_attributes.map {|a| a.to_s }.sort.should == ['created_at','id','name','updated_at']
+  end
+
+  it "should save only: the new and the updated attributes, and update the :updated_at timestamp" do
+    @c.name = 'foo'
+    @c.lastname = 'bar'
+    saved_attributes = @c.save
+    saved_attributes.map {|a| a.to_s }.sort.should == ['created_at','id','lastname','name','updated_at']
+    @c.age = 25
+    @c.lastname = 'baz'
+    new_saved_attributes = @c.save
+    new_saved_attributes.map {|a| a.to_s }.sort.should == ['age','lastname','updated_at']
+  end
+
+end

data/spec/finder_spec.rb

@@ -0,0 +1,82 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "RedisRecord" do
+
+  before do
+    @c1 = Customer.new
+    @c1.name = 'Foo'
+    @c1.age = 25
+    @c1.save
+
+    @c2 = Customer.new
+    @c2.name = 'Bar'
+    @c2.age = 30
+    @c2.save
+
+    @c3 = Customer.new
+    @c3.name = 'Baz'
+    @c3.age = 35
+    @c3.save
+  end
+
+  after do
+    r = Redis.new
+    #r.select_db 15
+    r.flush_db
+  end
+
+  it "should find a stored Customer by id" do
+    customer = Customer.find(@c1.id)
+    customer.attrs.map {|a| a.to_s }.sort.should == ['age','created_at','id','name','updated_at']
+    customer.new_record?.should == false
+    customer.dirty?.should == false
+  end
+
+  it "should find an array of Customers by id" do
+    customers = Customer.find(@c1.id, @c2.id)
+    customers.length.should == 2
+    customers.each do |c|
+      c.attrs.map {|a| a.to_s }.sort.should == ['age','created_at','id','name','updated_at']
+      c.new_record?.should == false
+      c.dirty?.should == false
+      ['Foo', 'Bar'].include?(c.name).should == true
+    end
+  end
+
+  it "should find the :first Customer" do
+    customer = Customer.find(:first)
+    customer.name.should == 'Foo'
+  end
+
+  it "should find the :last Customer" do
+    customer = Customer.find(:last)
+    customer.name.should == 'Baz'
+  end
+
+  it "should find :all the Customers" do
+    customers = Customer.find(:all)
+    customers.each do |c|
+      c.attrs.map {|a| a.to_s }.sort.should == ['age','created_at','id','name','updated_at']
+      c.new_record?.should == false
+      c.dirty?.should == false
+      [@c1.id, @c2.id, @c3.id].map {|id| id.to_s}.include?(c.id).should == true
+    end
+  end
+
+  it "should return the last 10 or less Customers in descendent order of creation when sorting by :created_at" do
+    customers = Customer.sort_by(:created_at)
+    names_by_created_at = ['Baz', 'Bar', 'Foo']
+    until customers.empty?
+      customers.pop.name.should == names_by_created_at.pop
+    end
+  end
+
+  it "should return the first 2 Customers in ascendent order when sorting by :age" do
+    customers = Customer.sort_by(:age, :limit => 2, :order => 'ALPHA ASC')
+    ordered_ages = ['25','30']
+    until customers.empty?
+      customers.pop.age.should == ordered_ages.pop
+    end
+  end
+
+end

data/spec/relationships_spec.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "RedisRecord" do
+
+  before do
+    # User
+    @u1 = User.new(:name => 'Foo')
+    @u1.save
+    #puts "User1 => #{@u1.inspect}"
+
+    # Posts
+    @p1 = Post.new(:title => 'Post1', :body => 'Lorem ipsum')
+    @p1.user_id = @u1.id
+    @p1.save
+    #puts "Post1 => #{@p1.inspect}"
+    @p2 = Post.new(:title => 'Post2', :body => 'Lorem ipsum')
+    @p2.user_id = @u1.id
+    @p2.save
+    #puts "Post2 => #{@p2.inspect}"
+
+    # Comments
+    @c1 = Comment.new(:text => 'Comment1|Post1')
+    @c1.user_id = @u1.id
+    @c1.post_id = @p1.id
+    @c1.save
+    #puts "Comment1 => #{@c1.inspect}"
+    @c2 = Comment.new(:text => 'Comment2|Post1')
+    @c2.user_id = @u1.id
+    @c2.post_id = @p1.id
+    @c2.save
+    #puts "Comment2 => #{@c2.inspect}"
+  end
+
+  after do
+    r = Redis.new
+    #r.select_db 15
+    r.flush_db
+  end
+
+  it "should find the Posts/Comments relationships through the :has_many methods of the User" do
+    posts = @u1.posts
+    posts.length.should == 2
+    posts.each do |p|
+      ['Post1','Post2'].include?(p.title).should == true
+    end
+    comments = @u1.comments
+    comments.length.should == 2
+    comments.each do |c|
+      ['Comment1|Post1','Comment2|Post1'].include?(c.text).should == true
+    end
+  end
+
+  it "should find the User relationship through the Post :belongs_to method" do
+    @p1.user.id.should == '1'
+  end
+
+  it "should find the User/Post relationships through the Comment :belongs_to methods" do
+    @c1.user.id.should == '1'
+    @c1.post.id.should == '1'
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+require 'rubygems'
+$TESTING=true
+$:.push File.join(File.dirname(__FILE__), '..', 'lib')
+require 'redisrecord'
+
+# Spec helper
+class Customer < RedisRecord::Model
+  #database 15
+end
+
+# Spec helper
+class User < RedisRecord::Model
+  #database 15
+  has_many :posts
+  has_many :comments
+end
+
+# Spec helper
+class Post < RedisRecord::Model
+  #database 15
+  belongs_to :user
+  has_many :comments
+end
+
+# Spec helper
+class Comment < RedisRecord::Model
+  #database 15
+  belongs_to :post
+  belongs_to :user
+end
+

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification 
+name: redisrecord
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Mauro Pompilio
+autorequire: redisrecord
+bindir: bin
+cert_chain: []
+
+date: 2009-11-25 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: A 'virtual' ORM on top of Redis.
+email: hackers.are.rockstars@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+files: 
+- LICENSE
+- README.markdown
+- lib/redisrecord.rb
+- lib/redisrecord/extensions.rb
+- spec/spec_helper.rb
+- spec/relationships_spec.rb
+- spec/basic_spec.rb
+- spec/finder_spec.rb
+- examples/demo.rb
+- examples/sphinx.conf
+- examples/users.yml
+has_rdoc: true
+homepage: http://github.com/malditogeek/redisrecord
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+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: 2
+summary: A 'virtual' ORM on top of Redis.
+test_files: []
+