pagy 3.10.0 → 5.7.3

data/lib/pagy/frontend.rb

@@ -1,75 +1,83 @@
 # See Pagy::Frontend API documentation: https://ddnexus.github.io/pagy/api/frontend
-# encoding: utf-8
 # frozen_string_literal: true
 
-require 'yaml'
+require 'pagy/url_helpers'
+require 'pagy/i18n'
 
 class Pagy
+  # Used for search and replace, hardcoded also in the pagy.js file
+  PAGE_PLACEHOLDER  = '__pagy_page__'
+  LABEL_PLACEHOLDER = '__pagy_label__'
 
-  PAGE_PLACEHOLDER  = '__pagy_page__'  # string used for search and replace, hardcoded also in the pagy.js file
-
-  # I18n static hash loaded at startup, used as default alternative to the i18n gem.
-  # see https://ddnexus.github.io/pagy/api/frontend#i18n
-  I18n = eval(Pagy.root.join('locales', 'utils', 'i18n.rb').read) #rubocop:disable Security/Eval
-
-  module Helpers
-    # This works with all Rack-based frameworks (Sinatra, Padrino, Rails, ...)
-    def pagy_url_for(page, pagy, url=false)
-      p_vars = pagy.vars; params = request.GET.merge(p_vars[:params]); params[p_vars[:page_param].to_s] = page
-      "#{request.base_url if url}#{request.path}?#{Rack::Utils.build_nested_query(pagy_get_params(params))}#{p_vars[:anchor]}"
-    end
-
-    # Sub-method called only by #pagy_url_for: here for easy customization of params by overriding
-    def pagy_get_params(params) params end
-  end
-
-  # All the code here has been optimized for performance: it may not look very pretty
-  # (as most code dealing with many long strings), but its performance makes it very sexy! ;)
+  # Frontend modules are specially optimized for performance.
+  # The resulting code may not look very elegant, but produces the best benchmarks
   module Frontend
-
-    include Helpers
-
-    EMPTY = ''               # EMPTY + 'string' is almost as fast as +'string' but is also 1.9 compatible
-    MARK  = PAGE_PLACEHOLDER # backward compatibility in case of helper-overriding in legacy apps
+    include UrlHelpers
 
     # Generic pagination: it returns the html with the series of links to the pages
-    def pagy_nav(pagy)
-      link, p_prev, p_next = pagy_link_proc(pagy), pagy.prev, pagy.next
+    def pagy_nav(pagy, pagy_id: nil, link_extra: '', **vars)
+      p_id   = %( id="#{pagy_id}") if pagy_id
+      link   = pagy_link_proc(pagy, link_extra: link_extra)
+      p_prev = pagy.prev
+      p_next = pagy.next
 
-      html = EMPTY + (p_prev ? %(<span class="page prev">#{link.call p_prev, pagy_t('pagy.nav.prev'), 'aria-label="previous"'}</span> )
-                             : %(<span class="page prev disabled">#{pagy_t('pagy.nav.prev')}</span> ))
-      pagy.series.each do |item|  # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
-        html << if    item.is_a?(Integer); %(<span class="page">#{link.call item}</span> )               # page link
-                elsif item.is_a?(String) ; %(<span class="page active">#{item}</span> )                  # current page
-                elsif item == :gap       ; %(<span class="page gap">#{pagy_t('pagy.nav.gap')}</span> )   # page gap
+      html = +%(<nav#{p_id} class="pagy-nav pagination" aria-label="pager">)
+      html << if p_prev
+                %(<span class="page prev">#{link.call p_prev, pagy_t('pagy.nav.prev'), 'aria-label="previous"'}</span> )
+              else
+                %(<span class="page prev disabled">#{pagy_t('pagy.nav.prev')}</span> )
+              end
+      pagy.series(**vars).each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
+        html << case item
+                when Integer then %(<span class="page">#{link.call item}</span> )
+                when String  then %(<span class="page active">#{pagy.label_for(item)}</span> )
+                when :gap    then %(<span class="page gap">#{pagy_t('pagy.nav.gap')}</span> )
+                else raise InternalError, "expected item types in series to be Integer, String or :gap; got #{item.inspect}"
                 end
       end
-      html << (p_next ? %(<span class="page next">#{link.call p_next, pagy_t('pagy.nav.next'), 'aria-label="next"'}</span>)
-                      : %(<span class="page next disabled">#{pagy_t('pagy.nav.next')}</span>))
-      %(<nav class="pagy-nav pagination" role="navigation" aria-label="pager">#{html}</nav>)
+      html << if p_next
+                %(<span class="page next">#{link.call p_next, pagy_t('pagy.nav.next'), 'aria-label="next"'}</span>)
+              else
+                %(<span class="page next disabled">#{pagy_t('pagy.nav.next')}</span>)
+              end
+      html << %(</nav>)
     end
 
-    # Return examples: "Displaying items 41-60 of 324 in total" of "Displaying Products 41-60 of 324 in total"
-    def pagy_info(pagy, item_name=nil)
-      path = if (count = pagy.count) == 0 ; 'pagy.info.no_items'
-             else pagy.pages == 1 ? 'pagy.info.single_page' : 'pagy.info.multiple_pages'
-             end
-      pagy_t(path, item_name: item_name || pagy_t(pagy.vars[:i18n_key], count: count), count: count, from: pagy.from, to: pagy.to)
+    # Return examples: "Displaying items 41-60 of 324 in total" or "Displaying Products 41-60 of 324 in total"
+    def pagy_info(pagy, pagy_id: nil, item_name: nil, i18n_key: nil)
+      p_id    = %( id="#{pagy_id}") if pagy_id
+      p_count = pagy.count
+      key     = if    p_count.zero?   then 'pagy.info.no_items'
+                elsif pagy.pages == 1 then 'pagy.info.single_page'
+                else                       'pagy.info.multiple_pages' # rubocop:disable Lint/ElseLayout
+                end
+
+      %(<span#{p_id} class="pagy-info">#{
+          pagy_t key, item_name: item_name || pagy_t(i18n_key || pagy.vars[:i18n_key], count: p_count),
+                      count: p_count, from: pagy.from, to: pagy.to
+        }</span>)
     end
 
-    # Returns a performance optimized proc to generate the HTML links
+    # Return a performance optimized proc to generate the HTML links
     # Benchmarked on a 20 link nav: it is ~22x faster and uses ~18x less memory than rails' link_to
-    def pagy_link_proc(pagy, link_extra='')
-      p_prev, p_next = pagy.prev, pagy.next
-      a, b = %(<a href="#{pagy_url_for(PAGE_PLACEHOLDER, pagy)}" #{pagy.vars[:link_extra]} #{link_extra}).split(PAGE_PLACEHOLDER, 2)
-      lambda {|n, text=n, extra=''| "#{a}#{n}#{b}#{ if    n == p_prev ; ' rel="prev"'
-                                                    elsif n == p_next ; ' rel="next"'
-                                                    else                           '' end } #{extra}>#{text}</a>"}
+    def pagy_link_proc(pagy, link_extra: '')
+      p_prev      = pagy.prev
+      p_next      = pagy.next
+      left, right = %(<a href="#{pagy_url_for pagy, PAGE_PLACEHOLDER}" #{
+                        pagy.vars[:link_extra]} #{link_extra}).split(PAGE_PLACEHOLDER, 2)
+      lambda do |page, text = pagy.label_for(page), extra_attrs = ''|
+        %(#{left}#{page}#{right}#{ case page
+                                   when p_prev then ' rel="prev"'
+                                   when p_next then ' rel="next"'
+                                   else             ''
+                                   end } #{extra_attrs}>#{text}</a>)
+      end
     end
 
     # Similar to I18n.t: just ~18x faster using ~10x less memory
-    # (@pagy_locale explicitly initilized in order to avoid warning)
-    def pagy_t(path, vars={}) Pagy::I18n.t(@pagy_locale||=nil, path, vars) end
-
+    # (@pagy_locale explicitly initialized in order to avoid warning)
+    def pagy_t(key, opts = {})
+      Pagy::I18n.translate(@pagy_locale ||= nil, key, opts)
+    end
   end
 end

data/lib/pagy/i18n.rb

@@ -0,0 +1,164 @@
+# See Pagy::I18n API documentation https://ddnexus.github.io/pagy/api/i18n
+# frozen_string_literal: true
+
+require 'yaml'
+
+class Pagy
+  # Pagy i18n implementation, compatible with the I18n gem, just a lot faster and lighter
+  module I18n
+    extend self
+
+    # Pluralization rules
+    module P11n
+      # Pluralization variables
+      from0to1   = (0..1).to_a.freeze
+      from2to4   = (2..4).to_a.freeze
+      from3to10  = (3..10).to_a.freeze
+      from5to9   = (5..9).to_a.freeze
+      from11to14 = (11..14).to_a.freeze
+      from11to99 = (11..99).to_a.freeze
+      from12to14 = (12..14).to_a.freeze
+
+      from0to1_from5to9 = from0to1 + from5to9
+
+      # Store the proc defining each pluralization RULE
+      # Logic adapted from https://github.com/svenfuchs/rails-i18n
+      RULE = {
+        arabic:
+          lambda do |n = 0|
+            mod100 = n % 100
+            case
+            when n == 0                      then 'zero' # rubocop:disable Style/NumericPredicate
+            when n == 1                      then 'one'
+            when n == 2                      then 'two'
+            when from3to10.include?(mod100)  then 'few'
+            when from11to99.include?(mod100) then 'many'
+            else                                  'other'
+            end
+          end,
+
+        east_slavic:
+          lambda do |n = 0|
+            mod10  = n % 10
+            mod100 = n % 100
+            case
+            when mod10 == 1 && mod100 != 11                                            then 'one'
+            when from2to4.include?(mod10) && !from12to14.include?(mod100)              then 'few'
+            when mod10 == 0 || from5to9.include?(mod10) || from11to14.include?(mod100) then 'many' # rubocop:disable Style/NumericPredicate
+            else                                                                            'other'
+            end
+          end,
+
+        one_other:
+          ->(n) { n == 1 ? 'one' : 'other' }, # default RULE
+
+        one_two_other:
+          lambda do |n|
+            case n
+            when 1 then 'one'
+            when 2 then 'two'
+            else        'other'
+            end
+          end,
+
+        one_upto_two_other:
+          ->(n) { n && n >= 0 && n < 2 ? 'one' : 'other' },
+
+        other:
+          ->(*) { 'other' },
+
+        polish:
+          lambda do |n = 0|
+            mod10  = n % 10
+            mod100 = n % 100
+            case
+            when n == 1                                                           then 'one'
+            when from2to4.include?(mod10) && !from12to14.include?(mod100)         then 'few'
+            when from0to1_from5to9.include?(mod10) || from12to14.include?(mod100) then 'many'
+            else                                                                       'other'
+            end
+          end,
+
+        west_slavic:
+          lambda do |n|
+            case n
+            when 1         then 'one'
+            when *from2to4 then 'few'
+            else                'other'
+            end
+          end
+
+      }.freeze
+
+      # Store the RULE to apply to each LOCALE
+      # the :one_other RULE is the default for locales missing from this list
+      LOCALE = Hash.new(RULE[:one_other]).tap do |hash|
+                 hash['ar']    = RULE[:arabic]
+                 hash['bs']    = RULE[:east_slavic]
+                 hash['cs']    = RULE[:west_slavic]
+                 hash['id']    = RULE[:other]
+                 hash['fr']    = RULE[:one_upto_two_other]
+                 hash['hr']    = RULE[:east_slavic]
+                 hash['ja']    = RULE[:other]
+                 hash['km']    = RULE[:other]
+                 hash['ko']    = RULE[:other]
+                 hash['pl']    = RULE[:polish]
+                 hash['ru']    = RULE[:east_slavic]
+                 hash['sr']    = RULE[:east_slavic]
+                 hash['sv']    = RULE[:one_two_other]
+                 hash['sv-SE'] = RULE[:one_two_other]
+                 hash['tr']    = RULE[:other]
+                 hash['uk']    = RULE[:east_slavic]
+                 hash['zh-CN'] = RULE[:other]
+                 hash['zh-HK'] = RULE[:other]
+                 hash['zh-TW'] = RULE[:other]
+               end.freeze
+    end
+
+    # Stores the i18n DATA structure for each loaded locale
+    # default on the first locale DATA
+    DATA = Hash.new { |hash, _| hash.first[1] }
+
+    private
+
+    # Create a flat hash with dotted notation keys
+    def flatten(initial, prefix = '')
+      initial.each.reduce({}) do |hash, (key, value)|
+        hash.merge!(value.is_a?(Hash) ? flatten(value, "#{prefix}#{key}.") : { "#{prefix}#{key}" => value })
+      end
+    end
+
+    # Build the DATA hash out of the passed locales
+    def build(*locales)
+      locales.each do |locale|
+        locale[:filepath]  ||= Pagy.root.join('locales', "#{locale[:locale]}.yml")
+        locale[:pluralize] ||= P11n::LOCALE[locale[:locale]]
+        dictionary = YAML.safe_load(File.read(locale[:filepath], encoding: 'UTF-8'))
+        raise I18nError, %(expected :locale "#{locale[:locale]}" not found in :filepath "#{locale[:filepath].inspect}") \
+              unless dictionary.key?(locale[:locale])
+
+        DATA[locale[:locale]] = [flatten(dictionary[locale[:locale]]), locale[:pluralize]]
+      end
+    end
+    # Build the default at require time
+    build(locale: 'en')
+
+    public
+
+    # Public method to configure the locales: overrides the default, build the DATA and freezes it
+    def load(*locales)
+      DATA.clear
+      build(*locales)
+      DATA.freeze
+    end
+
+    # Translate and pluralize the key with the locale DATA
+    def translate(locale, key, opts = {})
+      data, pluralize = DATA[locale]
+      translation = data[key] || (opts[:count] && data[key += ".#{pluralize.call(opts[:count])}"]) \
+                      or return %([translation missing: "#{key}"])
+      translation.gsub(/%{[^}]+?}/) { |match| opts[:"#{match[2..-2]}"] || match }
+    end
+    alias t translate
+  end
+end

data/lib/pagy/url_helpers.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class Pagy
+  # Provide the helpers to handle the url in frontend and backend
+  module UrlHelpers
+    # Return the URL for the page, relying on the params method and Rack by default.
+    # It supports all Rack-based frameworks (Sinatra, Padrino, Rails, ...).
+    # For non-rack environments you can use the standalone extra
+    def pagy_url_for(pagy, page, absolute: nil)
+      vars                = pagy.vars
+      page_param          = vars[:page_param].to_s
+      items_param         = vars[:items_param].to_s
+      params              = pagy.params.is_a?(Hash) ? pagy.params.transform_keys(&:to_s) : {}
+      params              = request.GET.merge(params)
+      params[page_param]  = page
+      params[items_param] = vars[:items] if vars[:items_extra]
+      query_string        = "?#{Rack::Utils.build_nested_query(pagy_deprecated_params(pagy, params))}"  # remove in 6.0
+      # params              = pagy.params.call(params) if pagy.params.is_a?(Proc)                       # add in 6.0
+      # query_string        = "?#{Rack::Utils.build_nested_query(params)}"                              # add in 6.0
+      "#{request.base_url if absolute}#{request.path}#{query_string}#{vars[:fragment]}"
+    end
+
+    private
+
+    # Transitional code to handle params deprecations. It will be removed in version 6.0
+    def pagy_deprecated_params(pagy, params)    # remove in 6.0
+      if pagy.params.is_a?(Proc)                # new code
+        pagy.params.call(params)
+      elsif respond_to?(:pagy_massage_params)   # deprecated code
+        Warning.warn '[PAGY WARNING] The pagy_massage_params method has been deprecated and it will be ignored from version 6. ' \
+                     'Set the :params variable to a Proc with the same code as the pagy_massage_params method.'
+        pagy_massage_params(params)
+      else
+        params                                  # no massage params
+      end
+    end
+  end
+end

data/lib/pagy.rb

@@ -1,50 +1,116 @@
 # See Pagy API documentation: https://ddnexus.github.io/pagy/api/pagy
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'pathname'
 
-class Pagy ; VERSION = '3.10.0'
+# Core class
+class Pagy
+  VERSION = '5.7.3'
 
   # Root pathname to get the path of Pagy files like templates or dictionaries
-  def self.root; @root ||= Pathname.new(__FILE__).dirname.freeze end
+  def self.root
+    @root ||= Pathname.new(__dir__).freeze
+  end
 
-  # default vars
-  VARS = { page:1, items:20, outset:0, size:[1,4,4,1], page_param: :page, params:{}, anchor:'', link_extra:'', i18n_key:'pagy.item_name', cycle:false }
+  # Default core vars: constant for easy access, but mutable for customizable defaults
+  DEFAULT = { page:       1, # rubocop:disable Style/MutableConstant
+              items:      20,
+              outset:     0,
+              size:       [1, 4, 4, 1],
+              page_param: :page,
+              params:     {},
+              fragment:   '',
+              link_extra: '',
+              i18n_key:   'pagy.item_name',
+              cycle:      false }
 
-  attr_reader :count, :page, :items, :vars, :pages, :last, :offset, :from, :to, :prev, :next
+  attr_reader :count, :page, :items, :vars, :pages, :last, :offset, :in, :from, :to, :prev, :next, :params
 
   # Merge and validate the options, do some simple arithmetic and set the instance variables
   def initialize(vars)
-    @vars = VARS.merge(vars.delete_if{|_,v| v.nil? || v == '' })               # default vars + cleaned vars
-    { count:0, items:1, outset:0, page:1 }.each do |k,min|                     # validate instance variables
-      (@vars[k] && instance_variable_set(:"@#{k}", @vars[k].to_i) >= min) \
-         or raise(VariableError.new(self), "expected :#{k} >= #{min}; got #{@vars[k].inspect}")
-    end
-    @pages = @last = [(@count.to_f / @items).ceil, 1].max                      # cardinal and ordinal meanings
-    @page <= @last or raise(OverflowError.new(self), "expected :page in 1..#{@last}; got #{@page.inspect}")
-    @offset = @items * (@page - 1) + @outset                                   # pagination offset + outset (initial offset)
-    @items  = @count - ((@pages-1) * @items) if @page == @last && @count > 0   # adjust items for last non-empty page
-    @from   = @count == 0 ? 0 : @offset+1 - @outset                            # page begins from item
-    @to     = @count == 0 ? 0 : @offset + @items - @outset                     # page ends to item
-    @prev   = (@page-1 unless @page == 1)                                      # nil if no prev page
-    @next   = @page == @last ? (1 if @vars[:cycle]) : @page+1                  # nil if no next page, 1 if :cycle
+    normalize_vars(vars)
+    setup_vars(count: 0, page: 1, outset: 0)
+    setup_items_var
+    setup_pages_var
+    setup_params_var
+    raise OverflowError.new(self, :page, "in 1..#{@last}", @page) if @page > @last
+
+    @offset = (@items * (@page - 1)) + @outset
+    @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 = []) and size.empty? and return series
-    4.times{|i| (size[i]>=0 rescue nil) or raise(VariableError.new(self), "expected 4 items >= 0 in :size; got #{size.inspect}")}
-    [*0..size[0], *@page-size[1]..@page+size[2], *@last-size[3]+1..@last+1].sort!.each_cons(2) do |a, b|
-      if    a<0 || a==b || a>@last                                        # skip out of range and duplicates
-      elsif a+1 == b; series.push(a)                                      # no gap     -> no additions
-      elsif a+2 == b; series.push(a, a+1)                                 # 1 page gap -> fill with missing page
-      else            series.push(a, :gap)                                # n page gap -> add gap
-      end                                                                 # skip the end boundary (last+1)
-    end                                                                   # shift the start boundary (0) and
-    series.shift; series[series.index(@page)] = @page.to_s; series        # convert the current page to String
+  def series(size: @vars[:size], **_)
+    return [] if size.empty?
+    raise VariableError.new(self, :size, 'to contain 4 items >= 0', size) \
+          unless 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]   # rubocop:disable Layout/ExtraSpacing, Layout/SpaceAroundOperators
+    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
+    series          = []
+    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)
+    series[series.index(@page)] = @page.to_s
+    series
   end
 
+  # Allow the customization of the output (overridden by the calendar extra)
+  def label_for(page)
+    page.to_s
+  end
+
+  # Allow the customization of the output (overridden by the calendar extra)
+  def label
+    @page.to_s
+  end
+
+  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
+
+  # Setup and validates the passed vars: var must be present and value.to_i must be >= to min
+  def setup_vars(name_min)
+    name_min.each do |name, min|
+      raise VariableError.new(self, name, ">= #{min}", @vars[name]) \
+            unless @vars[name] && instance_variable_set(:"@#{name}", @vars[name].to_i) >= min
+    end
+  end
+
+  # Setup and validate the items (overridden by the gearbox extra)
+  def setup_items_var
+    setup_vars(items: 1)
+  end
+
+  # Setup and validates the pages (overridden by the gearbox extra)
+  def setup_pages_var
+    @pages = @last = [(@count.to_f / @items).ceil, 1].max
+  end
+
+  # Setup and validates the 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)
+  end
 end
 
 require 'pagy/backend'

data/lib/templates/bootstrap_nav.html.erb

@@ -5,7 +5,7 @@
   The link variable is set to a proc that returns the link tag.
   Usage: link.call( page_number [, text [, extra_attributes_string ]])
 -%>
-<% link = pagy_link_proc(pagy, 'class="page-link"') -%>
+<% link = pagy_link_proc(pagy, link_extra: 'class="page-link"') -%>
 <%#                            -%><nav aria-label="pager"  class="pagy-bootstrap-nav" role="navigation">
 <%#                            -%>  <ul class="pagination">
 <% if pagy.prev                -%>    <li class="page-item prev"><%== link.call(pagy.prev, pagy_t('pagy.nav.prev'), 'aria-label="previous"') %></li>

data/lib/templates/bootstrap_nav.html.haml

@@ -4,7 +4,7 @@
 -# The link variable is set to a proc that returns the link tag.
 -# Usage: link.call( page_number [, text [, extra_attributes_string ]])
 
-- link = pagy_link_proc(pagy, 'class="page-link"')
+- link = pagy_link_proc(pagy, link_extra: 'class="page-link"')
 
 %nav.pagy-bootstrap-nav{"aria-label" => "pager", :role => "navigation"}
 

data/lib/templates/bootstrap_nav.html.slim

@@ -4,7 +4,7 @@
 / The link variable is set to a proc that returns the link tag.
 / Usage: link.call( page_number [, text [, extra_attributes_string ]])
 
-- link = pagy_link_proc(pagy, 'class="page-link"')
+- link = pagy_link_proc(pagy, link_extra: 'class="page-link"')
 
 nav.pagy-bootstrap-nav role="navigation" aria-label="pager"
 

data/lib/templates/foundation_nav.html.erb

@@ -13,7 +13,7 @@
 <% end                         -%>
 <% pagy.series.each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36] -%>
 <%   if    item.is_a?(Integer) -%>    <li><%== link.call(item) %></li>
-<%   elsif item.is_a?(String)  -%>    <li class="current"><%= item %></li>
+<%   elsif item.is_a?(String)  -%>    <li class="current"><%= pagy.label_for(item) %></li>
 <%   elsif item == :gap        -%>    <li class="ellipsis gap" aria-hidden="true"></li>
 <%   end                       -%>
 <% end                         -%>

data/lib/templates/foundation_nav.html.haml

@@ -22,7 +22,7 @@
 
       - elsif item.is_a?(String)                      # current page
         %li.current
-          = item
+          = pagy.label_for(item)
 
       - elsif item == :gap                            # page gap
         %li.ellipsis.gap{"aria-hidden" => true}

data/lib/templates/foundation_nav.html.slim

@@ -22,7 +22,7 @@ nav.pagy-foundation-nav role="navigation" aria-label="Pagination"
 
       - elsif item.is_a?(String)                 # current page
         li.current
-          = item
+          = pagy.label_for(item)
 
       - elsif item == :gap                       # page gap
         li.ellipsis.gap aria-hidden="true"

data/lib/templates/uikit_nav.html.erb

@@ -5,11 +5,11 @@
 <% end                         -%>
 <% pagy.series.each do |item|  -%>
 <%   if    item.is_a?(Integer) -%>   <li><%== link.call(item) %></li>
-<%   elsif item.is_a?(String)  -%>   <li class="uk-active"><span><%== item %></span></li>
+<%   elsif item.is_a?(String)  -%>   <li class="uk-active"><span><%== pagy.label_for(item) %></span></li>
 <%   elsif item == :gap        -%>   <li class="uk-disabled"><span><%== pagy_t('pagy.nav.gap') %></span></li>
 <%   end                       -%>
 <% end                         -%>
-<% if pagy.next                -%>   <li><%== link.call(p_next, "<span uk-pagination-next>#{pagy_t('pagy.nav.next')}</span>") %></li>
+<% if pagy.next                -%>   <li><%== link.call(pagy.next, "<span uk-pagination-next>#{pagy_t('pagy.nav.next')}</span>") %></li>
 <% else                        -%>   <li class="uk-disabled"><a href="#"><span uk-pagination-next><%== pagy_t('pagy.nav.next') %></span></a></li>
 <% end                         -%>
 <%#                            -%> </ul>

data/lib/templates/uikit_nav.html.haml

@@ -14,7 +14,7 @@
 
     - elsif item.is_a?(String)
       %li.uk-active
-        %span!= item
+        %span!= pagy.label_for(item)
 
     - elsif item == :gap
       %li.uk-disabled

data/lib/templates/uikit_nav.html.slim

@@ -14,14 +14,14 @@ ul.uk-pagination.uk-flex-center
 
     - elsif item.is_a?(String)
       li.uk-active
-        span== item
+        span== pagy.label_for(item)
 
     - elsif item == :gap
       li.uk-disabled
         span== pagy_t('pagy.nav.gap')
 
   - if pagy.next
-    li== link.call(p_next, "<span uk-pagination-next>#{pagy_t('pagy.nav.next')}</span>")
+    li== link.call(pagy.next, "<span uk-pagination-next>#{pagy_t('pagy.nav.next')}</span>")
   - else
     li.uk-disabled
       a href="#"