pagy 43.0.0 → 43.3.0

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

@@ -12,6 +12,7 @@ class Pagy
   # Build the nav tag, with the specific inner html for the style
   def wrap_series_nav(html, nav_classes, id: nil, aria_label: nil, **)
     data = %( #{data_pagy_attribute(:k, @update)}) if keynav?
-    %(<nav#{id && %( id="#{id}")} class="#{nav_classes}" #{nav_aria_label_attribute(aria_label:)}#{data}>#{html}</nav>)
+
+    %(<nav#{%( id="#{id}") if id} class="#{nav_classes}" #{nav_aria_label_attribute(aria_label:)}#{data}>#{html}</nav>)
   end
 end

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

@@ -20,15 +20,21 @@ class Pagy
 
   # Support for the Calendar API
   def page_labels(series)
-    series.map { |s| s.map { |item| item == :gap ? :gap : page_label(item) } } if calendar?
+    return unless calendar?
+
+    series.map do |s|
+      s.map { _1 == :gap ? :gap : page_label(_1) }
+    end
   end
 
   # Build the nav_js tag, with the specific tokens for the style
   def wrap_series_nav_js(tokens, nav_classes, id: nil, aria_label: nil, **)
-    sequels = sequels(**)
-    %(<nav#{id && %( id="#{id}")} class="#{'pagy-rjs ' if sequels[0].size > 1}#{nav_classes}" #{
+    sequels     = sequels(**)
+    nav_classes = "pagy-rjs #{nav_classes}" if sequels[0].size > 1
+
+    %(<nav#{%( id="#{id}") if id} class="#{nav_classes}" #{
       nav_aria_label_attribute(aria_label:)} #{
-      data = [:snj, tokens.values, sequels]
+      data = [:snj, tokens.values, PAGE_TOKEN, sequels]
       data.push(@update) if keynav?
       data_pagy_attribute(*data)
       }></nav>)

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

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 class Pagy
-  # Generte  hash of the pagination links
+  # Generate the hash of the pagination links
   def urls_hash(**)
-    url = compose_page_url(PAGE_TOKEN, **)
-    { first: compose_page_url(nil, **) }.tap do |urls| # first is present, but the URL omits the nil page param
-      urls[:previous] = url.sub(PAGE_TOKEN, @previous.to_s) if @previous
-      urls[:next]     = url.sub(PAGE_TOKEN, @next.to_s)     if @next
-      urls[:last]     = url.sub(PAGE_TOKEN, @last.to_s)     if @count # offset and not countless
-    end
+    template = compose_page_url(PAGE_TOKEN, **)
+
+    { first:    compose_page_url(nil, **),
+      previous: @previous && template.sub(PAGE_TOKEN, @previous.to_s),
+      next:     @next     && template.sub(PAGE_TOKEN, @next.to_s),
+      last:     @count    && template.sub(PAGE_TOKEN, @last.to_s) }.compact
   end
 end

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

@@ -8,20 +8,24 @@ class Pagy
     def paginate(context, collection, config)
       context.instance_eval do
         allowed_options = Calendar::UNITS + %i[offset disabled request]
-        raise ArgumentError, "keys must be in #{allowed_options.inspect}" \
-              unless config.is_a?(Hash) && (config.keys - allowed_options).empty?
 
-        config[:request]  = Request.new(config[:request] || request)
+        unless config.is_a?(Hash) && (config.keys - allowed_options).empty?
+          raise ArgumentError, "keys must be in #{allowed_options.inspect}"
+        end
+
         config[:offset] ||= {}
+
         unless config[:disabled]
-          calendar, from, to =
-            Calendar.send(:init, config,
-                          pagy_calendar_period(collection),
-                          config[:request].query) 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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../../modules/abilities/countable'
+
+class Pagy
+  module CountishPaginator
+    module_function
+
+    # 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
+
+      options[:limit] = options[:request].resolve_limit
+      setup_options(count, epoch, collection, 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
+      ongoing = !options[:ttl] || (epoch && epoch <= now && now < (epoch + options[:ttl]))
+
+      if !options[:count] && count && ongoing
+        options[:count] = count
+        options[:epoch] = epoch if options[:ttl]
+      else # recount
+        options[:count] ||= Countable.get_count(collection, options)
+        options[:epoch]   = now if options[:ttl]
+      end
+    end
+  end
+end

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

@@ -4,22 +4,20 @@ class Pagy
   module CountlessPaginator
     module_function
 
-    # Return Pagy object and records
-    def paginate(context, collection, **options)
-      context.instance_eval do
-        request = Request.new(options[:request] || self.request, options)
-        if options[:page].nil?
-          page = request.resolve_page(options, force_integer: false) # accept nil and strings
-          if page.is_a?(String)
-            p, l = page.split(/ /, 2).map(&:to_i)
-            options[:page] = p if p.positive?
-            options[:last] = l if l&.positive?
-          end
-        end
-        options[:limit] = request.resolve_limit(options)
-        pagy = Offset::Countless.new(**options, request:)
-        [pagy, pagy.records(collection)]
+    # 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) # ' ' 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, pagy.records(collection)]
     end
   end
 end

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

@@ -7,26 +7,51 @@ class Pagy
     module_function
 
     # Paginate from the search object
-    def paginate(context, search, **options)
-      context.instance_eval do
-        if search.is_a?(Search::Arguments)
-          # The search is the array of pagy_search arguments
-          Searcher.wrap(self, search, options) do
-            model, query_or_payload, search_options = search
-            search_options[:size] = options[:limit]
-            search_options[:from] = options[:limit] * ((options[:page] || 1) - 1)
-            results               = model.send(ElasticsearchRails::DEFAULT[:search_method], query_or_payload, **search_options)
-            options[:count]       = ElasticsearchRails.total_count(results)
-            [ElasticsearchRails.new(**options), results]
-          end
-        else
-          # The search is an elasticsearch_rails response
-          options[:limit] = search.search.options[:size] || 10
-          options[:page]  = ((search.search.options[:from] || 0) / options[:limit]) + 1
-          options[:count] = ElasticsearchRails.total_count(search)
-          ElasticsearchRails.new(**options)
+    def paginate(search, options)
+      if search.is_a?(Search::Arguments)  # Active mode
+
+        Searcher.wrap(search, options) do
+          model, arguments, search_options = search
+
+          search_options[:size] = options[:limit]
+          search_options[:from] = options[:limit] * ((options[:page] || 1) - 1)
+
+          method          = options[:search_method] || ElasticsearchRails::DEFAULT[:search_method]
+          response_object = model.send(method, *arguments, **search_options)
+          options[:count] = total_count_from(response_object)
+
+          [ElasticsearchRails.new(**options), response_object]
         end
+
+      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
+
+    # Get from and size params from the response object, supporting different versions of ElasticsearchRails
+    def pagination_params_from(response_object)
+      definition = response_object.search.definition
+      definition = definition.to_hash if definition.respond_to?(:to_hash)
+      container  = (definition.is_a?(Hash) && (definition[:body] || definition)) || response_object.search.options
+      from       = (container[:from] || container['from']).to_i
+      size       = (container[:size] || container['size']).to_i
+      size       = 10 if size.zero?
+
+      [from, size]
+    end
+
+    # Get the count from the response object, supporting different versions of ElasticsearchRails
+    def total_count_from(response_object)
+      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
 end

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

@@ -6,24 +6,23 @@ class Pagy
   module KeynavJsPaginator
     module_function
 
-    # Return Pagy::Keyset::Keynav object and paginated records.
+    # Return the Pagy::Keyset::Keynav instance and paginated records.
     # Fall back to :countless if the :page has no client data.
-    def paginate(context, set, **options)
-      context.instance_eval do
-        request = Request.new(options[:request] || self.request, options)
-        page    = request.resolve_page(options, force_integer: false) # allow nil
-        if page&.match(' ')       # countless page -> no augmentation -> fallback
-          return pagy(:countless, set, page:, **options)
-        elsif page.is_a?(String)  # keynav page param
-          page_arguments = JSON.parse(B64.urlsafe_decode(page))
-          # Restart the pagination from page 1 if the url has been requested from another browser
-          options[:page] = page_arguments if request.cookie == page_arguments.shift
-        end
+    def paginate(set, options)
+      page = options[:request].resolve_page(force_integer: false) # allow nil
 
-        options[:limit] = request.resolve_limit(options)
-        pagy = Keyset::Keynav.new(set, **options, request:)
-        [pagy, pagy.records]
+      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
   end
 end

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

@@ -4,15 +4,13 @@ class Pagy
   module KeysetPaginator
     module_function
 
-    # Return Pagy::Keyset object and paginated records
-    def paginate(context, set, **options)
-      context.instance_eval do
-        request = Request.new(options[:request] || self.request, options)
-        options[:page] ||= request.resolve_page(options, force_integer: false) # allow nil
-        options[:limit]  = request.resolve_limit(options)
-        pagy = Keyset.new(set, **options, request:)
-        [pagy, pagy.records]
-      end
+    # Return Pagy::Keyset instance and paginated records
+    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, pagy.records]
     end
   end
 end

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

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

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

@@ -5,22 +5,34 @@ require_relative '../../classes/request'
 class Pagy
   paginators = { offset:              :OffsetPaginator,
                  countless:           :CountlessPaginator,
+                 countish:            :CountishPaginator,
                  keyset:              :KeysetPaginator,
                  keynav_js:           :KeynavJsPaginator,
                  calendar:            :CalendarPaginator,
                  elasticsearch_rails: :ElasticsearchRailsPaginator,
                  meilisearch:         :MeilisearchPaginator,
-                 searchkick:          :SearchkickPaginator }.freeze
+                 searchkick:          :SearchkickPaginator,
+                 typesense_rails:     :TypesenseRailsPaginator }.freeze
 
   path = Pathname.new(__dir__)
   paginators.each { |symbol, name| autoload name, path.join(symbol.to_s) }
 
-  # Defines the pagy method. Include in the app controller/view.
+  # Pagy::Method defines the #pagy method to be included in the app controller/view.
   Method = Module.new do
              protected
 
              define_method :pagy do |paginator = :offset, collection, **options|
-               Pagy.const_get(paginators[paginator]).paginate(self, collection, **Pagy.options, **options)
+               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
 end

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

@@ -1,33 +1,25 @@
 # frozen_string_literal: true
 
+require_relative '../../modules/abilities/countable'
+
 class Pagy
   module OffsetPaginator
     module_function
 
-    # Return instance and page of results
-    def paginate(context, collection, **options)
-      context.instance_eval do
-        request = Request.new(options[:request] || self.request, options)
-        options[:page]  ||= request.resolve_page(options)
-        options[:limit]   = request.resolve_limit(options)
-        options[:count] ||= collection.instance_of?(Array) ? collection.size : OffsetPaginator.get_count(collection, options)
-        pagy = Offset.new(**options, request:)
-        [pagy, collection.instance_of?(Array) ? collection[pagy.offset, pagy.limit] : pagy.records(collection)]
-      end
-    end
+    # Return the Pagy::Offset instance and results
+    def paginate(collection, options)
+      options[:page]  ||= options[:request].resolve_page
+      options[:limit]   = options[:request].resolve_limit
+      options[:count] ||= Countable.get_count(collection, options)
 
-    # Get the collection count
-    def get_count(collection, options)
-      return collection.count unless defined?(::ActiveRecord) && collection.is_a?(::ActiveRecord::Relation)
+      pagy    = Offset.new(**options)
+      records = if collection.instance_of?(Array)
+                  collection[pagy.offset, pagy.limit]
+                else
+                  pagy.records(collection)
+                end
 
-      count = if options[:count_over] && !collection.group_values.empty?
-                # COUNT(*) OVER ()
-                sql = Arel.star.count.over(Arel::Nodes::Grouping.new([]))
-                collection.unscope(:order).pick(sql).to_i
-              else
-                collection.count(:all)
-              end
-      count.is_a?(Hash) ? count.size : count
+      [pagy, records]
     end
   end
 end

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

@@ -7,25 +7,28 @@ class Pagy
     module_function
 
     # Paginate from the search object
-    def paginate(context, search, **options)
-      context.instance_eval do
-        if search.is_a?(Search::Arguments)
-          # The search is the array of pagy_search arguments
-          Searcher.wrap(self, search, options) do
-            model, term, search_options, block = search
-            search_options[:per_page] = options[:limit]
-            search_options[:page]     = options[:page]
-            results                   = model.send(Searchkick::DEFAULT[:search_method], term || '*', **search_options, &block)
-            options[:count]           = results.total_count
-            [Searchkick.new(**options), results]
-          end
-        else
-          # The search is a searchkick results object
-          options[:limit] = search.options[:per_page]
-          options[:page]  = search.options[:page]
-          options[:count] = search.total_count
-          Searchkick.new(**options)
+    def paginate(search, options)
+      if search.is_a?(Search::Arguments) # Active mode
+
+        Searcher.wrap(search, options) do
+          model, arguments, search_options, block = search
+
+          search_options[:per_page] = options[:limit]
+          search_options[:page]     = options[:page]
+
+          method          = options[:search_method] || Searchkick::DEFAULT[:search_method]
+          results         = model.send(method, *arguments || '*', **search_options, &block)
+          options[:count] = results.total_count
+
+          [Searchkick.new(**options), results]
         end
+
+      else # Passive mode
+        options[:limit] = search.respond_to?(:options) ? search.options[:per_page] : search.per_page
+        options[:page]  = search.respond_to?(:options) ? search.options[:page]     : search.current_page
+        options[:count] = search.total_count
+
+        Searchkick.new(**options)
       end
     end
   end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative '../../modules/searcher'
+
+class Pagy
+  module TypesenseRailsPaginator
+    module_function
+
+    # Paginate from the search object
+    def paginate(search, options)
+      if search.is_a?(Search::Arguments) # Active mode
+
+        Searcher.wrap(search, options) do
+          model, arguments, search_options = search
+
+          search_options[:per_page] = options[:limit]
+          search_options[:page]     = options[:page]
+
+          method          = options[:search_method] || TypesenseRails::DEFAULT[:search_method]
+          results         = model.send(method, *arguments, search_options)
+          options[:count] = results.raw_answer['found']
+
+          [TypesenseRails.new(**options), results]
+        end
+
+      else # Passive mode
+        options[:limit] = search.raw_answer['request_params']['per_page']
+        options[:page]  = search.raw_answer['page']
+        options[:count] = search.raw_answer['found']
+
+        TypesenseRails.new(**options)
+      end
+    end
+  end
+end

data/lib/pagy.rb

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
 
 require 'pathname'
+
 require_relative 'pagy/classes/exceptions'
 require_relative 'pagy/modules/abilities/linkable'
 require_relative 'pagy/modules/abilities/configurable'
 require_relative 'pagy/toolbox/helpers/loader'
 
 # Top superclass: it defines only what's common to all the subclasses
+# noinspection RubyMismatchedArgumentType
 class Pagy
-  VERSION     = '43.0.0'
+  VERSION     = '43.3.0'
   ROOT        = Pathname.new(__dir__).parent.freeze
   DEFAULT     = { limit: 20, limit_key: 'limit', page_key: 'page' }.freeze
-  PAGE_TOKEN  = 'P '
-  LIMIT_TOKEN = 'L '
+  PAGE_TOKEN  = EscapedValue.new('P ')
+  LIMIT_TOKEN = EscapedValue.new('L ')
   LABEL_TOKEN = 'L'
   A_TAG       = '<a style="display: none;">#</a>'
 
@@ -26,9 +28,11 @@ class Pagy
   autoload :ElasticsearchRails, path.join('classes/offset/search')
   autoload :Meilisearch,        path.join('classes/offset/search')
   autoload :Searchkick,         path.join('classes/offset/search')
+  autoload :TypesenseRails,     path.join('classes/offset/search')
   autoload :Keyset,             path.join('classes/keyset/keyset')
 
-  def self.options = @options ||= {}
+  OPTIONS = {} # rubocop:disable Style/MutableConstant
+  def self.options = OPTIONS
 
   extend Configurable
   include Linkable
@@ -46,11 +50,16 @@ class Pagy
   def keyset?    = false
   def keynav?    = false
 
-  # Validates and assign the passed options: var must be present and value.to_i must be >= to min
+  # Validates and assign the passed options: they must be present and value.to_i must be >= min
   def assign_and_check(name_min)
     name_min.each do |name, min|
-      raise OptionError.new(self, name, ">= #{min}", @options[name]) \
-            unless @options[name].respond_to?(:to_i) && instance_variable_set(:"@#{name}", @options[name].to_i) >= min
+      value = @options[name]
+
+      if value.respond_to?(:to_i) && (integer = value.to_i) >= min
+        instance_variable_set(:"@#{name}", integer)
+      else
+        raise OptionError.new(self, name, ">= #{min}", value)
+      end
     end
   end
 
@@ -59,10 +68,14 @@ class Pagy
     @request = options.delete(:request) # internal object
     default  = {}
     current  = self.class
-    begin
+
+    loop do
       default = current::DEFAULT.merge(default)
       current = current.superclass
-    end until current == Object  # rubocop:disable Lint/Loop  -- see https://github.com/rubocop/rubocop-performance/issues/362
-    @options = default.merge!(options.delete_if { |k, v| default.key?(k) && (v.nil? || v == '') }).freeze
+      break if current == Object
+    end
+
+    clean_options = options.delete_if { |k, v| default.key?(k) && (v.nil? || v == '') }
+    @options      = default.merge!(clean_options).freeze
   end
 end

data/locales/id.yml

@@ -4,9 +4,7 @@ id:
   pagy:
     p11n: 'Other'
     aria_label:
-      # please add a comment in the https://github.com/ddnexus/pagy/issues/588
-      # posting the translation of the following  "Page"/"Pages" with the plurals for this locale
-      nav: "Pages"
+      nav: "Halaman"
       previous: "Sebelumnya"
       next: "Selanjutnya"
     previous: "<"

data/locales/ja.yml

@@ -4,9 +4,7 @@ ja:
   pagy:
     p11n: 'Other'
     aria_label:
-      # please add a comment in the https://github.com/ddnexus/pagy/issues/590
-      # posting the translation of the following  "Page"/"Pages" with the plurals for this locale
-      nav: "Pages"
+      nav: "ページ"
       previous: "前へ"
       next: "次へ"
     previous: "<"

data/locales/km.yml

@@ -4,9 +4,7 @@ km:
   pagy:
     p11n: 'Other'
     aria_label:
-      # please add a comment in the https://github.com/ddnexus/pagy/issues/591
-      # posting the translation of the following  "Page"/"Pages" with the plurals for this locale
-      nav: "Pages"
+      nav: "ទំព័រ"
       previous: "មុន"
       next: "បន្ទាប់"
     previous: "<"

data/locales/sw.yml

@@ -9,8 +9,8 @@ sw:
     # after you make these changes.
     aria_label:
       nav:
-        one: "Page"
-        other: "Pages"
+        one: "Ukurasa"
+        other: "Kurasa"
       previous: "Awali"
       next: "Ifuatayo"
     previous: "<"