objectreload-pagination 0.1.0

data/CHANGELOG.rdoc

@@ -0,0 +1,3 @@
+== 0.1.0, released 2009-08-08
+
+* Initial release

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2009 Mateusz Drożdżyński
+Based partially on will_paginate (c) 2007 PJ Hyett and Mislav Marohnić
+
+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,35 @@
+Display options:
+ :previous_label -- default: "« Previous" (this parameter is called :prev_label in versions 2.3.2 and older!)
+ :next_label -- default: "Next »"
+ :page_links -- when false, only previous/next links are rendered (default: true)
+ :inner_window -- how many links are shown around the current page (default: 4)
+ :outer_window -- how many links are around the first and the last page (default: 1)
+ :separator -- string separator for page HTML elements (default: single space)
+ :controls -- display controls only at the :top or :bottom of the pagination block (default: :both)
+ :per_page -- number of items displayed per page (default: 10)
+
+HTML options:
+ :class -- CSS class name for the generated DIV (default: "pagination")
+ :container -- toggles rendering of the DIV container for pagination links, set to false only when you are rendering your own pagination markup (default: true)
+ :id -- HTML ID for the container (default: nil). Pass +true+ to have the ID automatically generated from the class name of objects in collection: for example, paginating
+ ArticleComment models would yield an ID of "article_comments_pagination".
+
+Advanced options:
+ :param_name -- parameter name for page number in URLs (default: :page)
+ :params -- additional parameters when generating pagination links (eg. :controller => "foo", :action => nil)
+ :renderer -- class name, class or instance of a link renderer (default: Pagination::LinkRenderer)
+
+
+All options not recognized by paginate will become HTML attributes on the container
+element for pagination links (the DIV).
+For example:
+
+<% paginate @posts, :style => 'font-size: small' do |posts| %>
+...
+<% end %>
+
+... will result in:
+
+<div class="pagination" style="font-size: small"> ... </div>
+
+No changes in controllers.

data/Rakefile

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "objectreload-pagination"
+    gem.summary = "Simple pagination - without changes in controllers"
+    gem.email = "gems@objectreload.com"
+    gem.homepage = "http://github.com/objectreload/pagination"
+    gem.authors = ["Mateusz Drozdzynski"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "pagination_gem #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/init.rb

@@ -0,0 +1 @@
+require 'pagination'

data/lib/active_record/base_extensions.rb

@@ -0,0 +1,19 @@
+ActiveRecord::Base.class_eval do
+  class << self
+    VALID_FIND_OPTIONS = VALID_FIND_OPTIONS + [:eager]
+                           
+    def find_every_with_scope(options)
+      if options.delete(:eager)
+        find_every_without_scope(options)
+      else
+        scoped(options)
+      end
+    end
+    alias_method_chain :find_every, :scope
+    
+    def find_initial_with_eager_loading(options)
+      find_initial_without_eager_loading(options.merge(:eager => true))
+    end
+    alias_method_chain :find_initial, :eager_loading
+  end
+end

data/lib/active_record/scope_extensions.rb

@@ -0,0 +1,6 @@
+ActiveRecord::NamedScope::Scope.class_eval do
+  private
+  def load_found(*args)
+    @found = find(:all, :eager => true)
+  end
+end

data/lib/pagination.rb

@@ -0,0 +1,12 @@
+# Loads extensions to Ruby on Rails libraries needed to support pagination and lazy loading
+require 'active_record/base_extensions'
+require 'active_record/scope_extensions'
+
+# Loads internal pagination classes
+require 'pagination/collection'
+require 'pagination/named_scope'
+require 'pagination/enumerable'
+require 'pagination/view_helpers'
+
+# Loads the :paginate view helper
+ActionView::Base.send :include, Pagination::ViewHelpers

data/lib/pagination/collection.rb

@@ -0,0 +1,62 @@
+module Pagination
+  class InvalidPage < ArgumentError
+    def initialize(page, max = 1)
+      super "#{page} must be greater than 0" if page < 1
+      super "#{page} must be less than #{max}" if page >= 1
+    end
+  end
+  
+  class Collection < Array
+    attr_reader :current_page, :per_page, :total_entries, :total_pages
+    
+    def initialize(options = {})
+      @collection = options[:collection]
+      
+      @current_page = options[:current_page].to_i
+      raise InvalidPage.new(@current_page) if @current_page < 1
+      
+      @per_page = options[:per_page].to_i
+      raise ArgumentError, "`per_page` setting cannot be less than 1 (#{@per_page} given)" if @per_page < 1
+      
+      self.replace(@collection.paginate(:limit => limit, :offset => offset))
+      
+      self.total_entries ||= @collection.count
+      raise InvalidPage.new(current_page, total_pages) if current_page > total_pages
+    end
+    
+    def previous_page
+      current_page - 1 if current_page > 1
+    end
+    
+    def next_page
+      current_page + 1 if current_page < total_pages
+    end
+    
+  protected
+    
+    def limit
+      per_page
+    end
+    
+    def offset
+      offset = (current_page-1)*limit
+    end
+    
+    def total_entries=(number)
+      @total_entries = number.to_i
+      @total_pages = @total_entries > 0 ? (@total_entries / per_page.to_f).ceil : 1
+    end
+    
+    def replace(array)
+      result = super
+
+      # The collection is shorter then page limit? Rejoice, because
+      # then we know that we are on the last page!
+      if total_entries.nil? and length < per_page and (current_page == 1 or length > 0)
+        self.total_entries = offset + length
+      end
+
+      result
+    end
+  end
+end

data/lib/pagination/enumerable.rb

@@ -0,0 +1,5 @@
+Enumerable.module_eval do
+  def paginate(options = {})
+    self[options[:offset]..(options[:offset] + options[:limit] - 1)] || []
+  end
+end

data/lib/pagination/named_scope.rb

@@ -0,0 +1,5 @@
+ActiveRecord::NamedScope::Scope.class_eval do
+  def paginate(options = {})
+    scoped(:limit => options[:limit], :offset => options[:offset])
+  end
+end

data/lib/pagination/version.rb

@@ -0,0 +1,9 @@
+module Pagination
+  module VERSION
+    MAJOR = 0
+    MINOR = 1
+    TINY = 0
+    
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/pagination/view_helpers.rb

@@ -0,0 +1,322 @@
+module Pagination
+  # = Pagination view helpers
+  #
+  # The main view helper, #paginate, renders
+  # pagination links around (top and bottom) given collection. The helper itself is lightweight
+  # and serves only as a wrapper around LinkRenderer instantiation; the
+  # renderer then does all the hard work of generating the HTML.
+  # 
+  # == Global options for helpers
+  #
+  # Options for pagination helpers are optional and get their default values from the
+  # <tt>Pagination::ViewHelpers.pagination_options</tt> hash. You can write to this hash to
+  # override default options on the global level:
+  #
+  #   Pagination::ViewHelpers.pagination_options[:previous_label] = 'Previous page'
+  #
+  # By putting this into "config/initializers/pagination.rb" (or simply environment.rb in
+  # older versions of Rails) you can easily translate link texts to previous
+  # and next pages, as well as override some other defaults to your liking.
+  module ViewHelpers
+    # default options that can be overridden on the global level
+    @@pagination_options = {
+      :class          => 'pagination',
+      :previous_label => '&laquo; Previous',
+      :next_label     => 'Next &raquo;',
+      :inner_window   => 4, # links around the current page
+      :outer_window   => 1, # links around beginning and end
+      :separator      => ' ', # single space is friendly to spiders and non-graphic browsers
+      :controls       => :both,
+      :per_page       => 10,
+      :param_name     => :page,
+      :params         => nil,
+      :renderer       => 'Pagination::LinkRenderer',
+      :page_links     => true,
+      :container      => true
+    }
+    mattr_reader :pagination_options
+
+    # Renders Digg/Flickr-style pagination for a Pagination::Collection
+    # object. Nil is returned if there is only one page in total; no point in
+    # rendering the pagination in that case...
+    # 
+    # ==== Options
+    # Display options:
+    # * <tt>:previous_label</tt> -- default: "« Previous" (this parameter is called <tt>:prev_label</tt> in versions <b>2.3.2</b> and older!)
+    # * <tt>:next_label</tt> -- default: "Next »"
+    # * <tt>:page_links</tt> -- when false, only previous/next links are rendered (default: true)
+    # * <tt>:inner_window</tt> -- how many links are shown around the current page (default: 4)
+    # * <tt>:outer_window</tt> -- how many links are around the first and the last page (default: 1)
+    # * <tt>:separator</tt> -- string separator for page HTML elements (default: single space)
+    # * <tt>:controls</tt> -- display controls only at the <tt>:top</tt> or <tt>:bottom</tt> of the pagination block (default: <tt>:both</tt>)
+    # * <tt>:per_page</tt> -- number of items displayed per page (default: 10)
+    # 
+    # HTML options:
+    # * <tt>:class</tt> -- CSS class name for the generated DIV (default: "pagination")
+    # * <tt>:container</tt> -- toggles rendering of the DIV container for pagination links, set to
+    #   false only when you are rendering your own pagination markup (default: true)
+    # * <tt>:id</tt> -- HTML ID for the container (default: nil). Pass +true+ to have the ID
+    #   automatically generated from the class name of objects in collection: for example, paginating
+    #   ArticleComment models would yield an ID of "article_comments_pagination".
+    #
+    # Advanced options:
+    # * <tt>:param_name</tt> -- parameter name for page number in URLs (default: <tt>:page</tt>)
+    # * <tt>:params</tt> -- additional parameters when generating pagination links
+    #   (eg. <tt>:controller => "foo", :action => nil</tt>)
+    # * <tt>:renderer</tt> -- class name, class or instance of a link renderer (default:
+    #   <tt>Pagination::LinkRenderer</tt>)
+    #
+    # All options not recognized by paginate will become HTML attributes on the container
+    # element for pagination links (the DIV). For example:
+    # 
+    #   <% paginate @posts, :style => 'font-size: small' do |posts| %>
+    #     ...
+    #   <% end %>
+    #
+    # ... will result in:
+    #
+    #   <div class="pagination" style="font-size: small"> ... </div>
+    #
+    def paginate(collection = [], options = {}, &block)
+      options = options.symbolize_keys.reverse_merge Pagination::ViewHelpers.pagination_options
+      
+      collection = Pagination::Collection.new(options.merge(:collection => collection, :current_page => params[options[:param_name]]|| 1))
+      yield collection and return nil unless collection.total_pages > 1
+
+      # get the renderer instance
+      renderer = case options[:renderer]
+      when String
+        options[:renderer].to_s.constantize.new
+      when Class
+        options[:renderer].new
+      else
+        options[:renderer]
+      end
+      
+      # render HTML for pagination
+      renderer.prepare collection, options, self
+      pagination = renderer.to_html.to_s
+
+      if block_given?
+        top = [:top, :both].include?(options[:controls]) ? pagination : ""
+        bottom = [:bottom, :both].include?(options[:controls]) ? pagination : ""
+        unless ActionView::Base.respond_to? :erb_variable
+          concat top
+          yield collection
+          unless bottom.empty?
+            concat bottom
+          end
+        else
+          content = top + capture(&block) + bottom
+          concat(content, block.binding)
+        end
+      else
+        collection
+      end
+    end
+  end
+
+  # This class does the heavy lifting of actually building the pagination
+  # links. It is used by the <tt>paginate</tt> helper internally.
+  class LinkRenderer
+
+    # The gap in page links is represented by:
+    #
+    #   <span class="gap">&hellip;</span>
+    attr_accessor :gap_marker
+    
+    def initialize
+      @gap_marker = '<span class="gap">&hellip;</span>'
+    end
+    
+    # * +collection+ is a Pagination::Collection instance or any other object
+    #   that conforms to that API
+    # * +options+ are forwarded from +paginate+ view helper
+    # * +template+ is the reference to the template being rendered
+    def prepare(collection, options, template)
+      @collection = collection
+      @options    = options
+      @template   = template
+
+      # reset values in case we're re-using this instance
+      @total_pages = @param_name = @url_string = nil
+    end
+
+    # Process it! This method returns the complete HTML string which contains
+    # pagination links. Feel free to subclass LinkRenderer and change this
+    # method as you see fit.
+    def to_html
+      links = @options[:page_links] ? windowed_links : []
+      # previous/next buttons
+      links.unshift page_link_or_span(@collection.previous_page, 'disabled prev_page', @options[:previous_label])
+      links.push    page_link_or_span(@collection.next_page,     'disabled next_page', @options[:next_label])
+      
+      html = links.join(@options[:separator])
+      @options[:container] ? @template.content_tag(:div, html, html_attributes) : html
+    end
+
+    # Returns the subset of +options+ this instance was initialized with that
+    # represent HTML attributes for the container element of pagination links.
+    def html_attributes
+      return @html_attributes if @html_attributes
+      @html_attributes = @options.except *(Pagination::ViewHelpers.pagination_options.keys - [:class])
+      # pagination of Post models will have the ID of "posts_pagination"
+      if @options[:container] and @options[:id] === true
+        @html_attributes[:id] = @collection.first.class.name.underscore.pluralize + '_pagination'
+      end
+      @html_attributes
+    end
+    
+  protected
+
+    # Collects link items for visible page numbers.
+    def windowed_links
+      prev = nil
+
+      visible_page_numbers.inject [] do |links, n|
+        # detect gaps:
+        links << gap_marker if prev and n > prev + 1
+        links << page_link_or_span(n, 'current')
+        prev = n
+        links
+      end
+    end
+
+    # Calculates visible page numbers using the <tt>:inner_window</tt> and
+    # <tt>:outer_window</tt> options.
+    def visible_page_numbers
+      inner_window, outer_window = @options[:inner_window].to_i, @options[:outer_window].to_i
+      window_from = current_page - inner_window
+      window_to = current_page + inner_window
+      
+      # adjust lower or upper limit if other is out of bounds
+      if window_to > total_pages
+        window_from -= window_to - total_pages
+        window_to = total_pages
+      end
+      if window_from < 1
+        window_to += 1 - window_from
+        window_from = 1
+        window_to = total_pages if window_to > total_pages
+      end
+      
+      visible   = (1..total_pages).to_a
+      left_gap  = (2 + outer_window)...window_from
+      right_gap = (window_to + 1)...(total_pages - outer_window)
+      visible  -= left_gap.to_a  if left_gap.last - left_gap.first > 1
+      visible  -= right_gap.to_a if right_gap.last - right_gap.first > 1
+
+      visible
+    end
+    
+    def page_link_or_span(page, span_class, text = nil)
+      text ||= page.to_s
+      
+      if page and page != current_page
+        classnames = span_class && span_class.index(' ') && span_class.split(' ', 2).last
+        page_link page, text, :rel => rel_value(page), :class => classnames
+      else
+        page_span page, text, :class => span_class
+      end
+    end
+
+    def page_link(page, text, attributes = {})
+      @template.link_to text, url_for(page), attributes
+    end
+
+    def page_span(page, text, attributes = {})
+      @template.content_tag :span, text, attributes
+    end
+
+    # Returns URL params for +page_link_or_span+, taking the current GET params
+    # and <tt>:params</tt> option into account.
+    def url_for(page)
+      page_one = page == 1
+      unless @url_string and !page_one
+        @url_params = {}
+        # page links should preserve GET parameters
+        stringified_merge @url_params, @template.params if @template.request.get?
+        stringified_merge @url_params, @options[:params] if @options[:params]
+        
+        if complex = param_name.index(/[^\w-]/)
+          page_param = parse_query_parameters("#{param_name}=#{page}")
+          
+          stringified_merge @url_params, page_param
+        else
+          @url_params[param_name] = page_one ? 1 : 2
+        end
+
+        url = @template.url_for(@url_params)
+        return url if page_one
+        
+        if complex
+          @url_string = url.sub(%r!((?:\?|&amp;)#{CGI.escape param_name}=)#{page}!, "\\1\0")
+          return url
+        else
+          @url_string = url
+          @url_params[param_name] = 3
+          @template.url_for(@url_params).split(//).each_with_index do |char, i|
+            if char == '3' and url[i, 1] == '2'
+              @url_string[i] = "\0"
+              break
+            end
+          end
+        end
+      end
+      # finally!
+      @url_string.sub "\0", page.to_s
+    end
+
+  private
+
+    def rel_value(page)
+      case page
+      when @collection.previous_page; 'prev' + (page == 1 ? ' start' : '')
+      when @collection.next_page; 'next'
+      when 1; 'start'
+      end
+    end
+
+    def current_page
+      @current_page ||= @collection.current_page
+    end
+
+    def total_pages
+      @total_pages ||= @collection.total_pages
+    end
+
+    def param_name
+      @param_name ||= @options[:param_name].to_s
+    end
+
+    # Recursively merge into target hash by using stringified keys from the other one
+    def stringified_merge(target, other)
+      other.each do |key, value|
+        key = key.to_s # this line is what it's all about!
+        existing = target[key]
+
+        if value.is_a?(Hash) and (existing.is_a?(Hash) or existing.nil?)
+          stringified_merge(existing || (target[key] = {}), value)
+        else
+          target[key] = value
+        end
+      end
+    end
+
+    def parse_query_parameters(params)
+      if defined? Rack::Utils
+        # For Rails > 2.3
+        Rack::Utils.parse_nested_query(params)
+      elsif defined?(ActionController::AbstractRequest)
+        ActionController::AbstractRequest.parse_query_parameters(params)
+      elsif defined?(ActionController::UrlEncodedPairParser)
+        # For Rails > 2.2
+        ActionController::UrlEncodedPairParser.parse_query_parameters(params)
+      elsif defined?(CGIMethods)
+        CGIMethods.parse_query_parameters(params)
+      else
+        raise "unsupported ActionPack version"
+      end
+    end
+  end
+end

data/test/active_record_extentions_test.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/test_helper'
+require 'active_record/base_extensions'
+require 'active_record/scope_extensions'
+require 'mocha'
+
+
+class ActiveRecordExtentionsTest < Test::Unit::TestCase
+  context "active record extentions" do
+    setup do
+      User.delete_all
+      Article.delete_all
+      
+      @user1 = User.create :first_name => 'Bob', :last_name => 'Builder'
+      @user2 = User.create :first_name => 'Bob', :last_name => 'Builder2'
+      @user3 = User.create :first_name => 'Tom', :last_name => 'Builder'
+      
+      5.times do |i|
+        Article.create(:title => "title_#{i}", :user => @user1)
+      end
+      
+      3.times do |i|
+        Article.create!(:title => "2title_#{i}", :user => @user2)
+      end
+    end
+
+    should "difference between Article.find_every_with_scope and Article.find_every_without_scope" do
+      users1 = User.all
+      users2 = User.all(:eager => true)
+      assert_equal users1, users2
+      assert_not_equal users1.class, users2.class
+
+      users1 = User.all(:conditions => {:first_name => 'Bob'})
+      users2 = User.all(:eager => true, :conditions => {:first_name => 'Bob'})
+      assert_equal users1, users2
+      assert_not_equal users1.class, users2.class
+    end
+
+    should "return ActiveRecord::NamedScope::Scope" do
+      assert_equal ActiveRecord::NamedScope::Scope, User.all.class
+      assert_equal ActiveRecord::NamedScope::Scope, User.all(:conditions => {:first_name => 'Bob'}).class
+    end
+
+    should "return an Array when called with :eager => true" do
+      assert_equal Array, Article.all(:eager => true).class
+      assert_equal Array, Article.all(:eager => true, :conditions => {:title => "title_1"}).class
+    end
+  end
+end

data/test/collection_test.rb

@@ -0,0 +1,71 @@
+require File.dirname(__FILE__) + '/test_helper'
+require File.dirname(__FILE__) + '/../lib/pagination/collection'
+require File.dirname(__FILE__) + '/../lib/pagination/enumerable'
+
+class CollectionTest < Test::Unit::TestCase
+  context "collection test" do
+    setup do
+      @collection = ('a'..'e').to_a
+    end
+
+    should "return elements from specific range" do
+      # see: enumerable.rb
+      # limit = per_page
+      # offset = (current_page - 1) * limit
+      [
+        { :offset => 0,  :limit => 3,  :expected => %w( a b c ) },
+        { :offset => 3,  :limit => 3,  :expected => %w( d e ) },
+        { :offset => 0,  :limit => 5,  :expected => %w( a b c d e ) },
+        { :offset => 6,  :limit => 3,  :expected => [] },
+      ].
+      each do |conditions|
+        expected = conditions.delete :expected
+        assert_equal expected, @collection.paginate(conditions)
+      end
+    end
+  
+    context "init pagination collection" do
+      setup do
+        @collection = [1,2,3,4,5]
+        @paginated_collection = paginate_collection(@collection)
+      end
+
+      should "return total pages" do
+        assert_equal 3, @paginated_collection.total_pages
+      end
+
+      should "return previous page" do
+        assert_equal 1, @paginated_collection.previous_page
+      end
+
+      should "return next page" do
+        assert_equal 3, @paginated_collection.next_page
+      end
+
+      should "array be shorter after paginate" do
+        pag_array = paginate_collection(@collection, 1, 4)
+        assert_not_equal  @collection, pag_array.count
+        assert_equal 4, pag_array.count
+      end
+
+      should "rise an error InvalidPage" do
+        assert_raise(Pagination::InvalidPage) { paginate_collection(@collection, -2, 2) }
+        assert_raise(Pagination::InvalidPage) { paginate_collection(@collection, 1000, 2) }
+      end
+
+      should "rise an error ArgumentError" do
+        assert_raise(ArgumentError) { paginate_collection(@collection, 2, -2) }
+      end
+    end
+  end
+  
+  private
+    def paginate_collection(collection, current_page=2, per_page=2, total_entries=nil)
+      Pagination::Collection.new(
+            :collection => collection,
+            :current_page => current_page,
+            :per_page => per_page,
+            :total_entries => total_entries
+          )
+    end
+end

data/test/lib/view_test_process.rb

@@ -0,0 +1,180 @@
+require 'action_controller'
+require 'action_controller/test_process'
+
+require 'pagination'
+
+ActionController::Routing::Routes.draw do |map|
+  map.connect 'dummy/page/:page', :controller => 'dummy'
+  map.connect 'dummy/dots/page.:page', :controller => 'dummy', :action => 'dots'
+  map.connect 'ibocorp/:page', :controller => 'ibocorp',
+                               :requirements => { :page => /\d+/ },
+                               :defaults => { :page => 1 }
+
+  map.connect ':controller/:action/:id'
+end
+
+ActionController::Base.perform_caching = false
+
+class Pagination::ViewTestCase < Test::Unit::TestCase
+  if defined?(ActionController::TestCase::Assertions)
+    include ActionController::TestCase::Assertions
+  end
+  if defined?(ActiveSupport::Testing::Deprecation)
+    include ActiveSupport::Testing::Deprecation
+  end
+
+  def setup
+    super
+    @controller  = DummyController.new
+    @request     = @controller.request
+    @html_result = nil
+    @template    = '<%= paginate collection, options do |tmp|; tmp.each do |t|; end; end %>'
+
+    @view = ActionView::Base.new
+    @view.assigns['controller'] = @controller
+    @view.assigns['_request']   = @request
+    @view.assigns['_params']  = @request.params
+  end
+
+  def default_test; end
+  
+  protected
+
+    def paginate(collection = {}, options = {}, &block)
+
+      if collection.instance_of? Hash
+        @request.params :page => collection[:page] || 1
+        collection = [1,2,3,4,5,6,7,8,9,10,11]
+      end      
+      options = {:per_page => 4, :controls => :top}.merge(options)
+
+      locals = { :collection => collection, :options => options }
+
+      unless @view.respond_to? :render_template
+        # Rails 2.2
+        @html_result = ActionView::InlineTemplate.new(@template).render(@view, locals)
+      else
+        if defined? ActionView::InlineTemplate
+          # Rails 2.1
+          args = [ ActionView::InlineTemplate.new(@view, @template, locals) ]
+        else
+          # older Rails versions
+          args = [nil, @template, nil, locals]
+        end
+
+        @html_result = @view.render_template(*args)
+      end
+
+      @html_document = HTML::Document.new(@html_result, true, false)
+
+      if block_given?
+        classname = options[:class] || Pagination::ViewHelpers.pagination_options[:class]
+        assert_select("div.#{classname}",1 , 'no main DIV', &block)
+      end
+
+    end
+
+    def response_from_page_or_rjs
+      @html_document.root
+    end
+
+    def validate_page_numbers expected, links, param_name = :page
+      param_pattern = /\W#{CGI.escape(param_name.to_s)}=([^&]*)/
+
+      assert_equal(expected, links.map { |e|
+        e['href'] =~ param_pattern
+        $1 ? $1.to_i : $1
+      })
+    end
+
+    def assert_links_match pattern, links = nil, numbers = nil
+      links ||= assert_select 'div.pagination a[href]' do |elements|
+        elements
+      end
+
+      pages = [] if numbers
+
+      links.each do |el|
+        assert_match pattern, el['href']
+        if numbers
+          el['href'] =~ pattern
+          pages << ($1.nil?? nil : $1.to_i)
+        end
+      end
+
+      assert_equal numbers, pages, "page numbers don't match" if numbers
+    end
+
+    def assert_no_links_match pattern
+      assert_select 'div.pagination a[href]' do |elements|
+        elements.each do |el|
+          assert_no_match pattern, el['href']
+        end
+      end
+    end
+end
+
+class DummyRequest
+  attr_accessor :symbolized_path_parameters
+
+  def initialize
+    @get = true
+    @params = {}
+    @symbolized_path_parameters = { :controller => 'foo', :action => 'bar'}
+  end
+
+  def get?
+    @get
+  end
+
+  def post
+    @get = false
+  end
+
+  def relative_url_root
+    ''
+  end
+
+  def params(more = nil)
+    @params.update(more) if more
+    @params
+  end
+end
+
+class DummyController
+  attr_reader :request
+  attr_accessor :controller_name
+
+  def initialize
+    @request = DummyRequest.new
+    @url = ActionController::UrlRewriter.new(@request, @request.params)
+  end
+
+  def params
+    @request.params
+  end
+
+  def url_for(params)
+    @url.rewrite(params)
+  end
+end
+
+module HTML
+  Node.class_eval do
+    def inner_text
+      children.map(&:inner_text).join('')
+    end
+  end
+
+  Text.class_eval do
+    def inner_text
+      self.to_s
+    end
+  end
+
+  Tag.class_eval do
+    def inner_text
+      childless?? '' : super
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'activerecord'
+require 'shoulda'
+require 'logger'
+
+
+ActiveRecord::Base.configurations = {'sqlite3' => {:adapter => 'sqlite3', :database => ':memory:'}}
+ActiveRecord::Base.establish_connection('sqlite3')
+
+ActiveRecord::Base.logger = Logger.new(STDERR)
+ActiveRecord::Base.logger.level = Logger::WARN
+
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :users do |t|
+    t.string :first_name, :default => ''
+    t.string :last_name, :default => ''
+  end
+
+  create_table :articles do |t|
+    t.string :title, :default => ''
+    t.integer :user_id
+  end
+end
+
+class User < ActiveRecord::Base
+  has_many :articles
+  named_scope :bob, :conditions => {:first_name => 'Bob'}
+
+  def find_all
+    User.find_all
+  end
+end
+
+class Article < ActiveRecord::Base
+  belongs_to :user
+end

data/test/view_helpers_test.rb

@@ -0,0 +1,224 @@
+require File.dirname(__FILE__) + '/test_helper'
+require File.dirname(__FILE__) + '/lib/view_test_process'
+
+class ViewHelpersTest < Pagination::ViewTestCase
+  context "paginate method" do
+
+    should "return full output" do
+      paginate({:page => 1})
+      expected = <<-HTML
+        <div class="pagination"><span class="disabled prev_page">&laquo; Previous</span>
+        <span class="current">1</span>
+        <a href="/foo/bar?page=2" rel="next">2</a>
+        <a href="/foo/bar?page=3">3</a>
+        <a href="/foo/bar?page=2" class="next_page" rel="next">Next &raquo;</a></div>
+      HTML
+      expected.strip!.gsub!(/\s{2,}/, ' ')
+
+      assert_dom_equal expected, @html_result
+    end
+    
+    should "show links to pages" do
+      paginate do |pagination|
+        assert_select 'a[href]', 3 do |elements|
+          validate_page_numbers [2,3,2], elements
+          assert_select elements.last, ':last-child', "Next &raquo;"
+        end
+        assert_select 'span', 2
+        assert_select 'span.disabled:first-child', '&laquo; Previous'
+        assert_select 'span.current', '1'
+        assert_equal '&laquo; Previous 1 2 3 Next &raquo;', pagination.first.inner_text
+      end
+    end
+
+    should "paginate with options" do
+      paginate({:page => 2},
+             :class => 'paginate', :previous_label => 'Prev', :next_label => 'Next') do
+        assert_select 'a[href]', 4 do |elements|
+          validate_page_numbers [1,1,3,3], elements
+          # test rel attribute values:
+          assert_select elements[1], 'a', '1' do |link|
+            assert_equal 'prev start', link.first['rel']
+          end
+          assert_select elements.first, 'a', "Prev" do |link|
+            assert_equal 'prev start', link.first['rel']
+          end
+          assert_select elements.last, 'a', "Next" do |link|
+            assert_equal 'next', link.first['rel']
+          end
+        end
+        assert_select 'span.current', '2'
+      end
+    end
+
+    should "paginate using renderer class" do
+      paginate( {}, :per_page => 5, :renderer => AdditionalLinkAttributesRenderer) do
+        assert_select 'a[default=true]', 3
+      end
+    end
+
+    should "no pagination when page count is one" do
+      paginate({:page => 1}, {:per_page => 30})
+      assert_equal '', @html_result
+    end
+
+    should "paginate using renderer instance" do
+      renderer = Pagination::LinkRenderer.new
+      renderer.gap_marker = '<span class="my-gap">~~</span>'
+
+      paginate({},  {:per_page => 2, :inner_window => 0, :outer_window => 0, :renderer => renderer}) do
+        assert_select 'span.my-gap', '~~'
+      end
+
+      renderer = AdditionalLinkAttributesRenderer.new(:title => 'rendered')
+      paginate({}, :per_page => 5, :renderer => renderer) do
+        assert_select 'a[title=rendered]', 3
+      end
+    end
+
+    should "previous next links have classnames" do
+      paginate do |pagination|
+        assert_select 'span.disabled.prev_page:first-child'
+        assert_select 'a.next_page[href]:last-child'
+      end
+    end
+
+    should "paginate without container" do
+      paginate({}, :container => false)
+      assert_select 'div.pagination', 0, 'main DIV present when it shouldn\'t'
+    end
+
+    should "paginate without page links" do
+      paginate({:page => 2}, :page_links => false) do
+        assert_select 'a[href]', 2 do |elements|
+          validate_page_numbers [1,3], elements
+        end
+      end
+    end
+
+    should "paginate windows" do
+      paginate({:page => 6}, {:per_page => 1, :inner_window => 1}) do |pagination|
+        assert_select 'a[href]', 8 do |elements|
+          validate_page_numbers [5,1,2,5,7,10,11,7], elements
+          assert_select elements.first, 'a', '&laquo; Previous'
+          assert_select elements.last, 'a', 'Next &raquo;'
+        end
+        assert_select 'span.current', '6'
+        assert_equal '&laquo; Previous 1 2 &hellip; 5 6 7 &hellip; 10 11 Next &raquo;', pagination.first.inner_text
+      end
+    end
+
+    should "paginate eliminates small gaps" do
+      paginate({:page => 6}, {:per_page => 1, :inner_window => 2}) do
+        assert_select 'a[href]', 12 do |elements|
+          validate_page_numbers [5,1,2,3,4,5,7,8,9,10,11,7], elements
+        end
+      end
+    end
+
+    should "return container id" do
+      paginate do |div|
+        assert_nil div.first['id']
+      end
+
+      # magic ID
+      paginate({}, :id => true) do |div|
+        assert_equal 'fixnums_pagination', div.first['id']
+      end
+
+      # explicit ID
+      paginate({}, :id => 'custom_id') do |div|
+        assert_equal 'custom_id', div.first['id']
+      end
+    end
+
+    should "paginate with custom page param" do
+      paginate({}, {:param_name => :developers_page}) do
+        assert_select 'a[href]', 3 do |elements|
+          validate_page_numbers [2,3,2], elements, :developers_page
+        end
+      end
+    end
+
+    should "paginate preserves parameters on get" do
+      @request.params :foo => { :bar => 'baz' }
+      paginate
+      assert_links_match /foo%5Bbar%5D=baz/
+    end
+
+    should "paginate doesnt preserve parameters on post" do
+      @request.post
+      @request.params :foo => 'bar'
+      paginate
+      assert_no_links_match /foo=bar/
+    end
+
+    should "adding additional parameters" do
+      paginate({}, :params => { :foo => 'bar' })
+      assert_links_match /foo=bar/
+    end
+
+    should "adding anchor parameter" do
+      paginate({}, :params => { :anchor => 'anchor' })
+      assert_links_match /#anchor$/
+    end
+
+    should "removing arbitrary parameters" do
+      @request.params :foo => 'bar'
+      paginate({}, :params => { :foo => nil })
+      assert_no_links_match /foo=bar/
+    end
+
+    should "adding additional route parameters" do
+      paginate({}, :params => { :controller => 'baz', :action => 'list' })
+      assert_links_match %r{\Wbaz/list\W}
+    end
+
+    should "will paginate with atmark url" do
+      @request.symbolized_path_parameters[:action] = "@tag"
+      renderer = Pagination::LinkRenderer.new
+
+      paginate({ :page => 1 }, :renderer=>renderer)
+      assert_links_match %r[/foo/@tag\?page=\d]
+    end
+
+    should "custom routing page param" do
+      @request.symbolized_path_parameters.update :controller => 'dummy', :action => nil
+      paginate({}, :per_page => 2) do
+        assert_select 'a[href]', 6 do |links|
+          assert_links_match %r{/page/(\d+)$}, links, [2, 3, 4, 5, 6, 2]
+        end
+      end
+    end
+
+    should "custom routing page param with dot separator" do
+      @request.symbolized_path_parameters.update :controller => 'dummy', :action => 'dots'
+      paginate({}, :per_page => 2) do
+        assert_select 'a[href]', 6 do |links|
+          assert_links_match %r{/page\.(\d+)$}, links, [2, 3, 4, 5, 6, 2]
+        end
+      end
+    end
+
+    should "custom routing with first page hidden" do
+      @request.symbolized_path_parameters.update :controller => 'ibocorp', :action => nil
+      paginate({:page => 2}, :per_page => 2) do
+        assert_select 'a[href]', 7 do |links|
+          assert_links_match %r{/ibocorp(?:/(\d+))?$}, links, [nil, nil, 3, 4, 5, 6, 3]
+        end
+      end
+    end
+
+  end
+end
+
+class AdditionalLinkAttributesRenderer < Pagination::LinkRenderer
+  def initialize(link_attributes = nil)
+    super()
+    @additional_link_attributes = link_attributes || { :default => 'true' }
+  end
+
+  def page_link(page, text, attributes = {})
+    @template.link_to text, url_for(page), attributes.merge(@additional_link_attributes)
+  end
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification 
+name: objectreload-pagination
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Mateusz Drozdzynski
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-13 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: gems@objectreload.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- CHANGELOG.rdoc
+- LICENSE
+- README.rdoc
+- Rakefile
+- init.rb
+- lib/active_record/base_extensions.rb
+- lib/active_record/scope_extensions.rb
+- lib/pagination.rb
+- lib/pagination/collection.rb
+- lib/pagination/enumerable.rb
+- lib/pagination/named_scope.rb
+- lib/pagination/version.rb
+- lib/pagination/view_helpers.rb
+- test/active_record_extentions_test.rb
+- test/collection_test.rb
+- test/lib/view_test_process.rb
+- test/test_helper.rb
+- test/view_helpers_test.rb
+has_rdoc: true
+homepage: http://github.com/objectreload/pagination
+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: Simple pagination - without changes in controllers
+test_files: 
+- test/test_helper.rb
+- test/lib/view_test_process.rb
+- test/active_record_extentions_test.rb
+- test/collection_test.rb
+- test/view_helpers_test.rb