paginary 0.0.1.pre1 → 0.0.1.pre2

data/.gitignore

@@ -1,4 +1,5 @@
 .bundle
 *.sqlite3
 *.log
+pkg
 test/dummy/tmp/**/*

data/Rakefile

@@ -10,9 +10,9 @@ Jeweler::Tasks.new do |spec|
 
   spec.authors = ["Rolf Timmermans"]
   spec.email = "r.timmermans@voormedia.com"
-  spec.homepage = "http://rails-erd.rubyforge.org/"
+  spec.homepage = "http://github.com/voormedia/paginary"
 
-  spec.add_development_dependency "rails"
+  spec.add_runtime_dependency "rails", "~> 3.0"
   spec.add_development_dependency "sqlite3-ruby"
 end
 

data/VERSION

@@ -1 +1 @@
-0.0.1.pre1
+0.0.1.pre2

data/lib/paginary/helpers/page_builder.rb

@@ -5,10 +5,12 @@ module Paginary
       alias_method :items, :relation
       
       delegate :content_tag, :link_to, :params, :translate, :to => :template
+      delegate :current_page, :page_count, :first_page?, :last_page?, :to => :relation
       
       def initialize(template, relation, options = {})
         @template = template
         @param_name = options.delete(:param) || :page
+        @link_range = options.delete(:link_range) || 10
         @relation = relation.paginated? ? relation : relation.paginate(params[@param_name], options)
       end
       
@@ -17,11 +19,11 @@ module Paginary
       end
 
       def previous_url
-        page_url @relation.current_page - 1
+        page_url current_page - 1
       end
       
       def next_url
-        page_url @relation.current_page + 1
+        page_url current_page + 1
       end
       
       def links
@@ -30,14 +32,18 @@ module Paginary
       end
 
       def page_links
-        (1..@relation.page_count).collect do |page|
-          link_to content_tag(:span, page), page_url(page), :class => "page#{@relation.current_page == page ? " selected" : ""}"
+        page_numbers.collect do |page|
+          page_link(page)
         end.inject(:+)
       end
+      
+      def page_link(page)
+        link_to content_tag(:span, page), page_url(page), :class => "page#{current_page == page ? " selected" : ""}"
+      end
 
       def previous_link
         text = content_tag(:span, translate("previous", :default => "< Previous"))
-        unless @relation.first_page?
+        unless first_page?
           link_to text, previous_url, :class => "previous"
         else
           content_tag :span, text, :class => "previous disabled"
@@ -46,12 +52,29 @@ module Paginary
 
       def next_link
         text = content_tag(:span, translate("previous", :default => "Next >"))
-        unless @relation.last_page?
+        unless last_page?
           link_to text, next_url, :class => "next"
         else
           content_tag :span, text, :class => "next disabled"
         end
       end
+      
+      protected
+      
+      def page_numbers
+        start  = current_page - @link_range
+        finish = current_page + @link_range
+
+        if start < 1
+          finish = [finish + 1 - start, page_count].min
+          start = 1
+        elsif finish > page_count
+          start = [start + page_count - finish, 1].max
+          finish = page_count
+        end
+        
+        (start..finish).to_a
+      end
     end
   end
 end

data/lib/paginary/helpers/pagination_helper.rb

@@ -1,8 +1,9 @@
 module Paginary
   module Helpers
     module PaginationHelper
-      def paginate(relation, *args, &block)
-        capture(PageBuilder.new(self, relation, *args), &block)
+      def paginate(relation, options = {}, &block)
+        builder = options.delete(:builder) || PageBuilder
+        capture(builder.new(self, relation, options), &block)
       end
     end
   end

data/lib/paginary/relation/paginated.rb

@@ -8,14 +8,17 @@ module Paginary
       def paginate!(*args)
         options = args.extract_options!
         self.items_per_page = options[:per_page] || 50
-        self.current_page   = args.first ? args.first.to_i : 1
+        self.current_page   = args.first || 1
         self.limit_value    = items_per_page
         self.offset_value   = items_per_page * (current_page - 1)
       end
       
       def current_page=(page)
-        raise ActiveRecord::RecordNotFound, "page #{page} out of bounds, expected 1..#{page_count}" unless page.between?(1, page_count)
-        @current_page = page
+        number = page.to_i
+        unless number.to_s == page.to_s && number.between?(1, page_count)
+          raise ActiveRecord::RecordNotFound, "unknown page #{page}, expected 1..#{page_count}"
+        end
+        @current_page = number
       end
 
       def paginated?

data/paginary.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{paginary}
-  s.version = "0.0.1.pre1"
+  s.version = "0.0.1.pre2"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Rolf Timmermans"]
-  s.date = %q{2010-10-20}
+  s.date = %q{2010-11-12}
   s.description = %q{Simple, view-based pagination for Rails, built on top of Active Record 3 awesomeness.}
   s.email = %q{r.timmermans@voormedia.com}
   s.extra_rdoc_files = [
@@ -54,7 +54,7 @@ Gem::Specification.new do |s|
      "test/unit/relation/paginated_test.rb",
      "test/unit/relation/query_methods_test.rb"
   ]
