kaminari-core 1.0.0.beta2

data/lib/kaminari/config.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+require 'active_support/configurable'
+
+module Kaminari
+  # Configures global settings for Kaminari
+  #   Kaminari.configure do |config|
+  #     config.default_per_page = 10
+  #   end
+  include ActiveSupport::Configurable
+
+  config.instance_eval do
+    self.default_per_page = 25
+    self.max_per_page = nil
+    self.window = 4
+    self.outer_window = 0
+    self.left = 0
+    self.right = 0
+    self.page_method_name = :page
+    self.param_name = :page
+    self.max_pages = nil
+    self.params_on_first_page = false
+
+    # If param_name was given as a callable object, call it when returning
+    def param_name
+      self[:param_name].respond_to?(:call) ? self[:param_name].call : self[:param_name]
+    end
+  end
+end

data/lib/kaminari/core.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+module Kaminari
+end
+
+# load Rails/Railtie
+begin
+  require 'rails'
+rescue LoadError
+  #do nothing
+end
+
+# load Kaminari components
+require 'kaminari/config'
+require 'kaminari/exceptions'
+require 'kaminari/helpers/paginator'
+require 'kaminari/models/page_scope_methods'
+require 'kaminari/models/configuration_methods'
+require 'kaminari/models/array_extension'
+
+if defined? ::Rails::Railtie
+  require 'kaminari/railtie'
+  require 'kaminari/engine'
+end

data/lib/kaminari/core/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module Kaminari
+  module Core
+    VERSION = '1.0.0.beta2'
+  end
+end

data/lib/kaminari/engine.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+module Kaminari #:nodoc:
+  class Engine < ::Rails::Engine #:nodoc:
+  end
+end

data/lib/kaminari/exceptions.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Kaminari
+  class ZeroPerPageOperation < ZeroDivisionError; end
+end

data/lib/kaminari/helpers/helper_methods.rb

