paged_scopes 0.1.0

data/spec/index_spec.rb

@@ -0,0 +1,31 @@
+require File.dirname(__FILE__) + '/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,249 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Pages" do
+  in_contexts do
+    before(:each) do
+      @pages = @articles.pages
+      @per_page = 2
+      @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 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.upto(@pages.count) 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|
+        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 not find the page of an object if the object is a new record" do
+      lambda { @pages.find_by_article!(Article.new) }.should raise_error(PagedScopes::PageNotFound)
+    end
+    
+    it "should not find the page of an object if the object is not an ActiveRecord::Base instance" do
+      lambda { @pages.find_by_article!(Object.new) }.should raise_error(PagedScopes::PageNotFound)
+    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("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 = 2
+    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
+
+describe "Page instance" do
+  in_contexts do
+    before(:each) do
+      @pages = @articles.pages
+      @per_page = 2
+      @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 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
+      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,256 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Paginator" do
+  before(:each) do
+    @articles = Article.scoped({})
+    @articles.per_page = 2
+    @pages = @articles.pages
+    @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(RuntimeError)
+  end
+    
+  it "should call the path proc with the last page when #last is called" do
+    @pages.each do |page|
+      path = lambda { |page| }
+      page.paginator.set_path(&path)
+      path.should_receive(:call).with(@pages.last).and_return("/path")
+      page.paginator.last.should == "/path"
+    end
+  end
+  
+  it "should call the path proc with the first page when #first is called" do
+    @pages.each do |page|
+      path = lambda { |page| }
+      page.paginator.set_path(&path)
+      path.should_receive(:call).with(@pages.first).and_return "/path"
+      page.paginator.first.should == "/path"
+    end
+  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).and_return("/path")
+      @paginator.next.should == "/path"
+    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.last
+      @paginator = @page.paginator
+      @paginator.set_path(&@path)
+    end
+
+    it "should call the path proc with the previous page when #previous is called" do
+      @path.should_receive(:call).with(@page.previous).and_return("/path")
+      @paginator.previous.should == "/path"
+    end
+    
+    it "should not call the path proc when #next is called" do
+      @path.should_not_receive(:call)
+      @paginator.next.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).and_return("/path")
+      @paginator.next.should == "/path"
+    end
+    
+    it "should call the path proc with the previous page when #previous is called" do
+      @path.should_receive(:call).with(@page.previous).and_return("/path")
+      @paginator.previous.should == "/path"
+    end
+  end
+  
+  describe "window generator" do
+    before(:each) do
+      @pages.stub!(:count).and_return(14)
+      @count = @pages.count
+    end
+    
+    it "should raise an error if no block is provided" do
+      lambda { @pages.first.paginator.window(:inner => 2) }.should raise_error(ArgumentError)
+    end
+
+    it "should raise an error if no inner size is provided" do
+      lambda { @pages.first.paginator.window({}) { |page, path| } }.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 = (4..8).map { |n| "<li><a href='/path/to/page/#{6+n}'>#{6+n}</a></li>" }
+      links.join("\n").should == page.paginator.window(:inner => 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,        4..8             ],
+        [ 3,        1..5             ],
+        [ 1,        1..5             ],
+        [ @count-2, @count-4..@count ],
+        [ @count,   @count-4..@count ]
+      ].each do |number, range|
+        page = @pages.find(number)
+        page.paginator.set_path(&@path)
+        pages, paths = [], []
+        range.each do |n|
+          pages << @pages.find(n)
+          paths << (n == page.number ? nil : @path.call(@pages.find(n)))
+        end
+        page.paginator.window(:inner => 2) do |pg, path, classes|
+          pg.should == pages.shift
+          path.should == paths.shift
+          pg == page ? classes.should(include(:selected)) : classes.should_not(include(:selected))
+        end
+      end
+    end
+    
+    context "with an outer window" do
+      it "should also call the block for each page in a window from the first and last pages, and include separators between the windws if necessary" do
+        [
+          [ 6,        1..2, 6-2..6+2,   @count-1..@count ],
+          [ 5,                1..5+2,   @count-1..@count ],
+          [ 3,                  1..5,   @count-1..@count ],
+          [ 1,                  1..5,   @count-1..@count ],
+          [ @count-4, 1..2,           @count-4-2..@count ],
+          [ @count-2, 1..2,             @count-4..@count ],
+          [ @count,   1..2,             @count-4..@count ]
+        ].each do |number, *ranges|
+          page = @pages.find(number)
+          page.paginator.set_path(&@path)
+          pages, paths, gaps_before, gaps_after = [], [], [], []
+          ranges.each do |range|
+            range.each do |n|
+              pages << @pages.find(n)
+              paths << (n == page.number ? nil : @path.call(@pages.find(n)))
+            end
+          end
+          pages.each_with_index { |pg, n| gaps_before << (pages[n-1] ? pages[n-1].number < pg.number - 1 : false) }
+          pages.each_with_index { |pg, n| gaps_after << (pages[n+1] ? pages[n+1].number > pg.number + 1 : false) }
+          page.paginator.window(:inner => 2, :outer => 2) do |pg, path, classes|
+            pg.should == pages.shift
+            path.should == paths.shift
+            gaps_before.shift ? classes.should(include(:gap_before)) : classes.should_not(include(:gap_before))
+            gaps_after.shift ? classes.should(include(:gap_after)) : classes.should_not(include(:gap_after))
+          end
+        end
+      end
+    end
+    
+    [ [ :previous, 2, 1 ], [ :next, 1, 2 ] ].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)
+        pages_paths = []
+        page.paginator.window(:inner => 2, :extras => [ extra ]) do |page, path, classes|
+          pages_paths << [ page, path ]
+        end
+        pages_paths.should include([ extra, @path.call(@pages.find(new_number)) ])
+      end
+    end
+
+    [ [ :previous, "1" ], [ :next, "@count" ] ].each do |extra, number|
+      it "should call the block with #{extra.inspect} and a nil path if #{extra.inspect} is specified as an extra but there is no #{extra} page" do
+        page = @pages.find(eval(number))
+        page.paginator.set_path(&@path)
+        pages_paths = []
+        page.paginator.window(:inner => 2, :extras => [ extra ]) do |page, path, classes|
+          pages_paths << [ page, path ]
+        end
+        pages_paths.should include([ extra, nil ])
+      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)
+        pages_paths = []
+        page.paginator.window(:inner => 2, :extras => [ extra ]) do |page, path, classes|
+          pages_paths << [ page, path ]
+        end
+        pages_paths.should include([ extra, @path.call(@pages.send(extra)) ])
+      end
+    end
+
+    [ [ :first, "1" ], [ :last, "@count" ] ].each do |extra, number|
+      it "should call the block with #{extra.inspect} and a nil path if #{extra.inspect} is specified as an extra but the current page is the #{extra} page" do
+        page = @pages.find(eval(number))
+        page.paginator.set_path(&@path)
+        pages_paths = []
+        page.paginator.window(:inner => 2, :extras => [ extra ]) do |page, path, classes|
+          pages_paths << [ page, path ]
+        end
+        pages_paths.should include([ extra, 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 = []
+      page.paginator.window(:inner => 1, :extras => [ :first, :previous, :next, :last ]) do |page, path, classes|
+        pages << page
+      end
+      pages.should == [ :first, :previous, @pages.find(5), @pages.find(6), @pages.find(7), :next, :last ]
+    end
+  end
+
+  describe "window generator for a collection with fewer pages than the window size" do
+    it "should list all the page" do
+      @pages.stub!(:count).and_return(5)
+      @pages.each do |page|
+        page.paginator.set_path(&@path)
+        pages = @pages.all
+        page.paginator.window(:inner => 2) do |pg, path, classes|
+          pg.should == pages.shift
+          if pg == page
+            path.should be_nil
+            classes.should include(:selected)
+          else
+            path.should_not be_nil
+            classes.should_not include(:selected)
+          end
+          classes.should_not include(:gap_before, :gap_after)
+        end
+        pages.should be_empty
+      end
+    end
+  end
+  
+  describe "window generator for a collection with only one page" do
+    it "should not generate any links" do
+      @pages.stub!(:count).and_return(1)
+      page = @pages.first
+      page.paginator.set_path(&@path)
+      @path.should_not_receive(:call)
+      page.paginator.window(:inner => 2) do |pg, path, classes|
+        fail "expected block not to be called"
+        "<a>some link</a>"
+      end.should be_blank
+    end
+  end
+end