kaminari-jets-core 0.2.0

data/lib/kaminari/helpers/helper_methods.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+module Kaminari
+  module Helpers
+
+    # The Kaminari::Helpers::UrlHelper module provides useful methods for
+    # generating a path or url to a particular page. A class must implement the
+    # following methods:
+    #
+    #   * <tt>url_for</tt>: A method that generates an actual path
+    #   * <tt>params</tt>: A method that returns query string parameters
+    #   * <tt>request</tt>: A method that returns a Rack::Request object
+    #
+    # A normal Rails controller implements all the methods, which make it
+    # trivial to use this module:
+    #
+    # ==== Examples
+    #
+    #   class UsersController < ApplicationController
+    #     include Kaminari::Helpers::UrlHelper
+    #
+    #     def index
+    #       @users = User.page(1)
+    #
+    #       path_to_next_page(@items)
+    #       # => /items?page=2
+    #     end
+    #   end
+    #
+    module UrlHelper
+
+      # A helper that calculates the url to the next page.
+      #
+      # ==== Examples
+      # Basic usage:
+      #
+      #   <%= next_page_url @items %>
+      #   #-> http://www.example.org/items?page=2
+      #
+      # It will return `nil` if there is no next page.
+      def next_page_url(scope, options = {})
+        "#{request.base_url}#{next_page_path(scope, options)}" if scope.next_page
+      end
+      alias url_to_next_page next_page_url
+
+      def path_to_next_url(scope, options = {})
+        ActiveSupport::Deprecation.warn 'path_to_next_url is deprecated. Use next_page_url or url_to_next_page instead.'
+        next_page_url(scope, options)
+      end
+
+      # A helper that calculates the url to the previous page.
+      #
+      # ==== Examples
+      # Basic usage:
+      #
+      #   <%= prev_page_url @items %>
+      #   #-> http://www.example.org/items
+      #
+      # It will return `nil` if there is no previous page.
+      def prev_page_url(scope, options = {})
+        "#{request.base_url}#{prev_page_path(scope, options)}" if scope.prev_page
+      end
+      alias previous_page_url     prev_page_url
+      alias url_to_prev_page      prev_page_url
+      alias url_to_previous_page  prev_page_url
+
+      # 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 next_page_path(scope, options = {})
+        Kaminari::Helpers::NextPage.new(self, **options.reverse_merge(current_page: scope.current_page)).url if scope.next_page
+      end
+      alias path_to_next_page next_page_path
+
+      # 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 prev_page_path(scope, options = {})
+        Kaminari::Helpers::PrevPage.new(self, **options.reverse_merge(current_page: scope.current_page)).url if scope.prev_page
+      end
+      alias previous_page_path     prev_page_path
+      alias path_to_previous_page  prev_page_path
+      alias path_to_prev_page      prev_page_path
+    end
+
+    module HelperMethods
+      include UrlHelper
+
+      # 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'
+
+        if prev_page
+          link_to name, prev_page, options
+        elsif block_given?
+          yield
+        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'
+
+        if next_page
+          link_to name, next_page, options
+        elsif block_given?
+          yield
+        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, I18n.locale)
+                     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
+          from = collection.offset_value + 1
+          to   = collection.offset_value + (collection.respond_to?(:records) ? collection.records : collection.to_a).size
+
+          t('helpers.page_entries_info.more_pages.display_entries', entry_name: entry_name, first: from, last: to, 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 << %Q|<link rel="next" href="#{next_page}">| if next_page
+        output << %Q|<link rel="prev" href="#{prev_page}">| if prev_page
+        output.html_safe
+      end
+    end
+  end
+end

data/lib/kaminari/helpers/paginator.rb

@@ -0,0 +1,191 @@
+# 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: Kaminari.config.outer_window, left: Kaminari.config.left, right: Kaminari.config.right, inner_window: Kaminari.config.window, **options) #:nodoc:
+        @window_options = {window: window || inner_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
+
+        # This allows for showing fall-back HTML when there's only one page:
+        #
+        #   <%= paginate(@search_results) || "Showing all search results" %>
+        @output_buffer.presence
+      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,164 @@
+# frozen_string_literal: true
+
+module Kaminari
+  module Helpers
+    PARAM_KEY_EXCEPT_LIST = [:authenticity_token, :commit, :utf8, :_method, :script_name, :original_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 templates 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_EXCEPT_LIST)
+        @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("/").gsub('//', '/')
+      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
+
+      # TODO: Remove this initializer before 1.3.0.
+      def initialize(template, params: {}, param_name: nil, theme: nil, views_prefix: nil, **options) #:nodoc:
+        # params in Rails 5 may not be a Hash either,
+        # so it must be converted to a Hash to be merged into @params
+        if params && params.respond_to?(:to_unsafe_h)
+          ActiveSupport::Deprecation.warn 'Explicitly passing params to helpers could be omitted.'
+          params = params.to_unsafe_h
+        end
+
+        super(template, params: params, param_name: param_name, theme: theme, views_prefix: views_prefix, **options)
+      end
+
+      def page #:nodoc:
+        @options[:current_page] - 1
+      end
+    end
+
+    # The "next" page of the current page
+    class NextPage < Tag
+      include Link
+
+      # TODO: Remove this initializer before 1.3.0.
+      def initialize(template, params: {}, param_name: nil, theme: nil, views_prefix: nil, **options) #:nodoc:
+        # params in Rails 5 may not be a Hash either,
+        # so it must be converted to a Hash to be merged into @params
+        if params && params.respond_to?(:to_unsafe_h)
+          ActiveSupport::Deprecation.warn 'Explicitly passing params to helpers could be omitted.'
+          params = params.to_unsafe_h
+        end
+
+        super(template, params: params, param_name: param_name, theme: theme, views_prefix: views_prefix, **options)
+      end
+
+      def page #:nodoc:
+        @options[:current_page] + 1
+      end
+    end
+
+    # Non-link tag that stands for skipped pages...
+    class Gap < Tag
+    end
+  end
+end

data/lib/kaminari/jets/engine.rb

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

data/lib/kaminari/jets/turbine.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Kaminari
+  class Turbine < ::Jets::Turbine #:nodoc:
+    # Doesn't actually do anything. Just keeping this hook point, mainly for compatibility
+    initializer 'kaminari' do
+    end
+  end
+end

data/lib/kaminari/models/array_extension.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/module'
+module Kaminari
+  # Kind of Array that can paginate
+  class PaginatableArray < Array
+    include Kaminari::ConfigurationMethods::ClassMethods
+
+    ENTRY = 'entry'.freeze
+
+    attr_internal_accessor :limit_value, :offset_value
+
+    # ==== Options
+    # * <tt>:limit</tt> - limit
+    # * <tt>:offset</tt> - offset
+    # * <tt>:total_count</tt> - total_count
+    # * <tt>:padding</tt> - padding
+    def initialize(original_array = [], limit: nil, offset: nil, total_count: nil, padding: nil)
+      @_original_array, @_limit_value, @_offset_value, @_total_count, @_padding = original_array, (limit || default_per_page).to_i, offset.to_i, total_count, padding.to_i
+
+      if limit && offset
+        extend Kaminari::PageScopeMethods
+      end
+
+      if @_total_count && (@_total_count <= original_array.count)
+        original_array = original_array.first(@_total_count)[@_offset_value, @_limit_value]
+      end
+
+      unless @_total_count
+        original_array = original_array[@_offset_value, @_limit_value]
+      end
+
+      super(original_array || [])
+    end
+
+    # Used for page_entry_info
+    def entry_name(options = {})
+      I18n.t('helpers.page_entries_info.entry', **options.reverse_merge(default: ENTRY.pluralize(options[:count])))
+    end
+
+    # items at the specified "page"
+    class_eval <<-RUBY, __FILE__, __LINE__ + 1
+      def #{Kaminari.config.page_method_name}(num = 1)
+        offset(limit_value * ((num = num.to_i - 1) < 0 ? 0 : num))
+      end
+    RUBY
+
+    # returns another chunk of the original array
+    def limit(num)
+      self.class.new @_original_array, limit: num, offset: @_offset_value, total_count: @_total_count, padding: @_padding
+    end
+
+    # total item numbers of the original array
+    def total_count
+      @_total_count || @_original_array.length
+    end
+
+    # returns another chunk of the original array
+    def offset(num)
+      self.class.new @_original_array, limit: @_limit_value, offset: num, total_count: @_total_count, padding: @_padding
+    end
+  end
+
+  # Wrap an Array object to make it paginatable
+  # ==== Options
+  # * <tt>:limit</tt> - limit
+  # * <tt>:offset</tt> - offset
+  # * <tt>:total_count</tt> - total_count
+  # * <tt>:padding</tt> - padding
+  def self.paginate_array(array, limit: nil, offset: nil, total_count: nil, padding: nil)
+    PaginatableArray.new array, limit: limit, offset: offset, total_count: total_count, padding: padding
+  end
+end