simply_stored 0.1.14 → 0.1.15

data/CHANGELOG.md

@@ -1,6 +1,33 @@
 Changelog
 =============
 
+- Support :order option to has_many associations and classes, e.g:
+
+    @user.posts(:order => :desc)
+    Post.find(:all, :order => :desc)
+    
+  Default to the CouchDB default of ascending.
+
+
+- Support :limit option to has_many and has_many :through associations, e.g:
+
+    @user.posts(:limit => 5)
+
+0.1.14
+=============
+
+- Add ability to delete all design documents:
+    
+    SimplyStored::Couch.delete_all_design_documents('http://localhost:5984/mydbname')
+
+- Add rake tasks to delete all design documents. In your Rakefile:
+
+    require 'simply_stored/rake'
+
+Then you can delete all design documents in a database like this:
+
+    DATABASE=http://localhost:5984/mydb rake simply_stored:delete_design_documents    
+
 0.1.13
 =============
 

data/README.md

@@ -119,6 +119,12 @@ The supported associations are: belongs_to, has_one, has_many, and has_many :thr
     post.comments
     # => [mikes_comment, johns_comment]
     
+    post.comments(:order => :desc)
+    # => [johns_comment, mikes_comment]
+    
+    post.comments(:limit => 1)
+    # => [mikes_comment]
+    
     post.comment_count
     # => 2
     

data/lib/simply_stored/couch/has_many.rb

@@ -9,18 +9,25 @@ module SimplyStored
         define_method(name) do |*args|
           options = args.first && args.first.is_a?(Hash) && args.first
           if options
-            options.assert_valid_keys(:force_reload, :with_deleted)
-            forced_reload = options[:force_reload]
+            options.assert_valid_keys(:force_reload, :with_deleted, :limit, :order)
+            forced_reload = options.delete(:force_reload)
             with_deleted = options[:with_deleted]
+            limit = options[:limit]
+            descending = (options[:order] == :desc) ? true : false
           else
             forced_reload = false
             with_deleted = false
+            limit = nil
+            descending = false
           end
 
-          if forced_reload || instance_variable_get("@#{name}").nil?
-            instance_variable_set("@#{name}", find_associated(name, self.class, :with_deleted => with_deleted))
+          cached_results = cached_results = send("_get_cached_#{name}")
+          cache_key = _cache_key_for(options)
+          if forced_reload || cached_results[cache_key].nil? 
+            cached_results[cache_key] = find_associated(name, self.class, :with_deleted => with_deleted, :limit => limit, :descending => descending)
+            instance_variable_set("@#{name}", cached_results)
           end
-          instance_variable_get("@#{name}")
+          cached_results[cache_key]
         end
       end
       
@@ -30,26 +37,31 @@ module SimplyStored
         define_method(name) do |*args|
           options = args.first && args.first.is_a?(Hash) && args.first
           if options
-            options.assert_valid_keys(:force_reload, :with_deleted)
+            options.assert_valid_keys(:force_reload, :with_deleted, :limit)
             forced_reload = options[:force_reload]
             with_deleted = options[:with_deleted]
+            limit = options[:limit]
           else
             forced_reload = false
             with_deleted = false
+            limit = nil
           end
           
-          if forced_reload || instance_variable_get("@#{name}").nil?
+          cached_results = send("_get_cached_#{name}")
+          cache_key = _cache_key_for(options)
+          
+          if forced_reload || cached_results[cache_key].nil?
             
             # there is probably a faster way to query this
-            intermediate_objects = find_associated(through, self.class, :with_deleted => with_deleted)
+            intermediate_objects = find_associated(through, self.class, :with_deleted => with_deleted, :limit => limit)
             
             through_objects = intermediate_objects.map do |intermediate_object|
               intermediate_object.send(name.to_s.singularize.underscore, :with_deleted => with_deleted)
             end.flatten.uniq
-            
-            instance_variable_set("@#{name}", through_objects)
+            cached_results[cache_key] = through_objects
+            instance_variable_set("@#{name}", cached_results)
           end
-          instance_variable_get("@#{name}")
+          cached_results[cache_key]
         end
       end
       
@@ -59,9 +71,11 @@ module SimplyStored
           raise ArgumentError, "expected #{klass} got #{value.class}" unless value.is_a?(klass)
           
           value.send("#{self.class.foreign_key}=", id)