-  s.homepage = %q{http://rails-erd.rubyforge.org/}
+  s.homepage = %q{http://github.com/voormedia/paginary}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{paginary}
@@ -82,14 +82,14 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rails>, [">= 0"])
+      s.add_runtime_dependency(%q<rails>, ["~> 3.0"])
       s.add_development_dependency(%q<sqlite3-ruby>, [">= 0"])
     else
-      s.add_dependency(%q<rails>, [">= 0"])
+      s.add_dependency(%q<rails>, ["~> 3.0"])
       s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
     end
   else
-    s.add_dependency(%q<rails>, [">= 0"])
+    s.add_dependency(%q<rails>, ["~> 3.0"])
     s.add_dependency(%q<sqlite3-ruby>, [">= 0"])
   end
 end

data/test/unit/helpers/page_builder_test.rb

@@ -20,6 +20,12 @@ class PaginationHelperTest < ActionView::TestCase
     builder
   end
   
+  def assert_page_link_chunks(chunks, actual_dom)
+    to_link = lambda { |i| %Q{<a href="/widgets?page=#{i}" class="page#{params[:page] == i ? " selected" : ""}"><span>#{i}</span></a>} }
+    expected_dom = chunks.collect { |chunk| chunk.to_a.map(&to_link).join } * %Q{<span class="omitted">...</span>}
+    assert_dom_equal expected_dom, actual_dom
+  end
+  
   # Items ====================================================================
   test "items should return paginated relation" do
     assert_equal_relation @relation.paginate, builder(@relation).items
@@ -65,4 +71,38 @@ class PaginationHelperTest < ActionView::TestCase
   test "previous_link should return disabled link to previous page if current page is first" do
     assert_dom_equal %Q{<span class="previous disabled"><span>&lt; Previous</span></span>}, builder(@relation).previous_link
   end
+  
+  # Chunks ===================================================================
+  test "page_link_ranges should return full range when page count is at maximum" do
+    assert_equal (1..11).to_a, builder(@relation, :per_page => 17, :link_range => 5).send(:page_numbers)
+  end
+
+  test "page_link_ranges should return full range when page count is below maximum" do
+    assert_equal (1..10).to_a, builder(@relation, :per_page => 18, :link_range => 5).send(:page_numbers)
+  end
+
+  test "page_link_ranges should return long beginning range and short closing range when current page is near beginning" do
+    params[:page] = 2
+    assert_equal (1..11).to_a, builder(@relation, :per_page => 1, :link_range => 5).send(:page_numbers)
+  end
+
+  test "page_link_ranges should return short beginning range and long closing range when current page is near end" do
+    params[:page] = 175
+    assert_equal (167..177).to_a, builder(@relation, :per_page => 1, :link_range => 5).send(:page_numbers)
+  end
+
+  test "page_link_ranges should return short beginning and closing range and long middle range when current page is somewhere in the middle" do
+    params[:page] = 155
+    assert_equal (150..160).to_a, builder(@relation, :per_page => 1, :link_range => 5).send(:page_numbers)
+  end
+  
+  test "page_links should return page links with omission near the end when page is first" do
+    params[:page] = 1
+    assert_page_link_chunks [1..11], builder(@relation, :per_page => 1, :link_range => 5).page_links
+  end
+
+  test "page_links should return page links with omission near the end and beginning when page is somewhere in the middle" do
+    params[:page] = 100
+    assert_page_link_chunks [95..105], builder(@relation, :per_page => 1, :link_range => 5).page_links
+  end
 end

data/test/unit/helpers/pagination_helper_test.rb

@@ -21,6 +21,13 @@ class PaginationHelperTest < ActionView::TestCase
     assert_kind_of Paginary::Helpers::PageBuilder, builder
   end
   
+  test "paginate should accept builder class" do
+    custom_builder = Class.new(Paginary::Helpers::PageBuilder)
+    builder = nil
+    paginate(@relation, :builder => custom_builder) { |b| builder = b }
+    assert_kind_of custom_builder, builder
+  end
+  
   test "paginate should query database for total number of items only once" do
     num = count_queries do
       paginate(@relation) { |page| page.links; page.items.to_a }

data/test/unit/relation/paginated_test.rb

@@ -40,6 +40,10 @@ class PaginatedTest < ActiveRecord::TestCase
   end
   
   # Page validation ==========================================================
+  test "paginate should set current page if given page is an integer string" do
+    assert_equal 2, @relation.paginate("2").current_page
+  end
+  
   test "paginate should raise error if given page is less than one" do
     assert_raises ActiveRecord::RecordNotFound do
       @relation.paginate(0)
@@ -52,6 +56,12 @@ class PaginatedTest < ActiveRecord::TestCase
     end
   end
   
+  test "paginate should raise error if given page is not well formatted" do
+    assert_raises ActiveRecord::RecordNotFound do
+      @relation.paginate("1.5")
+    end
+  end
+  
   # Page calculation =========================================================
   test "page_count should return 1 if there are no items" do
     assert_equal 1, @relation.where(:deleted => true).paginate.page_count

metadata

@@ -6,8 +6,8 @@ version: !ruby/object:Gem::Version
   - 0
   - 0
   - 1
-  - pre1
-  version: 0.0.1.pre1
+  - pre2
+  version: 0.0.1.pre2
 platform: ruby
 authors: 
 - Rolf Timmermans
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-10-20 00:00:00 +02:00
+date: 2010-11-12 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -24,12 +24,13 @@ dependencies:
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - ">="
+    - - ~>
       - !ruby/object:Gem::Version 
         segments: 
+        - 3
         - 0
-        version: "0"
-  type: :development
+        version: "3.0"
+  type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: sqlite3-ruby
@@ -91,7 +92,7 @@ files:
 - test/unit/relation/paginated_test.rb
 - test/unit/relation/query_methods_test.rb
 has_rdoc: true
-homepage: http://rails-erd.rubyforge.org/
+homepage: http://github.com/voormedia/paginary
 licenses: []
 
 post_install_message: