pagy 9.3.4 → 43.0.0.rc1

data/lib/pagy/toolbox/helpers/support/wrap_input_nav_js.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'nav_aria_label_attribute'
+require_relative 'data_pagy_attribute'
+require_relative 'a_lambda' # inherited use
+
+# Relegate internal functions. Make overriding navs easier.
+class Pagy
+  private
+
+  # Build the input_nav_js tag, with the specific inner html for the style
+  def wrap_input_nav_js(html, nav_classes, id: nil, aria_label: nil, **)
+    %(<nav#{%( id="#{id}") if id} class="#{nav_classes}" #{
+      nav_aria_label_attribute(aria_label:)} #{
+      data = [:inj, compose_page_url(PAGE_TOKEN, **)]
+      data.push(@update) if keynav?
+      data_pagy_attribute(*data)
+      }>#{html}</nav>)
+  end
+end

data/lib/pagy/toolbox/helpers/support/wrap_series_nav.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative 'series'
+require_relative 'nav_aria_label_attribute'
+require_relative 'data_pagy_attribute'
+require_relative 'a_lambda' # inherited use
+
+# Relegate internal functions. Make overriding navs easier.
+class Pagy
+  private
+
+  # Build the nav tag, with the specific inner html for the style
+  def wrap_series_nav(html, nav_classes, id: nil, aria_label: nil, **)
+    data = %( #{data_pagy_attribute(:k, @update)}) if keynav?
+    %(<nav#{id && %( id="#{id}")} class="#{nav_classes}" #{nav_aria_label_attribute(aria_label:)}#{data}>#{html}</nav>)
+  end
+end

data/lib/pagy/toolbox/helpers/support/wrap_series_nav_js.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'series'
+require_relative 'nav_aria_label_attribute'
+require_relative 'data_pagy_attribute'
+require_relative 'a_lambda' # inherited use
+
+# Relegate internal functions. Make overriding navs easier.
+class Pagy
+  private
+
+  # Return the reverse sorted array of widths, series, and labels generated from the :steps hash
+  # If :steps is false it will use the single {0 => @options[:slots]} length
+  def sequels(steps: @options[:steps] || { 0 => @options[:slots] || SERIES_SLOTS }, **)
+    raise OptionError.new(self, :steps, 'to define the 0 width', steps) unless steps.key?(0)
+
+    widths, series = steps.sort.reverse.map { |width, slots| [width, series(slots:)] }.transpose
+    [widths, series, page_labels(series)]
+  end
+
+  # Support for the Calendar API
+  def page_labels(series)
+    series.map { |s| s.map { |item| item == :gap ? :gap : page_label(item) } } if calendar?
+  end
+
+  # Build the nav_js tag, with the specific tokens for the style
+  def wrap_series_nav_js(tokens, nav_classes, id: nil, aria_label: nil, **)
+    sequels = sequels(**)
+    %(<nav#{id && %( id="#{id}")} class="#{'pagy-rjs ' if sequels[0].size > 1}#{nav_classes}" #{
+      nav_aria_label_attribute(aria_label:)} #{
+      data = [:snj, tokens.values, sequels]
+      data.push(@update) if keynav?
+      data_pagy_attribute(*data)
+      }></nav>)
+  end
+end

data/lib/pagy/toolbox/helpers/urls_hash.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Pagy
+  # Generte  hash of the pagination links
+  def urls_hash(**)
+    url = compose_page_url(PAGE_TOKEN, **)
+    { first: compose_page_url(nil, **) }.tap do |urls| # first is present, but the URL omits the nil page param
+      urls[:previous] = url.sub(PAGE_TOKEN, @previous.to_s) if @previous
+      urls[:next]     = url.sub(PAGE_TOKEN, @next.to_s)     if @next
+      urls[:last]     = url.sub(PAGE_TOKEN, @last.to_s)     if @count # offset and not countless
+    end
+  end
+end

data/lib/pagy/toolbox/paginators/calendar.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Pagy
+  module CalendarPaginator
+    module_function
+
+    # Take a collection and a configuration Hash and return an array with 3 items: [calendar, pagy, results]
+    def paginate(context, collection, config)
+      context.instance_eval do
+        allowed_options = Calendar::UNITS + %i[offset disabled request]
+        raise ArgumentError, "keys must be in #{allowed_options.inspect}" \
+              unless config.is_a?(Hash) && (config.keys - allowed_options).empty?
+
+        config[:request]  = Request.new(config[:request] || request)
+        config[:offset] ||= {}
+        unless config[:disabled]
+          calendar, from, to =
+            Calendar.send(:init, config,
+                          pagy_calendar_period(collection),
+                          config[:request].query) do |unit, period|
+              pagy_calendar_counts(collection, unit, *period) if respond_to?(:pagy_calendar_counts)
+            end
+          collection = pagy_calendar_filter(collection, from, to)
+        end
+        pagy, records = pagy(:offset, collection, **config[:offset])
+        [calendar, pagy, records]
+      end
+    end
+  end
+end

data/lib/pagy/toolbox/paginators/countless.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class Pagy
+  module CountlessPaginator
+    module_function
+
+    # Return Pagy object and records
+    def paginate(context, collection, **options)
+      context.instance_eval do
+        request = Request.new(options[:request] || self.request, options)
+        if options[:page].nil?
+          page = request.resolve_page(options, force_integer: false) # accept nil and strings
+          if page.is_a?(String)
+            p, l = page.split(/ /, 2).map(&:to_i)
+            options[:page] = p if p.positive?
+            options[:last] = l if l&.positive?
+          end
+        end
+        options[:limit] = request.resolve_limit(options)
+        pagy = Offset::Countless.new(**options, request:)
+        [pagy, pagy.records(collection)]
+      end
+    end
+  end
+end

data/lib/pagy/toolbox/paginators/elasticsearch_rails.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../modules/searcher'
+
+class Pagy
+  module ElasticsearchRailsPaginator
+    module_function
+
+    # Paginate from search object
+    def paginate(context, search, **options)
+      context.instance_eval do
+        if search.is_a?(Search::Arguments)
+          # The search is the array of pagy_search arguments
+          Searcher.wrap(self, search, options) do
+            model, query_or_payload, search_options = search
+            search_options[:size] = options[:limit]
+            search_options[:from] = options[:limit] * ((options[:page] || 1) - 1)
+            results               = model.send(ElasticsearchRails::DEFAULT[:search_method], query_or_payload, **search_options)
+            options[:count]       = ElasticsearchRails.total_count(results)
+            [ElasticsearchRails.new(**options), results]
+          end
+        else
+          # The search is an elasticsearch_rails response
+          options[:limit] = search.search.options[:size] || 10
+          options[:page]  = ((search.search.options[:from] || 0) / options[:limit]) + 1
+          options[:count] = ElasticsearchRails.total_count(search)
+          ElasticsearchRails.new(**options)
+        end
+      end
+    end
+  end
+end

data/lib/pagy/toolbox/paginators/keynav_js.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require_relative '../../../pagy/modules/b64'
+
+class Pagy
+  module KeynavJsPaginator
+    module_function
+
+    # Return Pagy::Keyset::Keynav object and paginated records.
+    # Fall back to :countless if the :page has no client data.
+    def paginate(context, set, **options)
+      context.instance_eval do
+        request = Request.new(options[:request] || self.request, options)
+        page    = request.resolve_page(options, force_integer: false) # allow nil
+        if page&.match(' ')       # countless page -> no augmentation -> fallback
+          return pagy(:countless, set, page:, **options)
+        elsif page.is_a?(String)  # keynav page param
+          page_arguments = JSON.parse(B64.urlsafe_decode(page))
+          # Restart the pagination from page 1 if the url has been requested from another browser
+          options[:page] = page_arguments if request.cookie == page_arguments.shift
+        end
+
+        options[:limit] = request.resolve_limit(options)
+        pagy = Keyset::Keynav.new(set, **options, request:)
+        [pagy, pagy.records]
+      end
+    end
+  end
+end

data/lib/pagy/toolbox/paginators/keyset.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+class Pagy
+  module KeysetPaginator
+    module_function
+
+    # Return Pagy::Keyset object and paginated records
+    def paginate(context, set, **options)
+      context.instance_eval do
+        request = Request.new(options[:request] || self.request, options)
+        options[:page] ||= request.resolve_page(options, force_integer: false) # allow nil
+        options[:limit]  = request.resolve_limit(options)
+        pagy = Keyset.new(set, **options, request:)
+        [pagy, pagy.records]
+      end
+    end
+  end
+end

data/lib/pagy/toolbox/paginators/meilisearch.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../modules/searcher'
+
+class Pagy
+  module MeilisearchPaginator
+    module_function
+
+    # Paginate from search object
+    def paginate(context, search, **options)
+      context.instance_eval do
+        if search.is_a?(Search::Arguments)
+          # The search is the array of pagy_search arguments
+          Searcher.wrap(self, search, options) do
+            model, term, search_options    = search
+            search_options[:hits_per_page] = options[:limit]
+            search_options[:page]          = options[:page]
+            results                        = model.send(Meilisearch::DEFAULT[:search_method], term, search_options)
+            options[:count]                = results.raw_answer['totalHits']
+            [Meilisearch.new(**options), results]
+          end
+        else
+          # The search is a meilisearch results object
+          options[:limit] = search.raw_answer['hitsPerPage']
+          options[:page]  = search.raw_answer['page']
+          options[:count] = search.raw_answer['totalHits']
+          Meilisearch.new(**options)
+        end
+      end
+    end
+  end
+end

data/lib/pagy/toolbox/paginators/method.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../../classes/request'
+
+class Pagy
+  paginators = { offset:              :OffsetPaginator,
+                 countless:           :CountlessPaginator,
+                 keyset:              :KeysetPaginator,
+                 keynav_js:           :KeynavJsPaginator,
+                 calendar:            :CalendarPaginator,
+                 elasticsearch_rails: :ElasticsearchRailsPaginator,
+                 meilisearch:         :MeilisearchPaginator,
+                 searchkick:          :SearchkickPaginator }.freeze
+
+  path = Pathname.new(__dir__)
+  paginators.each { |symbol, name| autoload name, path.join(symbol.to_s) }
+
+  # Defines the pagy method. Include in the app controller/view.
+  Method = Module.new do
+             protected
+
+             define_method :pagy do |paginator = :offset, collection, **options|
+               Pagy.const_get(paginators[paginator]).paginate(self, collection, **Pagy.options, **options)
+             end
+           end
+end

data/lib/pagy/toolbox/paginators/offset.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Pagy
+  module OffsetPaginator
+    module_function
+
+    # Return instance and page of results
+    def paginate(context, collection, **options)
+      context.instance_eval do
+        request = Request.new(options[:request] || self.request, options)
+        options[:page]  ||= request.resolve_page(options)
+        options[:limit]   = request.resolve_limit(options)
+        options[:count] ||= collection.instance_of?(Array) ? collection.size : OffsetPaginator.get_count(collection, options)
+        pagy = Offset.new(**options, request:)
+        [pagy, collection.instance_of?(Array) ? collection[pagy.offset, pagy.limit] : pagy.records(collection)]
+      end
+    end
+
+    # Get the collection count
+    def get_count(collection, options)
+      return collection.count unless defined?(::ActiveRecord) && collection.is_a?(::ActiveRecord::Relation)
+
+      count = if options[:count_over] && !collection.group_values.empty?
+                # COUNT(*) OVER ()
+                sql = Arel.star.count.over(Arel::Nodes::Grouping.new([]))
+                collection.unscope(:order).pick(sql).to_i
+              else
+                collection.count(:all)
+              end
+      count.is_a?(Hash) ? count.size : count
+    end
+  end
+end

