mholling-paged_scopes 0.0.1

data/spec/controller_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe "Controller" do
+  context "class" do
+    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
+    end
+  end
+  
+  describe "instance" do
+    it "should raise an error if no collection is set" do
+      in_controller_instance_with_paged(:articles) 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
+      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 })
+          get_page_for_articles
+          @page.articles.should include(@articles.last)
+        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
+          get_page_for_articles
+          @page.should == @articles.pages.find_by_article(@article)
+          @page.articles.should include(@article)
+        end
+      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
+          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
+          get_page_for_articles
+          @page.should == @articles.pages.first
+        end
+      end
+    end
+  end
+end

data/spec/index_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe "Indexing" do
+  in_contexts do
+    it "should know the index of an object in the collection" do
+      @articles.all.each_with_index do |article, index|
+        @articles.index_of(article).should == index
+      end
+    end
+    
+    it "should raise an error if asked for the index of an object not in the collection" do
+      (Article.all - @articles.all).each do |article|
+        lambda { @articles.index_of(article) }.should raise_error(ActiveRecord::RecordNotFound)
+      end
+    end
+
+    it "should know the object after an object in the collection" do
+      articles = @articles.all
+      until articles.empty? do
+        @articles.after(articles.shift).should == articles.first
+      end
+    end
+
+    it "should know the object before an object in the collection" do
+      articles = @articles.all
+      until articles.empty? do
+        @articles.before(articles.pop).should == articles.last
+      end
+    end
+  end  
+end

