pagy 7.0.11 → 43.5.1

data/lib/pagy/backend.rb

@@ -1,39 +0,0 @@
-# See Pagy::Backend API documentation: https://ddnexus.github.io/pagy/docs/api/backend
-# frozen_string_literal: true
-
-class Pagy
-  # Define a few generic methods to paginate a collection out of the box,
-  # or any collection by overriding pagy_get_items and/or pagy_get_vars in your controller
-  # See also the extras if you need specialized methods to paginate Arrays or other collections
-  module Backend
-    private
-
-    # Return Pagy object and paginated items/results
-    def pagy(collection, vars = {})
-      pagy = Pagy.new(pagy_get_vars(collection, vars))
-      [pagy, pagy_get_items(collection, pagy)]
-    end
-
-    # Sub-method called only by #pagy: here for easy customization of variables by overriding
-    # You may need to override the count call for non AR collections
-    def pagy_get_vars(collection, vars)
-      pagy_set_items_from_params(vars) if defined?(ItemsExtra)
-      count_args = vars[:count_args] || DEFAULT[:count_args]
-      vars[:count] ||= (count = collection.count(*count_args)).is_a?(Hash) ? count.size : count
-      vars[:page]  ||= pagy_get_page(vars)
-      vars
-    end
-
-    # Get the page integer from the params
-    # Overridable by the jsonapi extra
-    def pagy_get_page(vars)
-      (params[vars[:page_param] || DEFAULT[:page_param]] || 1).to_i
-    end
-
-    # Sub-method called only by #pagy: here for easy customization of record-extraction by overriding
-    # You may need to override this method for collections without offset|limit
-    def pagy_get_items(collection, pagy)
-      collection.offset(pagy.offset).limit(pagy.items)
-    end
-  end
-end

data/lib/pagy/calendar/helper.rb

@@ -1,65 +0,0 @@
-# frozen_string_literal: true
-
-class Pagy # :nodoc:
-  class Calendar # :nodoc:
-    # Initializes the calendar objects, reducing complexity in the extra
-    # The returned calendar is a simple hash of units/objects
-    class Helper < Hash
-      class << self
-        private
-
-        def init(conf, period, params)
-          new.send(:init, conf, period, params)
-        end
-      end
-
-      private
-
-      # Create the calendar
-      def init(conf, period, params)
-        @conf  = Marshal.load(Marshal.dump(conf))  # store a copy
-        @units = Calendar::UNITS & @conf.keys # get the units in time length desc order
-        raise ArgumentError, 'no calendar unit found in pagy_calendar @configuration' if @units.empty?
-
-        @period     = period
-        @params     = params
-        @page_param = conf[:pagy][:page_param] || DEFAULT[:page_param]
-        @units.each do |unit|  # set all the :page_param vars for later deletion
-          unit_page_param         = :"#{unit}_#{@page_param}"
-          conf[unit][:page_param] = unit_page_param
-          conf[unit][:page]       = @params[unit_page_param]
-        end
-        calendar = {}
-        object   = nil
-        @units.each_with_index do |unit, index|
-          params_to_delete    = @units[(index + 1), @units.size].map { |sub| conf[sub][:page_param] } + [@page_param]
-          conf[unit][:params] = lambda { |up| up.except(*params_to_delete.map(&:to_s)) } # rubocop:disable Style/Lambda
-          conf[unit][:period] = object&.send(:active_period) || @period
-          calendar[unit]      = object = Calendar.send(:create, unit, conf[unit])
-        end
-        [replace(calendar), object.from, object.to]
-      end
-
-      # Return the calendar object at time
-      def calendar_at(time, **opts)
-        conf        = Marshal.load(Marshal.dump(@conf))
-        page_params = {}
-        @units.inject(nil) do |object, unit|
-          conf[unit][:period] = object&.send(:active_period) || @period
-          conf[unit][:page]   = page_params[:"#{unit}_#{@page_param}"] \
-                              = Calendar.send(:create, unit, conf[unit]).send(:page_at, time, **opts)
-          conf[unit][:params] ||= {}
-          conf[unit][:params].merge!(page_params)
-          Calendar.send(:create, unit, conf[unit])
-        end
-      end
-
-      public
-
-      # Return the current time of the smallest time unit shown
-      def showtime
-        self[@units.last].from
-      end
-    end
-  end
-end

