will_paginate 3.0.pre4 → 3.0.0

data/lib/will_paginate/data_mapper.rb

@@ -0,0 +1,91 @@
+require 'dm-core'
+require 'dm-aggregates'
+require 'will_paginate/per_page'
+require 'will_paginate/page_number'
+require 'will_paginate/collection'
+
+module WillPaginate
+  module DataMapper
+    module Pagination
+      def page(num)
+        pagenum = ::WillPaginate::PageNumber(num.nil? ? 1 : num)
+        per_page = query.limit || self.per_page
+        options = {:offset => pagenum.to_offset(per_page).to_i}
+        options[:limit] = per_page unless query.limit
+        col = new_collection(query.merge(options))
+        col.current_page = pagenum
+        col
+      end
+
+      def paginate(options)
+        options  = options.dup
+        pagenum  = options.fetch(:page) { raise ArgumentError, ":page parameter required" }
+        per_page = options.delete(:per_page) || self.per_page
+
+        options.delete(:page)
+        options[:limit] = per_page.to_i
+
+        all(options).page(pagenum)
+      end
+    end
+
+    module CollectionMethods
+      attr_accessor :current_page
+
+      def paginated?
+        !current_page.nil?
+      end
+
+      def per_page
+        query.limit || model.per_page
+      end
+
+      def offset
+        query.offset
+      end
+
+      def total_entries
+        @total_entries ||= begin
+          if loaded? and @array.size < per_page and (current_page == 1 or @array.size > 0)
+            offset + @array.size
+          else
+            clean_query = query.merge(:order => [])
+            # seems like the only way
+            clean_query.instance_variable_set('@limit', nil)
+            clean_query.instance_variable_set('@offset', 0)
+            new_collection(clean_query).count
+          end
+        end
+      end
+
+      def total_pages
+        (total_entries / per_page.to_f).ceil
+      end
+
+      def to_a
+        ::WillPaginate::Collection.create(current_page, per_page) do |col|
+          col.replace super
+          col.total_entries ||= total_entries
+        end
+      end
+
+      private
+
+      def new_collection(query, resources = nil)
+        col = super
+        col.current_page = self.current_page
+        col
+      end
+
+      def initialize_copy(original)
+        super
+        @total_entries = nil
+      end
+    end
+
+    ::DataMapper::Model.append_extensions PerPage
+    ::DataMapper::Model.append_extensions Pagination
+    ::DataMapper::Collection.send(:include, Pagination)
+    ::DataMapper::Collection.send(:include, CollectionMethods)
+  end
+end

data/lib/will_paginate/i18n.rb

@@ -0,0 +1,22 @@
+module WillPaginate
+  module I18n
+    def self.locale_dir
+      File.expand_path('../locale', __FILE__)
+    end
+
+    def self.load_path
+      Dir["#{locale_dir}/*.{rb,yml}"]
+    end
+
+    def will_paginate_translate(keys, options = {})
+      if defined? ::I18n
+        defaults = Array(keys).dup
+        defaults << Proc.new if block_given?
+        ::I18n.translate(defaults.shift, options.merge(:default => defaults, :scope => :will_paginate))
+      else
+        key = Array === keys ? keys.first : keys
+        yield key, options
+      end
+    end
+  end
+end

data/lib/will_paginate/locale/en.yml

@@ -0,0 +1,33 @@
+en:
+  will_paginate:
+    previous_label: "← Previous"
+    next_label: "Next →"
+    page_gap: "…"
+
+    page_entries_info:
+      single_page:
+        zero:  "No %{model} found"
+        one:   "Displaying 1 %{model}"
+        other: "Displaying all %{count} %{model}"
+      single_page_html:
+        zero:  "No %{model} found"
+        one:   "Displaying <b>1</b> %{model}"
+        other: "Displaying <b>all&nbsp;%{count}</b> %{model}"
+
+      multi_page: "Displaying %{model} %{from} - %{to} of %{count} in total"
+      multi_page_html: "Displaying %{model} <b>%{from}&nbsp;-&nbsp;%{to}</b> of <b>%{count}</b> in total"
+
+    # models:
+    #   entry:
+    #     zero:  entries
+    #     one:   entry
+    #     few:   entries
+    #     other: entries
+
+    # line_item:
+    #   page_entries_info:
+    #     single_page:
+    #       zero:  "Your shopping cart is empty"
+    #       one:   "Displaying one item in your cart"
+    #       other: "Displaying all %{count} items"
+    #     multi_page: "Displaying items %{from} - %{to} of %{count} in total"

data/lib/will_paginate/page_number.rb