data/spec/page_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+describe "Pages" do
+  in_contexts do
+    before(:each) do
+      @per_page = 3
+      @articles.stub!(:per_page).and_return(@per_page)
+      @articles.stub!(:page_name).and_return("Page")
+    end
+    
+    it "should raise an error if per_page is not specified" do
+      @articles.stub!(:per_page).and_return(nil)
+      lambda { @pages.per_page }.should raise_error(RuntimeError)
+    end
+    
+    it "should paginate using per_page from its proxy if available" do
+      @articles.stub!(:per_page).and_return(@per_page)
+      @pages.per_page.should == @per_page
+    end
+      
+    it "should be a class" do
+      @pages.should be_a_kind_of(Class)
+    end
+    
+    it "should be a class with name of the proxy's page name" do
+      @pages.name.should == "Page"
+    end
+        
+    it "should know the page count" do
+      @pages.count.should == (@articles.all.length - 1)/@per_page + 1
+    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 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|
+        lambda { @pages.find(number) }.should raise_error do |error|
+          error.substitute.should == substitute_page
+        end
+      end  
+    end
+    
+    it "should be enumerable" do
+      @pages.metaclass.included_modules.should include(Enumerable)
+      @pages.should respond_to(:each)
+      args_for_each = []
+      @pages.each { |page| args_for_each << page }
+      args_for_each.should == (1..@pages.count).map { |number| @pages.find(number) }
+    end
+    
+    it "should find the first page" do
+      @pages.first.number.should == 1
+    end
+    
+    it "should find the last page" do
+      @pages.last.number.should == @pages.count
+    end
+    
+    it "should find all pages" do
+      @pages.all.should == (1..@pages.count).map { |number| @pages.find(number) }
+    end
+    
+    it "should find a page closest to a given number" do
+      @pages.closest_to(0               ).should == @pages.first
+      @pages.closest_to(@pages.count    ).should == @pages.last
+      @pages.closest_to(@pages.count + 1).should == @pages.last
+    end
+    
+    it "should find the page of an object in the collection" do
+      @articles.all.each_with_index do |article, index|
+        @pages.find_by_article(article).number.should == 1 + index/@pages.per_page
+      end
+    end
+    
+    it "should not find the page of an object not in the collection" do
+      (Article.all - @articles.all).each do |article|
+        @pages.find_by_article(article).should be_nil
+        lambda { @pages.find_by_article!(article) }.should raise_error(PagedScopes::PageNotFound)
+      end
+    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
+    end
+  end
+end
+
+describe "Page instance" do
+  in_contexts do
+    before(:each) do
+      @per_page = 3
+      @articles.stub!(:per_page).and_return(@per_page)
+    end
+    
+    it "should have a scope representing the objects in the page" do
+      @pages.each { |page| page.articles.class.should == ActiveRecord::NamedScope::Scope }
+    end
+    
+    it "should know its number" do
+      @pages.find(1).number.should == 1
+    end
+    
+    it "should parameterise to the page number" do
+      @pages.map(&:to_param).should == @pages.map(&:number).map(&:to_s)
+    end
+    
+    it "should have the page number as id" do
+      @pages.map(&:id).should == @pages.map(&:number)
+    end
+    
+    it "should know whether it's first" do
+      pages = @pages.all
+      pages.shift.should be_first
+      pages.each { |page| page.should_not be_first }
+    end
+    
+    it "should know whether it's last" do
+      pages = @pages.all
+      pages.pop.should be_last
+      pages.each { |page| page.should_not be_last }
+    end
+    
+    it "should know the next page" do
+      pages = @pages.all
+      until pages.empty? do
+        pages.shift.next.should == pages.first
+      end
+    end
+    
+    it "should know the previous page" do
+      pages = @pages.all
+      until pages.empty? do
+        pages.pop.previous.should == pages.last
+      end
+    end
+    
+    it "should know the page which is offset by a specified amount" do
+      [ -2, 0, +2 ].each do |offset|
+        pages = @pages.all
+        pages.each_with_index do |page, index|
+          page.offset(offset).should == (index + offset < 0 ? nil : pages[index + offset])
+        end
+      end
+    end
+    
+    it "should be equal based on its page number" do
+      @pages.find(1).should == @pages.find(1)
+      @pages.find(1).should_not == @pages.find(2)
+    end
+    
+    it "should know the page count" do
+      @pages.first.page_count.should == @pages.count
+    end
+    
+    it "should be sortable by page number" do
+      @pages.all.reverse.sort.should == @pages.all
+    end
+                
+    it "should know whether it's full" do
+      @pages.each do |page|
+        page.articles.all.length == @per_page ? page.should(be_full) : page.should_not(be_full)
+      end
+    end
+    
+    it "should be correctly paginated and ordered" do
+      @pages.map(&:articles).should == @articles.all.in_groups_of(@per_page, false)
+    end
+  end
+end

