pagy 7.0.11 → 43.5.1

data/lib/pagy/modules/abilities/linkable.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+class Pagy
+  # Support spaces in placeholder params
+  class EscapedValue < String; end
+
+  # Handle the url and anchor
+  module Linkable
+    module QueryUtils
+      module_function
+
+      # Extracted from Rack::Utils and reformatted for rubocop.
+      # Allow unescaped Pagy::RawQueryValue.
+      def build_nested_query(value, prefix = nil)
+        case value
+        when Array
+          value.map { |v| build_nested_query(v, "#{prefix}[]") }.join('&')
+        when Hash
+          value.map do |k, v|
+            build_nested_query(v, prefix ? "#{prefix}[#{k}]" : k)
+          end.delete_if(&:empty?).join('&')
+        when nil
+          escape(prefix)
+        else
+          raise ArgumentError, 'value must be a Hash' if prefix.nil?
+
+          escaped_value = value.is_a?(EscapedValue) ? value : escape(value)
+          "#{escape(prefix)}=#{escaped_value}"
+        end
+      end
+
+      def escape(str)
+        URI.encode_www_form_component(str)
+      end
+    end
+
+    protected
+
+    # Overriding support for classes with composite page param
+    def compose_page_param(page) = page
+
+    # Return the URL for the page, relying on the Pagy::Request
+    def compose_page_url(page, **options)
+      opts      = @options.merge(options)
+      params    = @request.params.clone(freeze: false)
+      root_key  = opts[:root_key]
+      container = if root_key
+                    params[root_key] = params[root_key]&.clone(freeze: false) || {}
+                  else
+                    params
+                  end
+
+      { opts[:page_key]  => compose_page_param(page),
+        opts[:limit_key] => opts[:max_limit] && opts[:limit] }.each do |k, v|
+        v ? container[k] = v : container.delete(k)
+      end
+
+      opts[:querify]&.(params) # Must modify the params: the returned value is ignored
+      fragment = opts[:fragment].to_s.sub(/\A(?=[^#])/, '#') # conditionally prepend '#'
+
+      compose_url(opts[:absolute], opts[:path], params, fragment)
+    end
+
+    # Overriding support
+    def compose_url(absolute, path, params, fragment)
+      query_string = QueryUtils.build_nested_query(params).sub(/\A(?=.)/, '?') # conditionally prepend '?'
+      "#{@request.base_url if absolute}#{path || @request.path}#{query_string}#{fragment}"
+    end
+  end
+end

data/lib/pagy/modules/abilities/rangeable.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class Pagy
+  # Support range checking, error and rescue
+  module Rangeable
+    def in_range?
+      return @in_range if defined?(@in_range)
+      return true if (@in_range = yield)
+      raise RangeError.new(self, :page, "in 1..#{@last}", @page) if @options[:raise_range_error]
+
+      @in_range = false
+    end
+  end
+end

data/lib/pagy/modules/abilities/shiftable.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class Pagy
+  module Shiftable
+    protected
+
+    def assign_previous_and_next
+      @previous = @page - 1 unless @page == 1
+      @next     = @page + 1 unless @page == @last
+    end
+  end
+end

data/lib/pagy/modules/b64.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Pagy
+  # Cheap Base64 specialized methods to avoid dependencies
+  module B64
+    module_function
+
+    def encode(bin)
+      [bin].pack('m0')
+    end
+
+    def decode(str)
+      str.unpack1('m0')
+    end
+
+    def urlsafe_encode(bin)
+      str = encode(bin)
+      str.tr!('+/', '-_')
+      str.delete!('=')
+
+      str
+    end
+
+    def urlsafe_decode(str)
+      if !str.end_with?('=') && str.length % 4 != 0
+        str = str.ljust((str.length + 3) & ~3, '=')
+        str.tr!('-_', '+/')
+      else
+        str = str.tr('-_', '+/')
+      end
+
+      decode(str)
+    end
+  end
+end

data/lib/pagy/modules/console.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+class Pagy
+  # Ready to use pagy environment when included in irb/rails console
+  module Console
+    class Collection < Array
+      def initialize(arr = Array(1..1000))
+        super
+        @collection = clone
+      end
+
+      def offset(value)
+        tap { @collection = self[value..] }
+      end
+
+      def limit(value)
+        @collection[0, value]
+      end
+
+      def count(*) = size
+    end
+
+    include Method
+
+    def request
+      @request ||= { base_url: 'http://www.example.com', path: '/path', params: { example: '123' } }
+    end
+
+    def params = request[:params]
+
+    def collection = Collection
+  end
+end

data/lib/pagy/modules/i18n/i18n.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require_relative 'p11n'
+
+class Pagy
+  # Faster and lighter Pagy i18n implementation, compatible with the I18n gem
+  module I18n
+    class KeyError < KeyError; end
+
+    extend self
+
+    def pathnames
+      @pathnames ||= [ROOT.join('locales')]
+    end
+
+    def locales
+      @locales ||= {}
+    end
+
+    # Store the variable for the duration of a single request
+    def locale=(value)
+      Thread.current[:pagy_locale] = value.to_s
+    end
+
+    def locale
+      Thread.current[:pagy_locale] || 'en'
+    end
+
+    # Translate and pluralize the key with the locale entries
+    def translate(key, **options)
+      data, p11n = locales[locale] || self.load
+      key       += ".#{p11n.plural_for(options[:count])}" if !data[key] && options[:count]
+
+      translation = data[key] or return %([translation missing: "#{key}"])
+
+      translation.gsub(/%{[^}]+?}/) { options.fetch(_1[2..-2].to_sym, _1) } # replace the interpolation placeholders
+    end
+
+    private
+
+    def load(locale: self.locale)
+      path = pathnames.reverse.map { |p| p.join("#{locale}.yml") }.find(&:exist?)
+      unless path
+        warn %(Pagy::I18n: missing dictionary file for #{locale.inspect} locale; using "en" instead)
+        return locales[locale] = locales['en'] || load(locale: 'en')
+      end
+
+      dictionary = YAML.load_file(path)[locale]
+      raise KeyError, "missing 'pagy' key in #{locale.inspect} locale" unless dictionary['pagy']
+
+      p11n = dictionary['pagy'].delete('p11n')
+      raise KeyError, "missing 'p11n' key in #{locale.inspect} locale" unless p11n
+
+      locales[locale] = [dotify_keys(dictionary), Object.const_get("Pagy::I18n::P11n::#{p11n}")]
+    end
+
+    # Flatten a nested hash by "dotifying" its keys
+    # e.g. { 'a' => { 'b' => {'c' => 3, 'd' => 4 }}} -> { 'a.b.c' => 3, 'a.b.d' => 4 }
+    def dotify_keys(initial, prefix = '')
+      initial.each_with_object({}) do |(key, value), hash|
+        key = "#{prefix}#{key}"
+
+        if value.is_a?(Hash)
+          hash.merge!(dotify_keys(value, "#{key}."))
+        else
+          hash[key] = value
+        end
+      end
+    end
+  end
+end

data/lib/pagy/modules/i18n/p11n/arabic.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+class Pagy
+  module I18n
+    module P11n
+      module Arabic
+        module_function
+
+        def plural_for(n = 0)
+          mod100 = n % 100
+
+          case
+          when n == 0  # rubocop:disable Style/NumericPredicate
+            :zero
+          when n == 1
+            :one
+          when n == 2
+            :two
+          when (3..10).to_a.include?(mod100)
+            :few
+          when (11..99).to_a.include?(mod100)
+            :many
+          else
+            :other
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pagy/modules/i18n/p11n/east_slavic.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Pagy
+  module I18n
+    module P11n
+      module EastSlavic
+        module_function
+
+        def plural_for(n = 0)
+          mod10  = n % 10
+          mod100 = n % 100
+
+          case
+          when mod10 == 1 && mod100 != 11
+            :one
+          when (2..4).to_a.include?(mod10) && !(12..14).to_a.include?(mod100)
+            :few
+          when mod10 == 0 || (5..9).to_a.include?(mod10) || (11..14).to_a.include?(mod100) # rubocop:disable Style/NumericPredicate
+            :many
+          else
+            :other
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pagy/modules/i18n/p11n/one_other.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Pagy
+  module I18n
+    module P11n
+      module OneOther
+        module_function
+
+        def plural_for(n = 0)
+          n == 1 ? :one : :other
+        end
+      end
+    end
+  end
+end

data/lib/pagy/modules/i18n/p11n/one_upto_two_other.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class Pagy
+  module I18n
+    module P11n
+      module OneUptoTwoOther
+        module_function
+
+        def plural_for(n = 0)
+          n >= 0 && n < 2 ? :one : :other
+        end
+      end
+    end
+  end
+end

data/lib/pagy/modules/i18n/p11n/other.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+class Pagy
+  module I18n
+    module P11n
+      module Other
+        module_function
+
+        def plural_for(*) = :other
+      end
+    end
+  end
+end

data/lib/pagy/modules/i18n/p11n/polish.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Pagy
+  module I18n
+    module P11n
+      module Polish
+        module_function
+
+        def plural_for(n = 0)
+          mod10  = n % 10
+          mod100 = n % 100
+
+          case
+          when n == 1
+            :one
+          when [2, 3, 4].include?(mod10) && ![12, 13, 14].include?(mod100)
+            :few
+          when [0, 1, 5, 6, 7, 8, 9].include?(mod10) || [12, 13, 14].include?(mod100)
+            :many
+          else
+            :other
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pagy/modules/i18n/p11n/west_slavic.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class Pagy
+  module I18n
+    module P11n
+      module WestSlavic
+        module_function
+
+        def plural_for(n = 0)
+          case n
+          when 1
+            :one
+          when 2, 3, 4
+            :few
+          else
+            :other
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pagy/modules/i18n/p11n.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Pagy
+  module I18n
+    module P11n
+      path = ROOT.join('lib/pagy/modules/i18n/p11n')
+      autoload :Arabic,          path.join('arabic')
+      autoload :EastSlavic,      path.join('east_slavic')
+      autoload :OneOther,        path.join('one_other')
+      autoload :OneUptoTwoOther, path.join('one_upto_two_other')
+      autoload :Other,           path.join('other')
+      autoload :Polish,          path.join('polish')
+      autoload :WestSlavic,      path.join('west_slavic')
+    end
+  end
+end

data/lib/pagy/modules/searcher.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Pagy
+  module Searcher
+    module_function
+
+    # Common search logic
+    def wrap(search_arguments, options)
+      options[:page] ||= options[:request].resolve_page
+      options[:limit]  = options[:request].resolve_limit
+
+      pagy, results = yield
+
+      called  = search_arguments[4..]
+      results = results.send(*called) unless called.empty?
+
+      [pagy, results]
+    end
+  end
+end

data/lib/pagy/next.rb

@@ -0,0 +1,25 @@
+# See https://ddnexus.github.io/pagy/guides/pagy-next/
+# frozen_string_literal: true
+
+ENV['PAGY_NEXT'] = 'true'
+# :nocov:
+require_relative '../pagy' unless defined?(Pagy)  # avoid circular require (also from pagy itself)
+# :nocov:
+
+class Pagy
+  VERSION = "#{remove_const(:VERSION)}.next".freeze
+
+  class NextError < ArgumentError; end
+
+  module Discontinued
+    # Ensure a discontinued option won't pass unnoticed shadowing a bug
+    def assign_options(**options)
+      discontinued = options.keys & %i[max_pages client_max_limit]
+      return super if discontinued.empty?
+
+      raise NextError, "discontinued #{discontinued.map(&:inspect).join(', ')}: " \
+                       'check https://ddnexus.github.io/pagy/changelog/#deprecations for alternatives'
+    end
+  end
+  prepend Discontinued
+end

data/lib/pagy/tasks/sync.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'rake'
+require 'rake/tasklib'
+
+class Pagy
+  class SyncTask < Rake::TaskLib
+    # Define a rake task for syncing a specific resource on demand
+    def initialize(resource, destination, *targets)
+      namespace :pagy do
+        namespace :sync do
+          desc "Sync #{resource}"
+          task(resource) do
+            Pagy.sync(resource, destination, *targets)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative 'support/a_lambda' # inheritable
+
+class Pagy
+  module NumericHelpers
+    def previous_tag(...) = anchor_tag_for(:previous, ...)
+  end
+
+  def next_tag(...) = anchor_tag_for(:next, ...)
+
+  private
+
+  def anchor_tag_for(which, a = nil, text: I18n.translate("pagy.#{which}"),
+                     aria_label: I18n.translate("pagy.aria_label.#{which}"), **)
+    page = send(which)
+    return %(<a role="link" aria-disabled="true" aria-label="#{aria_label}">#{text}</a>) unless page
+
+    (a || a_lambda(**)).(page, text, aria_label:)
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative 'previous_next_html'
+require_relative '../support/wrap_input_nav_js'
+
+class Pagy
+  module NumericHelpers
+    private
+
+    def bootstrap_input_nav_js(classes: 'pagination', **)
+      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; border-radius: .25rem; ) +
+                 %(border: none; display: inline-block;" class="page-link active">#{A_TAG})
+
+      html     = %(<ul class="#{classes}">#{
+                   bootstrap_html_for(:previous, a_lambda)
+                   }<li class="page-item"><label class="page-link">#{
+                   I18n.translate('pagy.input_nav_js', page_input: input, pages: @last)
+                   }</label></li>#{
+                   bootstrap_html_for(:next, a_lambda)
+                   }</ul>)
+
+      wrap_input_nav_js(html, 'pagy-bootstrap input-nav-js', **)
+    end
+  end
+end

data/lib/pagy/toolbox/helpers/bootstrap/previous_next_html.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class Pagy
+  module NumericHelpers
+    private
+
+    def bootstrap_html_for(which, a_lambda)
+      if send(which)
+        %(<li class="page-item #{which}">#{
+          a_lambda.(send(which), I18n.translate("pagy.#{which}"),
+                    classes:    'page-link',
+                    aria_label: I18n.translate("pagy.aria_label.#{which}"))}</li>)
+      else
+        %(<li class="page-item #{which} disabled"><a role="link" class="page-link" aria-disabled="true" aria-label="#{
+        I18n.translate("pagy.aria_label.#{which}")}">#{I18n.translate("pagy.#{which}")}</a></li>)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require_relative 'previous_next_html'
+require_relative '../support/wrap_series_nav'
+
+class Pagy
+  module NumericHelpers
+    private
+
+    def bootstrap_series_nav(classes: 'pagination', **)
+      a_lambda = a_lambda(**)
+
+      html = %(<ul class="#{classes}">#{bootstrap_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 class="page-item">#{a_lambda.(item, classes: 'page-link')}</li>)
+                when String
+                  %(<li class="page-item active"><a role="link" class="page-link" aria-current="page" aria-disabled="true">#{
+                      page_label(item)}</a></li>)
+                when :gap
+                  %(<li class="page-item gap disabled"><a role="link" class="page-link" aria-disabled="true">#{
+                    I18n.translate('pagy.gap')}</a></li>)
+                else raise InternalError, "expected item types in series to be Integer, String or :gap; got #{item.inspect}"
+                end
+      end
+      html << %(#{bootstrap_html_for(:next, a_lambda)}</ul>)
+
+      wrap_series_nav(html, 'pagy-bootstrap series-nav', **)
+    end
+  end
+end

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

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

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require_relative 'previous_next_html'
+require_relative '../support/wrap_input_nav_js'
+
+class Pagy
+  module NumericHelpers
+    private
+
+    def bulma_input_nav_js(classes: 'pagination', **)
+      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; line-height: 1.2rem; ) +
+                 %(border: none; border-radius: .25rem; padding: .0625rem; color: white; ) +
+                 %(background-color: #485fc7;">#{A_TAG})
+
+      html     = %(<ul class="pagination-list">#{bulma_html_for(:previous, a_lambda)}<li class="pagination-link"><label>#{
+                   I18n.translate('pagy.input_nav_js', page_input: input, pages: @last)
+                   }</label></li>#{bulma_html_for(:next, a_lambda)}</ul>)
+
+      wrap_input_nav_js(html, "pagy-bulma input-nav-js #{classes}", **)
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+class Pagy
+  module NumericHelpers
+    private
+
+    def bulma_html_for(which, a_lambda)
+      %(<li>#{
+        if send(which)
+          a_lambda.(send(which), I18n.translate("pagy.#{which}"),
+                    classes:    "pagination-#{which}",
+                    aria_label: I18n.translate("pagy.aria_label.#{which}"))
+        else
+          %(<a role="link" class="pagination-#{which}" disabled aria-disabled="true" aria-label="#{
+          I18n.translate("pagy.aria_label.#{which}")}">#{I18n.translate("pagy.#{which}")}</a>)
+        end
+        }</li>)
+    end
+  end
+end