@@ -0,0 +1,169 @@
+module Kaminari
+  module Helpers
+    module HelperMethods
+      # A helper that renders the pagination links.
+      #
+      #   <%= paginate @articles %>
+      #
+      # ==== Options
+      # * <tt>:window</tt> - The "inner window" size (4 by default).
+      # * <tt>:outer_window</tt> - The "outer window" size (0 by default).
+      # * <tt>:left</tt> - The "left outer window" size (0 by default).
+      # * <tt>:right</tt> - The "right outer window" size (0 by default).
+      # * <tt>:params</tt> - url_for parameters for the links (:controller, :action, etc.)
+      # * <tt>:param_name</tt> - parameter name for page number in the links (:page by default)
+      # * <tt>:remote</tt> - Ajax? (false by default)
+      # * <tt>:paginator_class</tt> - Specify a custom Paginator (Kaminari::Helpers::Paginator by default)
+      # * <tt>:template</tt> - Specify a custom template renderer for rendering the Paginator (receiver by default)
+      # * <tt>:ANY_OTHER_VALUES</tt> - Any other hash key & values would be directly passed into each tag as :locals value.
+      def paginate(scope, paginator_class: Kaminari::Helpers::Paginator, template: nil, **options)
+        options[:total_pages] ||= scope.total_pages
+        options.reverse_merge! current_page: scope.current_page, per_page: scope.limit_value, remote: false
+
+        paginator = paginator_class.new (template || self), options
+        paginator.to_s
+      end
+
+      # A simple "Twitter like" pagination link that creates a link to the previous page.
+      #
+      # ==== Examples
+      # Basic usage:
+      #
+      #   <%= link_to_previous_page @items, 'Previous Page' %>
+      #
+      # Ajax:
+      #
+      #   <%= link_to_previous_page @items, 'Previous Page', remote: true %>
+      #
+      # By default, it renders nothing if there are no more results on the previous page.
+      # You can customize this output by passing a block.
+      #
+      #   <%= link_to_previous_page @users, 'Previous Page' do %>
+      #     <span>At the Beginning</span>
+      #   <% end %>
+      def link_to_previous_page(scope, name, **options)
+        prev_page = path_to_prev_page(scope, options)
+
+        options.except! :params, :param_name
+        options[:rel] ||= 'prev'
+
+        link_to_if prev_page, name, prev_page, options do
+          yield if block_given?
+        end
+      end
+      alias link_to_prev_page link_to_previous_page
+
+      # A simple "Twitter like" pagination link that creates a link to the next page.
+      #
+      # ==== Examples
+      # Basic usage:
+      #
+      #   <%= link_to_next_page @items, 'Next Page' %>
+      #
+      # Ajax:
+      #
+      #   <%= link_to_next_page @items, 'Next Page', remote: true %>
+      #
+      # By default, it renders nothing if there are no more results on the next page.
+      # You can customize this output by passing a block.
+      #
+      #   <%= link_to_next_page @users, 'Next Page' do %>
+      #     <span>No More Pages</span>
+      #   <% end %>
+      def link_to_next_page(scope, name, **options)
+        next_page = path_to_next_page(scope, options)
+
+        options.except! :params, :param_name
+        options[:rel] ||= 'next'
+
+        link_to_if next_page, name, next_page, options do
+          yield if block_given?
+        end
+      end
+
+      # Renders a helpful message with numbers of displayed vs. total entries.
+      # Ported from mislav/will_paginate
+      #
+      # ==== Examples
+      # Basic usage:
+      #
+      #   <%= page_entries_info @posts %>
+      #   #-> Displaying posts 6 - 10 of 26 in total
+      #
+      # By default, the message will use the humanized class name of objects
+      # in collection: for instance, "project types" for ProjectType models.
+      # The namespace will be cutted out and only the last name will be used.
+      # Override this with the <tt>:entry_name</tt> parameter:
+      #
+      #   <%= page_entries_info @posts, entry_name: 'item' %>
+      #   #-> Displaying items 6 - 10 of 26 in total
+      def page_entries_info(collection, entry_name: nil)
+        entry_name = if entry_name
+                       entry_name.pluralize(collection.size)
+                     else
+                       collection.entry_name(count: collection.size).downcase
+                     end
+
+        if collection.total_pages < 2
+          t('helpers.page_entries_info.one_page.display_entries', entry_name: entry_name, count: collection.total_count)
+        else
+          t('helpers.page_entries_info.more_pages.display_entries', entry_name: entry_name, first: collection.offset_value + 1, last: [collection.offset_value + collection.limit_value, collection.total_count].min, total: collection.total_count)
+        end.html_safe
+      end
+
+      # Renders rel="next" and rel="prev" links to be used in the head.
+      #
+      # ==== Examples
+      # Basic usage:
+      #
+      #   In head:
+      #   <head>
+      #     <title>My Website</title>
+      #     <%= yield :head %>
+      #   </head>
+      #
+      #   Somewhere in body:
+      #   <% content_for :head do %>
+      #     <%= rel_next_prev_link_tags @items %>
+      #   <% end %>
+      #
+      #   #-> <link rel="next" href="/items/page/3" /><link rel="prev" href="/items/page/1" />
+      #
+      def rel_next_prev_link_tags(scope, options = {})
+        next_page = path_to_next_page(scope, options)
+        prev_page = path_to_prev_page(scope, options)
+
+        output = String.new
+        output << tag(:link, rel: "next", href: next_page) if next_page
+        output << tag(:link, rel: "prev", href: prev_page) if prev_page
+        output.html_safe
+      end
+
+      # A helper that calculates the path to the next page.
+      #
+      # ==== Examples
+      # Basic usage:
+      #
+      #   <%= path_to_next_page @items %>
+      #   #-> /items?page=2
+      #
+      # It will return `nil` if there is no next page.
+      def path_to_next_page(scope, options = {})
+        Kaminari::Helpers::NextPage.new(self, options.reverse_merge(current_page: scope.current_page)).url if scope.next_page
+      end
+
+      # A helper that calculates the path to the previous page.
+      #
+      # ==== Examples
+      # Basic usage:
+      #
+      #   <%= path_to_prev_page @items %>
+      #   #-> /items
+      #
+      # It will return `nil` if there is no previous page.
+      def path_to_prev_page(scope, options = {})
+        Kaminari::Helpers::PrevPage.new(self, options.reverse_merge(current_page: scope.current_page)).url if scope.prev_page
+      end
+    end
+  end
+end

data/lib/kaminari/helpers/paginator.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+require 'active_support/inflector'
+require 'kaminari/helpers/tags'
+
+module Kaminari
+  module Helpers
+    # The main container tag
+    class Paginator < Tag
+      def initialize(template, window: nil, outer_window: nil, left: nil, right: nil, inner_window: nil, **options) #:nodoc:
+        outer_window ||= Kaminari.config.outer_window
+        left ||= Kaminari.config.left
+        right ||= Kaminari.config.right
+        @window_options = {window: window || inner_window || Kaminari.config.window, left: left.zero? ? outer_window : left, right: right.zero? ? outer_window : right}
+
+        @template, @options, @theme, @views_prefix, @last = template, options, options[:theme], options[:views_prefix], nil
+        @window_options.merge! @options
+        @window_options[:current_page] = @options[:current_page] = PageProxy.new(@window_options, @options[:current_page], nil)
+
+        #XXX Using parent template's buffer class for rendering each partial here. This might cause problems if the handler mismatches
+        @output_buffer = if defined?(::ActionView::OutputBuffer)
+          ::ActionView::OutputBuffer.new
+        elsif template.instance_variable_get(:@output_buffer)
+          template.instance_variable_get(:@output_buffer).class.new
+        else
+          ActiveSupport::SafeBuffer.new
+        end
+      end
+
+      # render given block as a view template
+      def render(&block)
+        instance_eval(&block) if @options[:total_pages] > 1
+        @output_buffer
+      end
+
+      # enumerate each page providing PageProxy object as the block parameter
+      # Because of performance reason, this doesn't actually enumerate all pages but pages that are seemingly relevant to the paginator.
+      # "Relevant" pages are:
+      # * pages inside the left outer window plus one for showing the gap tag
+      # * pages inside the inner window plus one on the left plus one on the right for showing the gap tags
+      # * pages inside the right outer window plus one for showing the gap tag
+      def each_relevant_page
+        return to_enum(:each_relevant_page) unless block_given?
+
+        relevant_pages(@window_options).each do |page|
+          yield PageProxy.new(@window_options, page, @last)
+        end
+      end
+      alias each_page each_relevant_page
+
+      def relevant_pages(options)
+        left_window_plus_one = [*1..options[:left] + 1]
+        right_window_plus_one = [*options[:total_pages] - options[:right]..options[:total_pages]]
+        inside_window_plus_each_sides = [*options[:current_page] - options[:window] - 1..options[:current_page] + options[:window] + 1]
+
+        (left_window_plus_one | inside_window_plus_each_sides | right_window_plus_one).sort.reject {|x| (x < 1) || (x > options[:total_pages])}
+      end
+      private :relevant_pages
+
+      def page_tag(page)
+        @last = Page.new @template, @options.merge(page: page)
+      end
+
+      %w[first_page prev_page next_page last_page gap].each do |tag|
+        eval <<-DEF, nil, __FILE__, __LINE__ + 1
+          def #{tag}_tag
+            @last = #{tag.classify}.new @template, @options
+          end
+        DEF
+      end
+
+      def to_s #:nodoc:
+        Thread.current[:kaminari_rendering] = true
+        super @window_options.merge paginator: self
+      ensure
+        Thread.current[:kaminari_rendering] = false
+      end
+
+      # delegates view helper methods to @template
+      def method_missing(name, *args, &block)
+        @template.respond_to?(name) ? @template.send(name, *args, &block) : super
+      end
+      private :method_missing
+
+      # Wraps a "page number" and provides some utility methods
+      class PageProxy
+        include Comparable
+
+        def initialize(options, page, last) #:nodoc:
+          @options, @page, @last = options, page, last
+        end
+
+        # the page number
+        def number
+          @page
+        end
+
+        # current page or not
+        def current?
+          @page == @options[:current_page]
+        end
+
+        # the first page or not
+        def first?
+          @page == 1
+        end
+
+        # the last page or not
+        def last?
+          @page == @options[:total_pages]
+        end
+
+        # the previous page or not
+        def prev?
+          @page == @options[:current_page] - 1
+        end
+
+        # the next page or not
+        def next?
+          @page == @options[:current_page] + 1
+        end
+
+        # relationship with the current page
+        def rel
+          if next?
+            'next'
+          elsif prev?
+            'prev'
+          end
+        end
+
+        # within the left outer window or not
+        def left_outer?
+          @page <= @options[:left]
+        end
+
+        # within the right outer window or not
+        def right_outer?
+          @options[:total_pages] - @page < @options[:right]
+        end
+
+        # inside the inner window or not
+        def inside_window?
+          (@options[:current_page] - @page).abs <= @options[:window]
+        end
+
+        # Current page is an isolated gap or not
+        def single_gap?
+          ((@page == @options[:current_page] - @options[:window] - 1) && (@page == @options[:left] + 1)) ||
+            ((@page == @options[:current_page] + @options[:window] + 1) && (@page == @options[:total_pages] - @options[:right]))
+        end
+
+        # The page number exceeds the range of pages or not
+        def out_of_range?
+          @page > @options[:total_pages]
+        end
+
+        # The last rendered tag was "truncated" or not
+        def was_truncated?
+          @last.is_a? Gap
+        end
+
+        #Should we display the link tag?
+        def display_tag?
+          left_outer? || right_outer? || inside_window? || single_gap?
+        end
+
+        def to_i #:nodoc:
+          number
+        end
+
+        def to_s #:nodoc:
+          number.to_s
+        end
+
+        def +(other) #:nodoc:
+          to_i + other.to_i
+        end
+
+        def -(other) #:nodoc:
+          to_i - other.to_i
+        end
+
+        def <=>(other) #:nodoc:
+          to_i <=> other.to_i
+        end
+      end
+    end
+  end
+end