-          value.save
-          cached_version = instance_variable_get("@#{name}") || []
-          instance_variable_set("@#{name}", cached_version << value)
+          value.save(false)
+          
+          cached_results = send("_get_cached_#{name}")[:all]
+          send("_set_cached_#{name}", (cached_results || []) << value, :all)
+          nil
         end
       end
 
@@ -78,8 +92,9 @@ module SimplyStored
             value.save
           end
           
-          cached_version = instance_variable_get("@#{name}") || []
-          instance_variable_set("@#{name}", cached_version.delete_if{|item| item.id == value.id})
+          cached_results = send("_get_cached_#{name}")[:all]
+          send("_set_cached_#{name}", (cached_results || []).delete_if{|item| item.id == value.id}, :all)
+          nil
         end
       end
       
@@ -113,6 +128,22 @@ module SimplyStored
         end
       end
       
+      def define_cache_accessors(name)
+        define_method "_get_cached_#{name}" do
+          instance_variable_get("@#{name}") || {}
+        end
+        
+        define_method "_set_cached_#{name}" do |value, cache_key|
+          cached = send("_get_cached_#{name}")
+          cached[cache_key] = value
+          instance_variable_set("@#{name}", cached)
+        end
+        
+        define_method "_cache_key_for" do |options|
+          options.blank? ? :all : options.to_s
+        end
+      end
+      
       class Property
         attr_reader :name, :options
         
@@ -127,11 +158,13 @@ module SimplyStored
           
           if options[:through]
             owner_clazz.class_eval do
+              define_cache_accessors(name)
               define_has_many_through_getter(name, options[:through])
               define_has_many_count(name, options[:through])
             end
           else
             owner_clazz.class_eval do
+              define_cache_accessors(name)
               define_has_many_getter(name)
               define_has_many_setter_add(name)
               define_has_many_setter_remove(name)

data/lib/simply_stored/couch.rb

@@ -50,6 +50,9 @@ module SimplyStored
       def find(*args)
         what = args.shift
         options = args.last.is_a?(Hash) ? args.last : {}
+        if options && order = options.delete(:order)
+          options[:descending] = true if order == :desc
+        end
         
         with_deleted = options.delete(:with_deleted)
         

data/lib/simply_stored/instance_methods.rb

@@ -121,14 +121,19 @@ module SimplyStored
     end
     
     def find_associated(from, to, options = {})
+      view_options = {}
+      view_options[:reduce] = false
+      view_options[:key] = id
+      view_options[:descending] = options[:descending] if options[:descending]
+      view_options[:limit] = options[:limit] if options[:limit]
       if options[:with_deleted]
         CouchPotato.database.view(
           self.class.get_class_from_name(from).send(
-            "association_#{from.to_s.singularize.underscore}_belongs_to_#{to.name.singularize.underscore}_with_deleted", :reduce => false, :key => id))
+            "association_#{from.to_s.singularize.underscore}_belongs_to_#{to.name.singularize.underscore}_with_deleted", view_options))
       else
         CouchPotato.database.view(
           self.class.get_class_from_name(from).send(
-            "association_#{from.to_s.singularize.underscore}_belongs_to_#{to.name.singularize.underscore}", :reduce => false, :key => id))
+            "association_#{from.to_s.singularize.underscore}_belongs_to_#{to.name.singularize.underscore}", view_options))
       end
     end
     

data/test/simply_stored_couch_test.rb

@@ -134,11 +134,22 @@ class CouchTest < Test::Unit::TestCase
     
     context "when finding instances" do
       context "with find(:all)" do
-        should "return all instances" do
+        setup do
           User.create(:title => "Mr.")
           User.create(:title => "Mrs.")
+        end
+        
+        should "return all instances" do  
           assert_equal 2, User.find(:all).size
         end
+        
+        should "allow a limit" do
+          assert_equal 1, User.find(:all, :limit => 1).size
+        end
+        
+        should "allow to order the results" do
+          assert_equal User.find(:all).reverse, User.find(:all, :order => :desc)
+        end
       end
 
       context "to find all instances" do
@@ -159,6 +170,12 @@ class CouchTest < Test::Unit::TestCase
           assert_equal user, User.first
         end
         
