peiji-san 0.1.1

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright © 2009 Fingertips, Eloy Duran <eloy.de.enige@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,22 @@
+= Peiji-San
+
+Peiji-San uses named scopes to create a thin pagination layer.
+
+Model:
+
+  class Member < ActiveRecord::Base
+    extend PeijiSan
+    self.entries_per_page = 32
+  end
+
+Controller:
+
+  @collection = Member.active.page(2)
+
+View:
+
+  <% if @collection.page_count > 1 %>
+    <% pages_to_link_to(@collection).each do |page %>
+      <%= page.is_a?(String) ? page : link_to_page(page, @collection) %>
+    <% end %>
+  <% end %>

data/Rakefile

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name     = "peiji-san"
+    s.homepage = "http://github.com/Fingertips/peiji-san"
+    s.email    = "eloy.de.enige@gmail.com"
+    s.authors  = ["Eloy Duran"]
+    s.summary  = s.description = "PeijiSan is a Rails plugin which uses named scopes to create a thin pagination layer."
+    s.files    = FileList['**/**'] # tmp until we've patched Jeweler to be able to easily add files to defaults
+  end
+rescue LoadError
+end
+
+begin
+  require 'jewelry_portfolio/tasks'
+  JewelryPortfolio::Tasks.new do |p|
+    p.account = 'Fingertips'
+  end
+rescue LoadError
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = 'PeijiSan'
+  rdoc.options << '--line-numbers' << '--inline-source' << '--charset=utf-8'
+  rdoc.rdoc_files.include('README*', 'LICENSE')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = false
+end
+
+task :default => :test

data/TODO

@@ -0,0 +1,2 @@
+* Merge Scope and Array methods
+* Make it possible to use this pattern: http://www.percona.com/ppc2009/PPC2009_mysql_pagination.pdf

data/VERSION.yml

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

data/lib/peiji_san/view_helper.rb

@@ -0,0 +1,103 @@
+module PeijiSan
+  # Include this module into your view helper module, for instance
+  # ApplicationController, for super paginating cow powers.
+  #
+  # Optionally define the peiji_san_options method in your helper to override
+  # the default options.
+  #
+  # Example:
+  #
+  #   @collection = Member.active.page(2)
+  #
+  #   <% pages_to_link_to(@collection).each do |page %>
+  #     <%= page.is_a?(String) ? page : link_to_page(page, @collection) %>
+  #   <% end %>
+  module ViewHelper
+    # The default options for link_to_page and pages_to_link_to.
+    DEFAULT_PEIJI_SAN_OPTIONS = {
+      # For link_to_page
+      :page_parameter => :page,
+      :anchor => :explore,
+      :current_class => :current,
+      # For pages_to_link_to
+      :max_visible => 11,
+      :separator => '…'
+    }
+    
+    # Override this method in your helper to override default values:
+    #
+    #   def peiji_san_options
+    #     { :max_visible => 7 }
+    #   end
+    def peiji_san_options
+    end
+    
+    # Creates a link using +link_to+ for a page in a pagination collection. If
+    # the specified page is the current page then its class will be `current'.
+    #
+    # Options:
+    #   [:page_parameter]
+    #     The name of the GET parameter used to indicate the page to display.
+    #     Defaults to <tt>:page</tt>.
+    #   [:current_class]
+    #     The CSS class name used when a page is the current page in a pagination
+    #     collection. Defaults to <tt>:current</tt>.
+    def link_to_page(page, paginated_set, options = {}, html_options = {})
+      page_parameter = peiji_san_option(:page_parameter, options)
+      url_options = (page == 1 ? controller.params.except(page_parameter) : controller.params.merge(page_parameter => page))
+      url_options[:anchor] = peiji_san_option(:anchor, options)
+      html_options[:class] = peiji_san_option(:current_class, options) if paginated_set.current_page?(page)
+      link_to page, url_for(url_options), html_options
+    end
+    
+    # Returns an array of pages to link to. This array includes the separator, so
+    # make sure to keep this in mind when iterating over the array and creating
+    # links.
+    #
+    # For consistency’s sake, it is adviced to use an odd number for
+    # <tt>:max_visible</tt>.
+    #
+    # Options:
+    #   [:max_visible]
+    #     The maximum amount of elements in the array, this includes the
+    #     separator(s). Defaults to 11.
+    #   [:separator]
+    #     The separator string used to indicate a range between the first or last
+    #     page and the ones surrounding the current page.
+    #
+    # Example:
+    #
+    #   collection = Model.all.page(40)
+    #   collection.page_count # => 80
+    #
+    #   pages_to_link_to(collection) # => [1, '…', 37, 38, 39, 40, 41, 42, 43, '…', 80]
+    def pages_to_link_to(paginated_set, options = {})
+      current, last = paginated_set.current_page, paginated_set.page_count
+      max = peiji_san_option(:max_visible, options)
+      separator = peiji_san_option(:separator, options)
+      
+      if last <= max
+        (1..last).to_a
+      elsif current <= ((max / 2) + 1)
+        (1..(max - 2)).to_a + [separator, last]
+      elsif current >= (last - (max / 2))
+        [1, separator, *((last - (max - 3))..last)]
+      else
+        offset = (max - 4) / 2
+        [1, separator] + ((current - offset)..(current + offset)).to_a + [separator, last]
+      end
+    end
+    
+    private
+    
+    def peiji_san_option(key, options)
+      if value = options[key]
+        value
+      elsif (user_options = peiji_san_options) && user_options[key]
+        user_options[key]
+      else
+        DEFAULT_PEIJI_SAN_OPTIONS[key]
+      end
+    end
+  end
+end

