will_paginate_couchrest 0.2.2 → 0.3.1

data/README.rdoc

@@ -10,6 +10,10 @@ Automatically generate views with an extra reduce method used to generate the to
 
 == History
 
+2010-06-26 - 0.3.1 - Minor fix, duplicate view options to avoid ExtendedDocument bug
+
+2010-06-21 - 0.3.0 - Added support for new CouchRest Model
+
 2010-04-05 - 0.2.0 - Added support for CouchRest Proxy class
 
 2010-03-05 - 0.1.0 - Initial version

data/VERSION

@@ -1 +1 @@
-0.2.2
+0.3.1

data/lib/will_paginate_couchrest.rb

@@ -1,22 +1,47 @@
 
-require('will_paginate_couchrest/class_methods')
-require('will_paginate_couchrest/proxy_methods')
+require 'will_paginate'
+require 'will_paginate_couchrest/class_methods'
+require 'will_paginate_couchrest/proxy_methods'
 
 # Take the liberty of adding ourself to the couchrest library
 
-module CouchRest
-  class ExtendedDocument < Document
-    include CouchRest::Mixins::WillPaginate
+if defined?(CouchRest::ExtendedDocument)
+  module CouchRest
+    class ExtendedDocument < Document
+      include CouchRest::WillPaginate
+    end
+  end
+
+  module CouchRest
+    module Mixins
+      module ClassProxy
+        class Proxy
+          include CouchRest::WillPaginate::ProxyMethods
+        end
+      end
+    end
   end
 end
 
-module CouchRest
-  module Mixins
-    module ClassProxy
-      class Proxy
-        include CouchRest::Mixins::WillPaginate::ProxyMethods
+if defined?(CouchRest::Model::Base)
+  module CouchRest
+    module Model
+      class Base < Document
+        include CouchRest::WillPaginate
+      end
+    end
+  end
+
+  module CouchRest
+    module Model
+      module ClassProxy
+        class Proxy
+          include CouchRest::WillPaginate::ProxyMethods
+        end
       end
     end
   end
 end
 
+
+

data/lib/will_paginate_couchrest/class_methods.rb

@@ -1,147 +1,146 @@
 module CouchRest
-  module Mixins 
-    module WillPaginate
+  module WillPaginate
 
-      def self.included(base)
-        base.extend(ClassMethods)
-      end
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
 