data/lib/kaminari/helpers/tags.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+module Kaminari
+  module Helpers
+    PARAM_KEY_BLACKLIST = [:authenticity_token, :commit, :utf8, :_method, :script_name].freeze
+
+    # A tag stands for an HTML tag inside the paginator.
+    # Basically, a tag has its own partial template file, so every tag can be
+    # rendered into String using its partial template.
+    #
+    # The template file should be placed in your app/views/kaminari/ directory
+    # with underscored class name (besides the "Tag" class. Tag is an abstract
+    # class, so _tag partial is not needed).
+    #   e.g.)  PrevLink  ->  app/views/kaminari/_prev_link.html.erb
+    #
+    # When no matching template were found in your app, the engine's pre
+    # installed template will be used.
+    #   e.g.)  Paginator  ->  $GEM_HOME/kaminari-x.x.x/app/views/kaminari/_paginator.html.erb
+    class Tag
+      def initialize(template, params: {}, param_name: nil, theme: nil, views_prefix: nil, **options) #:nodoc:
+        @template, @theme, @views_prefix, @options = template, theme, views_prefix, options
+        @param_name = param_name || Kaminari.config.param_name
+        @params = template.params
+        # @params in Rails 5 no longer inherits from Hash
+        @params = @params.to_unsafe_h if @params.respond_to?(:to_unsafe_h)
+        @params = @params.with_indifferent_access
+        @params.except!(*PARAM_KEY_BLACKLIST)
+        @params.merge! params
+      end
+
+      def to_s(locals = {}) #:nodoc:
+        formats = (@template.respond_to?(:formats) ? @template.formats : Array(@template.params[:format])) + [:html]
+        @template.render partial: partial_path, locals: @options.merge(locals), formats: formats
+      end
+
+      def page_url_for(page)
+        params = params_for(page)
+        params[:only_path] = true
+        @template.url_for params
+      end
+
+      private
+
+      def params_for(page)
+        page_params = Rack::Utils.parse_nested_query("#{@param_name}=#{page}")
+        page_params = @params.deep_merge(page_params)
+
+        if !Kaminari.config.params_on_first_page && (page <= 1)
+          # This converts a hash:
+          #   from: {other: "params", page: 1}
+          #     to: {other: "params", page: nil}
+          #   (when @param_name == "page")
+          #
+          #   from: {other: "params", user: {name: "yuki", page: 1}}
+          #     to: {other: "params", user: {name: "yuki", page: nil}}
+          #   (when @param_name == "user[page]")
+          @param_name.to_s.scan(/[\w\.]+/)[0..-2].inject(page_params){|h, k| h[k] }[$&] = nil
+        end
+
+        page_params
+      end
+
+      def partial_path
+        [
+         @views_prefix,
+         "kaminari",
+         @theme,
+         self.class.name.demodulize.underscore
+        ].compact.join("/")
+      end
+    end
+
+    # Tag that contains a link
+    module Link
+      # target page number
+      def page
+        raise 'Override page with the actual page value to be a Page.'
+      end
+      # the link's href
+      def url
+        page_url_for page
+      end
+      def to_s(locals = {}) #:nodoc:
+        locals[:url] = url
+        super locals
+      end
+    end
+
+    # A page
+    class Page < Tag
+      include Link
+      # target page number
+      def page
+        @options[:page]
+      end
+      def to_s(locals = {}) #:nodoc:
+        locals[:page] = page
+        super locals
+      end
+    end
+
+    # Link with page number that appears at the leftmost
+    class FirstPage < Tag
+      include Link
+      def page #:nodoc:
+        1
+      end
+    end
+
+    # Link with page number that appears at the rightmost
+    class LastPage < Tag
+      include Link
+      def page #:nodoc:
+        @options[:total_pages]
+      end
+    end
+
+    # The "previous" page of the current page
+    class PrevPage < Tag
+      include Link
+      def page #:nodoc:
+        @options[:current_page] - 1
+      end
+    end
+
+    # The "next" page of the current page
+    class NextPage < Tag
+      include Link
+      def page #:nodoc:
+        @options[:current_page] + 1
+      end
+    end
+
+    # Non-link tag that stands for skipped pages...
+    class Gap < Tag
+    end
+  end
+end