data/lib/peiji_san.rb

@@ -0,0 +1,124 @@
+# Peiji-San uses named scopes to create a thin pagination layer.
+#
+# Example:
+#
+#   class Member < ActiveRecord::Base
+#     extend PeijiSan
+#     self.entries_per_page = 32
+#   end
+#
+# Now you can start scoping your queries by `page':
+#
+#   Member.active.page(2)
+#
+# Which will return 32 records with an offset of 32, as that's the second page.
+#
+# See PeijiSan::PageScope and PeijiSan::ViewHelper for more info.
+module PeijiSan
+  class PageScope < ActiveRecord::NamedScope::Scope
+    attr_reader :current_page
+    
+    def initialize(proxy_scope, options)
+      @current_page = (options[:page].blank? ? 1 : options[:page]).to_i
+      @entries_per_page = options[:entries_per_page]
+      super(proxy_scope, :offset => ((@current_page - 1) * @entries_per_page), :limit => @entries_per_page)
+    end
+    
+    # Returns whether or not the given page is the current page.
+    def current_page?(page)
+      @current_page == page
+    end
+    
+    # Returns whether or not there is a next page for the current scope.
+    def has_next_page?
+      @current_page < page_count
+    end
+    
+    # Returns whether or not there is a previous page for the current scope.
+    def has_previous_page?
+      @current_page != 1
+    end
+    
+    # Returns the next page number if there is a next page, returns +nil+
+    # otherwise.
+    def next_page
+      @current_page + 1 if has_next_page?
+    end
+    
+    # Returns the previous page number if there is a previous page, returns
+    # +nil+ otherwise.
+    def previous_page
+      @current_page - 1 if has_previous_page?
+    end
+    
+    # Returns the row count for all the rows that would match the current
+    # scope, so not only on the current page.
+    def count
+      @proxy_scope.count
+    end
+    
+    # Returns the number of pages for the current scope.
+    def page_count
+      (count.to_f / @entries_per_page).ceil
+    end
+  end
+  
+  # Sets the number of entries you want per page.
+  #
+  #   class Member < ActiveRecord::Base
+  #     extend PeijiSan
+  #     entries_per_page 32
+  #   end
+  def entries_per_page=(entries)
+    @entries_per_page = entries
+  end
+  
+  # Returns the number of entries you want per page.
+  #
+  #   class Member < ActiveRecord::Base
+  #     extend PeijiSan
+  #     entries_per_page 32
+  #   end
+  #   Member.entries_per_page #=> 32
+  def entries_per_page
+    @entries_per_page
+  end
+  
+  # Set the current scope to a given page number.
+  #
+  # Consider:
+  #
+  #   class Member < ActiveRecord::Base
+  #     extend PeijiSan
+  #     entries_per_page 32
+  #   end
+  #
+  # This adds <tt>{ :limit => 32, :offset => 0 }</tt> to the scope:
+  #
+  #   Member.page(1)
+  #
+  # This adds <tt>{ :limit => 32, :offset => 31 }</tt> to the scope:
+  #
+  #   Member.page(2)
+  #
+  # You can optionally override the entries_per_page setting by sepcifying a
+  # second argument:
+  #
+  #   Member.page(2, 5) # Page 2, 5 entries
+  def page(page, entries_per_page = nil)
+    scopes[:page].call(self, page, entries_per_page)
+  end
+  
+  # Defines the page named_scope when it extends a model class.
+  #
+  #   Member.respond_to? :page # => false
+  #
+  #   class Member < ActiveRecord::Base
+  #     extend PeijiSan
+  #   end
+  #
+  #   Member.respond_to? :page # => true
+  def self.extended(klass)
+    klass.scopes[:page] = lambda { |parent_scope, *args| PageScope.new(parent_scope, :page => args[0], :entries_per_page => args[1] || klass.entries_per_page) }
+  end
+end

