will_paginate_seo 3.0.4

data/lib/will_paginate/core_ext.rb

@@ -0,0 +1,30 @@
+require 'set'
+
+# copied from ActiveSupport so we don't depend on it
+
+unless Hash.method_defined? :except
+  Hash.class_eval do
+    # Returns a new hash without the given keys.
+    def except(*keys)
+      rejected = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
+      reject { |key,| rejected.include?(key) }
+    end
+ 
+    # Replaces the hash without only the given keys.
+    def except!(*keys)
+      replace(except(*keys))
+    end
+  end
+end
+
+unless String.method_defined? :underscore
+  String.class_eval do
+    def underscore
+      self.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+    end
+  end
+end

data/lib/will_paginate/data_mapper.rb

@@ -0,0 +1,100 @@
+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
+        total    = options.delete(:total_entries)
+
+        options.delete(:page)
+        options[:limit] = per_page.to_i
+
+
+        col = all(options).page(pagenum)
+        col.total_entries = total.to_i unless total.nil? || (total.kind_of?(String) && total.strip.empty?)
+        col
+      end
+    end
+
+    module CollectionMethods
+      include WillPaginate::CollectionMethods
+
+      attr_accessor :current_page
+      attr_writer :total_entries
+
+      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
+            # :reload prevents Collection.filter from being run, which
+            # would cause a stack overflow
+            clean_query = query.merge(:reload => true)
+            # 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 to_a
+        if paginated?
+          ::WillPaginate::Collection.create(current_page, per_page) do |col|
+            col.replace super
+            col.total_entries ||= total_entries
+          end
+        else
+          super
+        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/deprecation.rb

@@ -0,0 +1,55 @@
+module WillPaginate::Deprecation
+  class << self
+    def warn(message, stack = caller)
+      offending_line = origin_of_call(stack)
+      full_message = "DEPRECATION WARNING: #{message} (called from #{offending_line})"
+      logger = rails_logger || Kernel
+      logger.warn full_message
+    end
+
+    private
+
+    def rails_logger
+      defined?(Rails) && Rails.logger
+    end
+
+    def origin_of_call(stack)
+      lib_root = File.expand_path('../../..', __FILE__)
+      stack.find { |line| line.index(lib_root) != 0 } || stack.first
+    end
+  end
+
+  class Hash < ::Hash
+    def initialize(values = {})
+      super()
+      update values
+      @deprecated = {}
+    end
+
+    def []=(key, value)
+      check_deprecated(key, value)
+      super
+    end
+
+    def deprecate_key(*keys)
+      message = block_given? ? Proc.new : keys.pop
+      Array(keys).each { |key| @deprecated[key] = message }
+    end
+
+    def merge(another)
+      to_hash.update(another)
+    end
+
+    def to_hash
+      ::Hash.new.update(self)
+    end
+
+    private
+
+    def check_deprecated(key, value)
+      if msg = @deprecated[key] and (!msg.respond_to?(:call) or (msg = msg.call(key, value)))
+        WillPaginate::Deprecation.warn(msg)
+      end
+    end
+  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/mongoid.rb

@@ -0,0 +1,46 @@
+require 'mongoid'
+require 'will_paginate/collection'
+
+module WillPaginate
+  module Mongoid
+    module CriteriaMethods
+      def paginate(options = {})
+        extend CollectionMethods
+        @current_page = WillPaginate::PageNumber(options[:page] || @current_page || 1)
+        @page_multiplier = current_page - 1
+        pp = (options[:per_page] || per_page || WillPaginate.per_page).to_i
+        limit(pp).skip(@page_multiplier * pp)
+      end
+
+      def per_page(value = :non_given)
+        if value == :non_given
+          options[:limit] == 0 ? nil : options[:limit] # in new Mongoid versions a nil limit is saved as 0
+        else
+          limit(value)
+        end
+      end
+
+      def page(page)
+        paginate(:page => page)
+      end
+    end
+
+    module CollectionMethods
+      attr_reader :current_page
+
+      def total_entries
+        @total_entries ||= count
+      end
+
+      def total_pages
+        (total_entries / per_page.to_f).ceil
+      end
+
+      def offset
+        @page_multiplier * per_page
+      end
+    end
+
+    ::Mongoid::Criteria.send(:include, CriteriaMethods)
+  end
+end

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

@@ -0,0 +1,68 @@
+require 'will_paginate'
+require 'will_paginate/page_number'
+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/active_record'
+      end
+
+      ActiveSupport.on_load :action_controller do
+        WillPaginate::Railtie.setup_actioncontroller
+      end
+
+      ActiveSupport.on_load :action_view do
+        require 'will_paginate/view_helpers/action_view'
+      end
+
+      self.class.add_locale_path config
+
+      # early access to ViewHelpers.pagination_options
+      require 'will_paginate/view_helpers'
+    end
+
+    def self.setup_actioncontroller
+      ( defined?(ActionDispatch::ExceptionWrapper) ?
+        ActionDispatch::ExceptionWrapper : ActionDispatch::ShowExceptions
+      ).send :include, ShowExceptionsPatch
+      ActionController::Base.extend ControllerRescuePatch
+    end
+
+    def self.add_locale_path(config)
+      config.i18n.railties_load_path.unshift(*WillPaginate::I18n.load_path)
+    end
+
+    # Extending the exception handler middleware so it properly detects
+    # WillPaginate::InvalidPage regardless of it being a tag module.
+    module ShowExceptionsPatch
+      extend ActiveSupport::Concern
+      included { alias_method_chain :status_code, :paginate }
+      def status_code_with_paginate(exception = @exception)
+        if exception.is_a?(WillPaginate::InvalidPage) or
+            (exception.respond_to?(:original_exception) &&
+              exception.original_exception.is_a?(WillPaginate::InvalidPage))
+          Rack::Utils.status_code(:not_found)
+        else
+          original_method = method(:status_code_without_paginate)
+          if original_method.arity != 0
+            original_method.call(exception)
+          else
+            original_method.call()
+          end
+        end
+      end
+    end
+
+    module ControllerRescuePatch
+      def rescue_from(*args, &block)
+        if idx = args.index(WillPaginate::InvalidPage)
+          args[idx] = args[idx].name
+        end
+        super(*args, &block)
+      end
+    end
+  end
+end