pagy 7.0.11 → 43.5.1

data/lib/pagy/toolbox/helpers/bulma/series_nav.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative 'previous_next_html'
+require_relative '../support/wrap_series_nav'
+
+class Pagy
+  module NumericHelpers
+    private
+
+    def bulma_series_nav(classes: 'pagination', **)
+      a_lambda = a_lambda(**)
+
+      html = %(<ul class="pagination-list">#{bulma_html_for(:previous, a_lambda)})
+      series(**).each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
+        html << case item
+                when Integer
+                  %(<li>#{a_lambda.(item, page_label(item), classes: 'pagination-link')}</li>)
+                when String
+                  %(<li><a role="link" class="pagination-link is-current" aria-current="page" aria-disabled="true">#{
+                    page_label(item)}</a></li>)
+                when :gap
+                  %(<li><span class="pagination-ellipsis">#{I18n.translate('pagy.gap')}</span></li>)
+                else raise InternalError, "expected item types in series to be Integer, String or :gap; got #{item.inspect}"
+                end
+      end
+      html << %(#{bulma_html_for(:next, a_lambda)}</ul>)
+
+      wrap_series_nav(html, "pagy-bulma series-nav #{classes}", **)
+    end
+  end
+end

data/lib/pagy/toolbox/helpers/bulma/series_nav_js.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'previous_next_html'
+require_relative '../support/wrap_series_nav_js'
+
+class Pagy
+  module NumericHelpers
+    private
+
+    def bulma_series_nav_js(classes: 'pagination', **)
+      a_lambda = a_lambda(**)
+
+      tokens   = { before:  %(<ul class="pagination-list">#{bulma_html_for(:previous, a_lambda)}),
+                   anchor:  %(<li>#{a_lambda.(PAGE_TOKEN, LABEL_TOKEN, classes: 'pagination-link')}</li>),
+                   current: %(<li><a role="link" class="pagination-link is-current" ) +
+                            %(aria-current="page" aria-disabled="true">#{LABEL_TOKEN}</a></li>),
+                   gap:     %(<li><span class="pagination-ellipsis">#{I18n.translate('pagy.gap')}</span></li>),
+                   after:   %(#{bulma_html_for(:next, a_lambda)}</ul>) }
+
+      wrap_series_nav_js(tokens, "pagy-bulma series-nav-js #{classes}", **)
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Pagy
+  DEFAULT_DATA_KEYS = %i[url_template first_url previous_url current_url page_url next_url last_url
+                         count page limit last in from to previous next options].freeze
+
+  # Generate a hash of the wanted internal data
+  def data_hash(data_keys: @options[:data_keys] || DEFAULT_DATA_KEYS, **)
+    template = compose_page_url(PAGE_TOKEN, **)
+    to_url   = ->(page) { template.sub(PAGE_TOKEN, page.to_s) if page }
+
+    data_keys -= %i[count limit] if calendar?
+
+    data_keys.each_with_object({}) do |key, data|
+      value = case key
+              when :url_template           then template
+              when :first_url              then compose_page_url(nil, **)
+              when :previous_url           then to_url.(@previous)
+              when :current_url, :page_url then to_url.(@page)
+              when :next_url               then to_url.(@next)
+              when :last_url               then to_url.(@last)
+              else send(key)
+              end
+      data[key] = value if value
+    rescue NoMethodError
+      raise OptionError.new(self, :data_keys, 'to contain known keys/methods', key)
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'urls_hash'
+
+# Handle pagination response headers
+class Pagy
+  DEFAULT_HEADERS_MAP = { page:  'current-page',
+                          limit: 'page-limit',
+                          count: 'total-count',
+                          pages: 'total-pages' }.freeze
+
+  # Generate a hash of RFC-8288-compliant http headers
+  def headers_hash(headers_map: @options[:headers_map] || DEFAULT_HEADERS_MAP, **)
+    links = urls_hash(**, absolute: true).map { %(<#{_2}>; rel="#{_1}") }.join(', ')
+
+    headers_map.each_with_object('link' => links) do |(key, name), hash|
+      next unless name
+
+      value = case key
+              # :nocov:
+              when :page  then @page
+              when :limit then @limit unless calendar?
+              when :pages then @last  if @count
+              when :count then @count
+                # :nocov:
+              end
+      hash[name] = value.to_s if value
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Pagy
+  module NumericHelpers
+    # Instances with count return "Displaying items 41-60 of 324 in total" or "Displaying Products 41-60 of 324 in total".
+    # Instances with no count return only page info: "Page 3 of 100".
+    def info_tag(id: nil, item_name: nil)
+      i18n_key  = if @count.nil?
+                    'pagy.info_tag.no_count'
+                  elsif @count.zero?
+                    'pagy.info_tag.no_items'
+                  elsif @in == @count
+                    'pagy.info_tag.single_page'
+                  else
+                    'pagy.info_tag.multiple_pages'
+                  end
+
+      info_data = if @count.nil?
+                    { page: @page, pages: @last }
+                  else
+                    { item_name: item_name || I18n.translate('pagy.item_name', count: @count),
+                      count:     @count,
+                      from:      @from,
+                      to:        @to }
+                  end
+
+      %(<span#{%( id="#{id}") if id} class="pagy info">#{I18n.translate(i18n_key, **info_data)}</span>)
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'support/wrap_input_nav_js'
+
+class Pagy
+  module NumericHelpers
+    def input_nav_js(style = nil, **)
+      return send(:"#{style}_input_nav_js", **) if style && style.to_s != 'pagy'
+
+      a_lambda = a_lambda(**)
+
+      input = %(<input name="page" type="number" min="1" max="#{@last}" value="#{@page}" aria-current="page" ) +
+              %(style="text-align: center; width: #{@page.to_s.length + 1}rem; padding: 0;">#{A_TAG})
+
+      html  = %(#{previous_tag(a_lambda)}<label>#{
+                I18n.translate('pagy.input_nav_js', page_input: input, pages: @last)}</label>#{
+                next_tag(a_lambda)})
+
+      wrap_input_nav_js(html, 'pagy input-nav-js', **)
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'support/data_pagy_attribute'
+
+class Pagy
+  module NumericHelpers
+    def limit_tag_js(id: nil, item_name: nil, max_limit: @options[:max_limit], **)
+      raise OptionError.new(self, :max_limit, 'to be truthy', max_limit) unless max_limit
+
+      limit_input = %(<input name="limit" type="number" min="1" max="#{max_limit}" value="#{
+                      @limit}" style="padding: 0; text-align: center; width: #{@limit.to_s.length + 1}rem;">#{A_TAG})
+
+      url_token = compose_page_url(PAGE_TOKEN, limit: LIMIT_TOKEN)
+
+      %(<span#{%( id="#{id}") if id} class="pagy limit-tag-js" #{
+        data_pagy_attribute(:ltj, @from, url_token, PAGE_TOKEN, LIMIT_TOKEN)
+        }><label>#{
+        I18n.translate('pagy.limit_tag_js',
+                       item_name: item_name || I18n.translate('pagy.item_name', count: @limit),
+                       limit_input:,
+                       count: @limit)
+        }</label></span>)
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+class Pagy
+  # The aliaser defines loader methods and aliases them.
+  # When a method is called for the first time, its loader will load the full implementation,
+  # which will overwrite the alias and will be executed.
+  # Subsequent calls will run the full implementation directly.
+  aliaser = lambda do |receiver, paths|
+              receiver.instance_eval do
+                paths.each do |visibility, methods|
+                  methods.each do |method, path|
+                    loader_name = :"_pagy_loader_for_#{method}"
+                    define_method(loader_name) do |*args, **kwargs|
+                      # Tests shadow the usage of these lines
+                      # :nocov:
+                      require_relative path
+                      send(method, *args, **kwargs)
+                      # :nocov:
+                    end
+                    alias_method method, loader_name
+                    send(visibility, method)
+                  end
+                end
+              end
+            end
+
+  module HelperLoader
+  end
+
+  paths = { public: { page_url:     'page_url',
+                      data_hash:    'data_hash',
+                      headers_hash: 'headers_hash',
+                      urls_hash:    'urls_hash',
+                      next_tag:     'anchor_tags' } }.freeze
+
+  aliaser.(HelperLoader, paths)
+
+  module NumericHelperLoader
+  end
+
+  paths = { public:    { previous_tag:            'anchor_tags',
+                         input_nav_js:            'input_nav_js',
+                         info_tag:                'info_tag',
+                         limit_tag_js:            'limit_tag_js',
+                         series_nav:              'series_nav',
+                         series_nav_js:           'series_nav_js' },
+            protected: { bootstrap_series_nav:    'bootstrap/series_nav',
+                         bootstrap_series_nav_js: 'bootstrap/series_nav_js',
+                         bootstrap_input_nav_js:  'bootstrap/input_nav_js',
+                         bulma_series_nav:        'bulma/series_nav',
+                         bulma_series_nav_js:     'bulma/series_nav_js',
+                         bulma_input_nav_js:      'bulma/input_nav_js' } }.freeze
+
+  aliaser.(NumericHelperLoader, paths)
+end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Pagy
+  def page_url(page, **)
+    target = case page
+             when :first          then nil
+             when :current, :page then @page
+             when :previous       then @previous
+             when :next           then @next
+             when :last           then @last
+             else                      page
+             end
+
+    compose_page_url(target, **) if target || page == :first
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'support/wrap_series_nav'
+
+class Pagy
+  module NumericHelpers
+    def series_nav(style = nil, **)
+      return send(:"#{style}_series_nav", **) if style && style.to_s != 'pagy'
+
+      a_lambda = a_lambda(**)
+
+      html = previous_tag(a_lambda)
+      series(**).each do |item|   # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
+        html << case item
+                when Integer
+                  a_lambda.(item)
+                when String
+                  %(<a role="link" aria-disabled="true" aria-current="page">#{page_label(item)}</a>)
+                when :gap
+                  %(<a role="separator" aria-disabled="true">#{I18n.translate('pagy.gap')}</a>)
+                else
+                  raise InternalError, "expected item types in series to be Integer, String or :gap; got #{item.inspect}"
+                end
+      end
+      html << next_tag(a_lambda)
+
+      wrap_series_nav(html, 'pagy series-nav', **)
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'support/wrap_series_nav_js'
+
+class Pagy
+  module NumericHelpers
+    def series_nav_js(style = nil, **)
+      return send(:"#{style}_series_nav_js", **) if style && style.to_s != 'pagy'
+
+      a_lambda = a_lambda(**)
+      tokens   = { before:  previous_tag(a_lambda),
+                   anchor:  a_lambda.(PAGE_TOKEN, LABEL_TOKEN),
+                   current: %(<a role="link" aria-current="page" aria-disabled="true">#{LABEL_TOKEN}</a>),
+                   gap:     %(<a role="separator" aria-disabled="true">#{I18n.translate('pagy.gap')}</a>),
+                   after:   next_tag(a_lambda) }
+
+      wrap_series_nav_js(tokens, 'pagy series-nav-js', **)
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+class Pagy
+  protected
+
+  def page_label(page, **options)
+    return page.to_s unless calendar?
+
+    options[:format] ||= @options[:format]
+    localize(starting_time_for(page.to_i), **options)  # page could be a string
+  end
+
+  # Return a performance optimized lambda to generate the anchor tag.
+  # Benchmarked on a 20 link nav: it is ~22x faster and uses ~18x less memory than rails' link_to.
+  def a_lambda(anchor_string: @options[:anchor_string], **)
+    left, right = %(<a href="#{compose_page_url(PAGE_TOKEN, **)}"#{
+                    %( #{anchor_string}) if anchor_string}).split(PAGE_TOKEN, 2)
+
+    lambda do |page, text = page_label(page), classes: nil, aria_label: nil|
+      title = if calendar? && (counts = @options[:counts])
+                count    = counts[page - 1]
+                classes  = classes ? "#{classes} empty-page" : 'empty-page' if count.zero?
+                info_key = count.zero? ? 'pagy.info_tag.no_items' : 'pagy.info_tag.single_page'
+                %( title="#{I18n.translate(info_key, item_name: I18n.translate('pagy.item_name', count:), count:)}")
+              end
+
+      rel = case page
+            when @previous then %( rel="prev")
+            when @next     then %( rel="next")
+            end
+
+      %(#{left}#{page}#{right}#{title}#{
+        %( class="#{classes}") if classes}#{rel}#{%( aria-label="#{aria_label}") if aria_label}>#{text}</a>)
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative '../../../modules/b64'
+
+class Pagy
+  private
+
+  # Compose the data-pagy attribute, with the base64 encoded JSON-serialized args. Use the faster oj gem if defined.
+  def data_pagy_attribute(*args)
+    data = if defined?(Oj)
+             Oj.dump(args, mode: :compat)
+           else
+             JSON.dump(args)
+           end
+
+    %(data-pagy="#{B64.encode(data)}")
+  end
+end

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

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class Pagy
+  private
+
+  def nav_aria_label_attribute(aria_label: nil)
+    aria_label ||= I18n.translate('pagy.aria_label.nav', count: @last)
+    %(aria-label="#{aria_label}")
+  end
+end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class Pagy
+  SERIES_SLOTS = 7
+
+  protected
+
+  # The array of page numbers and :gap e.g. [1, :gap, 8, "9", 10, :gap, 36]
+  def series(slots: @options[:slots] || SERIES_SLOTS, compact: @options[:compact], **)
+    raise OptionError.new(self, :slots, 'to be an Integer >= 0', slots) unless slots.is_a?(Integer) && slots >= 0
+    return [] if slots.zero?
+
+    [].tap do |series|
+      if slots >= @last
+        series.push(*1..@last)
+      else
+        half  = (slots - 1) / 2                       # even slots makes the left half shorter by 1
+        start = if @page <= half                      # @page in the first half
+                  1
+                elsif @page > (@last - slots + half)  # @page in the last half
+                  @last - slots + 1
+                else                                  # @page in the middle
+                  @page - half
+                end
+        series.push(*(start...(start + slots)))
+        unless compact || slots < SERIES_SLOTS        # Set first, last and :gap when needed
+          series[0]  = 1
+          series[1]  = :gap unless series[1]  == 2
+          series[-2] = :gap unless series[-2] == @last - 1
+          series[-1] = @last
+        end
+      end
+      current = series.index(@page)
+      series[current] = @page.to_s if current
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative 'nav_aria_label_attribute'
+require_relative 'data_pagy_attribute'
+require_relative 'a_lambda' # inherited use
+
+class Pagy
+  private
+
+  # Common input_nav_js logic
+  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, **), 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
+
+class Pagy
+  private
+
+  # Common series_nav logic
+  def wrap_series_nav(html, nav_classes, id: nil, aria_label: nil, **)
+    data = %( #{data_pagy_attribute(:k, @update)}) if keynav?
+
+    %(<nav#{%( id="#{id}") if 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,42 @@
+# 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
+
+  # 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 the Calendar API
+  def page_labels(series)
+    return unless calendar?
+
+    series.map do |s|
+      s.map { _1 == :gap ? :gap : page_label(_1) }
+    end
+  end
+
+  # Common series_nav_js logic
+  def wrap_series_nav_js(tokens, nav_classes, id: nil, aria_label: nil, **)
+    sequels     = sequels(**)
+    nav_classes = "pagy-rjs #{nav_classes}" if sequels[0].size > 1
+
+    %(<nav#{%( id="#{id}") if id} class="#{nav_classes}" #{
+      nav_aria_label_attribute(aria_label:)} #{
+      data = [:snj, tokens.values, PAGE_TOKEN, sequels]
+      data.push(@update) if keynav?
+      data_pagy_attribute(*data)
+      }></nav>)
+  end
+end

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

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class Pagy
+  def urls_hash(**)
+    template = compose_page_url(PAGE_TOKEN, **)
+
+    { first:    compose_page_url(nil, **),
+      previous: @previous && template.sub(PAGE_TOKEN, @previous.to_s),
+      next:     @next     && template.sub(PAGE_TOKEN, @next.to_s),
+      last:     @count    && template.sub(PAGE_TOKEN, @last.to_s) }.compact
+  end
+end

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Pagy
+  module CalendarPaginator
+    module_function
+
+    # Take a collection and a config Hash and return [calendar, pagy, results]
+    def paginate(context, collection, config)
+      context.instance_eval do
+        allowed_options = Calendar::UNITS + %i[offset disabled request]
+
+        unless config.is_a?(Hash) && (config.keys - allowed_options).empty?
+          raise ArgumentError, "keys must be in #{allowed_options.inspect}"
+        end
+
+        config[:offset] ||= {}
+
+        unless config[:disabled]
+          period = pagy_calendar_period(collection)
+          params = config[:request].params
+
+          calendar, from, to = Calendar.send(:init, config, period, params) do |unit, unit_period|
+                                 pagy_calendar_counts(collection, unit, *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/countish.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../../modules/abilities/countable'
+
+class Pagy
+  module CountishPaginator
+    module_function
+
+    def paginate(collection, options)
+      options[:page] ||= options[:request].resolve_page(force_integer: false)
+
+      if options[:page].is_a?(String)
+        page, count, epoch = options[:page].split.map(&:to_i)
+        options[:page]     = page
+      end
+
+      options[:limit] = options[:request].resolve_limit
+      setup_options(count, epoch, collection, options)
+
+      pagy = Offset::Countish.new(**options)
+      [pagy, pagy.records(collection)]
+    end
+
+    # Get the count from the page and set epoch when ttl (Time To Live) requires it
+    def setup_options(count, epoch, collection, options)
+      now     = Time.now.to_i
+      ongoing = !options[:ttl] || (epoch && epoch <= now && now < (epoch + options[:ttl]))
+
+      if !options[:count] && count && ongoing
+        options[:count] = count
+        options[:epoch] = epoch if options[:ttl]
+      else # recount
+        options[:count] ||= Countable.get_count(collection, options)
+        options[:epoch]   = now if options[:ttl]
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Pagy
+  module CountlessPaginator
+    module_function
+
+    def paginate(collection, options)
+      options[:page] ||= options[:request].resolve_page(force_integer: false) # accept nil and strings
+
+      if options[:page].is_a?(String)
+        page, last     = options[:page].split.map(&:to_i) # ' ' separator, (encoded as '+' by Countless#compose_page_param)
+        options[:page] = page
+        options[:last] = last if last&.positive?
+      end
+
+      options[:limit] = options[:request].resolve_limit
+
+      pagy = Offset::Countless.new(**options)
+      [pagy, pagy.records(collection)]
+    end
+  end
+end