mholling-paged_scopes 0.0.4 → 0.0.5

data/VERSION.yml

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

data/lib/paged_scopes/pages.rb

@@ -76,7 +76,7 @@ module PagedScopes
       end
 
       def each(&block)
-        (1..count).each { |number| yield find(number) }
+        1.upto(count) { |number| yield find(number) }
       end
 
       def all

data/lib/paged_scopes/paginator.rb

@@ -21,19 +21,47 @@ module PagedScopes
     def next
       path.call(@page.next) unless @page.last?
     end
+    
+    def first
+      path.call(@page.class.first)
+    end
+    
+    def last
+      path.call(@page.class.last)
+    end
 
     def window(options)
-      size = options[:size]
-      extras = [ options[:extras] ].flatten.compact
       raise ArgumentError, "No window block supplied." unless block_given?
+      raise ArgumentError, "please specify a :inner option" unless inner = options[:inner]
+      return if @page.page_count < 2
+      outer = options[:outer] || 0
+      extras = [ options[:extras] ].flatten.compact
+      numbers = case
+      when @page.number <= inner + 1
+        1 .. 1 + 2 * inner
+      when @page.number >= @page.page_count - inner
+        @page.page_count - 2 * inner .. @page.page_count
+      else
+        @page.number - inner .. @page.number + inner
+      end.to_a
+      1.upto(outer) { |n| numbers << n << @page.page_count-n+1 }
+      numbers.uniq!
+      numbers.sort!
+      numbers.reject! { |number| !number.between?(1, @page.page_count) }
       returning [] do |results|
-        results << yield(:first, @page.first? ? nil : @path.call(@page.class.first)) if extras.include?(:first)
-        results << yield(:previous, @page.first? ? nil : @path.call(@page.previous)) if extras.include?(:previous)
-        (-size..size).map { |offset| @page.offset(offset) }.compact.each do |page|
-          results << yield(page, @path.call(page))
-        end
-        results << yield(:next, @page.last? ? nil : @path.call(@page.next)) if extras.include?(:next)
-        results << yield(:last, @page.last? ? nil : @path.call(@page.class.last)) if extras.include?(:last)
+        results << yield(:first, @page.first? ? nil : first, []) if extras.include?(:first)
+        results << yield(:previous, previous, []) if extras.include?(:previous)
+        numbers.zip([nil]+numbers, numbers[1..-1]) do |number, prev_number, next_number|
+          page = @page.class.find(number)
+          path = page == @page ? nil : @path.call(page)
+          classes = []
+          classes << :selected if page == @page
+          classes << :gap_before if prev_number && prev_number < number - 1
+          classes << :gap_after  if next_number && next_number > number + 1
+          results << yield(page, path, classes)
+        end        
+        results << yield(:next, self.next, []) if extras.include?(:next)
+        results << yield(:last, @page.last? ? nil : last, []) if extras.include?(:last)
       end.join("\n")
     end
   end

data/spec/page_spec.rb

@@ -44,7 +44,7 @@ describe "Pages" do
     end
     
     it "should find pages with valid numbers" do
-      (1..@pages.count).each do |number|
+      1.upto(@pages.count) do |number|
         lambda { @pages.find(number) }.should_not raise_error
       end
     end
@@ -107,6 +107,14 @@ describe "Pages" do
         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")

data/spec/paginator_spec.rb

@@ -3,17 +3,32 @@ require 'spec_helper'
 describe "Paginator" do
   before(:each) do
     @articles = Article.scoped({})
-    @articles.per_page = 3
+    @articles.per_page = 2
     @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(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
@@ -23,8 +38,8 @@ describe "Paginator" do
     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
+      @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
@@ -35,19 +50,19 @@ describe "Paginator" do
 
   context "for the last page" do
     before(:each) do
-      @page = @pages.first
+      @page = @pages.last
       @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
+    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 #previous is called" do
+    it "should not call the path proc when #next is called" do
       @path.should_not_receive(:call)
-      @paginator.previous.should be_nil
+      @paginator.next.should be_nil
     end
   end
 
@@ -59,44 +74,89 @@ describe "Paginator" do
     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
+      @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)
-      @paginator.previous
+      @path.should_receive(:call).with(@page.previous).and_return("/path")
+      @paginator.previous.should == "/path"
     end
   end
   
   describe "window generator" do
     before(:each) do
-      @args = []
+      @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({}) }.should raise_error(ArgumentError)
+      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 = (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 }
+      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, 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|
+      [
+        [ 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)
-        expected_args = []
-        range.map { |nearby_number| @pages.find(nearby_number) }.each do |nearby_page|
-          expected_args << [ nearby_page, @path.call(nearby_page) ]
+        pages, paths = [], []
+        range.each do |n|
+          pages << @pages.find(n)
+          paths << (n == page.number ? nil : @path.call(@pages.find(n)))
         end
-        page.paginator.window(:size => @size) do |*args|
-          expected_args.shift.should == args
+        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
-        expected_args.should be_empty
       end
     end
     
@@ -104,21 +164,23 @@ describe "Paginator" do
       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 |*args|
-          @args << args
+        pages_paths = []
+        page.paginator.window(:inner => 2, :extras => [ extra ]) do |page, path, classes|
+          pages_paths << [ page, path ]
         end
-        @args.should include([ extra, @path.call(@pages.find(new_number)) ])
+        pages_paths.should include([ extra, @path.call(@pages.find(new_number)) ])
       end
     end
 
-    [ [ :previous, "1" ], [ :next, "@page_count" ] ].each do |extra, number|
+    [ [ :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)
-        page.paginator.window(:size => @size, :extras => [ extra ]) do |*args|
-          @args << args
+        pages_paths = []
+        page.paginator.window(:inner => 2, :extras => [ extra ]) do |page, path, classes|
+          pages_paths << [ page, path ]
         end
-        @args.should include([ extra, nil ])
+        pages_paths.should include([ extra, nil ])
       end
     end
     
@@ -126,33 +188,69 @@ describe "Paginator" do
       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 |*args|
-          @args << args
+        pages_paths = []
+        page.paginator.window(:inner => 2, :extras => [ extra ]) do |page, path, classes|
+          pages_paths << [ page, path ]
         end
-        @args.should include([ extra, @path.call(@pages.send(extra)) ])
+        pages_paths.should include([ extra, @path.call(@pages.send(extra)) ])
       end
     end
 
-    [ [ :first, "1" ], [ :last, "@page_count" ] ].each do |extra, number|
+    [ [ :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)
-        page.paginator.window(:size => @size, :extras => [ extra ]) do |*args|
-          @args << args
+        pages_paths = []
+        page.paginator.window(:inner => 2, :extras => [ extra ]) do |page, path, classes|
+          pages_paths << [ page, path ]
         end
-        @args.should include([ extra, nil ])
+        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_in_order = []
-      page.paginator.window(:size => 1, :extras => [ :first, :previous, :next, :last ]) do |page, path|
-        pages_in_order << page
+      pages = []
+      page.paginator.window(:inner => 1, :extras => [ :first, :previous, :next, :last ]) do |page, path, classes|
+        pages << page
       end
-      pages_in_order.should == [ :first, :previous, @pages.find(5), @pages.find(6), @pages.find(7), :next, :last ]
+      pages.should == [ :first, :previous, @pages.find(5), @pages.find(6), @pages.find(7), :next, :last ]
     end
   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

metadata

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