-      module ClassMethods
-        # Define a CouchDB will paginate view. The name of the view will be the concatenation
-        # of <tt>paginate_by</tt> and the keys joined by <tt>_and_</tt>
-        # 
-        # ==== Example paginated views:
-        #  
-        #   class Post
-        #     # view with default options
-        #     # query with Post.paginate_by_date
-        #     paginated_view_by :date, :descending => true
-        #  
-        #     # view with compound sort-keys
-        #     # query with Post.by_user_id_and_date
-        #     paginated_view_by :user_id, :date
-        #  
-        #     # view with custom map/reduce functions
-        #     # query with Post.by_tags :reduce => true
-        #     paginated_view_by :tags,                                                
-        #       :map =>                                                     
-        #         "function(doc) {                                          
-        #           if (doc['couchrest-type'] == 'Post' && doc.tags) {                   
-        #             doc.tags.forEach(function(tag){                       
-        #               emit(doc.tag, 1);                                   
-        #             });                                                   
-        #           }                                                       
-        #         }",                                                       
-        #       :reduce =>                                                  
-        #         "function(keys, values, rereduce) {                       
-        #           return sum(values);                                     
-        #         }"                                                        
-        #   end
-        #  
-        # <tt>paginated_view_by :date</tt> will create a view defined by this Javascript
-        # function:
-        #  
-        #   function(doc) {
-        #     if (doc['couchrest-type'] == 'Post' && doc.date) {
-        #       emit(doc.date, 1);
-        #     }
-        #   }
-        #
-        # And a standard summing reduce function like the following:
-        #  
-        #   function(keys, values, rereduce) {                       
-        #     return sum(values);
-        #   } 
-        #
-        # It can be queried by calling <tt>Post.paginate_by_date</tt> which accepts all
-        # valid options for CouchRest::Database#view. In addition, calling with
-        # the <tt>:raw => true</tt> option will return the view rows
-        # themselves. By default <tt>Post.by_date</tt> will return the
-        # documents included in the generated view.
-        #  
-        # For further details on <tt>view_by</tt>'s other options, please see the
-        # standard documentation.
-        def paginated_view_by(*keys)
+    module ClassMethods
+      # Define a CouchDB will paginate view. The name of the view will be the concatenation
+      # of <tt>paginate_by</tt> and the keys joined by <tt>_and_</tt>
+      # 
+      # ==== Example paginated views:
+      #  
+      #   class Post
+      #     # view with default options
+      #     # query with Post.paginate_by_date
+      #     paginated_view_by :date, :descending => true
+      #  
+      #     # view with compound sort-keys
+      #     # query with Post.by_user_id_and_date
+      #     paginated_view_by :user_id, :date
+      #  
+      #     # view with custom map/reduce functions
+      #     # query with Post.by_tags :reduce => true
+      #     paginated_view_by :tags,                                                
+      #       :map =>                                                     
+      #         "function(doc) {                                          
+      #           if (doc['couchrest-type'] == 'Post' && doc.tags) {                   
+      #             doc.tags.forEach(function(tag){                       
+      #               emit(doc.tag, 1);                                   
+      #             });                                                   
+      #           }                                                       
+      #         }",                                                       
+      #       :reduce =>                                                  
+      #         "function(keys, values, rereduce) {                       
+      #           return sum(values);                                     
+      #         }"                                                        
+      #   end
+      #  
+      # <tt>paginated_view_by :date</tt> will create a view defined by this Javascript
+      # function:
+      #  
+      #   function(doc) {
+      #     if (doc['couchrest-type'] == 'Post' && doc.date) {
+      #       emit(doc.date, 1);
+      #     }
+      #   }
+      #
+      # And a standard summing reduce function like the following:
+      #  
+      #   function(keys, values, rereduce) {                       
+      #     return sum(values);
+      #   } 
+      #
+      # It can be queried by calling <tt>Post.paginate_by_date</tt> which accepts all
+      # valid options for CouchRest::Database#view. In addition, calling with
+      # the <tt>:raw => true</tt> option will return the view rows
+      # themselves. By default <tt>Post.by_date</tt> will return the
+      # documents included in the generated view.
+      #  
+      # For further details on <tt>view_by</tt>'s other options, please see the
+      # standard documentation.
+      def paginated_view_by(*keys)
 
-          # Prepare the Traditional view
-          opts = keys.last.is_a?(Hash) ? keys.pop : {}
-          view_name = "by_#{keys.join('_and_')}"
-          method_name = "paginate_#{view_name}"
+        # Prepare the Traditional view
+        opts = keys.last.is_a?(Hash) ? keys.pop : {}
+        view_name = "by_#{keys.join('_and_')}"
+        method_name = "paginate_#{view_name}"
 
-          doc_keys = keys.collect{|k| "doc['#{k}']"}
-          key_emit = doc_keys.length == 1 ? "#{doc_keys.first}" : "[#{doc_keys.join(', ')}]"
-          guards = opts.delete(:guards) || []
-          guards.push("(doc['couchrest-type'] == '#{self.to_s}')")
-          guards.concat doc_keys
+        doc_keys = keys.collect{|k| "doc['#{k}']"}
+        key_emit = doc_keys.length == 1 ? "#{doc_keys.first}" : "[#{doc_keys.join(', ')}]"
+        guards = opts.delete(:guards) || []
+        guards.push("(doc['couchrest-type'] == '#{self.to_s}')")
+        guards.concat doc_keys
 
-          opts = {
-            :map => "
-              function( doc ) {
-                if (#{guards.join(' && ')}) {
-                  emit(#{key_emit}, 1 );
-                }
+        opts = {
+          :map => "
+            function( doc ) {
+              if (#{guards.join(' && ')}) {
+                emit(#{key_emit}, 1 );
               }
-            ",
-            :reduce => "
-              function(keys, values, rereduce) {                       
-                return sum(values);
-              }
-            "
-          }.merge(opts)
+            }
+          ",
+          :reduce => "
+            function(keys, values, rereduce) {                       
+              return sum(values);
+            }
+          "
+        }.merge(opts)
 
-          # View prepared, send to traditional view_by
-          view_by keys, opts
+        # View prepared, send to traditional view_by
+        view_by keys, opts
 
-          instance_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
-            def #{method_name}(options = {})
-              paginated_view('#{view_name}', options)
-            end
-          RUBY_EVAL
-        end
+        instance_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+          def #{method_name}(options = {})
+            paginated_view('#{view_name}', options)
+          end
+        RUBY_EVAL
+      end
 
-        ##
-        # Generate a Will Paginate collection from all the available
-        # documents stored with a matching couchrest-type.
-        #
-        # Requires no declaration as the 'all' view is built into couchrest
-        # Extended Documents.
-        #
-        def paginate_all(options = {})
-          paginated_view(:all, options)
-        end
+      ##
+      # Generate a Will Paginate collection from all the available
+      # documents stored with a matching couchrest-type.
+      #
+      # Requires no declaration as the 'all' view is built into couchrest
+      # Extended Documents.
+      #
+      def paginate_all(options = {})
+        paginated_view(:all, options)
+      end
 
-        ##
-        # Return a WillPaginate collection suitable for usage
-        # 
-        def paginated_view(view_name, options = {})
-          raise "Missing per_page parameter" if options[:per_page].nil?
+      ##
+      # Return a WillPaginate collection suitable for usage
+      # 
+      def paginated_view(view_name, options = {})
+        raise "Missing per_page parameter" if options[:per_page].nil?
 
-          options[:page] ||= 1
+        options[:page] ||= 1
 
-          ::WillPaginate::Collection.create( options[:page], options[:per_page] ) do |pager|
-            # perform view count first (should create designs if missing)
-            if view_name.to_sym == :all
-              pager.total_entries = count({:database => options[:database]})
-            else
-              total = view( view_name, options.dup.update(:reduce => true) )['rows'].pop
-              pager.total_entries = total ? total['value'] : 0
-            end
-            p_options = options.merge(
-              :design_doc => self.to_s, :view_name => view_name,
-              :include_docs => true
-            )
-            # Only provide the reduce parameter when necessary. This is when the view has
-            # been set with a reduce method and requires the reduce boolean parameter
-            # to be either true or false on all requests.
-            p_options[:reduce] = false unless view_name.to_sym == :all
-            results = paginate(p_options)
-            pager.replace( results )
+        ::WillPaginate::Collection.create( options[:page], options[:per_page] ) do |pager|
+          # perform view count first (should create designs if missing)
+          if view_name.to_sym == :all
+            pager.total_entries = count({:database => options[:database]})
+          else
+            total = view( view_name, options.update(:reduce => true).dup )['rows'].pop
+            pager.total_entries = total ? total['value'] : 0
           end
+          p_options = options.merge(
+            :design_doc => self.to_s,
+            :view_name => view_name,
+            :include_docs => true
+          )
+          # Only provide the reduce parameter when necessary. This is when the view has
+          # been set with a reduce method and requires the reduce boolean parameter
+          # to be either true or false on all requests.
+          p_options[:reduce] = false unless view_name.to_sym == :all
+          results = paginate(p_options)
+          pager.replace( results )
         end
       end
-      
     end
-  end # module mixins 
+    
+  end
 end # module CouchRest
 
 

data/lib/will_paginate_couchrest/proxy_methods.rb

@@ -1,28 +1,26 @@
 module CouchRest
-  module Mixins
-    module WillPaginate
-      module ProxyMethods
+  module WillPaginate
+    module ProxyMethods
 
-        def method_missing(m, *args, &block)
-          if m.to_s =~ /^paginate_(.+)/ && @klass.respond_to?(m)
-            view_name = $1 # view name
-            opts = args.shift || {}
-            paginated_view(view_name, opts)
-          else
-            super
-          end
-        end
-
-        def paginated_view(view_name, opts = {})
-          opts = { 
-            :database => @database
-          }.merge(opts)
-          result = @klass.paginated_view(view_name, opts)
-          result.each{|doc| doc.database = @database if respond_to?(:database) } if result
-          result
+      def method_missing(m, *args, &block)
+        if m.to_s =~ /^paginate_(.+)/ && @klass.respond_to?(m)
+          view_name = $1 # view name
+          opts = args.shift || {}
+          paginated_view(view_name, opts)
+        else
+          super
         end
+      end
 
+      def paginated_view(view_name, opts = {})
+        opts = { 
+          :database => @database
+        }.merge(opts)
+        result = @klass.paginated_view(view_name, opts)
+        result.each{|doc| doc.database = @database if respond_to?(:database) } if result
+        result
       end
+
     end
   end
 end

data/spec/spec_helper.rb

@@ -2,12 +2,13 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
 require 'rubygems'
-require 'couchrest'
-require 'will_paginate'
+require 'couchrest_extended_document'
+require 'couchrest_model'
 require 'will_paginate_couchrest'
 require 'spec'
 require 'spec/autorun'
 
+
 unless defined?(SPEC_COUCH)
   COUCH_URL = "http://127.0.0.1:5984"
   COUCH_NAME = 'couchrest-test'
@@ -26,6 +27,6 @@ Spec::Runner.configure do |config|
   }
   
   config.after(:all) do
-    SPEC_COUCH.delete! rescue nil
+    SPEC_COUCH.delete!
   end
 end

data/spec/will_paginate_couchrest_spec.rb

@@ -1,97 +1,104 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe CouchRest::Mixins::WillPaginate do
+describe CouchRest::WillPaginate do
   
-  class SomeDoc < CouchRest::ExtendedDocument
+  class SomeExtendedDoc < CouchRest::ExtendedDocument
     use_database SPEC_COUCH
-
     property :name
-
     paginated_view_by :name
   end
 
-  it "should respond to paginated_view_by class method" do
-    SomeDoc.should respond_to :paginated_view_by
-  end
-
-  it "should call view_by method when paginated view_by included" do
-    SomeDoc.should_receive(:view_by)
-    class SomeDoc
-      paginated_view_by :name
-    end
-  end
-  
-  it "should respond to the view and paginated method" do
-    SomeDoc.should respond_to :paginate_by_name
-    # @some_doc.stub(:id).and_return(123)
-  end
-
-  it "should accept request when no results" do
-    docs = SomeDoc.paginate_by_name(:per_page => 5)
-    docs.total_entries.should eql(0)    
+  class SomeModel < CouchRest::Model::Base
+    use_database SPEC_COUCH
+    property :name
+    paginated_view_by :name
   end
 
-  it "should accept request without page" do
-    docs = nil
-    lambda { docs = SomeDoc.paginate_by_name(:per_page => 5) }.should_not raise_error
-    docs.current_page.should eql(1)
-  end
+  [SomeExtendedDoc, SomeModel].each do |klass|
+   
+    describe klass do
 
-  it "should throw an exception when missing per_page parameter" do
-    lambda { SomeDoc.paginate_by_name() }.should raise_error
-  end
+      before(:all) do
+        reset_test_db!
+      end
 
+      it "should respond to paginated_view_by class method" do
+        klass.should respond_to :paginated_view_by
+      end
 
-  describe "performing pagination with lots of documents" do
+      it "should call view_by method when paginated view_by included" do
+        klass.should_receive(:view_by)
+        klass.paginated_view_by :name
+      end
+      
+      it "should respond to the view and paginated method" do
+        klass.should respond_to :paginate_by_name
+        # @some_doc.stub(:id).and_return(123)
+      end
 
-    before(:each) do
-      reset_test_db!
-      20.times do |i|
-        txt = "%02d" % i
-        SomeDoc.new(:name => "document #{txt}").save
+      it "should accept request when no results" do
+        docs = klass.paginate_by_name(:per_page => 5)
+        docs.total_entries.should eql(0)    
       end
-    end
 
-    it "should produce a will paginate collection" do
-      docs = SomeDoc.paginate_by_name( :page => 1, :per_page => 5 )
-      docs.should be_a_kind_of(::WillPaginate::Collection)
-      docs.total_pages.should eql(4)
-      docs.first.name.should eql('document 00')
-      docs.length.should eql(5)
-      docs.last.name.should eql('document 04')
-    end
+      it "should accept request without page" do
+        docs = nil
+        lambda { docs = klass.paginate_by_name(:per_page => 5) }.should_not raise_error
+        docs.current_page.should eql(1)
+      end
 
-    it "should produce second page from paginate collection" do
-      docs = SomeDoc.paginate_by_name( :page => 2, :per_page => 5 )
-      docs.first.name.should eql('document 05')
-      docs.length.should eql(5)
-      docs.last.name.should eql('document 09')
-    end
+      it "should throw an exception when missing per_page parameter" do
+        lambda { klass.paginate_by_name() }.should raise_error
+      end
 
-    it "should perform paginate on all entries" do
-      docs = SomeDoc.paginate_all(:page => 1, :per_page => 5)
-      docs.first.class.should eql(SomeDoc)
-      docs.total_pages.should eql(4)
-      docs.total_entries.should eql(20)
-      docs.length.should eql(5)
-    end
 
-  end
+      describe "performing pagination with lots of documents" do
+
+        before(:each) do
+          reset_test_db!
+          20.times do |i|
+            txt = "%02d" % i
+            klass.new(:name => "document #{txt}").save
+          end
+        end
+
+        it "should produce a will paginate collection" do
+          docs = klass.paginate_by_name( :page => 1, :per_page => 5 )
+          docs.should be_a_kind_of(::WillPaginate::Collection)
+          docs.total_pages.should eql(4)
+          docs.first.name.should eql('document 00')
+          docs.length.should eql(5)
+          docs.last.name.should eql('document 04')
+        end
+
+        it "should produce second page from paginate collection" do
+          docs = klass.paginate_by_name( :page => 2, :per_page => 5 )
+          docs.first.name.should eql('document 05')
+          docs.length.should eql(5)
+          docs.last.name.should eql('document 09')
+        end
+
+        it "should perform paginate on all entries" do
+          docs = klass.paginate_all(:page => 1, :per_page => 5)
+          docs.first.class.should eql(klass)
+          docs.total_pages.should eql(4)
+          docs.total_entries.should eql(20)
+          docs.length.should eql(5)
+        end
 
+      end
 
-  describe "using pagination via proxy class" do
-    before(:each) do
-      @proxy = SomeDoc.on(SPEC_COUCH)
-    end
 
-    it "should allow paginate call on proxy with database" do
-      SomeDoc.should_receive(:paginated_view).with('by_name', {:key => 'foo', :database => SPEC_COUCH})
-      @proxy.paginate_by_name :key => 'foo'
-    end
+      describe "using pagination via proxy class" do
+        before(:each) do
+          @proxy = klass.on(SPEC_COUCH)
+        end
 
-    it "should call paginate parent with database" do
-      SomeDoc.should_receive(:paginate).with(hash_including(:database => SPEC_COUCH)).and_return([])
-      @proxy.paginate_by_name :key => 'foo', :per_page => 10
+        it "should allow paginate call on proxy" do
+          klass.should_receive(:paginated_view).with('by_name', {:key => 'foo', :database => SPEC_COUCH})
+          @proxy.paginate_by_name :key => 'foo'
+        end
+      end
     end
   end
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 2
-  - 2
-  version: 0.2.2
+  - 3
+  - 1
+  version: 0.3.1
 platform: ruby
 authors: 
 - samlown
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-05 00:00:00 +00:00
+date: 2010-07-07 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -96,5 +96,5 @@ signing_key:
 specification_version: 3
 summary: adds will-paginate support to CouchRest
 test_files: 
-- spec/will_paginate_couchrest_spec.rb
 - spec/spec_helper.rb
+- spec/will_paginate_couchrest_spec.rb