pagy 7.0.11 → 43.5.1

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../../modules/searcher'
+
+class Pagy
+  module ElasticsearchRailsPaginator
+    module_function
+
+    def paginate(search, options)
+      if search.is_a?(Search::Arguments)  # Active mode
+
+        Searcher.wrap(search, options) do
+          model, arguments, search_options = search
+
+          search_options[:size] = options[:limit]
+          search_options[:from] = options[:limit] * ((options[:page] || 1) - 1)
+
+          method          = options[:search_method] || ElasticsearchRails::DEFAULT[:search_method]
+          response_object = model.send(method, *arguments, **search_options)
+          options[:count] = total_count_from(response_object)
+
+          [ElasticsearchRails.new(**options), response_object]
+        end
+
+      else # Passive mode
+        from, size      = pagination_params_from(search)
+        options[:limit] = size
+        options[:page]  = ((from || 0) / options[:limit]) + 1
+        options[:count] = total_count_from(search)
+
+        ElasticsearchRails.new(**options)
+      end
+    end
+
+    # Support different versions of ElasticsearchRails
+    def pagination_params_from(response_object)
+      definition = response_object.search.definition
+      definition = definition.to_hash if definition.respond_to?(:to_hash)
+      container  = (definition.is_a?(Hash) && (definition[:body] || definition)) || response_object.search.options
+      from       = (container[:from] || container['from']).to_i
+      size       = (container[:size] || container['size']).to_i
+      size       = 10 if size.zero?
+
+      [from, size]
+    end
+
+    # Support different versions of ElasticsearchRails
+    def total_count_from(response_object)
+      total = response_object.instance_eval do
+                respond_to?(:response) ? response['hits']['total'] : raw_response['hits']['total']
+              end
+
+      total.is_a?(Hash) ? total['value'] : total
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative '../../../pagy/modules/b64'
+
+class Pagy
+  module KeynavJsPaginator
+    module_function
+
+    def paginate(set, options)
+      page = options[:request].resolve_page(force_integer: false) # allow nil
+
+      return CountlessPaginator.paginate(set, page:, **options) if page&.match(' ')  # countless fallback
+
+      if page.is_a?(String)  # keynav page param
+        page_arguments = JSON.parse(B64.urlsafe_decode(page))
+        # Restart the pagination from page 1/nil if the url has been requested from another browser
+        options[:page] = page_arguments if options[:request].cookie == page_arguments.shift
+      end
+
+      options[:limit] = options[:request].resolve_limit
+
+      pagy = Keyset::Keynav.new(set, **options)
+      [pagy, pagy.records]
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Pagy
+  module KeysetPaginator
+    module_function
+
+    def paginate(set, options)
+      options[:page] ||= options[:request].resolve_page(force_integer: false) # allow nil
+      options[:limit]  = options[:request].resolve_limit
+
+      pagy = Keyset.new(set, **options)
+      [pagy, pagy.records]
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../../modules/searcher'
+
+class Pagy
+  module MeilisearchPaginator
+    module_function
+
+    def paginate(search, options)
+      if search.is_a?(Search::Arguments) # Active mode
+
+        Searcher.wrap(search, options) do
+          model, arguments, search_options = search
+
+          search_options[:hits_per_page] = options[:limit]
+          search_options[:page]          = options[:page]
+
+          method          = options[:search_method] || Meilisearch::DEFAULT[:search_method]
+          results         = model.send(method, *arguments, search_options)
+          options[:count] = results.raw_answer['totalHits']
+
+          [Meilisearch.new(**options), results]
+        end
+
+      else # Passive mode
+        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

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../../classes/request'
+
+class Pagy
+  paginators = { offset:              :OffsetPaginator,
+                 countless:           :CountlessPaginator,
+                 countish:            :CountishPaginator,
+                 keyset:              :KeysetPaginator,
+                 keynav_js:           :KeynavJsPaginator,
+                 calendar:            :CalendarPaginator,
+                 elasticsearch_rails: :ElasticsearchRailsPaginator,
+                 meilisearch:         :MeilisearchPaginator,
+                 searchkick:          :SearchkickPaginator,
+                 typesense_rails:     :TypesenseRailsPaginator }.freeze
+
+  path = Pathname.new(__dir__)
+  paginators.each { |symbol, name| autoload name, path.join(symbol.to_s) }
+
+  # Pagy::Method defines the #pagy method to be included in the app controller/view.
+  Method = Module.new do
+             protected
+
+             define_method :pagy do |paginator = :offset, collection, **options|
+               arguments = if paginator == :calendar
+                             [self, collection, options]
+                           else
+                             [collection, options = Pagy::OPTIONS.merge(options)]
+                           end
+
+               options[:root_key]  = 'page' if options[:jsonapi] # enforce 'page' root_key for JSON:API
+               options[:request] ||= request                     # custom request Hash or self.request
+               options[:request]   = Request.new(options)        # Pagy::Request
+
+               Pagy.const_get(paginators[paginator]).paginate(*arguments)
+             end
+           end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../../modules/abilities/countable'
+
+class Pagy
+  module OffsetPaginator
+    module_function
+
+    def paginate(collection, options)
+      options[:page]  ||= options[:request].resolve_page
+      options[:limit]   = options[:request].resolve_limit
+      options[:count] ||= Countable.get_count(collection, options)
+
+      pagy    = Offset.new(**options)
+      records = if collection.instance_of?(Array)
+                  collection[pagy.offset, pagy.limit]
+                else
+                  pagy.records(collection)
+                end
+
+      [pagy, records]
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../../modules/searcher'
+
+class Pagy
+  module SearchkickPaginator
+    module_function
+
+    def paginate(search, options)
+      if search.is_a?(Search::Arguments) # Active mode
+
+        Searcher.wrap(search, options) do
+          model, arguments, search_options, block = search
+
+          search_options[:per_page] = options[:limit]
+          search_options[:page]     = options[:page]
+
+          method          = options[:search_method] || Searchkick::DEFAULT[:search_method]
+          results         = model.send(method, *arguments || '*', **search_options, &block)
+          options[:count] = results.total_count
+
+          [Searchkick.new(**options), results]
+        end
+
+      else # Passive mode
+        options[:limit] = search.respond_to?(:options) ? search.options[:per_page] : search.per_page
+        options[:page]  = search.respond_to?(:options) ? search.options[:page]     : search.current_page
+        options[:count] = search.total_count
+
+        Searchkick.new(**options)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../../modules/searcher'
+
+class Pagy
+  module TypesenseRailsPaginator
+    module_function
+
+    def paginate(search, options)
+      if search.is_a?(Search::Arguments) # Active mode
+
+        Searcher.wrap(search, options) do
+          model, arguments, search_options = search
+
+          search_options[:per_page] = options[:limit]
+          search_options[:page]     = options[:page]
+
+          method          = options[:search_method] || TypesenseRails::DEFAULT[:search_method]
+          results         = model.send(method, *arguments, search_options)
+          options[:count] = results.raw_answer['found']
+
+          [TypesenseRails.new(**options), results]
+        end
+
+      else # Passive mode
+        options[:limit] = search.raw_answer['request_params']['per_page']
+        options[:page]  = search.raw_answer['page']
+        options[:count] = search.raw_answer['found']
+
+        TypesenseRails.new(**options)
+      end
+    end
+  end
+end