data/spec/paginator_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe "Paginator" do
+  before(:each) do
+    @articles = Article.scoped({})
+    @articles.per_page = 3
+    @pages = @articles.pages
+    @size = 2 # window size
+    @page_count = @pages.count
+    (@page_count >= 14).should be_true # window specs won't work otherwise
+    @path = lambda { |page| "/path/to/page/#{page.to_param}" }
+  end
+  
+  it "should raise an error if the paginator path is not set" do
+    lambda { @pages.first.paginator.next }.should raise_error
+  end
+  
+  context "for the first page" do
+    before(:each) do
+      @page = @pages.first
+      @paginator = @page.paginator
+      @paginator.set_path(&@path)
+    end
+
+    it "should call the path proc with the next page when #next is called" do
+      @path.should_receive(:call).with(@page.next)
+      @paginator.next
+    end
+    
+    it "should not call the path proc when #previous is called" do
+      @path.should_not_receive(:call)
+      @paginator.previous.should be_nil
+    end
+  end
+
+  context "for the last page" do
+    before(:each) do
+      @page = @pages.first
+      @paginator = @page.paginator
+      @paginator.set_path(&@path)
+    end
+
+    it "should call the path proc with the next page when #next is called" do
+      @path.should_receive(:call).with(@page.next)
+      @paginator.next
+    end
+    
+    it "should not call the path proc when #previous is called" do
+      @path.should_not_receive(:call)
+      @paginator.previous.should be_nil
+    end
+  end
+
+  context "for any other page" do
+    before(:each) do
+      @page = @pages.all.second
+      @paginator = @page.paginator
+      @paginator.set_path(&@path)
+    end
+
+    it "should call the path proc with the next page when #next is called" do
+      @path.should_receive(:call).with(@page.next)
+      @paginator.next
+    end
+    
+    it "should call the path proc with the previous page when #previous is called" do
+      @path.should_receive(:call).with(@page.previous)
+      @paginator.previous
+    end
+  end
+  
+  describe "window generator" do
+    it "should raise an error if no block is provided" do
+      lambda { @pages.first.paginator.window({}) }.should raise_error(ArgumentError)
+    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)
+        page.paginator.set_path(&@path)
+        expected_args = []
+        range.map { |nearby_number| @pages.find(nearby_number) }.each do |nearby_page|
+          expected_args << [ nearby_page, @path.call(nearby_page) ]
+        end
+        actual_args = []
+        page.paginator.window(:size => @size) do |*args|
+          actual_args << args
+        end
+        actual_args.should == expected_args
+      end
+    end
+    
+    [ :first, :last ].each do |extra|
+      it "should call the block with #{extra.inspect} and the path for the #{extra} page if #{extra.inspect} is specified as an extra" do
+        page = @pages.find(6)
+        page.paginator.set_path(&@path)
+        page.paginator.window(:size => @size, :extras => [ extra ]) do |page, path|
+          @received = true if extra == page && path == @path.call(@pages.send(extra))
+        end
+        @received.should be_true
+      end
+    end
+
+    [ [ :first, "1+@size" ], [ :last, "@page_count-@size" ] ].each do |extra, number|
+      it "should not call the block with #{extra.inspect} if #{extra.inspect} is specified as an extra but the #{extra} page is within the window" do
+        page = @pages.find(eval(number))
+        page.paginator.set_path(&@path)
+        page.paginator.window(:size => @size, :extras => [ extra ]) do |page, path|
+          @received = true if extra == page
+        end
+        @received.should be_nil
+      end
+    end
+    
+    [ [ :previous, 8, "8-2*@size-1" ], [ :next, 4, "4+2*@size+1" ] ].each do |extra, number, new_number|
+      it "should call the block with #{extra.inspect} and the path for the #{extra} page if #{extra.inspect} is specified as an extra" do
+        page = @pages.find(number)
+        page.paginator.set_path(&@path)
+        page.paginator.window(:size => @size, :extras => [ extra ]) do |page, path|
+          @received = true if extra == page && path == @path.call(@pages.find(eval(new_number)))
+        end
+        @received.should be_true
+      end
+    end
+
+    [ [ :previous, "1+2*@size" ], [ :next, "@page_count-2*@size" ] ].each do |extra, number|
+      it "should not call the block with #{extra.inspect} if #{extra.inspect} is specified as an extra but the #{extra} window is out of range" do
+        page = @pages.find(eval(number))
+        page.paginator.set_path(&@path)
+        page.paginator.window(:size => @size, :extras => [ extra ]) do |page, path|
+          @received = true if extra == page
+        end
+        @received.should be_nil
+      end
+    end
+    
+    it "should call the block with :first, :previous, pages, :next, :last in that order" do
+      page = @pages.find(6)
+      page.paginator.set_path(&@path)
+      pages_in_order = []
+      page.paginator.window(:size => 1, :extras => [ :first, :previous, :next, :last ]) do |page, path|
+        pages_in_order << page
+      end
+      pages_in_order.should == [ :first, :previous, @pages.find(5), @pages.find(6), @pages.find(7), :next, :last ]
+    end
+  end
+end

data/spec/resources_spec.rb