data/lib/pagy/toolbox/paginators/searchkick.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative '../../modules/searcher'
+
+class Pagy
+  module SearchkickPaginator
+    module_function
+
+    # Paginate from search object.
+    def paginate(context, search, **options)
+      context.instance_eval do
+        if search.is_a?(Search::Arguments)
+          # The search is the array of pagy_search arguments
+          Searcher.wrap(self, search, options) do
+            model, term, search_options, block = search
+            search_options[:per_page] = options[:limit]
+            search_options[:page]     = options[:page]
+            results                   = model.send(Searchkick::DEFAULT[:search_method], term || '*', **search_options, &block)
+            options[:count]           = results.total_count
+            [Searchkick.new(**options), results]
+          end
+        else
+          # The search is a searchkick results object
+          options[:limit] = search.options[:per_page]
+          options[:page]  = search.options[:page]
+          options[:count] = search.total_count
+          Searchkick.new(**options)
+        end
+      end
+    end
+  end
+end

data/lib/pagy.rb

@@ -1,106 +1,68 @@
-# See Pagy API documentation: https://ddnexus.github.io/pagy/docs/api/pagy
 # frozen_string_literal: true
 
 require 'pathname'
-require_relative 'pagy/shared_methods'
+require_relative 'pagy/classes/exceptions'
+require_relative 'pagy/modules/abilities/linkable'
+require_relative 'pagy/modules/abilities/configurable'
+require_relative 'pagy/toolbox/helpers/loader'
 
-# Top superclass: it should define only what's common to all the subclasses
+# Top superclass: it defines only what's common to all the subclasses
 class Pagy
-  VERSION = '9.3.4'
-
-  # Core default: constant for easy access, but mutable for customizable defaults
-  DEFAULT = { count_args: [:all], # rubocop:disable Style/MutableConstant
-              ends:       true,
-              limit:      20,
-              outset:     0,
-              page:       1,
-              page_param: :page,
-              size:       7 }  # AR friendly
-
-  # Gem root pathname to get the path of Pagy files stylesheets, javascripts, apps, locales, etc.
-  def self.root
-    @root ||= Pathname.new(__dir__).parent.freeze
-  end
-
-  include SharedMethods
-
-  attr_reader :count, :from, :in, :last, :next, :offset, :prev, :to
-  alias pages last
-
-  # Merge and validate the options, do some simple arithmetic and set the instance variables
-  def initialize(**vars)
-    assign_vars(DEFAULT, vars)
-    assign_and_check(count: 0, page: 1, outset: 0)
-    assign_limit
-    assign_offset
-    assign_last
-    check_overflow
-    @from = [@offset - @outset + 1, @count].min
-    @to   = [@offset - @outset + @limit, @count].min
-    @in   = [@to - @from + 1, @count].min
-    assign_prev_and_next
-  end
-
-  # Setup @last (overridden by the gearbox extra)
-  def assign_last
-    @last = [(@count.to_f / @limit).ceil, 1].max
-    @last = @vars[:max_pages] if @vars[:max_pages] && @last > vars[:max_pages]
-  end
-
-  # Assign @offset (overridden by the gearbox extra)
-  def assign_offset
-    @offset = (@limit * (@page - 1)) + @outset  # may be already set from gear_box
-  end
-
-  # Assign @prev and @next
-  def assign_prev_and_next
-    @prev = (@page - 1 unless @page == 1)
-    @next = @page == @last ? (1 if @vars[:cycle]) : @page + 1
-  end
-
-  # Checks the @page <= @last
-  def check_overflow
-    raise OverflowError.new(self, :page, "in 1..#{@last}", @page) if @page > @last
+  VERSION     = '43.0.0.rc1'
+  ROOT        = Pathname.new(__dir__).parent.freeze
+  DEFAULT     = { limit: 20, limit_key: 'limit', page_key: 'page' }.freeze
+  PAGE_TOKEN  = 'P '
+  LIMIT_TOKEN = 'L '
+  LABEL_TOKEN = 'L'
+  A_TAG       = '<a style="display: none;">#</a>'
+
+  path = Pathname.new(__FILE__).sub_ext('')
+  autoload :Method,             path.join('toolbox/paginators/method')
+  autoload :I18n,               path.join('modules/i18n/i18n')
+  autoload :Console,            path.join('modules/console')
+  autoload :Calendar,           path.join('classes/calendar/calendar')
+  autoload :Offset,             path.join('classes/offset/offset')
+  autoload :Search,             path.join('classes/offset/search')
+  autoload :ElasticsearchRails, path.join('classes/offset/search')
+  autoload :Meilisearch,        path.join('classes/offset/search')
+  autoload :Searchkick,         path.join('classes/offset/search')
+  autoload :Keyset,             path.join('classes/keyset/keyset')
+
+  def self.options = @options ||= {}
+
+  extend Configurable
+  include Linkable
+  include Loader
+
+  attr_reader :page, :next, :in, :limit, :options
+
+  protected
+
+  # Define the hierarchical identity methods, overridden by the respective classes
+  def offset?    = false
+  def countless? = false
+  def calendar?  = false
+  def search?    = false
+  def keyset?    = false
+  def keynav?    = false
+
+  # Validates and assign the passed options: var must be present and value.to_i must be >= to min
+  def assign_and_check(name_min)
+    name_min.each do |name, min|
+      raise OptionError.new(self, name, ">= #{min}", @options[name]) \
+            unless @options[name].respond_to?(:to_i) && instance_variable_set(:"@#{name}", @options[name].to_i) >= min
+    end
   end
 