data/lib/pagy.rb

@@ -1,151 +1,87 @@
-# See Pagy API documentation: https://ddnexus.github.io/pagy/docs/api/pagy
 # frozen_string_literal: true
 
 require 'pathname'
 
-# Core class
-class Pagy
-  VERSION = '7.0.11'
-
-  # Root pathname to get the path of Pagy files like templates or dictionaries
-  def self.root
-    @root ||= Pathname.new(__dir__).freeze
-  end
-
-  # Default core vars: constant for easy access, but mutable for customizable defaults
-  DEFAULT = { page:          1, # rubocop:disable Style/MutableConstant
-              items:         20,
-              outset:        0,
-              size:          7,
-              page_param:    :page,
-              params:        {},
-              fragment:      '',
-              link_extra:    '',
-              item_i18n_key: 'pagy.item_name',
-              nav_i18n_key: 'pagy.aria_label.nav',
-              cycle:         false,
-              request_path:  '',
-              count_args:    [:all] } # AR friendly
-
-  attr_reader :count, :page, :items, :vars, :pages, :last, :offset, :in, :from, :to, :prev, :next, :params, :request_path
-
-  # Merge and validate the options, do some simple arithmetic and set the instance variables
-  def initialize(vars)
-    normalize_vars(vars)
-    setup_vars(count: 0, page: 1, outset: 0)
-    setup_items_var
-    setup_pages_var
-    setup_offset_var
-    setup_params_var
-    setup_request_path_var
-    raise OverflowError.new(self, :page, "in 1..#{@last}", @page) if @page > @last
-
-    @from = [@offset - @outset + 1, @count].min
-    @to   = [@offset - @outset + @items, @count].min
-    @in   = [@to - @from + 1, @count].min
-    @prev = (@page - 1 unless @page == 1)
-    @next = @page == @last ? (1 if @vars[:cycle]) : @page + 1
-  end
-
-  # Return the array of page numbers and :gap items e.g. [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
-  def series(size: @vars[:size], **_)
-    series = []
-    if size.is_a?(Array) && size.size == 4 && size.all? { |num| !num.negative? rescue false } # rubocop:disable Style/RescueModifier
-      # This algorithm is up to ~5x faster and ~2.3x lighter than the previous one (pagy < 4.3)
-      left_gap_start  =     1 + size[0]
-      left_gap_end    = @page - size[1] - 1
-      right_gap_start = @page + size[2] + 1
-      right_gap_end   = @last - size[3]
-      left_gap_end    = right_gap_end  if left_gap_end   > right_gap_end
-      right_gap_start = left_gap_start if left_gap_start > right_gap_start
-      start           = 1
-      if (left_gap_end - left_gap_start).positive?
-        series.push(*start...left_gap_start, :gap)
-        start = left_gap_end + 1
-      end
-      if (right_gap_end - right_gap_start).positive?
-        series.push(*start...right_gap_start, :gap)
-        start = right_gap_end + 1
-      end
-      series.push(*start..@last)
-    elsif size.is_a?(Integer) && size.positive?    # only central series
-      # The simplest and fastest algorithm
-      size  = @pages if size > @pages              # reduce the max size to @pages
-      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 > @pages - (size - left) # end pages
-                @pages - size + 1
-              else                                 # intermediate pages
-                @page - left
-              end
-      series = (start..start + size - 1).to_a
-    else
-      return [] if size.empty?
-
-      raise VariableError.new(self, :size, 'to be a single positive Integer or an Array of 4', size)
-    end
-    series[series.index(@page)] = @page.to_s
-    series
-  end
-
-  # Label for any page. Allow the customization of the output (overridden by the calendar extra)
-  def label_for(page)
-    page.to_s
-  end
+require_relative 'pagy/classes/exceptions'
+require_relative 'pagy/modules/abilities/linkable'
+require_relative 'pagy/modules/abilities/configurable'
+require_relative 'pagy/toolbox/helpers/loaders'
 
-  # Label for the current page. Allow the customization of the output (overridden by the calendar extra)
-  def label
-    @page.to_s
-  end
+# Top superclass
+class Pagy
+  VERSION     = '43.5.1'
+  ROOT        = Pathname.new(__dir__).parent.freeze
+  DEFAULT     = { limit: 20, limit_key: 'limit', page_key: 'page' }.freeze
+  PAGE_TOKEN  = EscapedValue.new('P ')
+  LIMIT_TOKEN = EscapedValue.new('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 :TypesenseRails,     path.join('classes/offset/search')
+  autoload :Keyset,             path.join('classes/keyset/keyset')
+  autoload :SyncTask,           path.join('tasks/sync')
+
+  OPTIONS = {} # rubocop:disable Style/MutableConstant
+
+  extend Configurable
+  include Linkable
+  include HelperLoader
+
+  attr_reader :page, :next, :in, :limit, :options
 
   protected
 
-  # Apply defaults, cleanup blanks and set @vars
-  def normalize_vars(vars)
-    @vars = DEFAULT.merge(vars.delete_if { |k, v| DEFAULT.key?(k) && (v.nil? || v == '') })
-  end
+  # Instance 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
 
-  # Setup and validates the passed vars: var must be present and value.to_i must be >= to min
-  def setup_vars(name_min)
+  # Validate presence and min value of options
+  def assign_and_check(name_min)
     name_min.each do |name, min|
-      raise VariableError.new(self, name, ">= #{min}", @vars[name]) \
-            unless @vars[name]&.respond_to?(:to_i) && instance_variable_set(:"@#{name}", @vars[name].to_i) >= min
-    end
-  end
+      value = @options[name]
 
-  # Setup @items (overridden by the gearbox extra)
-  def setup_items_var
-    setup_vars(items: 1)
+      if value.respond_to?(:to_i) && (integer = value.to_i) >= min
+        instance_variable_set(:"@#{name}", integer)
+      else
+        raise OptionError.new(self, name, ">= #{min}", value)
+      end
+    end
   end
 
-  # Setup @pages and @last (overridden by the gearbox extra)
-  def setup_pages_var
-    @pages = @last = [(@count.to_f / @items).ceil, 1].max
-  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
 
-  # Setup @offset based on the :gearbox_items variable
-  def setup_offset_var
-    @offset = (@items * (@page - 1)) + @outset  # may be already set from gear_box
-  end
+    loop do
+      default = current::DEFAULT.merge(default)
+      current = current.superclass
+      break if current == Object
+    end
 
-  # Setup and validate @params
-  def setup_params_var
-    raise VariableError.new(self, :params, 'must be a Hash or a Proc', @params) \
-          unless (@params = @vars[:params]).is_a?(Hash) || @params.is_a?(Proc)
+    clean_options = options.delete_if { |k, v| default.key?(k) && (v.nil? || v == '') }
+    @options      = default.merge!(clean_options).freeze
   end
 
-  def setup_request_path_var
-    request_path = @vars[:request_path]
-    return if request_path.to_s.empty?
-
-    raise VariableError.new(self, :request_path, 'must be a bare path like "/foo"', request_path) \
-          if !request_path.start_with?('/') || request_path.include?('?')
-
-    @request_path = request_path
+  # Hook module for numeric UI helpers
+  module NumericHelpers
+    include NumericHelperLoader
   end
 end
 
-require 'pagy/backend'
-require 'pagy/frontend'
-require 'pagy/exceptions'
+require_relative ENV['PAGY_NEXT'] == 'true' ? 'pagy/next' : 'pagy/deprecated'

data/locales/ar.yml

@@ -0,0 +1,32 @@
+# See https://ddnexus.github.io/pagy/resources/i18n
+
+ar:
+  pagy:
+    p11n: 'Arabic'
+    aria_label:
+      nav:
+        zero: "لا يوجد صفحات"
+        one: "صفحة"
+        two: "صفحتين"
+        few: "صفحات"
+        many: "صفحات"
+        other: "صفحات"
+      previous: "السابق"
+      next: "التالي"
+    previous: "<"
+    next: ">"
+    gap: "…"
+    item_name:
+      zero: "صفر"
+      one: "عنصر"
+      two: "عنصرين"
+      few: "قليل"
+      many: "كثير"
+      other: "عناصر"
+    info_tag:
+      no_count: "الصفحة %{page} من %{pages}"
+      no_items: "لا يوجد %{item_name}"
+      single_page: "عرض %{count} %{item_name}"
+      multiple_pages: "عرض %{item_name} %{from}-%{to} من اجمالي %{count}"
+    input_nav_js: "الصفحة %{page_input} من %{pages}"
+    limit_tag_js: "عرض %{limit_input} %{item_name} لكل صفحة"

data/locales/be.yml

@@ -0,0 +1,28 @@
+# See https://ddnexus.github.io/pagy/resources/i18n
+
+be:
+  pagy:
+    p11n: 'EastSlavic'
+    aria_label:
+      nav:
+        one: "Старонка"
+        few: "Старонкi"
+        many: "Старонкi"
+        other: "Старонкi"
+      previous: "Назад"
+      next: "Наперад"
+    previous: "<"
+    next: ">"
+    gap: "…"
+    item_name:
+      one: "запіс"
+      few: "запісы"
+      many: "запісаў"
+      other: "запісаў"
+    info_tag:
+      no_count: "Старонка %{page} з %{pages}"
+      no_items: "Пакуль %{item_name} няма"
+      single_page: "%{count} %{item_name}"
+      multiple_pages: "Усяго %{count} %{item_name}, паказаны з %{from} па %{to}"
+    input_nav_js: "Старонка %{page_input} з %{pages}"
+    limit_tag_js: "Паказаць %{limit_input} %{item_name} на старонцы"

data/locales/bg.yml

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

data/locales/bs.yml

@@ -0,0 +1,28 @@
+# See https://ddnexus.github.io/pagy/resources/i18n
+
+bs:
+  pagy:
+    p11n: 'EastSlavic'
+    aria_label:
+      nav:
+        one: "Stranica"
+        few: "Stranice"
+        many: "Stranica"
+        other: "Stranice"
+      previous: "Prethodna"
+      next: "Sljedeća"
+    previous: "<"
+    next: ">"
+    gap: "…"
+    item_name:
+      one: "stavka"
+      few: "stavke"
+      many: "stavki"
+      other: "stavki"
+    info_tag:
+      no_count: "Stranica %{page} od %{pages}"
+      no_items: "Nije pronađena %{item_name}"
+      single_page: "Prikazuje se %{count} %{item_name}"
+      multiple_pages: "Prikaz %{item_name} %{from}-%{to} od %{count} ukupno"
+    input_nav_js: "Stranica %{page_input} od %{pages}"
+    limit_tag_js: "Prikaži %{limit_input} %{item_name} po stranici"

data/locales/ca.yml

@@ -0,0 +1,24 @@
+# See https://ddnexus.github.io/pagy/resources/i18n
+
+ca:
+  pagy:
+    p11n: 'OneOther'
+    aria_label:
+      nav:
+        one: "Pàgina"
+        other: "Pàgines"
+      previous: "Anterior"
+      next: "Següent"
+    previous: "<"
+    next: ">"
+    gap: "…"
+    item_name:
+      one: "element"
+      other: "elements"
+    info_tag:
+      no_count: "Pàgina %{page} de %{pages}"
+      no_items: "No s'ha trobat cap resultat"
+      single_page: "Mostrant %{count} %{item_name}"
+      multiple_pages: "Mostrant %{item_name} %{from}-%{to} de %{count} en total"
+    input_nav_js: "Pàgina %{page_input} de %{pages}"
+    limit_tag_js: "Mostra %{limit_input} %{item_name} per pàgina"

data/locales/ckb.yml

@@ -0,0 +1,20 @@
+# See https://ddnexus.github.io/pagy/resources/i18n
+
+ckb:
+  pagy:
+    p11n: 'Other'
+    item_name: "بابەت"
+    aria_label:
+      nav: "پەڕەکان"
+      previous: "پاش"
+      next: "پێش"
+    previous: "<"
+    next: ">"
+    gap: "…"
+    info_tag:
+      no_count: "پەڕی %{page} لە %{pages}"
+      no_items: "هیچ %{item_name}ێک نەدۆزرایەوە"
+      single_page: "پیشاندانی %{count} %{item_name}"
+      multiple_pages: "پشاندانی %{item_name}ی %{from}-%{to} لە کۆی %{count} بە گشتی"
+    input_nav_js: "پەڕی %{page_input} لە %{pages}"
+    limit_tag_js: "نیشاندانی %{limit_input} %{item_name} لە هەر پەڕێک"