@@ -0,0 +1,70 @@
+describe "Resources" do
+  before(:each) do
+    ActionController::Routing::Routes.clear!
+  end
+  
+  after(:each) do
+    ActionController::Routing::Routes.clear!
+  end
+
+  it "should not affect normal resource mapping if :paged option is not specified" do
+    drawing_routes { |map| map.resources :articles }.should change { number_of_routes }.by(7)
+  end
+  
+  it "should add a paged index route if a :paged option is specified" do
+    drawing_routes { |map| map.resources :articles, :paged => true }.should change { number_of_routes }.by(7+1)
+  end
+  
+  context "with a :paged options" do    
+    it "should map a paged index route for GET only" do
+      draw_routes { |map| map.resources :articles, :paged => true }
+      recognise_path(   :get, "/pages/1/articles").should == { :controller => "articles", :action => "index", :page_id => "1" }
+      recognise_path(   :put, "/pages/1/articles").should be_nil
+      recognise_path(  :post, "/pages/1/articles").should be_nil
+      recognise_path(:delete, "/pages/1/articles").should be_nil
+    end
+
+    it "should add a named route for the paged index route" do
+      draw_routes { |map| map.resources :articles, :paged => true }
+      named_routes.names.should include(:page_articles)
+    end
+    
+    it "should observe the :path_prefix option in the paged route" do
+      draw_routes { |map| map.resources :articles, :paged => true, :path_prefix => "foo" }
+      recognise_path(:get, "/foo/pages/1/articles").should == { :controller => "articles", :action => "index", :page_id => "1" }
+    end
+    
+    it "should observe a :namespace option in the paged route" do
+      draw_routes { |map| map.resources :articles, :paged => true, :namespace => "bar/" }
+      recognise_path(:get, "/pages/1/articles").should == { :controller => "bar/articles", :action => "index", :page_id => "1" }
+    end
+    
+    it "should accept an :as option in the :paged option" do
+      draw_routes { |map| map.resources :articles, :paged => { :as => "page" } }
+      recognise_path(:get, "/page/1/articles").should == { :controller => "articles", :action => "index", :page_id => "1" }
+    end
+    
+    it "should accept a :name option in the :paged option" do
+      draw_routes { |map| map.resources :articles, :paged => { :name => :groups } }
+      recognise_path(:get, "/groups/1/articles").should == { :controller => "articles", :action => "index", :group_id => "1" }
+    end
+    
+    it "should accept a :path_prefix hash as the :paged option" do
+      draw_routes { |map| map.resources :articles, :paged => true, :name_prefix => "baz_" }
+      named_routes.names.should include(:baz_page_articles)
+    end
+    
+    context "and nested resources" do
+      it "should not change the nested routes" do
+        drawing_routes do |map|
+          map.resources :articles, :paged => true do |article|
+            article.resources :comments
+          end
+        end.should change { number_of_routes }.by(7+1+7)
+        drawing_routes do |map|
+          map.resources :articles, :paged => true, :has_many => :comments
+        end.should change { number_of_routes }.by(7+1+7)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,132 @@
+require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'active_support'
+require 'active_record'
+require 'action_controller'
+require 'action_controller/test_process'
+require 'action_view/test_case'
+require 'paged_scopes'
+
+ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :dbfile => ':memory:')
+ActiveRecord::Schema.define do
+  create_table "users", :force => true do |t|
+    t.column "name",  :text
+  end
+  create_table "articles", :force => true do |t|
+    t.column "user_id",  :integer
+    t.column "title", :text
+  end
+  create_table "comments", :force => true do |t|
+    t.column "article_id", :integer
+    t.column "user_id", :integer
+  end
+end
+
+class ::User < ActiveRecord::Base
+  has_many :articles
+  has_many :comments
+  has_many :commented_articles, :through => :comments, :source => :article
+end
+class ::Article < ActiveRecord::Base
+  belongs_to :user
+  has_many :comments
+end
+class ::Comment < ActiveRecord::Base
+  belongs_to :article
+  belongs_to :user
+end
+
+[ "first user", nil, "last user" ].each { |name| User.create(:name => name) }
+7.times do
+  User.all.each do |user|
+    user.articles.create.comments << User.first.comments.new
+    user.articles.create(:title => "%03d title" % Article.count).comments << User.first.comments.new << User.last.comments.new
+  end
+end
+
+module ControllerHelpers
+  def in_controller_class(&block)
+    Class.new(ActionController::Base) 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
+      stub!(:params).and_return({})
+      instance_eval(&block)
+    end
+  end
+end
+
+module RoutingHelpers
+  def draw_routes(&block)
+    ActionController::Routing::Routes.draw(&block)
+  end
+
+  def drawing_routes(&block)
+    lambda { draw_routes(&block) }
+  end
+
+  def number_of_routes
+    ActionController::Routing::Routes.routes.size
+  end
+
+  def named_routes
+    ActionController::Routing::Routes.named_routes
+  end
+
+  def recognise_path(method, path)
+    request = ActionController::TestRequest.new
+    request.request_method = method
+    ActionController::Routing::Routes.recognize_path(path, ActionController::Routing::Routes.extract_request_environment(request))
+  rescue ActionController::RoutingError, ActionController::MethodNotAllowed
+    nil
+  end
+end
+
+module Contexts
+  def in_contexts(&block)
+    [ [ "a scoped ActiveRecord class",      "Article.scoped({})"            ],
+      [ "a has_many association",           "User.last.articles"            ], # not tested for habtm!
+      [ "a has_many, :through association", "User.first.commented_articles" ] ].each do |base_type, base|
+      [ [ "",                                         ""                                          ],
+        [ "scoped with :conditions",                  ".scoped(:conditions => { :title => nil })" ],
+        [ "scoped with :include",                     ".scoped(:include => :comments)"            ],
+        [ "scoped with :joins",                       ".scoped(:joins => 'INNER JOIN users ON users.id = articles.user_id')" ],
+        [ "scoped with :joins & :conditions",         ".scoped(:joins => 'INNER JOIN users ON users.id = articles.user_id', :conditions => [ 'users.name IS NOT :nil', { :nil => nil } ])" ],
+        [ "scoped with :joins, :conditions & :order", ".scoped(:joins => 'INNER JOIN users ON users.id = articles.user_id', :conditions => [ 'users.name IS NOT :nil', { :nil => nil } ], :order => 'users.name')" ],
+        [ "scoped with :joins & :group",              ".scoped(:joins => 'INNER JOIN comments AS article_comments ON article_comments.article_id = articles.id', :group => 'articles.id')" ],
+        [ "scoped with :joins, :group & :limit",      ".scoped(:joins => 'INNER JOIN comments AS article_comments ON article_comments.article_id = articles.id', :group => 'articles.id', :limit => 4)" ],
+        [ "scoped with :includes, :joins & subquery", ".scoped(:include => :comments, :joins => 'INNER JOIN (SELECT count(id) AS count, article_id FROM comments GROUP BY article_id) article_comments ON article_comments.article_id = articles.id', :conditions => 'article_comments.count > 1')"],
+        [ "scoped with :limit",                       ".scoped(:limit => 5)"                      ],
+        [ "scoped with :limit & :offset",             ".scoped(:limit => 5, :offset => 7)"        ],
+        [ "scoped with :order",                       ".scoped(:order => 'articles.id DESC')"     ] ].each do |scope_type, scope|
+        context "for #{base_type} #{scope_type}" do
+          before(:each) do
+            @articles = eval("#{base}#{scope}")
+            @articles.all.should_not be_empty
+            @pages = @articles.pages
+          end
+          instance_eval(&block)
+        end
+      end
+    end
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.extend Contexts
+  config.include RoutingHelpers
+  config.include ControllerHelpers
+end
+