paginate 2.0.0 → 3.0.0

data/lib/paginate.rb

@@ -4,6 +4,9 @@ require "paginate/base"
 require "paginate/config"
 require "paginate/helper"
 require "paginate/renderer"
+require "paginate/renderer/list"
+require "paginate/renderer/more"
+require "paginate/extension"
 require "paginate/active_record"
 require "paginate/action_controller"
 
@@ -16,4 +19,5 @@ end
 Paginate.configure do |config|
   config.param_name = :page
   config.size  = 10
+  config.renderer = Paginate::Renderer::List
 end

data/lib/paginate/active_record.rb

@@ -1,5 +1,17 @@
 module ActiveRecord
   class Base
-    scope :paginate, proc {|*args| Paginate::Base.new(*args).to_options }
+    class << self
+      def inherited_with_paginate(subclass)
+        inherited_without_paginate subclass
+        subclass.send(:include, Paginate::Extension) if subclass.superclass == ActiveRecord::Base
+      end
+
+      alias_method_chain :inherited, :paginate
+    end
+
+    # Extend existing models
+    self.descendants.each do |model|
+      model.send(:include, Paginate::Extension) if model.superclass == ActiveRecord::Base
+    end
   end
 end

data/lib/paginate/base.rb

@@ -1,12 +1,15 @@
 module Paginate
   class Base
     attr_accessor :options
+    attr_accessor :scope
+
+    def initialize(scope, options = {})
+      @scope = scope
 
-    def initialize(options = {})
       if options.kind_of?(Hash)
         @options = options
       else
-        @options = {:page => options.to_i}
+        @options = {page: options.to_i}
       end
 
       @options.reverse_merge!(Paginate::Config.to_hash)
@@ -21,7 +24,7 @@ module Paginate
     end
 
     def previous_page?
-      options[:page] > 1
+      page > 1
     end
 
     def page
@@ -37,7 +40,13 @@ module Paginate
     end
 
     def to_options
-      { :limit => limit, :offset => offset }
+      {limit: limit, offset: offset}
+    end
+
+    def to_scope
+      scope
+        .limit(limit)
+        .offset(offset)
     end
   end
 end

data/lib/paginate/config.rb

@@ -3,12 +3,14 @@ module Paginate
     class << self
       attr_accessor :size
       attr_accessor :param_name
+      attr_accessor :renderer
     end
 
     def self.to_hash
       {
-        :size => size,
-        :param_name => param_name
+        size: size,
+        param_name: param_name,
+        renderer: renderer
       }
     end
   end

data/lib/paginate/extension.rb

@@ -0,0 +1,14 @@
+module Paginate
+  module Extension
+    extend ActiveSupport::Concern
+
+    included do
+      scope :paginate, proc {|*args|
+        Paginate::Base.new(
+          ActiveRecord::VERSION::MAJOR < 4 ? scoped : all,
+          *args
+        ).to_scope
+      }
+    end
+  end
+end

data/lib/paginate/helper.rb

@@ -12,6 +12,7 @@ module Paginate
     # * <tt>:id</tt>: the HTML id that will identify the pagination block.
     # * <tt>:size</tt>: the page size. When not specified will default to <tt>Paginate::Config.size</tt>.
     # * <tt>:param_name</tt>: the page param name. When not specified will default to <tt>Paginate::Config.param_name</tt>.
+    # * <tt>:renderer</tt>: A class that will be used to render the pagination. When not specified will default to <tt>Paginate::Renderer::List</tt>.
     #
     #   <%= paginate @posts, proc {|page| posts_path(page) }
     #   <%= paginate @posts, :url => proc {|page| posts_path(page) }
@@ -20,16 +21,28 @@ module Paginate
     #
     def paginate(collection, *args)
       options = args.extract_options!
-      param_name = [options[:param_name], Paginate::Config.param_name, :page].compact.first
+
+      param_name = [
+        options[:param_name],
+        Paginate::Config.param_name,
+        :page
+      ].compact.first
+
+      renderer = [
+        options[:renderer],
+        Paginate::Config.renderer,
+        Paginate::Renderer::List
+      ].compact.first
+
       options.merge!({
-        :collection => collection,
-        :page => params[param_name],
-        :param_name => param_name,
-        :fullpath => request.respond_to?(:fullpath) ? request.fullpath : request.request_uri
+        collection: collection,
+        page: params[param_name],
+        param_name: param_name,
+        fullpath: request.fullpath
       })
-      options.merge!(:url => args.first) if args.any?
 
-      Paginate::Renderer.new(options).render
+      options.merge!(url: args.first) if args.any?
+      renderer.new(self, options).render
     end
 
     # Override the original render method, so we can strip the additional
@@ -49,49 +62,10 @@ module Paginate
       size       = options.delete(:size) { Paginate::Config.size }
 
       return super(*[*args, options], &block) unless paginated
-
       collection = options.delete(:collection) { args.shift }
       collection = collection[0, size]
 
       super(collection, *[*args, options], &block)
     end
-
-    # In order to iterate the correct items you have to skip the last collection's item.
-    # We added this helper to automatically skip the last item only if there's a next page.
-    #
-    #   <% iterate @items do |item| %>
-    #   <% end %>
-    #
-    # If you want to grab the iteration index as well just expect it as a block parameter.
-    #
-    #   <% iterate @items do |item, i|
-    #   <% end %>
-    #
-    # If you set a custom size while fetching items from database, you need to inform it while iterating.
-    #
-    #   @items = Item.paginate(:page => 1, :size => 5)
-    #
-    # Then in your view:
-    #
-    #   <% iterate @items, :size => 5 do |item| %>
-    #   <% end %>
-    #
-    # You can receive the iteration counter by expecting two arguments.
-    #
-    #   <% iterate @items do |item, i| do %>
-    #   <% end %>
-    #
-    def iterate(collection, options = {}, &block)
-      options.reverse_merge!(:size => Paginate::Config.size)
-      yield_index = block.arity == 2
-
-      collection[0, options[:size]].each_with_index do |item, i|
-        if yield_index
-          yield item, i
-        else
-          yield item
-        end
-      end
-    end
   end
 end

data/lib/paginate/renderer.rb

@@ -1,73 +1,57 @@
 module Paginate
-  class Renderer
-    attr_accessor :options
-    attr_accessor :current_page
-
-    def initialize(options)
-      @current_page = [options[:page].to_i, 1].max
-      options.reverse_merge!(Paginate::Config.to_hash)
-      @options = options.merge(:page => current_page)
-    end
-
-    def processor
-      @processor ||= Paginate::Base.new(options)
-    end
-
-    def url_for(page)
-      url = options[:url] || options[:fullpath]
-
-      if url.respond_to?(:call)
-        url = url.call(page).to_s.dup
-      else
-        url = url.dup
-
-        re = Regexp.new("([&?])#{Regexp.escape(options[:param_name].to_s)}=[^&]*")
-        url.gsub!(re, "\\1")
-        url.gsub!(/[\?&]$/, "")
-        url.gsub!(/&+/, "&")
-        url.gsub!(/\?&/, "?")
-
-        url << (url =~ /\?/ ? "&" : "?")
-        url << page.to_query(options[:param_name])
+  module Renderer
+    class Base
+      # Set the pagination options.
+      attr_reader :options
+
+      # Set the view context. You can use this object
+      # to call view and url helpers.
+      attr_reader :view_context
+
+      # Set the object with defines all pagination methods
+      # like `Paginate::Base#next_page?`.
+      attr_reader :processor
+
+      def initialize(view_context, options)
+        @view_context = view_context
+        @options = options.reverse_merge(Paginate::Config.to_hash)
+        @processor = Paginate::Base.new(nil, options)
       end
 