@@ -0,0 +1,57 @@
+require 'delegate'
+require 'forwardable'
+
+module WillPaginate
+  # a module that page number exceptions are tagged with
+  module InvalidPage; end
+
+  # integer representing a page number
+  class PageNumber < DelegateClass(Integer)
+    # a value larger than this is not supported in SQL queries
+    BIGINT = 9223372036854775807
+
+    extend Forwardable
+
+    def initialize(value, name)
+      value = Integer(value)
+      if 'offset' == name ? (value < 0 or value > BIGINT) : value < 1
+        raise RangeError, "invalid #{name}: #{value.inspect}"
+      end
+      @name = name
+      super(value)
+    rescue ArgumentError, TypeError, RangeError => error
+      error.extend InvalidPage
+      raise error
+    end
+
+    alias_method :to_i, :__getobj__
+
+    def inspect
+      "#{@name} #{to_i}"
+    end
+
+    def to_offset(per_page)
+      PageNumber.new((to_i - 1) * per_page.to_i, 'offset')
+    end
+
+    def kind_of?(klass)
+      super || to_i.kind_of?(klass)
+    end
+    alias is_a? kind_of?
+  end
+
+  # Ultrahax: makes `Fixnum === current_page` checks pass
+  Numeric.extend Module.new {
+    def ===(obj)
+      obj.instance_of? PageNumber or super
+    end
+  }
+
+  # An idemptotent coercion method
+  def self.PageNumber(value, name = 'page')
+    case value
+    when PageNumber then value
+    else PageNumber.new(value, name)
+    end
+  end
+end

data/lib/will_paginate/per_page.rb

@@ -0,0 +1,27 @@
+module WillPaginate
+  module PerPage
+    def per_page
+      defined?(@per_page) ? @per_page : WillPaginate.per_page
+    end
+
+    def per_page=(limit)
+      @per_page = limit.to_i
+    end
+
+    def self.extended(base)
+      base.extend Inheritance if base.is_a? Class
+    end
+
+    module Inheritance
+      def inherited(subclass)
+        super
+        subclass.per_page = self.per_page
+      end
+    end
+  end
+
+  extend PerPage
+
+  # default number of items per page
+  self.per_page = 30
+end

data/lib/will_paginate/railtie.rb

@@ -1,22 +1,31 @@
 require 'will_paginate'
 require 'will_paginate/collection'
+require 'will_paginate/i18n'
 
 module WillPaginate
   class Railtie < Rails::Railtie
     initializer "will_paginate" do |app|
       ActiveSupport.on_load :active_record do
-        require 'will_paginate/finders/active_record'
-        WillPaginate::Finders::ActiveRecord.enable!
+        require 'will_paginate/active_record'
       end
 
       ActiveSupport.on_load :action_controller do
-        ActionDispatch::ShowExceptions.rescue_responses['WillPaginate::InvalidPage'] = :not_found
+        WillPaginate::Railtie.setup_actioncontroller
       end
 
       ActiveSupport.on_load :action_view do
         require 'will_paginate/view_helpers/action_view'
-        include WillPaginate::ViewHelpers::ActionView
       end
+
+      self.class.add_locale_path config
+    end
+
+    def self.setup_actioncontroller
+      ActionDispatch::ShowExceptions.rescue_responses['WillPaginate::InvalidPage'] = :not_found
+    end
+
+    def self.add_locale_path(config)
+      config.i18n.railties_load_path.unshift(*WillPaginate::I18n.load_path)
     end
   end
 end

data/lib/will_paginate/sequel.rb

@@ -0,0 +1,36 @@
+require 'sequel'
+require 'sequel/extensions/pagination'
+
+module WillPaginate
+  # Sequel already supports pagination; we only need to make the
+  # resulting dataset look a bit more like WillPaginate::Collection
+  module SequelMethods
+    def total_pages
+      page_count
+    end
+
+    def per_page
+      page_size
+    end
+
+    def size
+      current_page_record_count
+    end
+    alias length size
+
+    def total_entries
+      pagination_record_count
+    end
+
+    def out_of_bounds?
+      current_page > total_pages
+    end
+
+    # Current offset of the paginated collection
+    def offset
+      (current_page - 1) * per_page
+    end
+  end
+
+  Sequel::Dataset::Pagination.send(:include, SequelMethods)
+end

data/lib/will_paginate/version.rb

@@ -2,7 +2,7 @@ module WillPaginate #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 0
-    TINY  = 'pre4'
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/lib/will_paginate/view_helpers.rb

@@ -1,4 +1,6 @@
-require 'will_paginate/deprecation'
+# encoding: utf-8
+require 'will_paginate/core_ext'
+require 'will_paginate/i18n'
 
 module WillPaginate
   # = Will Paginate view helpers
@@ -7,36 +9,148 @@ module WillPaginate
   # for the 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.
-  # 
-  # Read more in WillPaginate::ViewHelpers::Base
   module ViewHelpers
-    # ==== Global options for helpers
-    #
-    # Options for pagination helpers are optional and get their default values
-    # from the WillPaginate::ViewHelpers.pagination_options hash. You can write
-    # to this hash to override default options on the global level:
-    #
-    #   WillPaginate::ViewHelpers.pagination_options[:previous_label] = 'Previous page'
-    #
-    # By putting this into your environment.rb you can easily translate link
-    # texts to previous and next pages, as well as override some other defaults
-    # to your liking.
-    def self.pagination_options() @pagination_options; end
-    # Overrides the default +pagination_options+
-    def self.pagination_options=(value) @pagination_options = value; end
-    
+    class << self
+      # Write to this hash to override default options on the global level:
+      #
+      #   WillPaginate::ViewHelpers.pagination_options[:page_links] = false
+      #
+      attr_accessor :pagination_options
+    end
+
+    # default view options
     self.pagination_options = {
       :class          => 'pagination',
-      :previous_label => '&#8592; Previous',
-      :next_label     => 'Next &#8594;',
+      :previous_label => nil,
+      :next_label     => nil,
       :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
+      :link_separator => ' ', # single space is friendly to spiders and non-graphic browsers
       :param_name     => :page,
       :params         => nil,
-      :renderer       => 'WillPaginate::ViewHelpers::LinkRenderer',
+      :renderer       => nil,
       :page_links     => true,
       :container      => true
     }
+
+    include WillPaginate::I18n
+
+    # Returns HTML representing page links for a WillPaginate::Collection-like object.
+    # In case there is no more than one page in total, nil is returned.
+    # 
+    # ==== Options
+    # * <tt>:class</tt> -- CSS class name for the generated DIV (default: "pagination")
+    # * <tt>:previous_label</tt> -- default: "« Previous"
+    # * <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>:link_separator</tt> -- string separator for page HTML elements (default: single space)
+    # * <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>WillPaginate::LinkRenderer</tt>)
+    # * <tt>:page_links</tt> -- when false, only previous/next links are rendered (default: true)
+    # * <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)
+    #
+    # All options not recognized by will_paginate will become HTML attributes on the container
+    # element for pagination links (the DIV). For example:
+    # 
+    #   <%= will_paginate @posts, :style => 'color:blue' %>
+    #
+    # will result in:
+    #
+    #   <div class="pagination" style="color:blue"> ... </div>
+    #
+    def will_paginate(collection, options = {})
+      # early exit if there is nothing to render
+      return nil unless collection.total_pages > 1
+
+      options = WillPaginate::ViewHelpers.pagination_options.merge(options)
+
+      options[:previous_label] ||= will_paginate_translate(:previous_label) { '&#8592; Previous' }
+      options[:next_label]     ||= will_paginate_translate(:next_label) { 'Next &#8594;' }
+
+      # get the renderer instance
+      renderer = case options[:renderer]
+      when nil
+        raise ArgumentError, ":renderer not specified"
+      when String
+        klass = if options[:renderer].respond_to? :constantize then options[:renderer].constantize
+          else Object.const_get(options[:renderer]) # poor man's constantize
+          end
+        klass.new
+      when Class then options[:renderer].new
+      else options[:renderer]
+      end
+      # render HTML for pagination
+      renderer.prepare collection, options, self
+      renderer.to_html
+    end
+
+    # Renders a message containing number of displayed vs. total entries.
+    #
+    #   <%= page_entries_info @posts %>
+    #   #-> Displaying posts 6 - 12 of 26 in total
+    #
+    # The default output contains HTML. Use ":html => false" for plain text.
+    def page_entries_info(collection, options = {})
+      model = options[:model]
+      model = collection.first.class unless model or collection.empty?
+      model ||= 'entry'
+      model_key = if model.respond_to? :model_name
+                    model.model_name.i18n_key  # ActiveModel::Naming
+                  else
+                    model.to_s.underscore
+                  end
+
+      if options.fetch(:html, true)
+        b, eb = '<b>', '</b>'
+        sp = '&nbsp;'
+        html_key = '_html'
+      else
+        b = eb = html_key = ''
+        sp = ' '
+      end
+
+      model_count = collection.total_pages > 1 ? 5 : collection.size
+      defaults = ["models.#{model_key}"]
+      defaults << Proc.new { |_, opts|
+        if model.respond_to? :model_name
+          model.model_name.human(:count => opts[:count])
+        else
+          name = model_key.to_s.tr('_', ' ')
+          raise "can't pluralize model name: #{model.inspect}" unless name.respond_to? :pluralize
+          opts[:count] == 1 ? name : name.pluralize
+        end
+      }
+      model_name = will_paginate_translate defaults, :count => model_count
+
+      if collection.total_pages < 2
+        i18n_key = :"page_entries_info.single_page#{html_key}"
+        keys = [:"#{model_key}.#{i18n_key}", i18n_key]
+
+        will_paginate_translate keys, :count => collection.size, :model => model_name do |_, opts|
+          case opts[:count]
+          when 0; "No #{opts[:model]} found"
+          when 1; "Displaying #{b}1#{eb} #{opts[:model]}"
+          else    "Displaying #{b}all#{sp}#{opts[:count]}#{eb} #{opts[:model]}"
+          end
+        end
+      else
+        i18n_key = :"page_entries_info.multi_page#{html_key}"
+        keys = [:"#{model_key}.#{i18n_key}", i18n_key]
+        params = {
+          :model => model_name, :count => collection.total_entries,
+          :from => collection.offset + 1, :to => collection.offset + collection.length
+        }
+        will_paginate_translate keys, params do |_, opts|
+          %{Displaying %s #{b}%d#{sp}-#{sp}%d#{eb} of #{b}%d#{eb} in total} %
+            [ opts[:model], opts[:from], opts[:to], opts[:count] ]
+        end
+      end
+    end
   end
 end