redis_orm 0.2 → 0.3

data/CHANGELOG

@@ -1,3 +1,8 @@
+v0.3 [06-06-2011]
+* fixed #find functionality both for model itself and for has_many proxy
+* made sure ORM correctly resets associations when nil/[] provided
+* improved documentation, test for has_many proxy methods :+= and :<< added
+
 v0.2 [04-06-2011]
 * added polymorphic association
 * added *timestamps* declaration for the model

data/README.md

@@ -87,7 +87,15 @@ For example we associate 2 photos with the album
 @album.photos << @photo1
 ```
 
-To extract all or part of the associated records by far  you could use 3 options (#find is an alias for #all in has_many proxy):
+To extract all or part of the associated records you could use 3 options for now (#find is an alias for #all in has_many proxy):
+
+* :limit
+
+* :offset
+
+* :order
+
+  Either :desc or :asc (default), since records are stored with Time.now.to_f scores, be default they could be fetched only in that (or reversed) order. To store them in different order you should *zadd* record's id to some other sorted list manually.
 
 ```ruby
 @album.photos.all(:limit => 0, :offset => 0).should == []
@@ -295,6 +303,32 @@ All associations supports following options:
 
   Symbol could be either :destroy or :nullify (default value)
 
+### Clearing/reseting associations
+
+You could clear/reset associations by assigning appropriately nil/[] to it:
+
+```ruby
+# has_many association
+@article.comments << [@comment1, @comment2]
+@article.comments.count # => 2
+@comment1.article       # => @article
+
+# clear    
+@article.comments = []
+@article.comments.count # => 0
+@comment1.article       # => nil
+
+# belongs_to (same for has_one)
+@article.comments << [@comment1, @comment2]
+@article.comments.count # => 2
+@comment1.article       # => @article
+    
+# clear
+@comment1.article = nil
+@article.comments.count # => 1
+@comment1.article       # => nil
+```
+
 For more examples please check test/associations_test.rb and test/polymorphic_test.rb
 
 ## Validation

data/Rakefile

@@ -3,7 +3,7 @@ require 'rake'
 
 require 'echoe'
 
-Echoe.new('redis_orm', '0.2') do |p|
+Echoe.new('redis_orm', '0.3') do |p|
   p.description    = "ORM for Redis advanced key-value storage"
   p.url            = "https://github.com/german/redis_orm"
   p.author         = "Dmitrii Samoilov"

data/lib/redis_orm/associations/belongs_to.rb

@@ -34,34 +34,37 @@ module RedisOrm
         # look = Look.create :title => 'test'
         # look.user = User.find(1) => look:23:user => 1
         define_method "#{foreign_model_name}=" do |assoc_with_record|
-          old_assoc = nil
+          # we need to store this to clear old association later
+          old_assoc = self.send(foreign_model_name)
           
           if options[:polymorphic]
-            # we need to store this to clear old association later
-            old_assoc = self.send(foreign_model_name)
             $redis.set("#{model_name}:#{id}:#{foreign_model_name}_type", assoc_with_record.model_name)
             $redis.set("#{model_name}:#{id}:#{foreign_model_name}_id", assoc_with_record.id)
           else
-            if assoc_with_record.model_name == foreign_model.to_s
+            if assoc_with_record.nil?
+              $redis.del("#{model_name}:#{id}:#{foreign_model_name}")
+            elsif assoc_with_record.model_name == foreign_model.to_s
               $redis.set("#{model_name}:#{id}:#{foreign_model_name}", assoc_with_record.id)
             else
               raise TypeMismatchError
             end
           end
           
-          # check whether *assoc_with_record* object has *has_many* declaration and TODO it states *self.model_name* in plural and there is no record yet from the *assoc_with_record*'s side (in order not to provoke recursion)
-          if class_associations[assoc_with_record.model_name].detect{|h| h[:type] == :has_many && h[:foreign_models] == model_name.pluralize.to_sym} && !$redis.zrank("#{assoc_with_record.model_name}:#{assoc_with_record.id}:#{model_name.pluralize}", self.id)
-            # remove old assoc
-            if old_assoc
-              $redis.zrem "#{old_assoc.model_name}:#{old_assoc.id}:#{model_name.to_s.pluralize}", self.id
-            end
-            
-            assoc_with_record.send(model_name.pluralize.to_sym).send(:"<<", self)
+          if assoc_with_record.nil?
+            # remove old assoc            
+            $redis.zrem("#{old_assoc.model_name}:#{old_assoc.id}:#{model_name.to_s.pluralize}", self.id) if old_assoc
+          else
+            # check whether *assoc_with_record* object has *has_many* declaration and TODO it states *self.model_name* in plural and there is no record yet from the *assoc_with_record*'s side (in order not to provoke recursion)
+            if class_associations[assoc_with_record.model_name].detect{|h| h[:type] == :has_many && h[:foreign_models] == model_name.pluralize.to_sym} && !$redis.zrank("#{assoc_with_record.model_name}:#{assoc_with_record.id}:#{model_name.pluralize}", self.id)
+              # remove old assoc
+              $redis.zrem("#{old_assoc.model_name}:#{old_assoc.id}:#{model_name.to_s.pluralize}", self.id) if old_assoc   
+              assoc_with_record.send(model_name.pluralize.to_sym).send(:"<<", self)
 
-          # check whether *assoc_with_record* object has *has_one* declaration and TODO it states *self.model_name* and there is no record yet from the *assoc_with_record*'s side (in order not to provoke recursion)
-          elsif class_associations[assoc_with_record.model_name].detect{|h| h[:type] == :has_one && h[:foreign_model] == model_name.to_sym} && assoc_with_record.send(model_name.to_sym).nil?
-            # old association is being rewritten here automatically so we don't have to worry about it
-            assoc_with_record.send("#{model_name}=", self)
+            # check whether *assoc_with_record* object has *has_one* declaration and TODO it states *self.model_name* and there is no record yet from the *assoc_with_record*'s side (in order not to provoke recursion)
+            elsif class_associations[assoc_with_record.model_name].detect{|h| h[:type] == :has_one && h[:foreign_model] == model_name.to_sym} && assoc_with_record.send(model_name.to_sym).nil?
+              # old association is being rewritten here automatically so we don't have to worry about it
+              assoc_with_record.send("#{model_name}=", self)
+            end
           end
         end
       end

data/lib/redis_orm/associations/has_many.rb

@@ -23,10 +23,22 @@ module RedisOrm
         define_method "#{foreign_models_name}=" do |records|
           if !options[:as]
             # clear old assocs from related models side
-            self.send(foreign_models).to_a.each do |record|
-              $redis.zrem "#{record.model_name}:#{record.id}:#{model_name.pluralize}", id
+            old_records = self.send(foreign_models).to_a
+            if !old_records.empty?
+              # cache here which association with current model have old record's model
+              has_many_assoc = old_records[0].get_associations.detect{|h| h[:type] == :has_many && h[:foreign_models] == model_name.pluralize.to_sym}
+              
+              has_one_or_belongs_to_assoc = old_records[0].get_associations.detect{|h| [:has_one, :belongs_to].include?(h[:type]) && h[:foreign_model] == model_name.to_sym}
+              
+              old_records.each do |record|
+                if has_many_assoc
+                  $redis.zrem "#{record.model_name}:#{record.id}:#{model_name.pluralize}", id
+                elsif has_one_or_belongs_to_assoc
+                  $redis.del "#{record.model_name}:#{record.id}:#{model_name}"
+                end
+              end
             end
-
+            
             # clear old assocs from this model side
             $redis.zremrangebyscore "#{model_name}:#{id}:#{foreign_models}", 0, Time.now.to_f
           end
@@ -42,7 +54,8 @@ module RedisOrm
               if class_associations[record.model_name].detect{|h| h[:type] == :has_many && h[:foreign_models] == model_name.pluralize.to_sym} #&& !$redis.zrank("#{record.model_name}:#{record.id}:#{model_name.pluralize}", id)#record.model_name.to_s.camelize.constantize.find(id).nil?
                 $redis.zadd("#{record.model_name}:#{record.id}:#{model_name.pluralize}", Time.now.to_f, id)
               # check whether *record* object has *has_one* declaration and TODO it states *self.model_name*
-              elsif record.get_associations.detect{|h| [:has_one, :belongs_to].include?(h[:type]) && h[:foreign_model] == model_name.to_sym} # overwrite assoc anyway so we don't need to check record.send(model_name.to_sym).nil? here
+              elsif record.get_associations.detect{|h| [:has_one, :belongs_to].include?(h[:type]) && h[:foreign_model] == model_name.to_sym}
+                # overwrite assoc anyway so we don't need to check record.send(model_name.to_sym).nil? here
                 $redis.set("#{record.model_name}:#{record.id}:#{model_name}", id)
               end
             end

data/lib/redis_orm/associations/has_many_proxy.rb

@@ -19,6 +19,11 @@ module RedisOrm
         fetch if !@fetched
         @records[index]
       end
+      
+      def to_a
+        fetch if !@fetched
+        @records        
+      end
 
       # user = User.find(1)
       # user.avatars << Avatar.find(23) => user:1:avatars => [23]
@@ -55,10 +60,13 @@ module RedisOrm
             end
           end
         end
+        
+        # return *self* here so calls could be chained
+        self
       end
 
       def all(options = {})
-        if options[:limit] || options[:offset] || options[:order]
+        if options.is_a?(Hash) && (options[:limit] || options[:offset] || options[:order])
           limit = if options[:limit] && options[:offset]
             [options[:offset].to_i, options[:limit].to_i]            
           elsif options[:limit]
@@ -90,7 +98,10 @@ module RedisOrm
         elsif token == :all
           all(options)
         elsif token == :first
-          all(options.merge({:limit => 1}))
+          all(options.merge({:limit => 1}))[0]
+        elsif token == :last
+          reversed = options[:order] == 'asc' ? 'desc' : 'asc'
+          all(options.merge({:limit => 1, :order => reversed}))[0]
         end
       end
 

data/lib/redis_orm/associations/has_one.rb

@@ -25,23 +25,28 @@ module RedisOrm
           # we need to store this to clear old associations later
           old_assoc = self.send(foreign_model_name)
 
-          if assoc_with_record.model_name == foreign_model.to_s
+          if assoc_with_record.nil?
+            $redis.del("#{model_name}:#{id}:#{foreign_model_name}")
+          elsif assoc_with_record.model_name == foreign_model.to_s
             $redis.set("#{model_name}:#{id}:#{foreign_model_name}", assoc_with_record.id)
           else
             raise TypeMismatchError
           end
 
-          # check whether *assoc_with_record* object has *belongs_to* declaration and TODO it states *self.model_name* and there is no record yet from the *assoc_with_record*'s side (in order not to provoke recursion)
-          if class_associations[assoc_with_record.model_name].detect{|h| [:belongs_to, :has_one].include?(h[:type]) && h[:foreign_model] == model_name.to_sym} && assoc_with_record.send(model_name.to_sym).nil?
-            # old association is being rewritten here automatically so we don't have to worry about it
-            assoc_with_record.send("#{model_name}=", self)
-          elsif class_associations[assoc_with_record.model_name].detect{|h| :has_many == h[:type] && h[:foreign_models] == model_name.to_s.pluralize.to_sym} && !$redis.zrank("#{assoc_with_record.model_name}:#{assoc_with_record.id}:#{model_name.pluralize}", self.id)
+          if assoc_with_record.nil?
             # remove old assoc
-            if old_assoc
-              $redis.zrem "#{assoc_with_record.model_name}:#{old_assoc.id}:#{model_name.to_s.pluralize}", self.id
+            $redis.zrem("#{old_assoc.model_name}:#{old_assoc.id}:#{model_name.to_s.pluralize}", id) if old_assoc
+          else
+            # check whether *assoc_with_record* object has *belongs_to* declaration and TODO it states *self.model_name* and there is no record yet from the *assoc_with_record*'s side (in order not to provoke recursion)
+            if class_associations[assoc_with_record.model_name].detect{|h| [:belongs_to, :has_one].include?(h[:type]) && h[:foreign_model] == model_name.to_sym} && assoc_with_record.send(model_name.to_sym).nil?
+              # old association is being rewritten here automatically so we don't have to worry about it
+              assoc_with_record.send("#{model_name}=", self)
+            elsif class_associations[assoc_with_record.model_name].detect{|h| :has_many == h[:type] && h[:foreign_models] == model_name.to_s.pluralize.to_sym} && !$redis.zrank("#{assoc_with_record.model_name}:#{assoc_with_record.id}:#{model_name.pluralize}", self.id)
+              # remove old assoc
+              $redis.zrem("#{old_assoc.model_name}:#{old_assoc.id}:#{model_name.to_s.pluralize}", id) if old_assoc
+              # create/add new ones
+              assoc_with_record.send(model_name.pluralize.to_sym).send(:"<<", self)
             end
-            # create/add new ones
-            assoc_with_record.send(model_name.pluralize.to_sym).send(:"<<", self)
           end
         end
       end

data/lib/redis_orm/redis_orm.rb

@@ -138,25 +138,35 @@ module RedisOrm
         end
       end
 
-      def find(ids)
-        if ids.is_a?(Hash)
-          all(ids)
-        elsif ids.is_a?(Array)
-          return [] if ids.empty?
-          ids.inject([]) do |array, id|
+      def find(*args)
+        if args.first.is_a?(Array)
+          return [] if args.first.empty?
+          args.first.inject([]) do |array, id|
             record = $redis.hgetall "#{model_name}:#{id}"
             if record && !record.empty?
               array << new(record, id, true)
             end
           end
         else
-          return nil if ids.nil?
-          id = ids
-          record = $redis.hgetall "#{model_name}:#{id}"
-          if record && record.empty?
-            nil
-          else
-            new(record, id, true)
+          return nil if args.empty? || args.first.nil?
+          case first = args.shift
+            when :all
+              options = args.last
+              return nil if !options.is_a?(Hash)
+              all(options)
+            when :first
+              options = args.last
+              return nil if !options.is_a?(Hash)
+              all(options.merge({:limit => 1}))[0]
+            when :last
+              options = args.last
+              return nil if !options.is_a?(Hash)
+              reversed = options[:order] == 'asc' ? 'desc' : 'asc'
+              all(options.merge({:limit => 1, :order => reversed}))[0]
+            else
+              id = first
+              record = $redis.hgetall "#{model_name}:#{id}"
+              record && record.empty? ? nil : new(record, id, true)
           end
         end        
       end

data/redis_orm.gemspec

@@ -2,11 +2,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{redis_orm}
-  s.version = "0.2"
+  s.version = "0.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
   s.authors = ["Dmitrii Samoilov"]
-  s.date = %q{2011-06-04}
+  s.date = %q{2011-06-06}
   s.description = %q{ORM for Redis advanced key-value storage}
   s.email = %q{germaninthetown@gmail.com}
   s.extra_rdoc_files = ["CHANGELOG", "LICENSE", "README.md", "lib/redis_orm.rb", "lib/redis_orm/active_model_behavior.rb", "lib/redis_orm/associations/belongs_to.rb", "lib/redis_orm/associations/has_many.rb", "lib/redis_orm/associations/has_many_proxy.rb", "lib/redis_orm/associations/has_one.rb", "lib/redis_orm/redis_orm.rb"]

data/test/associations_test.rb

@@ -41,7 +41,7 @@ describe "check associations" do
     path_to_socket = File.dirname(File.expand_path(__FILE__)) + "/../redis.sock"
     $redis = Redis.new(:host => 'localhost', :path => path_to_socket)
   end
-  
+
   before(:each) do
     $redis.flushall if $redis
     @article = Article.new
@@ -84,10 +84,44 @@ describe "check associations" do
     @comment2.article.id.should == @article.id
     @article.comments.count.should == 2
     @article.comments[0].id.should == @comment2.id
+  end
+ 
+  it "should correctly resets associations when nil/[] provided" do
+    # from has_many proxy side
+    @article.comments << [@comment1, @comment2]
+    @article.comments.count.should == 2
+    @comment1.article.id.should == @article.id
+    @comment2.article.id.should == @article.id
     
-    #@comment1.article = nil
-    #@article.comments.count.should == 1
-    #@comment1.article.should == nil
+    # clear    
+    @article.comments = []
+    @article.comments.count.should == 0
+    @comment1.article.should == nil
+    @comment2.article.should == nil
+
+    # from belongs_to side
+    @article.comments << [@comment1, @comment2]
+    @article.comments.count.should == 2
+    @comment1.article.id.should == @article.id
+    
+    # clear
+    @comment1.article = nil
+    @article.comments.count.should == 1
+    @comment1.article.should == nil
+    
+    # from has_one side
+    profile = Profile.create :title => "test"
+    chicago = City.create :name => "Chicago"
+
+    profile.city = chicago
+    profile.city.name.should == "Chicago"
+    chicago.profiles.count.should == 1
+    chicago.profiles[0].id.should == profile.id
+    
+    # clear
+    profile.city = nil
+    profile.city.should == nil
+    chicago.profiles.count.should == 0
   end
   
   it "should return array" do
@@ -109,6 +143,28 @@ describe "check associations" do
     @comment1.article.id.should == @comment2.article.id
   end
 
+  it "should behave as active_record (proxy couldn't return records w/o #all call) += and << behave differently" do
+    @article.comments << @comment1 << @comment2
+    @article.comments.count.should == 2
+
+    comments = @article.comments
+    comments.count.should == 2
+    
+    comments = []
+    comments += @article.comments
+    comments.count.should == 2
+    comments.collect{|c| c.id}.should include(@comment1.id)
+    comments.collect{|c| c.id}.should include(@comment2.id)
+    
+    comments = []
+    comments << @article.comments.all
+    comments.flatten.count.should == 2
+    
+    comments = []
+    comments << @article.comments
+    comments.count.should == 1
+  end
+
   it "should return 1 comment when second was deleted" do
     Comment.count.should == 2
     @article.comments << [@comment1, @comment2]
@@ -150,7 +206,7 @@ describe "check associations" do
     @article.comments.count.should == 1
     @article.comments.first.id.should == @comment1.id
 
-    @comment1.article.id.should == @article.id
+    @comment1.article.id.should == @article.id    
   end
 
   it "should correctly use many-to-many associations both with '=' and '<<' " do

data/test/options_test.rb

@@ -96,15 +96,18 @@ describe "test options" do
     Photo.all(:order => "desc", :limit => 1, :offset => 1).map{|p| p.id}.should == [@photo1.id]
 
     # testing #find method
-    Photo.find(:order => "asc").map{|p| p.id}.should == [@photo1.id, @photo2.id]
-    Photo.find(:order => "desc").map{|p| p.id}.should == [@photo2.id, @photo1.id]
+    Photo.find(:all, :order => "asc").map{|p| p.id}.should == [@photo1.id, @photo2.id]
+    Photo.find(:all, :order => "desc").map{|p| p.id}.should == [@photo2.id, @photo1.id]
 
-    Photo.find(:order => "asc", :limit => 1).map{|p| p.id}.should == [@photo1.id]
-    Photo.find(:order => "desc", :limit => 1).map{|p| p.id}.should == [@photo2.id]
+    Photo.find(:all, :order => "asc", :limit => 1).map{|p| p.id}.should == [@photo1.id]
+    Photo.find(:all, :order => "desc", :limit => 1).map{|p| p.id}.should == [@photo2.id]
 
-    Photo.find(:order => "asc", :limit => 1, :offset => 1).map{|p| p.id}.should == [@photo2.id]
-    Photo.find(:order => "desc", :limit => 1, :offset => 1).map{|p| p.id}.should == [@photo1.id]
+    Photo.find(:first, :order => "asc", :limit => 1, :offset => 1).id.should == @photo2.id
+    Photo.find(:first, :order => "desc", :limit => 1, :offset => 1).id.should == @photo1.id
 
+    Photo.find(:last, :order => "asc").id.should == @photo2.id
+    Photo.find(:last, :order => "desc").id.should == @photo1.id
+    
     @album.photos.count.should == 0
     @album.photos.all(:limit => 2, :offset => 0).should == []
     @album.photos << @photo2
@@ -119,8 +122,16 @@ describe "test options" do
 
     @album.photos.find(:all, :order => "asc").map{|p| p.id}.should == [@photo2.id, @photo1.id]
     @album.photos.find(:all, :order => "desc").map{|p| p.id}.should == [@photo1.id, @photo2.id]
-    @album.photos.find(:first, :order => "asc").map{|p| p.id}.should == [@photo2.id]
-    @album.photos.find(:first, :order => "desc").map{|p| p.id}.should == [@photo1.id]
+    
+    @album.photos.find(:first, :order => "asc").id.should == @photo2.id
+    @album.photos.find(:first, :order => "desc").id.should == @photo1.id
+
+    @album.photos.find(:last, :order => "asc").id.should == @photo1.id
+    @album.photos.find(:last, :order => "desc").id.should == @photo2.id
+        
+    @album.photos.find(:last, :order => "desc", :offset => 2).should == nil
+    @album.photos.find(:first, :order => "desc", :offset => 2).should == nil
+    
     @album.photos.find(:all, :order => "asc", :limit => 1, :offset => 1).map{|p| p.id}.should == [@photo1.id]
     @album.photos.find(:all, :order => "desc", :limit => 1, :offset => 1).map{|p| p.id}.should == [@photo2.id]
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: redis_orm
 version: !ruby/object:Gem::Version
-  version: '0.2'
+  version: '0.3'
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,12 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-06-04 00:00:00.000000000 +03:00
+date: 2011-06-06 00:00:00.000000000 +03:00
 default_executable: 
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &85876430 !ruby/object:Gem::Requirement
+  requirement: &85879940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,10 +22,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *85876430
+  version_requirements: *85879940
 - !ruby/object:Gem::Dependency
   name: activemodel
-  requirement: &85876070 !ruby/object:Gem::Requirement
+  requirement: &85879580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -33,10 +33,10 @@ dependencies:
         version: 3.0.0
   type: :runtime
   prerelease: false
-  version_requirements: *85876070
+  version_requirements: *85879580
 - !ruby/object:Gem::Dependency
   name: redis
-  requirement: &85875730 !ruby/object:Gem::Requirement
+  requirement: &85879180 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -44,10 +44,10 @@ dependencies:
         version: 2.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *85875730
+  version_requirements: *85879180
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &85875400 !ruby/object:Gem::Requirement
+  requirement: &85878840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -55,7 +55,7 @@ dependencies:
         version: 2.5.0
   type: :development
   prerelease: false
-  version_requirements: *85875400
+  version_requirements: *85878840
 description: ORM for Redis advanced key-value storage
 email: germaninthetown@gmail.com
 executables: []