-  # Label for the current page. Allow the customization of the output (overridden by the calendar extra)
-  def label = @page.to_s
-
-  # Label for any page. Allow the customization of the output (overridden by the calendar extra)
-  def label_for(page) = page.to_s
-
-  # Return the array of page numbers and :gap e.g. [1, :gap, 8, "9", 10, :gap, 36]
-  def series(size: @vars[:size], **_)
-    raise VariableError.new(self, :size, 'to be an Integer >= 0', size) \
-    unless size.is_a?(Integer) && size >= 0
-    return [] if size.zero?
-
-    [].tap do |series|
-      if size >= @last
-        series.push(*1..@last)
-      else
-        left  = ((size - 1) / 2.0).floor             # left half might be 1 page shorter for even size
-        start = if @page <= left                     # beginning pages
-                  1
-                elsif @page > (@last - size + left)  # end pages
-                  @last - size + 1
-                else                                 # intermediate pages
-                  @page - left
-                end
-        series.push(*start...start + size)
-        # Set first and last pages plus gaps when needed, respecting the size
-        if vars[:ends] && size >= 7
-          series[0]  = 1
-          series[1]  = :gap  unless series[1]  == 2
-          series[-2] = :gap  unless series[-2] == @last - 1
-          series[-1] = @last
-        end
-      end
-      series[series.index(@page)] = @page.to_s
-    end
+  # Merge all the DEFAULT constants of the class hierarchy with the options
+  def assign_options(**options)
+    @request = options.delete(:request) # internal object
+    default  = {}
+    current  = self.class
+    begin
+      default = current::DEFAULT.merge(default)
+      current = current.superclass
+    end until current == Object  # rubocop:disable Lint/Loop  -- see https://github.com/rubocop/rubocop-performance/issues/362
+    @options = default.merge!(options.delete_if { |k, v| default.key?(k) && (v.nil? || v == '') }).freeze
   end
 end
-
-require_relative 'pagy/backend'
-require_relative 'pagy/frontend'
-require_relative 'pagy/exceptions'

data/locales/ar.yml

@@ -1,6 +1,8 @@
-# :arabic pluralization (see https://github.com/ddnexus/pagy/blob/master/gem/lib/pagy/i18n.rb)
+# See https://ddnexus.github.io/pagy/resources/i18n
+
 ar:
   pagy:
+    p11n: 'Arabic'
     aria_label:
       nav:
         zero: "لا يوجد صفحات"
@@ -9,9 +11,9 @@ ar:
         few: "صفحات"
         many: "صفحات"
         other: "صفحات"
-      prev: "السابق"
+      previous: "السابق"
       next: "التالي"
-    prev: "<"
+    previous: "<"
     next: ">"
     gap: "…"
     item_name:
@@ -21,9 +23,10 @@ ar:
       few: "قليل"
       many: "كثير"
       other: "عناصر"
-    info:
+    info_tag:
+      no_count: "الصفحة %{page} من %{pages}"
       no_items: "لا يوجد %{item_name}"
       single_page: "عرض %{count} %{item_name}"
       multiple_pages: "عرض %{item_name} %{from}-%{to} من اجمالي %{count}"
-    combo_nav_js: "الصفحة %{page_input} من %{pages}"
-    limit_selector_js: "عرض %{limit_input} %{item_name} لكل صفحة"
+    input_nav_js: "الصفحة %{page_input} من %{pages}"
+    limit_tag_js: "عرض %{limit_input} %{item_name} لكل صفحة"

data/locales/be.yml

@@ -1,15 +1,17 @@
-# :east_slavic pluralization (see https://github.com/ddnexus/pagy/blob/master/gem/lib/pagy/i18n.rb)
+# See https://ddnexus.github.io/pagy/resources/i18n
+
 be:
   pagy:
+    p11n: 'EastSlavic'
     aria_label:
       nav:
         one: "Старонка"
         few: "Старонкi"
         many: "Старонкi"
         other: "Старонкi"
-      prev: "Назад"
+      previous: "Назад"
       next: "Наперад"
-    prev: "<"
+    previous: "<"
     next: ">"
     gap: "…"
     item_name:
@@ -17,9 +19,10 @@ be:
       few: "запісы"
       many: "запісаў"
       other: "запісаў"
-    info:
+    info_tag:
+      no_count: "Старонка %{page} з %{pages}"
       no_items: "Пакуль %{item_name} няма"
       single_page: "%{count} %{item_name}"
       multiple_pages: "Усяго %{count} %{item_name}, паказаны з %{from} па %{to}"
-    combo_nav_js: "Старонка %{page_input} з %{pages}"
-    limit_selector_js: "Паказаць %{limit_input} %{item_name} на старонцы"
+    input_nav_js: "Старонка %{page_input} з %{pages}"
+    limit_tag_js: "Паказаць %{limit_input} %{item_name} на старонцы"

data/locales/bg.yml

@@ -1,21 +1,24 @@
-# :one_other pluralization (see https://github.com/ddnexus/pagy/blob/master/gem/lib/pagy/i18n.rb)
+# See https://ddnexus.github.io/pagy/resources/i18n
+
 bg:
   pagy:
+    p11n: 'OneOther'
     aria_label:
       nav:
         one: "Страница"
         other: "Страници"
-      prev: "Предишна"
+      previous: "Предишна"
       next: "Следваща"
-    prev: "<"
+    previous: "<"
     next: ">"
     gap: "…"
     item_name:
       one: "резултат"
       other: "резултати"
-    info:
+    info_tag:
+      no_count: "Страница %{page} от %{pages}"
       no_items: "Няма намерени %{item_name}"
       single_page: "Показани са %{count} %{item_name}"
       multiple_pages: "Показани са %{item_name} %{from}-%{to} от %{count} общо"
-    combo_nav_js: "Страница %{page_input} от %{pages}"
-    limit_selector_js: "Покажи %{limit_input} %{item_name} на страница"
+    input_nav_js: "Страница %{page_input} от %{pages}"
+    limit_tag_js: "Покажи %{limit_input} %{item_name} на страница"