pagy 3.13.0 → 4.4.0

data/lib/pagy/extras/shared.rb

@@ -1,4 +1,3 @@
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'digest'
@@ -17,35 +16,35 @@ class Pagy
   #       "350" => [1, 2, :gap, 17, 18, 19, "20", 21, 22, 23, :gap, 49, 50],
   #       "550" => [1, 2, 3, :gap, 16, 17, 18, 19, "20", 21, 22, 23, 24, :gap, 48, 49, 50] }
   # Notice: if :steps is false it will use the single {0 => @vars[:size]} size
-  def sequels
-    steps = @vars[:steps] || {0 => @vars[:size]}
-    steps.key?(0) or raise(VariableError.new(self), "expected :steps to define the 0 width; got #{steps.inspect}")
-    sequels = {}; steps.each {|width, size| sequels[width.to_s] = series(size)}; sequels
+  def sequels(steps=nil)
+    steps ||= @vars[:steps] || {0 => @vars[:size]}
+    raise VariableError.new(self), "expected :steps to define the 0 width; got #{steps.inspect}" \
+          unless steps.key?(0)
+    {}.tap do |sequels|
+      steps.each {|width, size| sequels[width.to_s] = series(size)}
+    end
   end
 
   module Frontend
 
     if defined?(Oj)
       # it returns a script tag with the JSON-serialized args generated with the faster oj gem
-      def pagy_json_tag(*args)
+      def pagy_json_tag(pagy, *args)
+        args << pagy.vars[:page_param] if pagy.vars[:enable_trim_extra]
         %(<script type="application/json" class="pagy-json">#{Oj.dump(args, mode: :strict)}</script>)
       end
     else
       require 'json'
       # it returns a script tag with the JSON-serialized args generated with the slower to_json
-      def pagy_json_tag(*args)
+      def pagy_json_tag(pagy, *args)
+        args << pagy.vars[:page_param] if pagy.vars[:enable_trim_extra]
         %(<script type="application/json" class="pagy-json">#{args.to_json}</script>)
       end
     end
 
-    # it returns the SHA1 (fastest on modern ruby) string used as default `id` attribute by all the `*_js` tags
-    def pagy_id
-      "pagy-#{Digest::SHA1.hexdigest(caller(2..2)[0].split(':in')[0])}"
-    end
-
     # it returns the marked link to used by pagy.js
     def pagy_marked_link(link)
-      link.call(PAGE_PLACEHOLDER, '', 'style="display: none;"')
+      link.call PAGE_PLACEHOLDER, '', 'style="display: none;"'
     end
 
   end

data/lib/pagy/extras/standalone.rb

@@ -0,0 +1,71 @@
+# See the Pagy documentation: https://ddnexus.github.io/pagy/extras/standalone
+# frozen_string_literal: true
+
+require 'uri'
+class Pagy
+
+  # extracted from Rack::Utils and reformatted for rubocop
+  module QueryUtils
+    module_function
+    def escape(str)
+      URI.encode_www_form_component(str)
+    end
+    def build_nested_query(value, prefix = nil)
+      case value
+      when Array
+        value.map { |v| build_nested_query(v, "#{prefix}[]") }.join('&')
+      when Hash
+        value.map { |k, v| build_nested_query(v, prefix ? "#{prefix}[#{escape(k)}]" : escape(k)) }.delete_if(&:empty?).join('&')
+      when nil
+        prefix
+      else
+        raise ArgumentError, 'value must be a Hash' if prefix.nil?
+        "#{prefix}=#{escape(value)}"
+      end
+    end
+  end
+
+  module UseStandaloneExtra
+    # without any :url var it works exactly as the regular #pagy_url_for;
+    # with a defined :url variable it does not use rack/request
+    def pagy_url_for(pagy, page, deprecated_url=nil, absolute: nil)
+      absolute = Pagy.deprecated_arg(:url, deprecated_url, :absolute, absolute) if deprecated_url
+      pagy, page = Pagy.deprecated_order(pagy, page) if page.is_a?(Pagy)
+      p_vars = pagy.vars
+      if p_vars[:url]
+        url_string = p_vars[:url]
+        params     = {}
+      else
+        url_string = "#{request.base_url if absolute}#{request.path}"
+        params     = request.GET
+      end
+      params = params.merge(p_vars[:params])
+      params[p_vars[:page_param].to_s]  = page
+      params[p_vars[:items_param].to_s] = p_vars[:items] if defined?(UseItemsExtra)
+      query_string = "?#{QueryUtils.build_nested_query(pagy_get_params(params))}" unless params.empty?
+      "#{url_string}#{query_string}#{p_vars[:fragment]}"
+    end
+  end
+  Helpers.prepend UseStandaloneExtra
+
+  # defines a dummy #params method if not already defined in the including module
+  module Backend
+    def self.included(controller)
+      controller.define_method(:params){{}} unless controller.method_defined?(:params)
+    end
+  end
+
+  # include Pagy::Console in irb/rails console for a ready to use pagy environment
+  module Console
+    def self.included(main)
+      main.include(Backend)
+      main.include(Frontend)
+      VARS[:url] = 'http://www.example.com/subdir'
+    end
+
+    def pagy_extras(*extras)
+      extras.each {|extra| require "pagy/extras/#{extra}"}
+    end
+  end
+
+end

data/lib/pagy/extras/support.rb

@@ -1,5 +1,4 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/extras/support
-# encoding: utf-8
 # frozen_string_literal: true
 
 class Pagy
@@ -7,29 +6,39 @@ class Pagy
   module Frontend
 
     def pagy_prev_url(pagy)
-      pagy_url_for(pagy.prev, pagy) if pagy.prev
+      pagy_url_for(pagy, pagy.prev) if pagy.prev
     end
 
     def pagy_next_url(pagy)
-      pagy_url_for(pagy.next, pagy) if pagy.next
+      pagy_url_for(pagy, pagy.next) if pagy.next
     end
 
-    def pagy_prev_link(pagy, text = pagy_t('pagy.nav.prev'), link_extra = '')
-      pagy.prev ? %(<span class="page prev"><a href="#{pagy_url_for(pagy.prev, pagy)}" rel="prev" aria-label="previous" #{pagy.vars[:link_extra]} #{link_extra}>#{text}</a></span>)
-                : %(<span class="page prev disabled">#{text}</span>)
+    def pagy_prev_link(pagy, deprecated_text=nil, deprecated_link_extra=nil, text: pagy_t('pagy.nav.prev'), link_extra: '')
+      text       = Pagy.deprecated_arg(:text, deprecated_text, :text, text) if deprecated_text
+      link_extra = Pagy.deprecated_arg(:link_extra, deprecated_link_extra, :link_extra, link_extra) if deprecated_link_extra
+      if pagy.prev
+        %(<span class="page prev"><a href="#{pagy_url_for(pagy, pagy.prev)}" rel="prev" aria-label="previous" #{pagy.vars[:link_extra]} #{link_extra}>#{text}</a></span>)
+      else
+        %(<span class="page prev disabled">#{text}</span>)
+      end
     end
 
-    def pagy_next_link(pagy, text = pagy_t('pagy.nav.next'), link_extra = '')
-      pagy.next ? %(<span class="page next"><a href="#{pagy_url_for(pagy.next, pagy)}" rel="next" aria-label="next" #{pagy.vars[:link_extra]} #{link_extra}>#{text}</a></span>)
-                : %(<span class="page next disabled">#{text}</span>)
+    def pagy_next_link(pagy, deprecated_text=nil, deprecated_link_extra=nil, text: pagy_t('pagy.nav.next'), link_extra: '')
+      text       = Pagy.deprecated_arg(:text, deprecated_text, :text, text) if deprecated_text
+      link_extra = Pagy.deprecated_arg(:link_extra, deprecated_link_extra, :link_extra, link_extra) if deprecated_link_extra
+      if pagy.next
+        %(<span class="page next"><a href="#{pagy_url_for(pagy, pagy.next)}" rel="next" aria-label="next" #{pagy.vars[:link_extra]} #{link_extra}>#{text}</a></span>)
+      else
+        %(<span class="page next disabled">#{text}</span>)
+      end
     end
 
     def pagy_prev_link_tag(pagy)
-      %(<link href="#{pagy_url_for(pagy.prev, pagy)}" rel="prev"/>) if pagy.prev
+      %(<link href="#{pagy_url_for(pagy, pagy.prev)}" rel="prev"/>) if pagy.prev
     end
 
     def pagy_next_link_tag(pagy)
-      %(<link href="#{pagy_url_for(pagy.next, pagy)}" rel="next"/>) if pagy.next
+      %(<link href="#{pagy_url_for(pagy, pagy.next)}" rel="next"/>) if pagy.next
     end
 
   end

data/lib/pagy/extras/trim.rb

@@ -1,23 +1,24 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/extras/trim
-# encoding: utf-8
 # frozen_string_literal: true
 
 class Pagy
 
-  module Frontend
+  VARS[:enable_trim_extra] = true
 
-    TRIM = true   # boolean used by *_js helpers
+  module UseTrimExtra
 
-    alias_method :pagy_link_proc_without_trim, :pagy_link_proc
-    def pagy_link_proc_with_trim(pagy, link_extra='')
-      link_proc = pagy_link_proc_without_trim(pagy, link_extra)
-      re = /[?&]#{pagy.vars[:page_param]}=1\b(?!&)|\b#{pagy.vars[:page_param]}=1&/
-      lambda do |n, text=n, extra=''|
-        link = link_proc.call(n, text, extra)
-        n == 1 ? link.sub(re, '') : link
+    def pagy_link_proc(pagy, deprecated_link_extra=nil, link_extra: '')
+      link_extra = Pagy.deprecated_arg(:link_extra, deprecated_link_extra, :link_extra, link_extra) if deprecated_link_extra
+      link_proc = super(pagy, link_extra: link_extra)
+      return link_proc unless pagy.vars[:enable_trim_extra]
+      lambda do |num, text=num, extra=''|
+        link = link_proc.call(num, text, extra)
+        return link unless num == 1
+        link.sub!(/[?&]#{pagy.vars[:page_param]}=1\b(?!&)|\b#{pagy.vars[:page_param]}=1&/, '')
       end
     end
-    alias_method :pagy_link_proc, :pagy_link_proc_with_trim
 
   end
+  Frontend.prepend UseTrimExtra
+
 end

data/lib/pagy/extras/uikit.rb

@@ -1,5 +1,4 @@
 # See the Pagy documentation: https://ddnexus.github.io/pagy/extras/uikit
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'pagy/extras/shared'
@@ -8,55 +7,86 @@ class Pagy
   module Frontend
 
     # Pagination for uikit: it returns the html with the series of links to the pages
-    def pagy_uikit_nav(pagy)
-      link, p_prev, p_next = pagy_link_proc(pagy), pagy.prev, pagy.next
+    def pagy_uikit_nav(pagy, pagy_id: nil, link_extra: '')
+      p_id = %( id="#{pagy_id}") if pagy_id
+      link = pagy_link_proc(pagy, link_extra: link_extra)
 
-      previous_span = "<span uk-pagination-previous>#{pagy_t('pagy.nav.prev')}</span>"
-      html = EMPTY + (p_prev ? %(<li>#{link.call p_prev, previous_span}</li>)
-                             : %(<li class="uk-disabled"><a href="#">#{previous_span}</a></li>))
+      html = %(<ul#{p_id} class="pagy-uikit-nav uk-pagination uk-flex-center">#{pagy_uikit_prev_html pagy, link})
       pagy.series.each do |item|
-        html << 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 == :gap       ; %(<li class="uk-disabled"><span>#{pagy_t('pagy.nav.gap')}</span></li>)
+        html << case    item
+                when Integer then %(<li>#{link.call item}</li>)
+                when String  then %(<li class="uk-active"><span>#{item}</span></li>)
+                when :gap    then %(<li class="uk-disabled"><span>#{pagy_t 'pagy.nav.gap'}</span></li>)
                 end
       end
-      next_span = "<span uk-pagination-next>#{pagy_t('pagy.nav.next')}</span>"
-      html << (p_next ? %(<li>#{link.call p_next, next_span}</li>)
-                      : %(<li class="uk-disabled"><a href="#">#{next_span}</a></li>))
-      %(<ul class="pagy-uikit-nav uk-pagination uk-flex-center">#{html}</ul>)
+      html << pagy_uikit_next_html(pagy, link)
+      html << %(</ul>)
     end
 
     # Javascript pagination for uikit: it returns a nav and a JSON tag used by the Pagy.nav javascript
-    def pagy_uikit_nav_js(pagy, id=pagy_id)
-      link, p_prev, p_next = pagy_link_proc(pagy), pagy.prev, pagy.next
-      previous_span = "<span uk-pagination-previous>#{pagy_t('pagy.nav.prev')}</span>"
-      next_span     = "<span uk-pagination-next>#{pagy_t('pagy.nav.next')}</span>"
-      tags = { 'before' => p_prev ? %(<li>#{link.call p_prev, previous_span}</li>)
-                                  : %(<li class="uk-disabled"><a href="#">#{previous_span}</a></li>),
+    def pagy_uikit_nav_js(pagy, deprecated_id=nil, pagy_id: nil, link_extra: '', steps: nil)
+      pagy_id = Pagy.deprecated_arg(:id, deprecated_id, :pagy_id, pagy_id) if deprecated_id
+      p_id = %( id="#{pagy_id}") if pagy_id
+      link = pagy_link_proc(pagy, link_extra: link_extra)
+      tags = { 'before' => pagy_uikit_prev_html(pagy, link),
                'link'   => %(<li>#{link.call(PAGE_PLACEHOLDER)}</li>),
                'active' => %(<li class="uk-active"><span>#{PAGE_PLACEHOLDER}</span></li>),
                'gap'    => %(<li class="uk-disabled"><span>#{pagy_t('pagy.nav.gap')}</span></li>),
-               'after'  => p_next ? %(<li>#{link.call p_next, next_span}</li>)
-                                  : %(<li class="uk-disabled"><a href="#">#{next_span}</a></li>) }
-      %(<ul id="#{id}" class="pagy-uikit-nav-js uk-pagination uk-flex-center"></ul>#{pagy_json_tag(:nav, id, tags, pagy.sequels, defined?(TRIM) && pagy.vars[:page_param])})
+               'after'  => pagy_uikit_next_html(pagy, link) }
+
+      html = %(<ul#{p_id} class="pagy-njs pagy-uikit-nav-js uk-pagination uk-flex-center"></ul>)
+      html << pagy_json_tag(pagy, :nav, tags, pagy.sequels(steps))
     end
 
     # Javascript combo pagination for uikit: it returns a nav and a JSON tag used by the Pagy.combo_nav javascript
-    def pagy_uikit_combo_nav_js(pagy, id=pagy_id)
-      link, p_prev, p_next, p_page, p_pages = pagy_link_proc(pagy), pagy.prev, pagy.next, pagy.page, pagy.pages
+    def pagy_uikit_combo_nav_js(pagy, deprecated_id=nil, pagy_id: nil, link_extra: '')
+      pagy_id = Pagy.deprecated_arg(:id, deprecated_id, :pagy_id, pagy_id) if deprecated_id
+      p_id    = %( id="#{pagy_id}") if pagy_id
+      link    = pagy_link_proc(pagy, link_extra: link_extra)
+      p_page  = pagy.page
+      p_pages = pagy.pages
+      input   = %(<input type="number" min="1" max="#{p_pages}" value="#{p_page}" class="uk-input" style="padding: 0; text-align: center; width: #{p_pages.to_s.length+1}rem;">)
+
+      %(<div#{p_id} class="pagy-uikit-combo-nav-js uk-button-group">#{
+          if (p_prev = pagy.prev)
+            link.call p_prev, pagy_t('pagy.nav.prev'), 'class="uk-button uk-button-default"'
+          else
+            %(<button class="uk-button uk-button-default" disabled>#{pagy_t 'pagy.nav.prev'}</button>)
+          end
+      }<div class="uk-text-middle uk-margin-left uk-margin-right">#{
+          pagy_t 'pagy.combo_nav_js', page_input: input, count: p_page, pages: p_pages
+      }</div>#{
+          if (p_next = pagy.next)
+            link.call p_next, pagy_t('pagy.nav.next'), 'class="uk-button uk-button-default"'
+          else
+            %(<button class="uk-button uk-button-default" disabled>#{pagy_t 'pagy.nav.next'}</button>)
+          end
+      }</div>#{
+          pagy_json_tag pagy, :combo_nav, p_page, pagy_marked_link(link)
+      })
+    end
 
-      html = %(<div id="#{id}" class="pagy-uikit-combo-nav-js uk-button-group">)
-      html = html + (p_prev ? link.call(p_prev, pagy_t('pagy.nav.prev'), 'class="uk-button uk-button-default"')
-                            : %(<button class="uk-button uk-button-default" disabled>#{pagy_t('pagy.nav.prev')}</button>))
 
-      html << %(<div class="uk-text-middle uk-margin-left uk-margin-right">)
-      input = %(<input type="number" min="1" max="#{p_pages}" value="#{p_page}" class="uk-input" style="padding: 0; text-align: center; width: #{p_pages.to_s.length+1}rem;">)
-      html << pagy_t('pagy.combo_nav_js', page_input: input, count: p_page, pages: p_pages) + '</div>'
 
-      html << (p_next ? link.call(p_next, pagy_t('pagy.nav.next'), 'class="uk-button uk-button-default"')
-                      : %(<button class="uk-button uk-button-default" disabled>#{pagy_t('pagy.nav.next')}</button>))
+    private
+
+      def pagy_uikit_prev_html(pagy, link)
+        previous_span = %(<span uk-pagination-previous>#{pagy_t 'pagy.nav.prev'}</span>)
+        if (p_prev = pagy.prev)
+          %(<li>#{link.call p_prev, previous_span}</li>)
+        else
+          %(<li class="uk-disabled"><a href="#">#{previous_span}</a></li>)
+        end
+      end
+
+      def pagy_uikit_next_html(pagy, link)
+        next_span = %(<span uk-pagination-next>#{pagy_t 'pagy.nav.next'}</span>)
+        if (p_next = pagy.next)
+          %(<li>#{link.call p_next, next_span}</li>)
+        else
+          %(<li class="uk-disabled"><a href="#">#{next_span}</a></li>)
+        end
+      end
 
-      html << %(</div>#{pagy_json_tag(:combo_nav, id, p_page, pagy_marked_link(link), defined?(TRIM) && pagy.vars[:page_param])})
-    end
   end
 end

data/lib/pagy/frontend.rb

@@ -1,26 +1,31 @@
 # See Pagy::Frontend API documentation: https://ddnexus.github.io/pagy/api/frontend
-# encoding: utf-8
 # frozen_string_literal: true
 
 require 'yaml'
 
 class Pagy
 
-  PAGE_PLACEHOLDER  = '__pagy_page__'  # string used for search and replace, hardcoded also in the pagy.js file
+  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
+  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]}"
+    def pagy_url_for(pagy, page, deprecated_url=nil, absolute: nil)
+      absolute = Pagy.deprecated_arg(:url, deprecated_url, :absolute, absolute) if deprecated_url
+      pagy, page = Pagy.deprecated_order(pagy, page) if page.is_a?(Pagy)
+      p_vars = pagy.vars
+      params = request.GET.merge(p_vars[:params])
+      params[p_vars[:page_param].to_s]  = page
+      params[p_vars[:items_param].to_s] = p_vars[:items] if defined?(UseItemsExtra)
+      query_string = "?#{Rack::Utils.build_nested_query(pagy_get_params(params))}" unless params.empty?
+      "#{request.base_url if absolute}#{request.path}#{query_string}#{p_vars[:fragment]}"
     end
 
     # Sub-method called only by #pagy_url_for: here for easy customization of params by overriding
-    def pagy_get_params(params) params end
+    def pagy_get_params(params) = params
   end
 
   # All the code here has been optimized for performance: it may not look very pretty
@@ -29,47 +34,71 @@ class Pagy
 
     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
-
     # 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: '')
+      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> ))
+      html  = +%(<nav#{p_id} class="pagy-nav pagination" role="navigation" 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.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 << case item
+                when Integer then %(<span class="page">#{link.call item}</span> )               # page link
+                when String  then %(<span class="page active">#{item}</span> )                  # current page
+                when :gap    then %(<span class="page gap">#{pagy_t('pagy.nav.gap')}</span> )   # page gap
                 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)
+    def pagy_info(pagy, deprecated_item_name=nil, pagy_id: nil, item_name: nil, i18n_key: nil)
+      p_id      = %( id="#{pagy_id}") if pagy_id
+      item_name = Pagy.deprecated_arg(:item_name, deprecated_item_name, :item_name, item_name) if deprecated_item_name
+      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'
+                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
     # 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, deprecated_link_extra=nil, link_extra: '')
+      link_extra = Pagy.deprecated_arg(:link_extra, deprecated_link_extra, :link_extra, link_extra) if deprecated_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 |num, text=num, extra_attrs=''|
+        %(#{left}#{num}#{right}#{ case num
+                                  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.t @pagy_locale||=nil, key, **opts
+    end
 
   end
 end