-      url.gsub!(/&/, "&amp;")
-      url
-    end
-
-    def render
-      html = String.new
-      previous_label = I18n.t("paginate.previous")
-      previous_url = url_for(options[:page] - 1)
-      next_label = I18n.t("paginate.next")
-      next_url = url_for(options[:page] + 1)
-      page_label = I18n.t("paginate.page", options)
-
-      css = %w[ paginate ]
-      css << "disabled" unless processor.previous_page? || processor.next_page?
-
-      html << %[<ul class="#{css.join(" ")}">]
-
-      # Previous page
-      if processor.previous_page?
-        html << %[<li class="previous-page"><a href="#{previous_url}" title="#{previous_label}">#{previous_label}</a></li>]
-      else
-        html << %[<li class="previous-page disabled"><span title="#{previous_label}">#{previous_label}</span></li>]
+      # Return the URL for previous page.
+      def previous_url
+        url_for(processor.page - 1)
       end
 
-      # Current page
-      html << %[<li class="page"><span>#{page_label}</span></li>]
-
-      # Next page
-      if processor.next_page?
-        html << %[<li class="next-page"><a href="#{next_url}" title="#{next_label}">#{next_label}</a></li>]
-      else
-        html << %[<li class="next-page disabled"><span title="#{next_label}">#{next_label}</span></li>]
+      # Return the URL for next page.
+      def next_url
+        url_for(processor.page + 1)
       end
 
-      html << %[</ul>]
-
-      html.html_safe
+      # Compute the URL for a given page.
+      # It will keep track of all query string and replace the
+      # page parameter with the specified `page`.
+      def url_for(page)
+        url = options[:url] || options[:fullpath]
+
+        if url.respond_to?(:call)
+          url = url.call(page).to_s.dup
+        else
+          url = url.dup
+
+          re = Regexp.new("([&?])#{Regexp.escape(options[:param_name].to_s)}=[^&]*")
+          url.gsub!(re, "\\1")
+          url.gsub!(/[\?&]$/, "")
+          url.gsub!(/&+/, "&")
+          url.gsub!(/\?&/, "?")
+
+          url << (url =~ /\?/ ? "&" : "?")
+          url << page.to_query(options[:param_name])
+        end
+
+        url.gsub!(/&/, "&amp;")
+        url
+      end
     end
   end
 end

data/lib/paginate/renderer/list.rb

@@ -0,0 +1,47 @@
+module Paginate
+  module Renderer
+    class List < Base
+      def previous_label
+        I18n.t("paginate.previous")
+      end
+
+      def next_label
+        I18n.t("paginate.next")
+      end
+
+      def page_label
+        I18n.t("paginate.page", page: processor.page)
+      end
+
+      def render
+        html = String.new
+
+        css = %w[ paginate ]
+        css << "disabled" unless processor.previous_page? || processor.next_page?
+
+        html << %[<ul class="#{css.join(" ")}">]
+
+        # Previous page
+        if processor.previous_page?
+          html << %[<li class="previous-page"><a href="#{previous_url}" title="#{previous_label}">#{previous_label}</a></li>]
+        else
+          html << %[<li class="previous-page disabled"><span title="#{previous_label}">#{previous_label}</span></li>]
+        end
+
+        # Current page
+        html << %[<li class="page"><span>#{page_label}</span></li>]
+
+        # Next page
+        if processor.next_page?
+          html << %[<li class="next-page"><a href="#{next_url}" title="#{next_label}">#{next_label}</a></li>]
+        else
+          html << %[<li class="next-page disabled"><span title="#{next_label}">#{next_label}</span></li>]
+        end
+
+        html << %[</ul>]
+
+        html.html_safe
+      end
+    end
+  end
+end

data/lib/paginate/renderer/more.rb

@@ -0,0 +1,19 @@
+module Paginate
+  module Renderer
+    class More < Base
+      def more_label
+        I18n.t("paginate.more")
+      end
+
+      def render
+        return unless processor.next_page?
+
+        <<-HTML.html_safe
+          <p class="paginate">
+            <a class="more" href="#{next_url}" title="#{more_label}">#{more_label}</a>
+          </p>
+        HTML
+      end
+    end
+  end
+end

data/lib/paginate/version.rb

@@ -1,6 +1,6 @@
 module Paginate
   module Version
-    MAJOR = 2
+    MAJOR = 3
     MINOR = 0
     PATCH = 0
     STRING = "#{MAJOR}.#{MINOR}.#{PATCH}"

data/paginate.gemspec

@@ -20,9 +20,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "nokogiri"
   s.add_development_dependency "test_notifier"
   s.add_development_dependency "sqlite3-ruby"
-  s.add_development_dependency "activesupport"
-  s.add_development_dependency "activerecord"
-  s.add_development_dependency "actionpack"
-  s.add_development_dependency "rspec"
+  s.add_development_dependency "rails", "~> 4.0.0"
+  s.add_development_dependency "rspec", "~> 2.14.0.rc1"
   s.add_development_dependency "pry-meta"
 end

data/spec/paginate/action_view_spec.rb

@@ -15,7 +15,7 @@ describe "ActionView support" do
     @view.lookup_context.prefixes << "application"
     @view.controller = @controller
     @view.extend(Paginate::Helper)
-    @view.stub :request => @request
+    @view.stub request: @request
 
     @helper = Object.new
     @helper.extend(Paginate::Helper)
@@ -28,84 +28,6 @@ describe "ActionView support" do
     I18n.locale = :en
   end
 
-  it "displays pagination list" do
-    @request.fullpath = "/some/path?page=1"
-    html = render(:default, [])
-
-    expect(html.css("ul.paginate").count).to eql(1)
-    expect(html.css("ul.paginate > li").count).to eql(3)
-  end
-
-  it "adds .disabled class when have no items" do
-    @request.fullpath = "/some/path"
-    html = render(:default, [])
-
-    expect(html.css("ul.paginate.disabled").first).to be
-  end
-
-  it "displays next page link" do
-    @request.fullpath = "/some/path?page=1"
-    html = render(:default, Array.new(11))
-    link = html.css("li.next-page > a").first
-
-    expect(link).to be
-    expect(link["href"]).to eql("/some/path?page=2")
-    expect(link.text).to eql("Next page")
-  end
-
-  it "displays next page link using proc as url" do
-    @request.fullpath = "/some/path?page=1"
-    html = render(:block_as_url, Array.new(11))
-    link = html.css("li.next-page > a").first
-
-    expect(link).to be
-    expect(link["href"]).to eql("/some/path/2")
-    expect(link.text).to eql("Next page")
-  end
-
-  it "displays previous page link" do
-    @params[:page] = 2
-    @request.fullpath = "/some/path?page=2"
-    html = render(:default, Array.new(11))
-    link = html.css("li.previous-page > a").first
-
-    expect(link).to be
-    expect(link["href"]).to eql("/some/path?page=1")
-    expect(link.text).to eql("Previous page")
-  end
-
-  it "disables element when have no next page" do
-    @request.fullpath = "/some/path?page=1"
-    html = render(:default, Array.new(10))
-    link = html.css("li.next-page > a").first
-    span = html.css("li.next-page.disabled > span").first
-
-    expect(link).not_to be
-    expect(span).to be
-    expect(span.text).to eql("Next page")
-  end
-
-  it "disables element when have no previous page" do
-    @request.fullpath = "/some/path?page=1"
-    html = render(:default, Array.new(10))
-    link = html.css("li.previous-page > a").first
-    span = html.css("li.previous-page.disabled > span").first
-
-    expect(link).not_to be
-    expect(span).to be
-    expect(span.text).to eql("Previous page")
-  end
-
-  it "displays current page" do
-    @params[:page] = 10
-    @request.fullpath = "/some/path?page=10"
-    html = render(:default, [])
-    span = html.css("li.page > span").first
-
-    expect(span).to be
-    expect(span.text).to eql("Page 10")
-  end
-
   it "overrides render method" do
     items = [*1..11].map do |i|
       OpenStruct.new(:to_partial_path => "number", :value => i)
@@ -114,58 +36,11 @@ describe "ActionView support" do
     html = render(:render, items)
   end
 
-  it "translates strings" do
-    I18n.locale = :"pt-BR"
-
-    @params[:page] = 10
-    @request.fullpath = "/some/path?page=10"
-    html = render(:default, Array.new(11))
-
-    expect(html.css("li.page > span").text).to eql("Página 10")
-    expect(html.css("li.next-page > a").text).to eql("Próxima página")
-    expect(html.css("li.previous-page > a").text).to eql("Página anterior")
-  end
-
-  it "skips the last item while iterating" do
-    values = []
-    items = Array.new(11) {|i| "User#{i}" }
-
-    @helper.iterate items do |item|
-      values << item
-    end
-
-    expect(values).to eql(items[0, 10])
-  end
-
-  it "iterates all items when have less records than size" do
-    values = []
-    items = Array.new(8) {|i| "User#{i}" }
-
-    @helper.iterate items do |item|
-      values << item
-    end
-
-    expect(values).to eql(items[0, 8])
-  end
-
-  it "yields iteration counter" do
-    values = []
-    indices = []
-    items = Array.new(11) {|i| "User#{i}" }
-
-    @helper.iterate items do |item, i|
-      values << item
-      indices << i
-    end
-
-    expect(values).to eql(items[0, 10])
-    expect(indices).to eql([*0...10])
-  end
-
   private
   def render(view_name, items)
+    @controller.params = @params
     view_info = Struct.new(:to_partial_path).new("#{view_name}")
-    Nokogiri @view.render(view_info, :items => items)
+    Nokogiri @view.render(view_info, items: items)
   end
 
   def load_view(name)