pagy 43.2.3 → 43.2.5

data/lib/pagy/classes/keyset/keyset.rb

@@ -13,7 +13,7 @@ class Pagy
       autoload :Sequel,       path.join('adapters/sequel')
     end
 
-    autoload :Keynav,  Pathname.new(__dir__).join('keynav')
+    autoload :Keynav, Pathname.new(__dir__).join('keynav')
 
     # Define empty subclasses to allow specific typing without triggering autoload
     class ActiveRecord < self; end
@@ -27,28 +27,24 @@ class Pagy
       if /::(?:ActiveRecord|Sequel)$/.match?(name)
         # Ensure the adapter is mixed in (lazy load)
         mix_in_adapter(name.split('::').last)
-        return allocate.tap { |instance| instance.send(:initialize, set, **) }
+        return allocate.tap { _1.send(:initialize, set, **) }
       end
 
       # 2. Handle Factory usage (Pagy::Keyset.new)
-      orm_name = if defined?(::ActiveRecord) && set.is_a?(::ActiveRecord::Relation)
-                   :ActiveRecord
-                 elsif defined?(::Sequel) && set.is_a?(::Sequel::Dataset)
-                   :Sequel
-                 else
-                   raise TypeError, "expected an ActiveRecord::Relation or Sequel::Dataset; got #{set.class}"
-                 end
-
-      # Get the specific subclass (self::ActiveRecord)
-      subclass = const_get(orm_name)
-      # Ensure the adapter is mixed in (lazy load)
-      subclass.mix_in_adapter(orm_name)
-      subclass.new(set, **)
+      adapter = if defined?(::ActiveRecord) && set.is_a?(::ActiveRecord::Relation)
+                  :ActiveRecord
+                elsif defined?(::Sequel) && set.is_a?(::Sequel::Dataset)
+                  :Sequel
+                else
+                  raise TypeError, "expected an ActiveRecord::Relation or Sequel::Dataset; got #{set.class}"
+                end
+
+      const_get(adapter).tap { _1.mix_in_adapter(adapter) }.new(set, **)
     end
 
     # Helper to lazy-include the adapter module
-    def self.mix_in_adapter(orm_name)
-      adapter_module = Pagy::Keyset::Adapters.const_get(orm_name)
+    def self.mix_in_adapter(adapter)
+      adapter_module = Adapters.const_get(adapter)
       include(adapter_module) unless self < adapter_module
     end
 

data/lib/pagy/classes/offset/countless.rb

@@ -34,15 +34,20 @@ class Pagy
       def finalize(fetched_size)
         # empty records (trigger the right info message for known 0 count)
         @count = 0 if fetched_size.zero? && @page == 1
-        return self unless in_range? { fetched_size.positive? || @page == 1 }
 
-        past  = @last && @page < @last # this page has been past
+        unless in_range? { fetched_size.positive? || @page == 1 }
+          assign_empty_page_variables
+          return self
+        end
+
+        past  = @last && @page < @last # current page is before the known last page
         more  = fetched_size > @limit  # more pages after this one
         @last = upto_max_pages(more ? @page + 1 : @page) unless past && more
         @in   = [fetched_size, @limit].min
         @from = @in.zero? ? 0 : @offset + 1
         @to   = @offset + @in
         assign_previous_and_next
+
         self
       end
 
@@ -55,7 +60,9 @@ class Pagy
       end
 
       # Support easy countless page param overriding (for legacy param and behavior)
-      def compose_page_param(page) = EscapedValue.new("#{page || 1}+#{@last}")
+      def compose_page_param(page)
+        EscapedValue.new("#{page || 1}+#{@last}")
+      end
     end
   end
 end

data/lib/pagy/classes/offset/offset.rb

@@ -19,11 +19,16 @@ class Pagy
       assign_and_check(limit: 1, count: 0, page: 1)
       assign_last
       assign_offset
-      return unless in_range? { @page <= @last }
+
+      unless in_range? { @page <= @last }
+        assign_empty_page_variables
+        return
+      end
 
       @from = [@offset + 1, @count].min
       @to   = [@offset + @limit, @count].min
       @in   = [@to - @from + 1, @count].min
+
       assign_previous_and_next
     end
 

data/lib/pagy/classes/request.rb

@@ -13,6 +13,7 @@ class Pagy
         else
           [request.base_url, request.path, get_params(request), request.cookies['pagy']]
         end
+      freeze
     end
 
     attr_reader :base_url, :path, :params, :cookie
@@ -20,21 +21,23 @@ class Pagy
     def resolve_page(force_integer: true)
       page_key = @options[:page_key] || DEFAULT[:page_key]
       page     = @params.dig(@options[:root_key], page_key) || @params[page_key]
-      page     = nil if page == ''   # fix for app-generated queries like ?page=
-      force_integer ? (page || 1).to_i : page
+      force_integer ? [page.to_i, 1].max : page
     end
 
     def resolve_limit
       limit_key = @options[:limit_key] || DEFAULT[:limit_key]
-      return @options[:limit] || DEFAULT[:limit] \
-             unless @options[:client_max_limit] &&
-                    (requested_limit = @params.dig(@options[:root_key], limit_key) || @params[limit_key])
+      default   = @options[:limit] || DEFAULT[:limit]
+      max_limit = @options[:client_max_limit]
+      return default unless max_limit
 
-      [requested_limit.to_i, @options[:client_max_limit]].min
+      limit = @params.dig(@options[:root_key], limit_key) || @params[limit_key]
+      limit ? [limit.to_i, max_limit].min : default
     end
 
     private
 
-    def get_params(request) = request.GET.merge(request.POST).to_h
+    def get_params(request)
+      request.GET.merge(request.POST).to_h.freeze
+    end
   end
 end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 class Pagy
-  # Add configurstion methods
+  # Add configuration methods
   module Configurable
     # Sync the pagy javascript targets
     def sync_javascript(destination, *targets)

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

@@ -17,6 +17,7 @@ class Pagy
               else
                 collection.count(:all)
               end
+
       count.is_a?(Hash) ? count.size : count
     end
   end

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

@@ -38,26 +38,33 @@ class Pagy
 
     protected
 
-    # Overriddable by classes with composite page param
+    # Overridable by 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)
-      root_key, page_key, limit_key, client_max_limit, limit, querify, absolute, path, fragment =
-        @options.merge(options)
-                .values_at(:root_key, :page_key, :limit_key, :client_max_limit, :limit, :querify, :absolute, :path, :fragment)
-      params = @request.params.clone(freeze: false)
-      (root_key ? params[root_key] = params[root_key]&.clone(freeze: false) || {} : params).tap do |h|
-        { page_key  => compose_page_param(page),
-          limit_key => client_max_limit && limit }.each { |k, v| v ? h[k] = v : h.delete(k) }
+      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[:client_max_limit] && opts[:limit] }.each do |k, v|
+        v ? container[k] = v : container.delete(k)
       end
-      querify&.(params) # Must modify the params: the returned value is ignored
-      fragment &&= "##{fragment.delete_prefix('#')}"
-      compose_url(absolute, path, params, fragment)
+
+      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
 
     def compose_url(absolute, path, params, fragment)
-      query_string = QueryUtils.build_nested_query(params).sub(/\A(?=.)/, '?')
+      query_string = QueryUtils.build_nested_query(params).sub(/\A(?=.)/, '?') # conditionally prepend '?'
       "#{@request.base_url if absolute}#{path || @request.path}#{query_string}#{fragment}"
     end
   end

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

@@ -9,7 +9,6 @@ class Pagy
       return true if (@in_range = yield)
       raise RangeError.new(self, :page, "in 1..#{@last}", @page) if @options[:raise_range_error]
 
-      assign_empty_page_variables
       @in_range = false
     end
   end

data/lib/pagy/modules/b64.rb

@@ -5,14 +5,19 @@ class Pagy
   module B64
     module_function
 
-    def encode(bin) = [bin].pack('m0')
+    def encode(bin)
+      [bin].pack('m0')
+    end
 
-    def decode(str) = str.unpack1('m0')
+    def decode(str)
+      str.unpack1('m0')
+    end
 
     def urlsafe_encode(bin)
       str = encode(bin)
       str.chomp!('==') or str.chomp!('=')
       str.tr!('+/', '-_')
+
       str
     end
 
@@ -23,6 +28,7 @@ class Pagy
       else
         str = str.tr('-_', '+/')
       end
+
       decode(str)
     end
   end

data/lib/pagy/modules/console.rb

@@ -9,16 +9,25 @@ class Pagy
         @collection = clone
       end
 
-      def offset(value) = tap { @collection = self[value..] }
-      def limit(value)  = @collection[0, value]
-      def count(*)      = size
+      def offset(value)
+        tap { @collection = self[value..] }
+      end
+
+      def limit(value)
+        @collection[0, value]
+      end
+
+      def count(*) = size
     end
 
     include Method
 
-    # Direct reference to request.params via a method
-    def request    = @request ||= { base_url: 'http://www.example.com', path: '/path', params: { example: '123' } }
-    def params     = request[:params]
+    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

@@ -8,15 +8,22 @@ class Pagy
   module I18n
     extend self
 
-    def pathnames = @pathnames ||= [ROOT.join('locales')]
-    def locales   = @locales   ||= {}
+    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
+      Thread.current[:pagy_locale] = value.to_s
     end
 
-    def locale = Thread.current[:pagy_locale] || 'en'
+    def locale
+      Thread.current[:pagy_locale] || 'en'
+    end
 
     # Translate and pluralize the key with the locale entries
     def translate(key, **options)

data/lib/pagy/modules/searcher.rb

@@ -6,12 +6,16 @@ class Pagy
     module_function
 
     # Common search logic
-    def wrap(pagy_search_args, options)
+    def wrap(search_arguments, options)
       options[:page] ||= options[:request].resolve_page
       options[:limit]  = options[:request].resolve_limit
-      pagy, results    = yield
-      calling          = pagy_search_args[4..]
-      [pagy, calling.empty? ? results : results.send(*calling)]
+
+      pagy, results = yield
+
+      arguments = search_arguments[4..]
+      results   = results.send(*arguments) unless arguments.empty?
+
+      [pagy, results]
     end
   end
 end

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

@@ -9,6 +9,7 @@ class Pagy
     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

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

@@ -4,7 +4,7 @@ require_relative 'urls_hash'
 
 # Add pagination response headers
 class Pagy
-  DEFAULT_HEADERS_MAP = { page: 'current-page',
+  DEFAULT_HEADERS_MAP = { page:  'current-page',
                           limit: 'page-limit',
                           count: 'total-count',
                           pages: 'total-pages' }.freeze
@@ -12,6 +12,7 @@ class Pagy
   # 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
 

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

@@ -13,6 +13,7 @@ class Pagy
                 else
                   'pagy.info_tag.multiple_pages'
                 end
+
     info_data = if @count.nil?
                   { page: @page, pages: @last }
                 else
@@ -21,6 +22,7 @@ class Pagy
                     from:      @from,
                     to:        @to }
                 end
+
     %(<span#{%( id="#{id}") if id} class="pagy info">#{I18n.translate(i18n_key, **info_data)}</span>)
   end
 end

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

@@ -13,6 +13,7 @@ class Pagy
     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

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

@@ -11,6 +11,7 @@ class Pagy
              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

@@ -23,6 +23,7 @@ class Pagy
               end
     end
     html << next_tag(a_lambda)
+
     wrap_series_nav(html, 'pagy series-nav', **)
   end
 end

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

@@ -13,6 +13,7 @@ class Pagy
                  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

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

@@ -13,7 +13,7 @@ class Pagy
 
   # 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: nil, **)
+  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)
 

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

@@ -12,15 +12,18 @@ class Pagy
               unless config.is_a?(Hash) && (config.keys - allowed_options).empty?
 
         config[:offset] ||= {}
+
         unless config[:disabled]
-          calendar, from, to =
-            Calendar.send(:init, config,
-                          pagy_calendar_period(collection),
-                          config[:request].params) do |unit, period|
-              pagy_calendar_counts(collection, unit, *period) if respond_to?(:pagy_calendar_counts)
-            end
+          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

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

@@ -9,26 +9,29 @@ class Pagy
     # Return the Offset::Countish instance and records
     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
+
       setup_options(count, epoch, collection, options)
       options[:limit] = options[:request].resolve_limit
-      pagy            = Offset::Countish.new(**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
+
       if !options[:count] && count && (!options[:ttl] ||
          (epoch && epoch <= now && now < (epoch + options[:ttl]))) # ongoing
-        # puts 'ongoing'
         options[:count] = count
         options[:epoch] = epoch if options[:ttl]
+
       else # recount
-        # puts 'recount'
         options[:count] ||= Countable.get_count(collection, options)
         options[:epoch]   = now if options[:ttl]
       end

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

@@ -7,13 +7,16 @@ class Pagy
     # Return the Offset::Countless instance and records
     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) # decoded '+' added by the compose_page_url
+        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 = Offset::Countless.new(**options)
       [pagy, pagy.records(collection)]
     end
   end

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

@@ -8,22 +8,26 @@ class Pagy
 
     # Paginate from the search object
     def paginate(search, options)
-      if search.is_a?(Search::Arguments)
-        # The search is the array of pagy_search arguments
+      if search.is_a?(Search::Arguments)  # Active mode
+
         Searcher.wrap(search, options) do
           model, query_or_payload, search_options = search
           search_options[:size] = options[:limit]
           search_options[:from] = options[:limit] * ((options[:page] || 1) - 1)
-          response_object       = model.send(options[:search_method] || ElasticsearchRails::DEFAULT[:search_method],
-                                             query_or_payload, **search_options)
-          options[:count]       = total_count_from(response_object)
+
+          method          = options[:search_method] || ElasticsearchRails::DEFAULT[:search_method]
+          response_object = model.send(method, query_or_payload, **search_options)
+          options[:count] = total_count_from(response_object)
+
           [ElasticsearchRails.new(**options), response_object]
         end
-      else
+
+      else # Passive mode
         from, size      = pagination_params_from(search)
         options[:limit] = size
         options[:page]  = ((from || 0) / options[:limit]) + 1
         options[:count] = total_count_from(search)
+
         ElasticsearchRails.new(**options)
       end
     end
@@ -36,6 +40,7 @@ class Pagy
       from       = (container[:from] || container['from']).to_i
       size       = (container[:size] || container['size']).to_i
       size       = 10 if size.zero?
+
       [from, size]
     end
 
@@ -44,6 +49,7 @@ class Pagy
       total = response_object.instance_eval do
                 respond_to?(:response) ? response['hits']['total'] : raw_response['hits']['total']
               end
+
       total.is_a?(Hash) ? total['value'] : total
     end
   end

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

@@ -10,15 +10,17 @@ class Pagy
     # Fall back to :countless if the :page has no client data.
     def paginate(set, options)
       page = options[:request].resolve_page(force_integer: false) # allow nil
-      if page&.match(' ')       # countless page -> no augmentation -> fallback
-        return CountlessPaginator.paginate(set, page:, **options)
-      elsif page.is_a?(String)  # keynav page param
+
+      return CountlessPaginator.paginate(set, page:, **options) if page&.match(' ')  # countless fallback
+
+      if page.is_a?(String)  # keynav page param
         page_arguments = JSON.parse(B64.urlsafe_decode(page))
         # Restart the pagination from page 1/nil if the url has been requested from another browser
         options[:page] = page_arguments if options[:request].cookie == page_arguments.shift
       end
 
       options[:limit] = options[:request].resolve_limit
+
       pagy = Keyset::Keynav.new(set, **options)
       [pagy, pagy.records]
     end

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

@@ -8,7 +8,8 @@ class Pagy
     def paginate(set, options)
       options[:page] ||= options[:request].resolve_page(force_integer: false) # allow nil
       options[:limit]  = options[:request].resolve_limit
-      pagy = Keyset.new(set, **options)
+      pagy             = Keyset.new(set, **options)
+
       [pagy, pagy.records]
     end
   end

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

@@ -8,22 +8,25 @@ class Pagy
 
     # Paginate from the search object
     def paginate(search, options)
-      if search.is_a?(Search::Arguments)
-        # The search is the array of pagy_search arguments
+      if search.is_a?(Search::Arguments) # Active mode
+
         Searcher.wrap(search, options) do
           model, term, search_options    = search
           search_options[:hits_per_page] = options[:limit]
           search_options[:page]          = options[:page]
-          results                        = model.send(options[:search_method] || Meilisearch::DEFAULT[:search_method],
-                                                      term, search_options)
-          options[:count]                = results.raw_answer['totalHits']
+
+          method          = options[:search_method] || Meilisearch::DEFAULT[:search_method]
+          results         = model.send(method, term, search_options)
+          options[:count] = results.raw_answer['totalHits']
+
           [Meilisearch.new(**options), results]
         end
-      else
-        # The search is a meilisearch results object
+
+      else # Passive mode
         options[:limit] = search.raw_answer['hitsPerPage']
         options[:page]  = search.raw_answer['page']
         options[:count] = search.raw_answer['totalHits']
+
         Meilisearch.new(**options)
       end
     end

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

@@ -21,14 +21,16 @@ class Pagy
              protected
 
              define_method :pagy do |paginator = :offset, collection, **options|
-               arguments           = if paginator == :calendar
-                                       [self, collection, options]
-                                     else
-                                       [collection, options = Pagy.options.merge(options)]
-                                     end
+               arguments = if paginator == :calendar
+                             [self, collection, options]
+                           else
+                             [collection, options = Pagy.options.merge(options)]
+                           end
+
                options[:root_key]  = 'page' if options[:jsonapi] # enforce 'page' root_key for JSON:API
                options[:request] ||= request                     # user set request or self.request
                options[:request]   = Request.new(options)        # Pagy::Request
+
                Pagy.const_get(paginators[paginator]).paginate(*arguments)
              end
            end