data/peiji-san.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{peiji-san}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Eloy Duran"]
+  s.date = %q{2009-03-09}
+  s.description = %q{PeijiSan is a Rails plugin which uses named scopes to create a thin pagination layer.}
+  s.email = %q{eloy.de.enige@gmail.com}
+  s.extra_rdoc_files = ["README.rdoc", "LICENSE"]
+  s.files = ["lib", "lib/peiji_san", "lib/peiji_san/view_helper.rb", "lib/peiji_san.rb", "LICENSE", "peiji-san.gemspec", "rails", "rails/init.rb", "Rakefile", "README.rdoc", "test", "test/peiji_san_test.rb", "test/test_helper.rb", "test/view_helper_test.rb", "VERSION.yml"]
+  s.has_rdoc = true
+  s.homepage = %q{http://github.com/Fingertips/peiji-san}
+  s.rdoc_options = ["--inline-source", "--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{PeijiSan is a Rails plugin which uses named scopes to create a thin pagination layer.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/rails/init.rb

@@ -0,0 +1,2 @@
+require 'peiji_san'
+require 'peiji_san/view_helper'

data/test/peiji_san_test.rb

@@ -0,0 +1,109 @@
+require File.expand_path('../test_helper', __FILE__)
+
+describe "PeijiSan mixin" do
+  it "should define an #entries_per_page= class method with which the max amount of entries per page is specified" do
+    Member.should.respond_to :entries_per_page=
+    Member.instance_variable_get(:@entries_per_page).should.be 10
+  end
+  
+  it "should define an #entries_per_page reader method" do
+    Member.entries_per_page.should == 10
+  end
+  
+  it "should have defined a #page class method and added it to the class's scopes" do
+    Member.should.respond_to :page
+  end
+end
+
+describe "PeijiSan::PageScope" do
+  before do
+    PeijiSanTest::Initializer.setup_database
+    199.times { |i| Member.create(:name => "KRS #{i}") }
+  end
+  
+  after do
+    PeijiSanTest::Initializer.teardown_database
+  end
+  
+  it "should have defined a named_scope called :page which returns the entries belonging to the page number given" do
+    page_1 = Member.page(1)
+    page_1.class.should.be PeijiSan::PageScope
+    page_1.length.should.be 10
+    page_1.should == Member.find(:all, :offset => 0, :limit => 10)
+  end
+  
+  it "should return the correct count of pages for the current scope" do
+    Member.all_like_krs_1.page(1).page_count.should.be 11
+  end
+  
+  it "should know the current page number" do
+    Member.page(2).current_page.should.be 2
+    Member.page(4).current_page.should.be 4
+  end
+  
+  it "should know if there's a next page" do
+    Member.page(1).should.have_next_page
+    Member.page(20).should.not.have_next_page
+    Member.all_like_krs_1.but_ending_with_9.page(1).should.not.have_next_page
+  end
+  
+  it "should return the next page" do
+    Member.page(1).next_page.should.be 2
+    Member.page(20).next_page.should.be nil
+  end
+  
+  it "should know if there's a previous page" do
+    Member.page(1).should.not.have_previous_page
+    Member.page(20).should.have_previous_page
+  end
+  
+  it "should return the previous page" do
+    Member.page(1).previous_page.should.be nil
+    Member.page(20).previous_page.should.be 19
+  end
+  
+  it "should return if a given page number is the current page" do
+    assert Member.page(1).current_page?(1)
+    assert !Member.page(1).current_page?(2)
+  end
+  
+  it "should default to page 1 if no valid page argument was given" do
+    Member.page(nil).current_page.should.be 1
+    Member.page('').current_page.should.be 1
+  end
+  
+  it "should cast the page argument to an integer" do
+    Member.page('2').current_page.should.be 2
+  end
+  
+  it "should take an optional second argument which overrides the entries_per_page setting" do
+    Member.all_like_krs_1.page(1, 20).page_count.should.be 6
+  end
+  
+  it "should return the count of all the entries across all pages for the current scope" do
+    Member.all_like_krs_1.page(1).count.should.be 110
+    Member.all_like_krs_1.page(2).count.should.be 110
+    Member.all_like_krs_1.but_ending_with_9.page(1).count.should.be 10
+  end
+  
+  it "should still work when chained with other regular named scopes" do
+    Member.all_like_krs_1.page(1).page_count.should.be 11
+    Member.all_like_krs_1.but_ending_with_9.page(2).page_count.should.be 1
+    
+    Member.all_like_krs_1.page(2).should == Member.find(:all, :conditions => "name LIKE 'KRS 1%'", :offset => 10, :limit => 10)
+    Member.all_like_krs_1.but_ending_with_9.page(1).should == Member.find(:all, :conditions => "name LIKE 'KRS 1%' AND name LIKE '%9'", :offset => 0, :limit => 10)
+  end
+  
+  it "should still work when chained through an association proxy" do
+    member = Member.first
+    16.times { member.works.create(:status => 'uploaded') }
+    5.times { member.works.create(:status => 'new') }
+    
+    page = member.reload.works.uploaded.page(1)
+    page.length.should.be 5
+    page.page_count.should.be 4
+    member.works.uploaded.page(4).length.should.be 1
+    
+    member.works.page(1).page_count.should.be 5
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,95 @@
+module PeijiSanTest
+  module Initializer
+    VENDOR_RAILS = File.expand_path('../../../../rails', __FILE__)
+    OTHER_RAILS = File.expand_path('../../../rails', __FILE__)
+    PLUGIN_ROOT = File.expand_path('../../', __FILE__)
+    
+    def self.rails_directory
+      if File.exist?(File.join(VENDOR_RAILS, 'railties'))
+        VENDOR_RAILS
+      elsif File.exist?(File.join(OTHER_RAILS, 'railties'))
+        OTHER_RAILS
+      end
+    end
+    
+    def self.load_dependencies
+      if rails_directory
+        $:.unshift(File.join(rails_directory, 'activesupport', 'lib'))
+        $:.unshift(File.join(rails_directory, 'activerecord', 'lib'))
+        $:.unshift(File.join(rails_directory, 'actionpack', 'lib'))
+      else
+        require 'rubygems' rescue LoadError
+      end
+      
+      require 'active_support'
+      require 'active_record'
+      require 'action_view'
+      
+      require 'rubygems' rescue LoadError
+      
+      require 'test/spec'
+      require 'mocha'
+      
+      require File.join(PLUGIN_ROOT, 'rails', 'init')
+    end
+    
+    def self.configure_database
+      ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :dbfile => ":memory:")
+      ActiveRecord::Migration.verbose = false
+    end
+    
+    def self.setup_database
+      ActiveRecord::Schema.define(:version => 1) do
+        create_table :members do |t|
+          t.column :name, :string
+          t.column :created_at, :datetime
+          t.column :updated_at, :datetime
+        end
+        
+        create_table :works do |t|
+          t.column :member_id, :integer
+          t.column :status, :string
+        end
+      end
+    end
+    
+    def self.teardown_database
+      ActiveRecord::Base.connection.tables.each do |table|
+        ActiveRecord::Base.connection.drop_table(table)
+      end
+    end
+    
+    def self.start
+      load_dependencies
+      configure_database
+    end
+  end
+end
+
+PeijiSanTest::Initializer.start
+
+class PeijiSan::PageScope
+  instance_methods.each { |method| alias_method method.sub(/^has_/, 'have_'), method if method =~ /^has_/ }
+  
+  # The delegation of all methods in NamedScope breaks #should.
+  def should
+    Test::Spec::Should.new(self)
+  end
+end
+
+class Member < ActiveRecord::Base
+  extend PeijiSan
+  self.entries_per_page = 10
+  
+  named_scope :all_like_krs_1, :conditions => "name LIKE 'KRS 1%'"
+  named_scope :but_ending_with_9, :conditions => "name LIKE '%9'"
+  
+  has_many :works
+end
+
+class Work < ActiveRecord::Base
+  extend PeijiSan
+  self.entries_per_page = 5
+  
+  named_scope :uploaded, :conditions => { :status => 'uploaded' }
+end

data/test/view_helper_test.rb

@@ -0,0 +1,168 @@
+require File.expand_path('../test_helper', __FILE__)
+
+class TestController
+  def params
+    @params ||= {}
+  end
+  
+  def url_for(options)
+    url = "/collections"
+    url += "?page=#{options[:page]}" if options[:page]
+    url += "?pagina=#{options[:pagina]}" if options[:pagina]
+    url += "&starts_with=#{options[:starts_with]}" if options[:starts_with]
+    url += "##{options[:anchor]}" if options[:anchor]
+    url
+  end
+end
+
+module PeijiSanHelperTestHelper
+  def self.included(klass)
+    klass.class_eval do
+      include ActionView::Helpers
+      
+      attr_reader :controller
+      attr_reader :collection
+      
+      before do
+        @controller = TestController.new
+        
+        @collection = stub('Artists paginated collection')
+        collection.stubs(:current_page?).with(1).returns(false)
+        collection.stubs(:current_page?).with(2).returns(false)
+        collection.stubs(:page_count).returns(125)
+      end
+    end
+  end
+end
+
+describe "PeijiSan::ViewHelper::link_to_page" do
+  include PeijiSanHelperTestHelper
+  include PeijiSan::ViewHelper
+  
+  it "should return a link for a given page number" do
+    link_to_page(2, collection).should == '<a href="/collections?page=2#explore">2</a>'
+  end
+  
+  it "should return a link for a given page number with the specified page parameter" do
+    link_to_page(2, collection, :page_parameter => 'pagina').should == '<a href="/collections?pagina=2#explore">2</a>'
+  end
+  
+  it "should return a link for a given page number with the specified anchor" do
+    link_to_page(2, collection, :anchor => 'dude_so_many_pages').should == '<a href="/collections?page=2#dude_so_many_pages">2</a>'
+  end
+  
+  it "should return a link for a given page number and include the original params" do
+    controller.params[:starts_with] = 'h'
+    link_to_page(2, collection).should == '<a href="/collections?page=2&amp;starts_with=h#explore">2</a>'
+  end
+  
+  it "should return a link which does not include the page GET variable if it's page number 1" do
+    controller.params[:page] = 34
+    link_to_page(1, collection).should.not.match /page=\d+/
+  end
+  
+  it "should return a link with the class current if it's for the currently selected page" do
+    collection.stubs(:current_page?).with(2).returns(true)
+    link_to_page(2, collection).should == '<a href="/collections?page=2#explore" class="current">2</a>'
+  end
+  
+  it "should return a link with the class current if it's for the currently selected page" do
+    collection.stubs(:current_page?).with(2).returns(true)
+    link_to_page(2, collection, :current_class => 'looking_at').should == '<a href="/collections?page=2#explore" class="looking_at">2</a>'
+  end
+end
+
+describe "PeijiSan::ViewHelper::pages_to_link_to" do
+  include PeijiSanHelperTestHelper
+  include PeijiSan::ViewHelper
+  
+  it "should return a list of page numbers that should be included in the pagination list" do
+    collection.stubs(:current_page).returns(83)
+    pages_to_link_to(collection).should == [1, '…', 80, 81, 82, 83, 84, 85, 86, '…', 125]
+  end
+  
+  it "should return a list of page links with an ellips between page 1 and the next if the current page is at the end of the list" do
+    collection.stubs(:current_page).returns(119)
+    pages_to_link_to(collection).should == [1, '…', 116, 117, 118, 119, 120, 121, 122, '…', 125]
+    
+    120.upto(124) do |page|
+      collection.stubs(:current_page).returns(page)
+      pages_to_link_to(collection).should == [1, '…', 117, 118, 119, 120, 121, 122, 123, 124, 125]
+    end
+  end
+  
+  it "should return a list of page links with an ellips between the last page and the previous one if the current page is at the beginning of the list" do
+    1.upto(6) do |page|
+      collection.stubs(:current_page).returns(page)
+      pages_to_link_to(collection).should == [1, 2, 3, 4, 5, 6, 7, 8, 9, '…', 125]
+    end
+    
+    collection.stubs(:current_page).returns(7)
+    pages_to_link_to(collection).should == [1, '…', 4, 5, 6, 7, 8, 9, 10, '…', 125]
+  end
+  
+  it "should not show an ellips but all pages if there are only 10 pages, this is the threshold for when an ellips starts to be necessary" do
+    collection.stubs(:page_count).returns(10)
+    collection.stubs(:current_page).returns(5)
+    pages_to_link_to(collection).should == (1..10).to_a
+  end
+  
+  it "should not return more page links if there aren't that many pages" do
+    1.upto(9) do |page|
+      collection.stubs(:page_count).returns(page)
+      collection.stubs(:current_page).returns(page)
+      pages_to_link_to(collection).should == (1..page).to_a
+    end
+  end
+  
+  it "should return a list of page numbers that should be included in the pagination list with the specified number of :max_visible" do
+    collection.stubs(:current_page).returns(83)
+    pages_to_link_to(collection, :max_visible => 5).should == [1, '…', 83, '…', 125]
+    pages_to_link_to(collection, :max_visible => 15).should == [1, '…', 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, '…', 125]
+    
+    collection.stubs(:current_page).returns(3)
+    pages_to_link_to(collection, :max_visible => 5).should == [1, 2, 3, '…', 125]
+    pages_to_link_to(collection, :max_visible => 15).should == (1..13).to_a + ['…', 125]
+  end
+  
+  it "should return a list of page numbers with the specified separator instead of the default ellips" do
+    collection.stubs(:current_page).returns(83)
+    pages_to_link_to(collection, :separator => '...').should == [1, '...', 80, 81, 82, 83, 84, 85, 86, '...', 125]
+  end
+end
+
+module ApplicationHelperWithDefaults
+  include PeijiSan::ViewHelper
+  
+  def peiji_san_options
+    { :page_parameter => 'pagina', :anchor => 'dude_so_many_pages', :max_visible => 5, :separator => '...' }
+  end
+end
+
+describe "ApplicationHelper, when overriding defaults" do
+  include PeijiSanHelperTestHelper
+  include ApplicationHelperWithDefaults
+  
+  it "should return a link for a given page number with the specified page parameter" do
+    link_to_page(2, collection).should == '<a href="/collections?pagina=2#dude_so_many_pages">2</a>'
+  end
+  
+  it "should return a link for a given page number with the specified anchor" do
+    link_to_page(2, collection).should == '<a href="/collections?pagina=2#dude_so_many_pages">2</a>'
+  end
+  
+  it "should return a link with the class current if it's for the currently selected page" do
+    collection.stubs(:current_page?).with(2).returns(true)
+    link_to_page(2, collection, :current_class => 'looking_at').should == '<a href="/collections?pagina=2#dude_so_many_pages" class="looking_at">2</a>'
+  end
+  
+  it "should return a list of page numbers that should be included in the pagination list with the specified number of :max_visible" do
+    collection.stubs(:current_page).returns(3)
+    pages_to_link_to(collection).should == [1, 2, 3, '...', 125]
+  end
+  
+  it "should return a list of page numbers with the specified separator instead of the default ellips" do
+    collection.stubs(:current_page).returns(83)
+    pages_to_link_to(collection).should == [1, '...', 83, '...', 125]
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: peiji-san
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Eloy Duran
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-22 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: PeijiSan is a Rails plugin which uses named scopes to create a thin pagination layer.
+email: eloy.de.enige@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- LICENSE
+- README.rdoc
+- Rakefile
+- TODO
+- VERSION.yml
+- lib/peiji_san.rb
+- lib/peiji_san/view_helper.rb
+- peiji-san.gemspec
+- rails/init.rb
+- test/peiji_san_test.rb
+- test/test_helper.rb
+- test/view_helper_test.rb
+has_rdoc: true
+homepage: http://github.com/Fingertips/peiji-san
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: PeijiSan is a Rails plugin which uses named scopes to create a thin pagination layer.
+test_files: 
+- test/peiji_san_test.rb
+- test/test_helper.rb
+- test/view_helper_test.rb