data/lib/pagy/calendar.rb

@@ -1,126 +0,0 @@
-# See Pagy::Countless API documentation: https://ddnexus.github.io/pagy/docs/api/calendar
-# frozen_string_literal: true
-
-require 'active_support'
-require 'active_support/core_ext/time'
-require 'active_support/core_ext/date_and_time/calculations'
-require 'active_support/core_ext/numeric/time'
-require 'active_support/core_ext/integer/time'
-
-require 'pagy'
-
-class Pagy # :nodoc:
-  # Base class for time units subclasses (Year, Quarter, Month, Week, Day)
-  class Calendar < Pagy
-    # Specific out of range error
-    class OutOfRangeError < VariableError; end
-
-    # List of units in desc order of duration. It can be used for custom units.
-    UNITS = %i[year quarter month week day]  # rubocop:disable Style/MutableConstant
-
-    attr_reader :order, :from, :to
-
-    # Merge and validate the options, do some simple arithmetic and set a few instance variables
-    def initialize(vars) # rubocop:disable Lint/MissingSuper
-      raise InternalError, 'Pagy::Calendar is a base class; use one of its subclasses' if instance_of?(Pagy::Calendar)
-
-      vars = self.class::DEFAULT.merge(vars)  # subclass specific default
-      normalize_vars(vars)                    # general default
-      setup_vars(page: 1)
-      setup_unit_vars
-      setup_params_var
-      raise OverflowError.new(self, :page, "in 1..#{@last}", @page) if @page > @last
-
-      @prev = (@page - 1 unless @page == 1)
-      @next = @page == @last ? (1 if @vars[:cycle]) : @page + 1
-    end
-
-    # The label for the current page (it can pass along the I18n gem opts when it's used with the i18n extra)
-    def label(opts = {})
-      label_for(@page, opts)
-    end
-
-    # The label for any page (it can pass along the I18n gem opts when it's used with the i18n extra)
-    def label_for(page, opts = {})
-      opts[:format] ||= @vars[:format]
-      localize(starting_time_for(page.to_i), opts)  # page could be a string
-    end
-
-    protected
-
-    # The page that includes time
-    # In case of out of range time, the :fit_time option avoids the outOfRangeError
-    # and returns the closest page to the passed time argument (first or last page)
-    def page_at(time, **opts)
-      fit_time  = time
-      fit_final = @final - 1
-      unless time.between?(@initial, fit_final)
-        raise OutOfRangeError.new(self, :time, "between #{@initial} and #{fit_final}", time) unless opts[:fit_time]
-
-        if time < @final
-          fit_time = @initial
-          ordinal  = 'first'
-        else
-          fit_time = fit_final
-          ordinal  = 'last'
-        end
-        Warning.warn "Pagy::Calendar#page_at: Rescued #{time} out of range by returning the #{ordinal} page."
-      end
-      offset = page_offset_at(fit_time)   # offset starts from 0
-      @order == :asc ? offset + 1 : @pages - offset
-    end
-
-    # Base class method for the setup of the unit variables (subclasses must implement it and call super)
-    def setup_unit_vars
-      raise VariableError.new(self, :format, 'to be a strftime format', @vars[:format]) unless @vars[:format].is_a?(String)
-      raise VariableError.new(self, :order, 'to be in [:asc, :desc]', @order) \
-            unless %i[asc desc].include?(@order = @vars[:order])
-
-      @starting, @ending = @vars[:period]
-      raise VariableError.new(self, :period, 'to be a an Array of min and max TimeWithZone instances', @vars[:period]) \
-            unless @starting.is_a?(ActiveSupport::TimeWithZone) \
-                && @ending.is_a?(ActiveSupport::TimeWithZone) && @starting <= @ending
-    end
-
-    # Apply the strftime format to the time (overridden by the i18n extra when localization is required)
-    def localize(time, opts)
-      time.strftime(opts[:format])
-    end
-
-    # Number of time units to offset from the @initial time, in order to get the ordered starting time for the page.
-    # Used in starting_time_for(page) where page starts from 1 (e.g. page to starting_time means subtracting 1)
-    def time_offset_for(page)
-      @order == :asc ? page - 1 : @pages - page
-    end
-
-    # Period of the active page (used internally for nested units)
-    def active_period
-      [[@starting, @from].max, [@to - 1, @ending].min] # -1 sec: include only last unit day
-    end
-
-    # :nocov:
-    # This method must be implemented by the unit subclass
-    def starting_time_for(*)
-      raise NoMethodError, 'the starting_time_for method must be implemented by the unit subclass'
-    end
-
-    # This method must be implemented by the unit subclass
-    def page_offset_at(*)
-      raise NoMethodError, 'the page_offset_at method must be implemented by the unit subclass'
-    end
-    # :nocov:
-
-    class << self
-      # Create a subclass instance by unit name (internal use)
-      def create(unit, vars)
-        raise InternalError, "unit must be in #{UNITS.inspect}; got #{unit}" unless UNITS.include?(unit)
-
-        name    = unit.to_s
-        name[0] = name[0].capitalize
-        Object.const_get("Pagy::Calendar::#{name}").new(vars)
-      end
-    end
-  end
-  # Require the subclass files in UNITS (no custom unit at this point yet)
-  Calendar::UNITS.each { |unit| require "pagy/calendar/#{unit}" }
-end

data/lib/pagy/countless.rb

@@ -1,37 +0,0 @@
-# See Pagy::Countless API documentation: https://ddnexus.github.io/pagy/docs/api/countless
-# frozen_string_literal: true
-
-require 'pagy'
-
-class Pagy
-  # No need to know the count to paginate
-  class Countless < Pagy
-    # Merge and validate the options, do some simple arithmetic and set a few instance variables
-    def initialize(vars = {}) # rubocop:disable Lint/MissingSuper
-      normalize_vars(vars)
-      setup_vars(page: 1, outset: 0)
-      setup_items_var
-      setup_offset_var
-      setup_params_var
-    end
-
-    # Finalize the instance variables based on the fetched size
-    def finalize(fetched_size)
-      raise OverflowError.new(self, :page, "to be < #{@page}", @page) if fetched_size.zero? && @page > 1
-
-      @pages = @last = (fetched_size > @items ? @page + 1 : @page)
-      @in    = [fetched_size, @items].min
-      @from  = @in.zero? ? 0 : @offset - @outset + 1
-      @to    = @offset - @outset + @in
-      @prev  = (@page - 1 unless @page == 1)
-      @next  = @page == @last ? (1 if @vars[:cycle]) : @page + 1
-      self
-    end
-
-    # Override the original series.
-    # Return nil if :countless_minimal is enabled
-    def series(*, **)
-      super unless @vars[:countless_minimal]
-    end
-  end
-end

data/lib/pagy/exceptions.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-class Pagy
-  # Generic variable error
-  class VariableError < ArgumentError
-    attr_reader :pagy, :variable, :value
-
-    # Set the variables and prepare the message
-    def initialize(pagy, variable, description, value)
-      @pagy     = pagy
-      @variable = variable
-      @value    = value
-      super("expected :#{@variable} #{description}; got #{@value.inspect}")
-    end
-  end
-
-  # Specific overflow error
-  class OverflowError < VariableError; end
-
-  # I18n configuration error
-  class I18nError < StandardError; end
-
-  # Generic internal error
-  class InternalError < StandardError; end
-end

data/lib/pagy/extras/arel.rb

@@ -1,36 +0,0 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/arel
-# frozen_string_literal: true
-
-class Pagy # :nodoc:
-  # Better performance of grouped ActiveRecord collections
-  module ArelExtra
-    private
-
-    # Return Pagy object and paginated collection/results
-    def pagy_arel(collection, vars = {})
-      pagy = Pagy.new(pagy_arel_get_vars(collection, vars))
-      [pagy, pagy_get_items(collection, pagy)]
-    end
-
-    # Sub-method called only by #pagy_arel: here for easy customization of variables by overriding
-    def pagy_arel_get_vars(collection, vars)
-      pagy_set_items_from_params(vars) if defined?(ItemsExtra)
-      vars[:count] ||= pagy_arel_count(collection)
-      vars[:page]  ||= params[vars[:page_param] || DEFAULT[:page_param]]
-      vars
-    end
-
-    # Count using Arel when grouping
-    def pagy_arel_count(collection)
-      if collection.group_values.empty?
-        # COUNT(*)
-        collection.count(:all)
-      else
-        # COUNT(*) OVER ()
-        sql = Arel.star.count.over(Arel::Nodes::Grouping.new([]))
-        collection.unscope(:order).limit(1).pluck(sql).first.to_i
-      end
-    end
-  end
-  Backend.prepend ArelExtra
-end

data/lib/pagy/extras/array.rb

@@ -1,24 +0,0 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/array
-# frozen_string_literal: true
-
-class Pagy # :nodoc:
-  # Paginate arrays efficiently, avoiding expensive array-wrapping and without overriding
-  module ArrayExtra
-    private
-
-    # Return Pagy object and paginated items
-    def pagy_array(array, vars = {})
-      pagy = Pagy.new(pagy_array_get_vars(array, vars))
-      [pagy, array[pagy.offset, pagy.items]]
-    end
-
-    # Sub-method called only by #pagy_array: here for easy customization of variables by overriding
-    def pagy_array_get_vars(array, vars)
-      pagy_set_items_from_params(vars) if defined?(ItemsExtra)
-      vars[:count] ||= array.size
-      vars[:page]  ||= params[vars[:page_param] || DEFAULT[:page_param]]
-      vars
-    end
-  end
-  Backend.prepend ArrayExtra
-end

data/lib/pagy/extras/bootstrap.rb

@@ -1,108 +0,0 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/bootstrap
-# frozen_string_literal: true
-
-require 'pagy/extras/frontend_helpers'
-
-class Pagy # :nodoc:
-  # Frontend modules are specially optimized for performance.
-  # The resulting code may not look very elegant, but produces the best benchmarks
-  module BootstrapExtra
-    # Pagination for bootstrap: it returns the html with the series of links to the pages
-    def pagy_bootstrap_nav(pagy, pagy_id: nil, link_extra: '',
-                           nav_aria_label: nil, nav_i18n_key: nil, **vars)
-      p_id = %( id="#{pagy_id}") if pagy_id
-      link = pagy_link_proc(pagy, link_extra: %(class="page-link" #{link_extra}))
-
-      html = +%(<nav#{p_id} class="pagy-bootstrap-nav" #{
-                  nav_aria_label_attr(pagy, nav_aria_label, nav_i18n_key)}><ul class="pagination">)
-      html << bootstrap_prev_html(pagy, link)
-      pagy.series(**vars).each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
-        html << case item
-                when Integer
-                  %(<li class="page-item">#{link.call(item)}</li>)
-                when String
-                  %(<li class="page-item active"><a role="link" class="page-link" aria-current="page" aria-disabled="true">#{
-                      pagy.label_for(item)}</a></li>)
-                when :gap
-                  %(<li class="page-item gap disabled"><a role="link" class="page-link" aria-disabled="true">#{
-                      pagy_t '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_next_html(pagy, link)
-      html << %(</ul></nav>)
-    end
-
-    # Javascript pagination for bootstrap: it returns a nav and a JSON tag used by the pagy.js file
-    def pagy_bootstrap_nav_js(pagy, pagy_id: nil, link_extra: '',
-                              nav_aria_label: nil, nav_i18n_key: nil, **vars)
-      sequels = pagy.sequels(**vars)
-      p_id = %( id="#{pagy_id}") if pagy_id
-      link = pagy_link_proc(pagy, link_extra: %(class="page-link" #{link_extra}))
-      tags = { 'before' => %(<ul class="pagination">#{bootstrap_prev_html pagy, link}),
-               'link'   => %(<li class="page-item">#{link.call(PAGE_TOKEN, LABEL_TOKEN)}</li>),
-               'active' => %(<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">#{
-                               pagy_t 'pagy.gap'}</a></li>),
-               'after'  => %(#{bootstrap_next_html pagy, link}</ul>) }
-
-      %(<nav#{p_id} class="#{'pagy-rjs ' if sequels.size > 1}pagy-bootstrap-nav-js" #{
-          nav_aria_label_attr(pagy, nav_aria_label, nav_i18n_key)} #{
-          pagy_data(pagy, :nav, tags, sequels, pagy.label_sequels(sequels))
-        }></nav>)
-    end
-
-    # Javascript combo pagination for bootstrap: it returns a nav and a JSON tag used by the pagy.js file
-    def pagy_bootstrap_combo_nav_js(pagy, pagy_id: nil, link_extra: '',
-                                    nav_aria_label: nil, nav_i18n_key: nil)
-      p_id    = %( id="#{pagy_id}") if pagy_id
-      link    = pagy_link_proc(pagy, link_extra:)
-      p_page  = pagy.page
-      p_pages = pagy.pages
-      input   = %(<input name="page" type="number" min="1" max="#{p_pages}" value="#{
-                    p_page}" style="padding: 0; border: none; text-align: center; width: #{
-                    p_pages.to_s.length + 1}rem;" aria-current="page">)
-
-      %(<nav#{p_id} class="pagy-bootstrap-combo-nav-js pagination" #{
-          nav_aria_label_attr(pagy, nav_aria_label, nav_i18n_key)} #{
-          pagy_data(pagy, :combo, pagy_url_for(pagy, PAGE_TOKEN)) }><div class="btn-group" role="group">#{
-          if (p_prev = pagy.prev)
-            link.call(p_prev, pagy_t('pagy.prev'), %(class="prev btn btn-primary" #{prev_aria_label_attr}))
-          else
-            %(<a role="link" class="prev btn btn-primary disabled" aria-disabled="true" #{
-                prev_aria_label_attr}>#{pagy_t('pagy.prev')}</a>)
-          end
-        }<div class="pagy-combo-input btn btn-secondary" style="white-space: nowrap;">#{
-          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.next'), %(class="next btn btn-primary" #{next_aria_label_attr}))
-          else
-            %(<a role="link" class="next btn btn-primary disabled" aria-disabled="true" #{
-                next_aria_label_attr}>#{pagy_t 'pagy.next'}</a>)
-          end
-        }</div></nav>)
-    end
-
-    private
-
-    def bootstrap_prev_html(pagy, link)
-      if (p_prev = pagy.prev)
-        %(<li class="page-item prev">#{link.call(p_prev, pagy_t('pagy.prev'), prev_aria_label_attr)}</li>)
-      else
-        %(<li class="page-item prev disabled"><a role="link" class="page-link" aria-disabled="true" #{
-            prev_aria_label_attr}>#{pagy_t('pagy.prev')}</a></li>)
-      end
-    end
-
-    def bootstrap_next_html(pagy, link)
-      if (p_next = pagy.next)
-        %(<li class="page-item next">#{link.call p_next, pagy_t('pagy.next'), next_aria_label_attr}</li>)
-      else
-        %(<li class="page-item next disabled"><a role="link" class="page-link" aria-disabled="true" #{
-            next_aria_label_attr}>#{pagy_t('pagy.next')}</a></li>)
-      end
-    end
-  end
-  Frontend.prepend BootstrapExtra
-end

data/lib/pagy/extras/bulma.rb

@@ -1,105 +0,0 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/bulma
-# frozen_string_literal: true
-
-require 'pagy/extras/frontend_helpers'
-
-class Pagy # :nodoc:
-  DEFAULT[:bulma_nav_classes] = 'is-centered'
-
-  # Frontend modules are specially optimized for performance.
-  # The resulting code may not look very elegant, but produces the best benchmarks
-  module BulmaExtra
-    # Pagination for bulma: it returns the html with the series of links to the pages
-    def pagy_bulma_nav(pagy, pagy_id: nil, link_extra: '',
-                       nav_aria_label: nil, nav_i18n_key: nil, **vars)
-      p_id = %( id="#{pagy_id}") if pagy_id
-      link = pagy_link_proc(pagy, link_extra:)
-
-      html = +%(<nav#{p_id} class="pagy-bulma-nav pagination #{DEFAULT[:bulma_nav_classes]}" #{
-                  nav_aria_label_attr(pagy, nav_aria_label, nav_i18n_key)}>)
-      html << bulma_prev_next_html(pagy, link)
-      html << %(<ul class="pagination-list">)
-      pagy.series(**vars).each do |item| # series example: [1, :gap, 7, 8, "9", 10, 11, :gap, 36]
-        html << case item
-                when Integer
-                  %(<li>#{link.call(item, pagy.label_for(item), %(class="pagination-link"))}</li>)
-                when String
-                  %(<li><a role="link" class="pagination-link is-current" aria-current="page" aria-disabled="true">#{
-                      pagy.label_for(item)}</a></li>)
-                when :gap
-                  %(<li><span class="pagination-ellipsis">#{pagy_t 'pagy.gap'}</span></li>)
-                else raise InternalError, "expected item types in series to be Integer, String or :gap; got #{item.inspect}"
-                end
-      end
-      html << %(</ul></nav>)
-    end
-
-    # Javascript pagination for bulma: it returns a nav and a JSON tag used by the Pagy.nav javascript
-    def pagy_bulma_nav_js(pagy, pagy_id: nil, link_extra: '',
-                          nav_aria_label: nil, nav_i18n_key: nil, **vars)
-      sequels = pagy.sequels(**vars)
-      p_id = %( id="#{pagy_id}") if pagy_id
-      link = pagy_link_proc(pagy, link_extra:)
-      tags = { 'before' => %(#{bulma_prev_next_html(pagy, link)}<ul class="pagination-list">),
-               'link'   => %(<li>#{link.call(PAGE_TOKEN, LABEL_TOKEN, %(class="pagination-link"))}</li>),
-               'active' => %(<li><a role="link" class="pagination-link is-current" aria-current="page" aria-disabled="true">#{
-                               LABEL_TOKEN}</a></li>),
-               'gap'    => %(<li><span class="pagination-ellipsis">#{pagy_t 'pagy.gap'}</span></li>),
-               'after'  => '</ul>' }
-
-      %(<nav#{p_id} class="#{'pagy-rjs ' if sequels.size > 1}pagy-bulma-nav-js pagination #{DEFAULT[:bulma_nav_classes]}" #{
-        nav_aria_label_attr(pagy, nav_aria_label, nav_i18n_key)}#{
-        pagy_data(pagy, :nav, tags, sequels, pagy.label_sequels(sequels))}></nav>)
-    end
-
-    # Javascript combo pagination for bulma: it returns a nav and a JSON tag used by the pagy.js file
-    def pagy_bulma_combo_nav_js(pagy, pagy_id: nil, link_extra: '',
-                                nav_aria_label: nil, nav_i18n_key: nil)
-      p_id    = %( id="#{pagy_id}") if pagy_id
-      link    = pagy_link_proc(pagy, link_extra:)
-      p_page  = pagy.page
-      p_pages = pagy.pages
-      input   = %(<input name="page" class="input" type="number" min="1" max="#{p_pages}" value="#{
-                    p_page}" style="padding: 0; text-align: center; width: #{
-                    p_pages.to_s.length + 1}rem; margin:0 0.3rem;" aria-current="page">)
-
-      html = %(<nav#{p_id} class="pagy-bulma-combo-nav-js #{DEFAULT[:bulma_nav_classes]}" #{
-                 nav_aria_label_attr(pagy, nav_aria_label, nav_i18n_key)} #{
-                 pagy_data(pagy, :combo, pagy_url_for(pagy, PAGE_TOKEN))}>)
-      %(#{html}<div class="field is-grouped is-grouped-centered" role="group">#{
-          if (p_prev  = pagy.prev)
-            %(<p class="control">#{link.call(p_prev, pagy_t('pagy.prev'), %(class="button" #{prev_aria_label_attr}))}</p>)
-          else
-            %(<p class="control"><a role="link" class="button" disabled aria-disabled="true" #{
-                prev_aria_label_attr}>#{pagy_t 'pagy.prev'}</a></p>)
-          end
-        }<div class="pagy-combo-input control level is-mobile">#{
-          pagy_t 'pagy.combo_nav_js', page_input: input, count: p_page, pages: p_pages}</div>#{
-          if (p_next  = pagy.next)
-            %(<p class="control">#{link.call(p_next, pagy_t('pagy.next'), %(class="button" #{next_aria_label_attr}))}</p>)
-          else
-            %(<p class="control"><a role="link" class="button" disabled aria-disabled="true"#{
-                next_aria_label_attr}>#{pagy_t 'pagy.next'}</a></p>)
-          end
-        }</div></nav>)
-    end
-
-    private
-
-    def bulma_prev_next_html(pagy, link)
-      html = +if (p_prev = pagy.prev)
-                link.call(p_prev, pagy_t('pagy.prev'), %(#{prev_aria_label_attr} class="pagination-previous"))
-              else
-                %(<a role="link" class="pagination-previous" disabled aria-disabled="true" #{
-                    prev_aria_label_attr}>#{pagy_t 'pagy.prev'}</a>)
-              end
-      html << if (p_next = pagy.next)
-                link.call(p_next, pagy_t('pagy.next'), %(#{next_aria_label_attr} class="pagination-next"))
-              else
-                %(<a role="link" class="pagination-next" disabled aria-disabled="true" #{
-                    next_aria_label_attr}>#{pagy_t('pagy.next')}</a>)
-              end
-    end
-  end
-  Frontend.prepend BulmaExtra
-end

data/lib/pagy/extras/calendar.rb

@@ -1,53 +0,0 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/calendar
-# frozen_string_literal: true
-
-require 'pagy/calendar'
-require 'pagy/calendar/helper'
-
-class Pagy # :nodoc:
-  # Add pagination filtering by calendar unit (:year, :quarter, :month, :week, :day) to the regular pagination
-  module CalendarExtra
-    # Additions for the Backend module
-    module BackendAddOn
-      CONF_KEYS = (Calendar::UNITS + %i[pagy active]).freeze
-
-      private
-
-      # Take a collection and a conf Hash with keys in CONF_KEYS and return an array with 3 items: [calendar, pagy, results]
-      def pagy_calendar(collection, conf)
-        raise ArgumentError, "keys must be in #{CONF_KEYS.inspect}" \
-              unless conf.is_a?(Hash) && (conf.keys - CONF_KEYS).empty?
-
-        conf[:pagy] ||= {}
-        unless conf.key?(:active) && !conf[:active]
-          calendar, from, to = Calendar::Helper.send(:init, conf, pagy_calendar_period(collection), params)
-          collection         = pagy_calendar_filter(collection, from, to)
-        end
-        pagy, results = send(conf[:pagy][:backend] || :pagy, collection, conf[:pagy])  # use backend: :pagy when omitted
-        [calendar, pagy, results]
-      end
-
-      # This method must be implemented by the application
-      def pagy_calendar_period(*)
-        raise NoMethodError, 'the pagy_calendar_period method must be implemented by the application ' \
-                             '(see https://ddnexus.github.io/pagy/docs/extras/calendar/#pagy-calendar-period-collection)'
-      end
-
-      # This method must be implemented by the application
-      def pagy_calendar_filter(*)
-        raise NoMethodError, 'the pagy_calendar_filter method must be implemented by the application ' \
-                             '(see https://ddnexus.github.io/pagy/docs/extras/calendar/#pagy-calendar-filter-collection-from-to)'
-      end
-    end
-
-    # Additions for the Frontend module
-    module UrlHelperAddOn
-      # Return the url for the calendar page at time
-      def pagy_calendar_url_at(calendar, time, **opts)
-        pagy_url_for(calendar.send(:calendar_at, time, **opts), 1, **opts)
-      end
-    end
-  end
-  Backend.prepend CalendarExtra::BackendAddOn, CalendarExtra::UrlHelperAddOn
-  Frontend.prepend CalendarExtra::UrlHelperAddOn
-end

data/lib/pagy/extras/countless.rb

@@ -1,37 +0,0 @@
-# See the Pagy documentation: https://ddnexus.github.io/pagy/docs/extras/countless
-# frozen_string_literal: true
-
-require 'pagy/countless'
-
-class Pagy # :nodoc:
-  DEFAULT[:countless_minimal] = false
-
-  # Paginate without the need of any count, saving one query per rendering
-  module CountlessExtra
-    private
-
-    # Return Pagy object and items
-    def pagy_countless(collection, vars = {})
-      pagy = Countless.new(pagy_countless_get_vars(collection, vars))
-      [pagy, pagy_countless_get_items(collection, pagy)]
-    end
-
-    # Sub-method called only by #pagy_countless: here for easy customization of variables by overriding
-    def pagy_countless_get_vars(_collection, vars)
-      pagy_set_items_from_params(vars) if defined?(ItemsExtra)
-      vars[:page] ||= params[vars[:page_param] || DEFAULT[:page_param]]
-      vars
-    end
-
-    # Sub-method called only by #pagy_countless: here for easy customization of record-extraction by overriding
-    # You may need to override this method for collections without offset|limit
-    def pagy_countless_get_items(collection, pagy)
-      return collection.offset(pagy.offset).limit(pagy.items) if pagy.vars[:countless_minimal]
-
-      fetched = collection.offset(pagy.offset).limit(pagy.items + 1).to_a # eager load items + 1
-      pagy.finalize(fetched.size)                                         # finalize the pagy object
-      fetched[0, pagy.items]                                              # ignore eventual extra item
-    end
-  end
-  Backend.prepend CountlessExtra
-end