+        should 'understand the order' do
+          assert_nothing_raised do
+            User.first(:order => :desc)
+          end
+        end
+        
         should 'return nil when no user found' do
           assert_nil User.first
         end
@@ -475,6 +492,72 @@ class CouchTest < Test::Unit::TestCase
           user.posts
         end
         
+        context "limit" do
+        
+          should "be able to limit the result set" do
+            user = User.create(:title => "Mr.")
+            3.times {
+              post = Post.new
+              post.user = user
+              post.save!
+            }
+            assert_equal 2, user.posts(:limit => 2).size
+          end
+        
+          should "use the given options in the cache-key" do
+            user = User.create(:title => "Mr.")
+            3.times {
+              post = Post.new
+              post.user = user
+              post.save!
+            }
+            assert_equal 2, user.posts(:limit => 2).size
+            assert_equal 3, user.posts(:limit => 3).size
+          end
+        
+          should "be able to limit the result set - also for through objects" do
+            @user = User.create(:title => "Mr.")
+            first_pain = Pain.create
+            frist_hemorrhoid = Hemorrhoid.create(:user => @user, :pain => first_pain)
+            assert_equal [first_pain], @user.pains          
+            second_pain = Pain.create
+            second_hemorrhoid = Hemorrhoid.create(:user => @user, :pain => second_pain)
+            @user.reload
+            assert_equal 2, @user.pains.size
+            assert_equal 1, @user.pains(:limit => 1).size
+          end
+        end
+        
+        context "order" do
+          setup do
+            @user = User.create(:title => "Mr.")
+            3.times {
+              post = Post.new
+              post.user = @user
+              post.save!
+            }
+          end
+          
+          should "support different order" do
+            assert_nothing_raised do
+              @user.posts(:order => :asc)
+            end
+            
+            assert_nothing_raised do
+              @user.posts(:order => :desc)
+            end
+          end
+          
+          should "reverse the order if :desc" do
+            assert_equal @user.posts(:order => :asc).map(&:id).reverse, @user.posts(:order => :desc).map(&:id)
+          end
+          
+          should "work with the limit option" do
+            last_post = Post.create(:user => @user)
+            assert_not_equal @user.posts(:order => :asc, :limit => 3).map(&:id).reverse, @user.posts(:order => :desc, :limit => 3).map(&:id)
+          end
+        end
+                
         should "verify the given options for the accessor method" do
           user = User.create(:title => "Mr.")
           assert_raise(ArgumentError) do
@@ -509,7 +592,7 @@ class CouchTest < Test::Unit::TestCase
           post.user = user
           post.save!
           user.posts
-          assert_equal [post], user.instance_variable_get("@posts")
+          assert_equal [post], user.instance_variable_get("@posts")[:all]
         end
         
         should "add methods to handle associated objects" do
@@ -535,7 +618,7 @@ class CouchTest < Test::Unit::TestCase
             assert_equal [], daddy.posts
             daddy.add_post(item)
             assert_equal [item], daddy.posts
-            assert_equal [item], daddy.instance_variable_get("@posts")
+            assert_equal [item], daddy.instance_variable_get("@posts")[:all]
           end
 
           should "raise an error when the added item is not an object of the expected class" do
@@ -575,7 +658,7 @@ class CouchTest < Test::Unit::TestCase
             assert user.posts.include?(post)
             user.remove_post(post)
             assert !user.posts.any?{|p| post.id == p.id}
-            assert_equal [], user.instance_variable_get("@posts")
+            assert_equal [], user.instance_variable_get("@posts")[:all]
           end
           
           should "save the removed item with the nullified foreign key" do
@@ -636,7 +719,7 @@ class CouchTest < Test::Unit::TestCase
             post2 = Post.create(:user => user)
             user.remove_all_posts
             assert_equal [], user.posts
-            assert_equal [], user.instance_variable_get("@posts")
+            assert_equal [], user.instance_variable_get("@posts")[:all]
           end
           
           context "when counting" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: simply_stored
 version: !ruby/object:Gem::Version 
-  version: 0.1.14
+  version: 0.1.15
 platform: ruby
 authors: 
 - Mathias Meyer, Jonathan Weiss
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-13 00:00:00 +01:00
+date: 2010-02-18 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency