mholling-paged_scopes 0.0.1 → 0.0.3

data/Rakefile

@@ -1,5 +1,6 @@
 require 'rubygems'
 require 'rake'
+require 'yaml'
 
 begin
   require 'jeweler'

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 1
+:patch: 3
 :major: 0
 :minor: 0

data/lib/paged_scopes/context.rb

@@ -11,11 +11,11 @@ module PagedScopes
     
     module ClassMethods
       def find_with_context(*args)
+        found_scope, found_options = (scope(:find) || {}).dup, args.dup.extract_options!.dup
         returning find_without_context(*args) do |results|
-          found_scope, found_options = scope(:find), args.extract_options!
-          [ results ].flatten.each do |result|
-            result.instance_variable_set "@found_scope", found_scope
-            result.instance_variable_set "@found_options", found_options
+          [ results ].flatten.compact.each do |result|
+            result.instance_variable_set "@found_scope", found_scope.dup
+            result.instance_variable_set "@found_options", found_options.dup
           end
         end
       end

data/lib/paged_scopes/controller.rb

@@ -7,16 +7,18 @@ module PagedScopes
         raise RuntimeError, "no @#{collection_name.to_s.pluralize} collection was set" unless collection
         object = instance_variable_get("@#{collection_name.to_s.singularize}")
         collection.per_page = options[:per_page] if options[:per_page]
-        collection.name = options[:name] if options[:name]
-        page = collection.pages.from_params(params) || (object && collection.pages.find_by_object(object)) || collection.pages.first
+        collection.page_name = options[:name] if options[:name]
+        page = collection.pages.from_params!(params) || (object && collection.pages.find_by_object(object)) || collection.pages.first
+        page.paginator.set_path { |pg| send(options[:path], pg) } if options[:path]
         instance_variable_set("@#{collection.pages.name.underscore}", page)
       end
       protected callback_method
-      before_filter callback_method
+      before_filter callback_method, options.except(:per_page, :name, :path)
     end
   end
 end
 
 if defined? ActionController::Base
   ActionController::Base.extend PagedScopes::Controller
+  ActionController::Base.rescue_responses.update('PagedScopes::PageNotFound' => :not_found)
 end

data/lib/paged_scopes/index.rb

@@ -64,10 +64,8 @@ module PagedScopes
 
     def after(object)
       after_index = index_of(object) + 1
-      find_scope = scope(:find) || {}
-      if find_scope[:limit]
-        offset = (find_scope[:offset] || 0).to_i
-        after_index >= find_scope[:limit] ? nil : first(:offset => after_index + offset)
+      if limit = scope(:find, :limit)
+        after_index >= limit ? nil : first(:offset => after_index + (scope(:find, :offset) || 0))
       else
         first(:offset => after_index)
       end
@@ -75,10 +73,8 @@ module PagedScopes
 
     def before(object)
       before_index = index_of(object) - 1
-      find_scope = scope(:find) || {}
-      if find_scope[:limit]
-        offset = find_scope[:offset].to_i
-        before_index < 0 ? nil : first(:offset => before_index + offset)
+      if scope(:find, :limit)
+        before_index < 0 ? nil : first(:offset => before_index + (scope(:find, :offset) || 0))
       else
         before_index < 0 ? nil : first(:offset => before_index)
       end

data/lib/paged_scopes/pages.rb

@@ -48,13 +48,8 @@ module PagedScopes
       end
       
       def from_params!(params)
-        find(params[name.underscore.foreign_key.to_sym])
-      end
-      
-      def from_params(params)
-        from_params!(params)
-      rescue PageNotFound
-        nil
+        number = params[name.underscore.foreign_key.to_sym]
+        number ? find(number) : nil
       end
 
       def count
@@ -67,7 +62,7 @@ module PagedScopes
         else
           proxy.count("#{proxy.table_name}.#{proxy.primary_key}", :distinct => true)
         end
-        (collection_count - 1)/per_page + 1
+        [ (collection_count - 1)/per_page + 1, 1].max
       end
       
       memoize :count
@@ -89,7 +84,12 @@ module PagedScopes
       end
       
       def closest_to(number)
-        find([ [ 1, number ].max, count ].min)
+        closest_number = [ [ 1, number ].max, count ].min
+        closest_number > 0 ? find(closest_number) : nil ## TODO this is unneeded now!
+      end
+      
+      def reload!
+        unmemoize_all
       end
       
       private
@@ -108,13 +108,19 @@ module PagedScopes
     private :proxy, :proxy_options, :proxy_scoped?
 
     def initialize(number)
-      unless number > 0 && number <= self.class.count
+      unless number > 0 && number <= page_count
         raise PageNotFound.new("couldn't find page number #{number}", self.class.closest_to(number))
       end
       @number = number
       @paginator = PagedScopes::Paginator.new(self)
     end
     
+    def reload!
+      self.class.reload!
+      self.class.find(number)
+      unmemoize_all
+    end
+    
     def page_count
       self.class.count
     end

data/lib/paged_scopes/paginator.rb

@@ -11,7 +11,7 @@ module PagedScopes
     end
     
     def path
-      @path || raise(ArgumentError, "No path proc supplied.")
+      @path || raise(RuntimeError, "No path proc supplied.")
     end
 
     def previous
@@ -23,25 +23,27 @@ module PagedScopes
     end
 
     def window(options)
+      results = []
       size = options[:size]
       extras = [ options[:extras] ].flatten.compact
       raise ArgumentError, "No window block supplied." unless block_given?
       return if @page.page_count < 2
       if @page.number - size > 1
-        yield :first, @path.call(@page.class.first) if extras.include? :first
+        results << yield(:first, @path.call(@page.class.first)) if extras.include? :first
         if extras.include?(:previous) && offset_page = @page.offset(-2 * size - 1)
-          yield :previous, @path.call(offset_page)
+          results << yield(:previous, @path.call(offset_page))
         end
       end
       (-size..size).map { |offset| @page.offset(offset) }.compact.each do |page|
-        yield page, @path.call(page)
+        results << yield( page, @path.call(page))
       end
       if @page.number + size < @page.page_count
         if extras.include?(:next) && offset_page = @page.offset(2 * size + 1)
-          yield :next, @path.call(offset_page)
+          results << yield(:next, @path.call(offset_page))
         end
-        yield :last, @path.call(@page.class.last) if extras.include? :last
+        results << yield(:last, @path.call(@page.class.last)) if extras.include? :last
       end
+      results.join("\n")
     end
   end
 end

data/spec/context_spec.rb

@@ -2,18 +2,26 @@ require 'spec_helper'
 
 describe "Context" do
   in_contexts do
-    it "should know the object after an object in the collection" do
+    it "should know the object after an object obtained with #all" do
       articles = @articles.all
       until articles.empty? do
         articles.shift.next.should == articles.first
       end
     end
 
-    it "should know the object before an object in the collection" do
+    it "should know the object before an object obtained with #all" do
       articles = @articles.all
       until articles.empty? do
         articles.pop.previous.should == articles.last
       end
     end
-  end  
+    
+    it "should be known for an object obtained with #first" do
+      @articles.all.should have_at_least(2).articles
+      @articles.first.next.should_not be_nil
+      @articles.first.previous.should be_nil
+    end
+    # (For a collection including :limit , this won't work with #last unless the collection
+    # has been evaluated already!)
+  end
 end

data/spec/controller_spec.rb

@@ -1,40 +1,71 @@
 require 'spec_helper'
 
 describe "Controller" do
+  
   context "class" do
+    before(:each) do
+      @class = Class.new(ActionController::Base)
+    end
+
+    it "should raise 404 on PagedScopes::PageNotFound" do
+      @class.rescue_responses['PagedScopes::PageNotFound'].should == :not_found
+    end
+    
     it "should add a protected get_page_for callback as a before filter when get_page_for is called" do
-      in_controller_class do
-        get_page_for :articles
-        before_filters.should include("get_page_for_articles")
-        protected_instance_methods.should include("get_page_for_articles")
-      end
+      @class.get_page_for :articles
+      @class.before_filters.map(&:to_s).should include("get_page_for_articles")
+      @class.protected_instance_methods.map(&:to_s).should include("get_page_for_articles")
     end
+    
+    it "should pass filter options except for :per_page, :name and :path on to the before filter" do
+      @options = { :per_page => 3, :name => "Group", :path => :page_articles_path, :only => [ :index, :show ], :if => :test }
+      @class.get_page_for :articles, @options
+      @filter = @class.filter_chain.detect { |filter| filter.method.to_s == "get_page_for_articles" }
+      @filter.options.keys.should_not include(:per_page, :name, :path)
+      @filter.options.keys.should include(:only, :if)
+    end
+    
   end
-  
-  describe "instance" do
+    
+  context "instance" do
+    before(:each) do
+      @controller = Class.new(ActionController::Base) do
+        get_page_for :articles
+      end.new
+    end
+
     it "should raise an error if no collection is set" do
-      in_controller_instance_with_paged(:articles) do
+      in_controller @controller do
         lambda { get_page_for_articles }.should raise_error(RuntimeError)
       end      
     end
-    
+
     context "when the collection is set" do
-      before(:all) do
-        @articles = User.first.articles
-        @articles.per_page = 3
+      before(:each) do
+        in_controller @controller do
+          @articles = User.first.articles
+          @articles.per_page = 3
+        end
       end
     
-      it "should get the page from a page id in the params" do 
-        in_controller_instance_with_paged(:articles) do
-          stub!(:params).and_return({ :page_id => @articles.pages.last.id })
+      it "should get the page from a page id in the params" do
+        in_controller @controller do
+          stub!(:params).and_return(:page_id => @articles.pages.last.id)
           get_page_for_articles
-          @page.articles.should include(@articles.last)
+          @page.should == @articles.pages.last
         end
       end
-    
+
+      it "should raise PageNotFound if the page id in the params is not in range" do
+        in_controller @controller do
+          stub!(:params).and_return(:page_id => @articles.pages.last.id + 1)
+          lambda { get_page_for_articles }.should raise_error(PagedScopes::PageNotFound)
+        end
+      end
+  
       it "should otherwise get the page from the current object if no page id is present in the params" do 
-        @article = @articles.last
-        in_controller_instance_with_paged(:articles) do
+        in_controller @controller do
+          @article = @articles.last
           get_page_for_articles
           @page.should == @articles.pages.find_by_article(@article)
           @page.articles.should include(@article)
@@ -42,19 +73,63 @@ describe "Controller" do
       end
           
       it "should get the first page if the current object is a new record" do
-        @article = @articles.new
-        in_controller_instance_with_paged(:articles) do
+        in_controller @controller do
+          @article = @articles.new
           get_page_for_articles
           @page.should == @articles.pages.first
         end
       end
           
       it "should otherwise get the first page" do
-        in_controller_instance_with_paged(:articles) do
+        in_controller @controller do
           get_page_for_articles
           @page.should == @articles.pages.first
         end
       end
     end
   end
-end
+  
+  context "instance when :per_page is specified in the call to #get_page_for" do
+    it "should set per_page on the collection" do
+      @controller = Class.new(ActionController::Base) do
+        get_page_for :articles, :per_page => 3
+      end.new
+      in_controller @controller do
+        @articles = User.first.articles
+        @articles.per_page = nil
+        get_page_for_articles
+        @articles.per_page.should == 3
+        @articles.pages.per_page.should == 3
+      end
+    end
+  end
+  
+  context "instance when :name is specified in the call to #get_page_for" do
+    it "should set page_name on the collection" do
+      @controller = Class.new(ActionController::Base) do
+        get_page_for :articles, :per_page => 3, :name => "Group"
+      end.new
+      in_controller @controller do
+        @articles = User.first.articles
+        get_page_for_articles
+        @articles.page_name.should == "Group"
+        @articles.pages.name.should == "Group"
+      end
+    end
+  end
+    
+  context "instance when :path is specified in the call to #get_page_for" do
+    it "should set page's pagination path to the specified controller method" do
+      @controller = Class.new(ActionController::Base) do
+        get_page_for :articles, :per_page => 3, :path => :page_articles_path
+      end.new
+      in_controller @controller do
+        @articles = User.first.articles
+        @article = @articles.first
+        get_page_for_articles
+        self.should_receive(:page_articles_path).with(@page.next)
+        @page.paginator.next
+      end
+    end
+  end
+end

data/spec/page_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 describe "Pages" do
   in_contexts do
     before(:each) do
+      @pages = @articles.pages
       @per_page = 3
       @articles.stub!(:per_page).and_return(@per_page)
       @articles.stub!(:page_name).and_return("Page")
@@ -30,11 +31,35 @@ describe "Pages" do
       @pages.count.should == (@articles.all.length - 1)/@per_page + 1
     end
     
+    it "should cache the page count" do
+      @articles.should_receive(:count).and_return(1)
+      2.times { @pages.count }
+    end
+
+    it "should clear the count cache when reloaded" do
+      @articles.should_receive(:count).twice.and_return(1)
+      @pages.count
+      @pages.reload!
+      @pages.count
+    end
+    
     it "should find pages with valid numbers" do
       (1..@pages.count).each do |number|
         lambda { @pages.find(number) }.should_not raise_error
       end
     end
+    
+    it "should cache the results of find" do
+      @pages.should_receive(:new).once
+      2.times { @pages.find(1) }
+    end
+    
+    it "should clear the find cache when reloaded" do
+      @pages.should_receive(:new).twice
+      @pages.find(1)
+      @pages.reload!
+      @pages.find(1)
+    end
         
     it "should raise an error containing the nearest substitute page for invalid page numbers" do
       [ [ -1, @pages.first], [ 0, @pages.first ], [ @pages.count + 1, @pages.last ] ].each do |number, substitute_page|
@@ -84,8 +109,38 @@ describe "Pages" do
     end
         
     it "should find a page from a params hash with a pages name as an id in the key" do
-      @pages.stub!(:name).and_return("Group")
-      @pages.from_params(:group_id => "1").should == @pages.first
+      @pages.stub!(:name).and_return("Page")
+      @pages.from_params!(:page_id => "1").should == @pages.first
+    end
+
+    it "should find a nil page from a params hash without a pages name as an id in the key" do
+      @pages.stub!(:name).and_return("Page")
+      @pages.from_params!({}).should be_nil
+    end
+
+    it "should raise an error from a params hash containing an out-of-range page id in the key" do
+      @pages.stub!(:name).and_return("Page")
+      lambda { @pages.from_params!(:page_id => @pages.count + 1) }.should raise_error(PagedScopes::PageNotFound)
+    end
+  end
+  
+  context "for an empty collection" do
+    before(:each) do
+      @articles = Article.scoped(:conditions => { :title => "Supercalifragilisticexpialidocious" })
+      @articles.all.should be_empty
+      @articles.per_page = 3
+    end
+    
+    it "should have one page" do
+      @articles.pages.count.should == 1
+    end
+    
+    it "should have a page numbered one" do
+      @articles.pages.first.number.should == 1
+    end
+    
+    it "should have an empty page" do
+      @articles.pages.first.articles.all.should be_empty
     end
   end
 end
@@ -93,6 +148,7 @@ end
 describe "Page instance" do
   in_contexts do
     before(:each) do
+      @pages = @articles.pages
       @per_page = 3
       @articles.stub!(:per_page).and_return(@per_page)
     end
@@ -113,6 +169,17 @@ describe "Page instance" do
       @pages.map(&:id).should == @pages.map(&:number)
     end
     
+    it "should clear the page class cache when reloaded" do
+      @pages.should_receive(:reload!)
+      @pages.first.reload!
+    end
+    
+    it "should be found again by the page class when reloaded" do
+      @page = @pages.first
+      @pages.should_receive(:find).with(@page.number)
+      @page.reload!
+    end
+    
     it "should know whether it's first" do
       pages = @pages.all
       pages.shift.should be_first

data/spec/paginator_spec.rb

@@ -12,7 +12,7 @@ describe "Paginator" do
   end
   
   it "should raise an error if the paginator path is not set" do
-    lambda { @pages.first.paginator.next }.should raise_error
+    lambda { @pages.first.paginator.next }.should raise_error(RuntimeError)
   end
   
   context "for the first page" do
@@ -74,6 +74,13 @@ describe "Paginator" do
       lambda { @pages.first.paginator.window({}) }.should raise_error(ArgumentError)
     end
     
+    it "should concatenate all the block return values into a string" do
+      page = @pages.find(6)
+      page.paginator.set_path { |page| }
+      links = (1..5).map { |n| "<li><a href='/path/to/page/#{n}'>1</a></li>" }
+      links.join("\n").should == page.paginator.window(:size => 2) { |page, path| links.shift }
+    end
+    
     it "should call the block with the page and the path for each page in a window surrounding the page" do
       [ [ 6, 6-@size..6+@size ], [ 2, 1..2+@size ], [ 1, 1..1+@size ], [ @page_count-1, @page_count-1-@size..@page_count ], [ @page_count, @page_count-@size..@page_count ] ].each do |number, range|
         page = @pages.find(number)

data/spec/resources_spec.rb

@@ -1,3 +1,5 @@
+require 'spec_helper'
+
 describe "Resources" do
   before(:each) do
     ActionController::Routing::Routes.clear!

data/spec/spec_helper.rb

@@ -48,20 +48,15 @@ end
 end
 
 module ControllerHelpers
-  def in_controller_class(&block)
-    Class.new(ActionController::Base) do
+  def in_instance(instance, &block)
+    instance.instance_eval do
       extend Spec::Matchers
       instance_eval(&block)
     end
   end
-
-  def in_controller_instance_with_paged(collection, &block)
-    controller = Class.new(ActionController::Base) do
-      get_page_for collection
-    end.new
-    controller.copy_instance_variables_from(self)
-    controller.instance_eval do    
-      extend Spec::Matchers
+  
+  def in_controller(controller, &block)
+    in_instance controller do
       stub!(:params).and_return({})
       instance_eval(&block)
     end
@@ -115,7 +110,6 @@ module Contexts
           before(:each) do
             @articles = eval("#{base}#{scope}")
             @articles.all.should_not be_empty
-            @pages = @articles.pages
           end
           instance_eval(&block)
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mholling-paged_scopes
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors: 
 - Matthew Hollingworth
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-15 00:00:00 -07:00
+date: 2009-06-17 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency