folio-pagination-legacy 0.0.2

data/lib/folio/invalid_page.rb

@@ -0,0 +1,5 @@
+# Raised when a value passed to a Folio's paginate method is
+# non-sensical or out of bounds for that folio.
+module Folio
+  class InvalidPage < ArgumentError; end
+end

data/lib/folio/ordinal.rb

@@ -0,0 +1,33 @@
+require 'folio'
+require 'folio/ordinal/page'
+require 'folio/invalid_page'
+
+# Mix in to a source to provide the same methods as Folio, but with simpler
+# build_page and fill_page methods required on the host (some responsibility is
+# moved into the paginate method).
+#
+#  * build_page no longer needs to configure ordinal_page?, first_page,
+#    or last_page on the instantiated page. Instead, just instantiate
+#    and return a Folio::Ordinal::Page. If what you return is not a
+#    Folio::Ordinal::Page, paginate will decorate it to be one.
+#
+#  * fill_page no longer needs to configure next_page and previous_page; the
+#    ordinal page will handle them. (Note that if necessary, you can still set
+#    next_page explicitly to nil.) Also, paginate will now perform ordinal
+#    bounds checking for you, so you can focus entirely on populating the page.
+#
+module Folio
+  module Ordinal
+    # decorate the page before configuring, and then validate the configured
+    # current_page before returning it
+    def configure_pagination(page, options)
+      page = super(::Folio::Ordinal::Page.decorate(page), options)
+      raise ::Folio::InvalidPage unless page.current_page.is_a?(Integer)
+      raise ::Folio::InvalidPage if page.out_of_bounds?
+      page
+    end
+
+    # otherwise acts like a normal folio
+    include ::Folio
+  end
+end

data/lib/folio/ordinal/page.rb

@@ -0,0 +1,107 @@
+require 'folio/page'
+
+# Mix in to an Enumerable to provide the same methods as Folio::Page but with
+# the following overrides:
+#
+#  * ordinal_pages is always true
+#
+#  * first_page is always 1
+#
+#  * current_page is forced to an integer
+#
+#  * previous_page is always either current_page-1 or nil, depending on how
+#    current_page relates to first_page.
+#
+#  * next_page can only be set if total_pages is unknown. if total_pages is
+#    known, next_page will be either current_page+1 or nil, depending on how
+#    current_page relates to last_page. if total_pages is unknown and next_page
+#    is unset (vs. explicitly set to nil), it will default to current_page+1.
+#    if next_page is set to a non-nil value, that value will be forced to an
+#    integer.
+#
+#  * last_page is deterministic: always total_pages if total_pages is known,
+#    current_page if total_pages is unknown and next_page is nil, nil otherwise
+#    (indicating the page sequence continues until next_page is nil).
+module Folio
+  module Ordinal
+    module Page
+      def ordinal_pages
+        true
+      end
+      alias :ordinal_pages? :ordinal_pages
+
+      def first_page
+        1
+      end
+
+      def last_page
+        (total_pages || next_page) ? total_pages : current_page
+      end
+
+      def current_page=(value)
+        @current_page = value.to_i
+      end
+
+      def next_page=(value)
+        @next_page = value && value.to_i
+      end
+
+      def next_page
+        if total_pages && current_page >= total_pages
+          # known number of pages and we've reached the last one. no next page
+          # (even if explicitly set)
+          nil
+        elsif total_pages || !defined?(@next_page)
+          # (1) known number of pages and we haven't reached the last one
+          #     (because we're not in the branch above), or
+          # (2) unknown number of pages, but nothing set, so we assume an
+          #     infinite stream
+          # so there's a next page, and it's the one after this one
+          current_page + 1
+        else
+          # just use what they set
+          @next_page
+        end
+      end
+
+      def previous_page
+        current_page > first_page ? current_page - 1 : nil
+      end
+
+      def out_of_bounds?
+        (current_page < first_page) || (last_page && current_page > last_page) || false
+      end
+
+      def offset
+        (current_page - 1) * per_page
+      end
+
+      class Decorator < Folio::Page::Decorator
+        include Folio::Ordinal::Page
+      end
+
+      class DecoratedArray < Decorator
+        def initialize
+          super []
+        end
+
+        def replace(array)
+          result = super
+          if total_entries.nil? and length < per_page and (current_page == 1 or length > 0)
+            self.total_entries = offset + length
+          end
+          result
+        end
+      end
+
+      def self.decorate(collection)
+        collection = Folio::Ordinal::Page::Decorator.new(collection) unless collection.is_a?(Folio::Ordinal::Page)
+        collection
+      end
+
+      def self.create
+        Folio::Ordinal::Page::DecoratedArray.new
+      end
+    end
+  end
+end

data/lib/folio/page.rb

@@ -0,0 +1,86 @@
+require 'folio/per_page'
+require 'delegate'
+
+# Mix into any Enumerable. The mixin gives you the eight attributes and
+# one method described below.
+#
+# ordinal_pages?, first_page, and last_page are common to all pages
+# created by a folio and are configured, as available, when the folio
+# creates a blank page.
+#
+# current_page, per_page, and total_entries control the filling of a
+# page and are configured from parameters to the folio's paginate
+# method.
+#
+# next_page and previous_page are configured, as available, when the
+# folio fills the configured page.
+module Folio
+  module Page
+    # indicates whether the page identifiers in current_page,
+    # first_page, last_page, previous_page, and next_page should be
+    # considered ordinal or not.
+    attr_accessor :ordinal_pages
+    alias :ordinal_pages? :ordinal_pages
+
+    # page identifier addressing this page within the folio.
+    attr_accessor :current_page
+
+    # number of items requested from the folio when filling the page.
+    include Folio::PerPage
+
+    # page identifier addressing the first page within the folio.
+    attr_accessor :first_page
+
+    # page identifier addressing the final page within the folio, if
+    # known.
+    def last_page=(value)
+      @last_page = value
+    end
+
+    def last_page
+      if next_page.nil?
+        current_page
+      else
+        @last_page
+      end
+    end
+
+    # page identifier addressing the immediately following page within
+    # the folio, if there is one.
+    attr_accessor :next_page
+
+    # page identifier addressing the immediately preceding page within
+    # the folio, if there is one and it is known.
+    attr_accessor :previous_page
+
+    # number of items in the folio, if known.
+    attr_accessor :total_entries
+
+    # number of pages in the folio, if known. calculated from
+    # total_entries and per_page.
+    def total_pages
+      return nil unless total_entries && per_page && per_page > 0
+      return 1 if total_entries <= 0
+      (total_entries / per_page.to_f).ceil
+    end
+
+    class Decorator < ::SimpleDelegator
+      include Folio::Page
+    end
+
+    class DecoratedArray < Decorator
+      def initialize
+        super []
+      end
+    end
+
+    def self.decorate(collection)
+      collection = Folio::Page::Decorator.new(collection) unless collection.is_a?(Folio::Page)
+      collection
+    end
+
+    def self.create
+      Folio::Page::DecoratedArray.new
+    end
+  end
+end

data/lib/folio/per_page.rb

@@ -0,0 +1,15 @@
+module Folio
+  module PerPage
+    def default_per_page
+      Folio.per_page
+    end
+
+    def per_page(*args)
+      raise ArgumentError if args.size > 1
+      @per_page = (args.first && args.first.to_i) if args.size > 0
+      @per_page ? @per_page : default_per_page
+    end
+
+    alias_method :per_page=, :per_page
+  end
+end

data/lib/folio/rails.rb

@@ -0,0 +1,21 @@
+begin
+  require 'active_support/core_ext/module/attribute_accessors'
+  require 'action_controller'
+rescue LoadError
+  raise "folio-pagination-legacy's rails support requires rails"
+end
+
+begin
+  require 'will_paginate/view_helpers'
+rescue LoadError
+  raise "folio-pagination-legacy's rails support requires will_paginate"
+end
+
+require 'folio/will_paginate/view_helpers'
+
+ActionView::Base.send :include, WillPaginate::ViewHelpers
+if defined?(ActionController::Base) and ActionController::Base.respond_to? :rescue_responses
+  ActionController::Base.rescue_responses['Folio::InvalidPage'] = :not_found
+end
+
+require 'folio/will_paginate/active_record'

data/lib/folio/version.rb

@@ -0,0 +1,3 @@
+module Folio
+  VERSION = "0.0.2"
+end

data/lib/folio/will_paginate/active_record.rb

@@ -0,0 +1,71 @@
+# place WillPaginate's versions in place first to ensure the folio versions
+# included later are used
+begin
+  require 'active_record'
+rescue LoadError
+  raise "folio-pagination-legacy's activerecord support requires activerecord"
+end
+
+begin
+  require 'will_paginate/finder'
+rescue LoadError
+  raise "folio-pagination-legacy's activerecord support requires will_paginate"
+end
+
+ActiveRecord::Base.send :include, WillPaginate::Finder
+ActiveRecord::Associations::AssociationCollection.send :include, WillPaginate::Finder::ClassMethods
+
+require 'folio/ordinal'
+require 'folio/ordinal/page'
+require 'folio/will_paginate/array'
+
+module Folio
+  module WillPaginate
+    # replaces model_or_association.paginate(...) method to behave like that
+    # from Folio while preserving basic mechanics of the version from
+    # WillPaginate.
+    #
+    # differences:
+    #
+    #  * paginate does *not* recognize any parameters beyond those described in
+    #    for Folio's paginate (e.g. finder options, count options).
+    #
+    module ActiveRecord
+      module Pagination
+        include Folio::Ordinal
+
+        def paginate_with_wp_count(options={})
+          unless options.has_key?(:total_entries)
+            page = (options.fetch(:page) { 1 }).to_i
+            per_page = (options.fetch(:per_page) { self.per_page }).to_i
+            offset = (page - 1) * per_page
+            options[:total_entries] = wp_count({}, [:all, {offset: offset, limit: per_page}], 'find')
+          end
+          paginate_without_wp_count(options)
+        end
+        alias_method_chain :paginate, :wp_count
+
+        def build_page
+          Folio::Ordinal::Page.create
+        end
+
+        # load the results and place them in the page
+        def fill_page(page)
+          page.replace self.find(:all, offset: page.offset, limit: page.per_page)
+          page
+        end
+
+        # don't try and look at Class (ActiveRecord::Base.class, etc.) for
+        # defaults
+        def default_per_page
+          Folio.per_page
+        end
+      end
+
+      # mix into Active Record. these are the same ones that WillPaginate mixes
+      # its version of pagination into.
+      ::ActiveRecord::Base.extend Pagination
+      ::ActiveRecord::Associations::AssociationCollection.send(:include, Pagination)
+    end
+  end
+end

data/lib/folio/will_paginate/array.rb

@@ -0,0 +1,10 @@
+require 'will_paginate/array'
+require 'folio/core_ext/enumerable'
+
+# make sure Array#paginate uses to folio version from Enumerable, not the one
+# will_paginate added.
+class Array
+  def paginate(*args)
+    super
+  end
+end

data/lib/folio/will_paginate/collection.rb

@@ -0,0 +1,19 @@
+require 'folio'
+require 'folio/ordinal/page'
+require 'will_paginate/collection'
+
+# overrides WillPaginate::Collection.create to return an ordinal folio page
+# instead of a WillPaginate::Collection; the rest of WillPaginate::Collection
+# is unused when in folio-land.
+module WillPaginate
+  class Collection
+    def self.create(current_page, per_page=nil, total_entries=nil)
+      page = ::Folio::Ordinal::Page.create
+      page.current_page = current_page
+      page.per_page = per_page
+      page.total_entries = total_entries
+      yield page if block_given?
+      page
+    end
+  end
+end

data/lib/folio/will_paginate/view_helpers.rb

@@ -0,0 +1,59 @@
+require 'folio'
+require 'folio/will_paginate/view_helpers/link_renderer'
+require 'will_paginate/view_helpers'
+
+module Folio
+  module WillPaginate
+    module ViewHelpers
+      # just copied from ::WillPaginate::ViewHelpers except line 20 (changed from
+      # "unless value > 1" to "if value == 1" to be friendly to unknown
+      # total_pages)
+      def will_paginate_with_folio(collection = nil, options = {})
+        options, collection = collection, nil if collection.is_a? Hash
+        unless collection or !controller
+          collection_name = "@#{controller.controller_name}"
+          collection = instance_variable_get(collection_name)
+          raise ArgumentError, "The #{collection_name} variable appears to be empty. Did you " +
+            "forget to pass the collection object for will_paginate?" unless collection
+        end
+        # early exit if there is nothing to render
+        return nil if ::WillPaginate::ViewHelpers.total_pages_for_collection(collection) == 1
+
+        options = options.symbolize_keys.reverse_merge ::WillPaginate::ViewHelpers.pagination_options
+        if options[:prev_label]
+          WillPaginate::Deprecation::warn(":prev_label view parameter is now :previous_label; the old name has been deprecated", caller)
+          options[:previous_label] = options.delete(:prev_label)
+        end
+
+        # 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
+        renderer.to_html
+      end
+
+      def page_entries_info_with_folio(collection, options = {})
+        # skip outputting anything unless the collection has ordinal pages (to
+        # be able to get an offset) *and* a known total count.
+        return unless collection.total_entries && collection.ordinal_pages
+        page_entries_info_without_folio(collection, options)
+      end
+
+      def self.included(klass)
+        [:will_paginate, :page_entries_info].each do |method|
+          klass.send(:alias_method, :"#{method}_without_folio", method)
+          klass.send(:alias_method, method, :"#{method}_with_folio")
+        end
+      end
+
+      ::WillPaginate::ViewHelpers.send :include, self
+    end
+  end
+end