rb_pager 0.1.0 → 0.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bf018c14e4ab9b25829e3400dee85caa296f7fcbd4cbdd96020eff0c620c5beb
-  data.tar.gz: 5629f3891861dda8bc388adcf3fd8196ba569bfb408ed2377bf80d61b1144871
+  metadata.gz: 9bb67cee0939ed57f6c150aac90522fee9be658c61a8d2885b2951cc8a9aee6b
+  data.tar.gz: 03f7db5037f0e0704b6b28029e4949158cdaa1f06fadfe05fac0f3bb29dceaf9
 SHA512:
-  metadata.gz: 370e67a57d010703c5d75dc4c0378876a39ad06d72da1d018d63eff8fc5ead95dce518cc2e4312dcc6181ea0c454e511fce210925686e8325f5e5b5b578106c9
-  data.tar.gz: 293378b679c82b97df6a25c35105e2024f3e1a8ad835261de14694cc23ffc34720b919fc8e26df8b136d0b8cb56171ffaf924a9c2e20dcfdd88bf5fb39bc10f7
+  metadata.gz: 6037bde51524e650d1c47ef421f6a4184abf81c94ff5cfb352cc7eb08ebbf272cdbe8447d92b3e8582bd47ac71b7502d90aede5b695f0d24e02ac1f2cb792d40
+  data.tar.gz: 39aca68ff3d20fde8157abac9daf19c1eb493e8e8f83f5c146a3c8acc0ca34b28507ec0a701f4f504500634317c2cafcb861bb54a424ccde36d68b971add12e4

data/.github/workflows/ruby.yml

@@ -0,0 +1,50 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+# This workflow will download a prebuilt Ruby version, install dependencies and run tests with Rake
+# For more information see: https://github.com/marketplace/actions/setup-ruby-jruby-and-truffleruby
+
+name: build
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+
+    runs-on: ubuntu-latest
+
+    services:
+      db:
+        image: postgres:11.6-alpine
+        env:
+          POSTGRES_PASSWORD: password
+          POSTGRES_DB: rb_pager_test
+        ports:
+          - 5432:5432
+        options: --health-cmd pg_isready --health-interval 10s --health-timeout 5s --health-retries 5
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Ruby
+    # To automatically get bug fixes and new Ruby versions for ruby/setup-ruby,
+    # change this to (see https://github.com/ruby/setup-ruby#versioning):
+    # uses: ruby/setup-ruby@v1
+      uses: ruby/setup-ruby@ec106b438a1ff6ff109590de34ddc62c540232e0
+      with:
+        ruby-version: 2.6
+    - name: Setup System
+      run: |
+          sudo apt-get -y install libpq-dev
+    - name: Install dependencies
+      run: bundle install
+    - name: Run tests
+      env:
+        DATABASE_URL: postgres://postgres:password@localhost:5432/rb_pager_test
+      run: |
+          bundle exec rake db:create
+          bundle exec rspec

data/Gemfile

@@ -2,6 +2,3 @@ source "https://rubygems.org"
 
 # Specify your gem's dependencies in pager.gemspec
 gemspec
-
-gem "rake", "~> 12.0"
-gem "rspec", "~> 3.0"

data/Gemfile.lock

@@ -0,0 +1,56 @@
+PATH
+  remote: .
+  specs:
+    rb_pager (0.2.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (6.0.3.2)
+      activesupport (= 6.0.3.2)
+    activerecord (6.0.3.2)
+      activemodel (= 6.0.3.2)
+      activesupport (= 6.0.3.2)
+    activesupport (6.0.3.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.2, >= 2.2.2)
+    concurrent-ruby (1.1.6)
+    diff-lcs (1.4.4)
+    i18n (1.8.3)
+      concurrent-ruby (~> 1.0)
+    minitest (5.14.1)
+    pg (1.2.3)
+    rake (13.0.1)
+    rspec (3.9.0)
+      rspec-core (~> 3.9.0)
+      rspec-expectations (~> 3.9.0)
+      rspec-mocks (~> 3.9.0)
+    rspec-core (3.9.2)
+      rspec-support (~> 3.9.3)
+    rspec-expectations (3.9.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-mocks (3.9.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.9.0)
+    rspec-support (3.9.3)
+    thread_safe (0.3.6)
+    tzinfo (1.2.7)
+      thread_safe (~> 0.1)
+    zeitwerk (2.3.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (>= 5.2)
+  pg
+  rake (~> 13.0)
+  rb_pager!
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   2.1.4

data/README.md

@@ -1,6 +1,7 @@
 
 # Pager
-
+[![Gem Version](https://badge.fury.io/rb/rb_pager.svg)](https://badge.fury.io/rb/rb_pager)
+![build](https://github.com/BambangSinaga/rb_pager/workflows/build/badge.svg)
 
 Cursor-based pagination (aka keyset pagination) is a  [common](https://slack.engineering/evolving-api-pagination-at-slack-1c1f644f8e12)  [pagination strategy](https://www.citusdata.com/blog/2016/03/30/five-ways-to-paginate/)  that avoids many of the pitfalls of “offset–limit” pagination.
 
@@ -8,7 +9,7 @@ For example, with offset–limit pagination, if an item from a prior page is del
 
 Cursor-based pagination also performs better for large data sets under most implementations.
 
-To support cursor-based pagination, this specification defines three query parameters `after`, `limit`, `sort`
+To support cursor-based pagination, this specification defines four query parameters `after`, `before`, `limit`, and `sort`
 
 ## Installation
 
@@ -37,24 +38,40 @@ The system use 	`Base64.strict_decode64` and `Base64.strict_encode64` for cursor
 
 ```ruby
 # return first 20 employee records, by default limit set to 20
-Employee.pager(after:  nil)
+Employee.pager
 
 # return first 15 employee records
-Employee.pager(after:  nil, limit: 15)
+Employee.pager(limit: 15)
 
 # return first 10 employee records order by created_at asc
 # /employee?limit=10&sort=created_at
-Employee.pager(after:  nil, limit:  10, sort:  'created_at')
+Employee.pager(after:  'w33t44==', limit:  10, sort:  'created_at')
 
 # return first 10 employee records order by created_at desc
 # /employee?limit=10&sort=-created_at
-Employee.pager(after:  nil, limit:  10, sort:  '-created_at')
+Employee.pager(after:  'w33t44==', limit:  10, sort:  '-created_at')
 
 # [order by non uniq column](https://engineering.shopify.com/blogs/engineering/pagination-relative-cursors)
-# /employee?limit=10&sort=name,id
-Employee.pager(after:  nil, limit:  10, sort:  'name,id')
+# /employee?limit=10&sort=name,id&after=w33t44==
+Employee.pager(after:  'w33t44==', limit:  10, sort:  'name,id')
+
+# /employee?limit=10&sort=name,id&before=w33t44==
+Employee.pager(before:  'w33t44==', limit:  10, sort:  'name,id')
+
+# on EmployeesController
+records, meta = Employee.pager(limit:  15)
+# meta => { prev_cursor => 'ergOW==' next_cursor => 'uahOI==' }
+render  json: EmployeeSerializer.new(records, meta: meta).serialized_json, status:  :ok
 ```
 
+## On progress
+
+ - [x] implement  `before`  cursor
+ - [x] meta url for next and previous page
+ - [ ] meta url for first, last and collection size
+ - [ ] [error-cases](https://jsonapi.org/profiles/ethanresnick/cursor-pagination/#auto-id-error-cases)
+ - [ ] custom encoder
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/Rakefile

@@ -4,3 +4,15 @@ require "rspec/core/rake_task"
 RSpec::Core::RakeTask.new(:spec)
 
 task :default => :spec
+
+namespace :db do
+  desc "Create the test DB"
+  task :create do
+    `createdb rb_pager_test`
+  end
+
+  desc "Drop the test DB"
+  task :drop do
+    `dropdb rb_pager_test`
+  end
+end

data/lib/config/rb_pager.rb

@@ -1,4 +1,4 @@
-# Pager.configure do |config|
+# RbPager.configure do |config|
 #   config.limit = 15
 #   config.max_limit = 100
 # end

data/lib/rb_pager.rb

@@ -1,9 +1,10 @@
 require 'active_record'
 require 'rb_pager/version'
-require "rb_pager/configuration"
+require 'rb_pager/configuration'
+require 'rb_pager/base64_encoder'
 
 module RbPager
-  class Error < StandardError; end
+  class InvalidLimitValueError < StandardError; end
 
   class << self
     attr_accessor :configuration
@@ -17,5 +18,6 @@ end
 
 if defined?(ActiveRecord)
   require 'rb_pager/orm/pager_active_record'
+  require 'rb_pager/orm/active_record_relation_methods'
   ActiveRecord::Base.send :include, RbPager::ActiveRecord
 end

data/lib/rb_pager/base64_encoder.rb

@@ -0,0 +1,20 @@
+require 'base64'
+module RbPager
+  module Base64Encoder
+    def encode(data)
+      return nil if data.to_s.empty?
+      Base64.strict_encode64(data)
+    end
+
+    def decode(data)
+      return nil if data.to_s.empty?
+
+      decoded_data = Base64.strict_decode64(data)
+      Hash[
+        decoded_data.split(',').map do |pair|
+          k, v = pair.split(':', 2)
+        end
+      ]
+    end
+  end
+end

data/lib/rb_pager/orm/active_record_relation_methods.rb

@@ -0,0 +1,36 @@
+module RbPager
+  module ActiveRecord
+    module ActiveRecordRelationMethods
+      def left_over?
+        @left_over ||= begin
+          # Cache #size otherwise multiple calls to the database will occur.
+          records.size.positive? && records.size < total_size
+        end
+      end
+
+      # Returns number of records that exist in scope of the current cursor
+      def total_size(column_name = :all) #:nodoc:
+        # #count overrides the #select which could include generated columns
+        # referenced in #order, so skip #order here, where it's irrelevant to the
+        # result anyway.
+        @total_size ||= begin
+          context = except(:offset, :limit, :order)
+
+          # Remove includes only if they are irrelevant
+          context = context.except(:includes) unless references_eager_loaded_tables?
+
+          args = [column_name]
+
+          # .group returns an OrderedHash that responds to #count
+          context = context.count(*args)
+
+          if context.is_a?(Hash) || context.is_a?(ActiveSupport::OrderedHash)
+            context.count
+          else
+            context.respond_to?(:count) ? context.count(*args) : context
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rb_pager/orm/pager_active_record.rb

@@ -3,130 +3,126 @@ module RbPager
     extend ActiveSupport::Concern
 
     module ClassMethods
+      include ::RbPager::Base64Encoder
+
       AR_ORDER = { '+' => :asc, '-' => :desc }
-      AREL_ORDER = { asc: :gt, desc: :lt }
-
-      def pager(after:, limit: nil, sort: nil)
-        page_limit = limit || RbPager.configuration.limit
-        sort_params = sort
-        sorted_columns, sorter = build_order_expression(sort)
-        collection = if after.nil?
-                       order(sorter).extending(ActiveRecordRelationMethods).limit(page_limit)
-                     else
-                       custom_expression = create_custom_expression(after, sorted_columns)
-                       where(custom_expression).order(sorter).extending(ActiveRecordRelationMethods).limit(page_limit)
-                     end
-
-        create_paginate_meta(collection, sorted_columns)
-      end
 
-      private
+      def pager(after: nil, before: nil, limit: nil, sort: nil)
+        instance_variable_set(:@sorted_columns, nil)
+        instance_variable_set(:@collection, nil)
+        instance_variable_set(:@records, nil)
 
-      def create_custom_expression(cursor_params, sorted_columns)
-        decode_cursor_params = JSON.parse(Base64.strict_decode64(cursor_params))
-        return arel_table[primary_key].gt(decode_cursor_params[primary_key]) if sorted_columns.blank?
+        limit = nil if limit && limit < 2
+        @page_limit = limit || RbPager.configuration.limit
+        raise InvalidLimitValueError if @page_limit && @page_limit < 1
+        @sort = sort
 
-        filter_ordered_columns = filter_with_ordered_columns(decode_cursor_params, sorted_columns)
-        filter_primary_key = filter_with_primary_key(decode_cursor_params)
+        @after = decode(after)
+        @before = decode(before)
+        @direction = :next
 
-        filter_ordered_columns.or(filter_primary_key)
+        create_paginate_meta
       end
 
-      def filter_with_ordered_columns(decode_cursor_params, sorted_columns)
-        result = self
-        sorted_columns.each_with_index do |(column, type), index|
-          result = if index.zero?
-                     result.arel_table[column].send(AREL_ORDER[type])
-                   else
-                     result.or(arel_table[column].send(AREL_ORDER[type]))
-                   end
-        end
+      private
 
-        result
+      def apply_after
+        return nil if @after.nil?
+
+        if sorted_columns.values.all? :asc
+          Arel::Nodes::GreaterThan.new(
+            Arel::Nodes::Grouping.new(@after.keys.map{ |col| arel_table[col] }),
+            Arel::Nodes::Grouping.new(@after.values.map{ |col| Arel::Nodes.build_quoted(col) })
+          )
+        else
+          @direction = :prev
+          Arel::Nodes::LessThan.new(
+            Arel::Nodes::Grouping.new(@after.keys.map{|col| arel_table[col]}),
+            Arel::Nodes::Grouping.new(@after.values.map{ |col| Arel::Nodes.build_quoted(col) })
+          )
+        end
       end
 
-      def filter_with_primary_key(decode_cursor_params)
-        result = self
-
-        decode_cursor_params.each_with_index do |(column, value), index|
-          result = if index.zero?
-                     result.arel_table[column].gt(value)
-                   else
-                     result.and(arel_table[column].eq(value))
-                   end
+      def apply_before
+        return nil if @before.nil?
+
+        if sorted_columns.values.all? :asc
+          @direction = :prev
+          Arel::Nodes::LessThan.new(
+            Arel::Nodes::Grouping.new(@before.keys.map{ |col| arel_table[col] }),
+            Arel::Nodes::Grouping.new(@before.values.map{ |col| Arel::Nodes.build_quoted(col) })
+          )
+        else
+          Arel::Nodes::GreaterThan.new(
+            Arel::Nodes::Grouping.new(@before.keys.map{|col| arel_table[col]}),
+            Arel::Nodes::Grouping.new(@before.values.map{ |col| Arel::Nodes.build_quoted(col) })
+          )
         end
-
-        result
       end
 
-      def build_order_expression(sort_params)
-        return {} if sort_params.nil?
+      def sorted_columns
+        @sorted_columns ||= begin
+          sorted_columns = {} if @sort.nil?
+          sorted_columns ||= construct_sorted_columns
+        end
+      end
 
-        sort_order = { '+' => 'ASC', '-' => 'DESC' }
+      def construct_sorted_columns
         sorted_params = {}
-        arel_orders = []
-
-        sort_params.split(',').each do |field|
-          next unless attribute_names.include?(field)
+        fields = @sort.split(',')
 
+        fields.each do |field|
           sort_sign = field =~ /\A[+-]/ ? field.slice!(0) : '+'
-          arel_orders << arel_table[field].send(AR_ORDER[sort_sign])
-          sorted_params[field] = AR_ORDER[sort_sign]
+          sorted_params[field] = AR_ORDER[sort_sign] if attribute_names.include?(field)
         end
 
-        [sorted_params, arel_orders]
+        sorted_params
       end
 
-      def create_paginate_meta(collection, sorted_columns)
-        next_cursor = next_cursor(collection, sorted_columns)
+      def create_paginate_meta
+        cursor = cursor(collection)
 
-        meta = { next_cursor: next_cursor }
-        [collection.to_a, meta]
+        meta = { prev_cursor: cursor.first, next_cursor: cursor.last }
+        [collection, meta]
       end
 
-      def next_cursor(collection, sorted_columns)
-        return '' unless collection.left_over?
-
-        next_cursor = { 'id': collection.last.id }
-
-        sorted_columns.each do |key, _value|
-          next_cursor.merge!(Hash[key, collection.last.send(key)])
-        end
-
-        Base64.strict_encode64(next_cursor.to_json)
+      def collection
+        @collection ||= where(apply_after)
+                        .where(apply_before)
+                        .order(sorted_columns)
+                        .extending(ActiveRecordRelationMethods)
+                        .limit(@page_limit)
       end
-    end
 
-    module ActiveRecordRelationMethods
-      def left_over?
-        @left_over ||= begin
-          # Cache #size otherwise multiple calls to the database will occur.
-          size.positive? && size < total_size
-        end
+      def records
+        @records || collection.to_a
       end
 
-      # Returns number of records that exist in scope of the current cursor
-      def total_size(column_name = :all) #:nodoc:
-        # #count overrides the #select which could include generated columns
-        # referenced in #order, so skip #order here, where it's irrelevant to the
-        # result anyway.
-        @total_size ||= begin
-          context = except(:offset, :limit, :order)
-
-          # Remove includes only if they are irrelevant
-          context = context.except(:includes) unless references_eager_loaded_tables?
+      def cursor(collection)
+        return ['', ''] if collection.total_size.zero?
 
-          args = [column_name]
+        prev_cursor, next_cursor = [], []
 
-          # .group returns an OrderedHash that responds to #count
-          context = context.count(*args)
+        if sorted_columns.blank?
+          prev_cursor = ["#{primary_key}:#{records.first.send(primary_key)}"]
+          next_cursor = ["#{primary_key}:#{records.last.send(primary_key)}"]
+        else
+          sorted_columns.each do |key, _value|
+            if type_for_attribute(key).type.eql? :datetime
+              prev_cursor << "#{key}:#{records.first.send(key).rfc3339(9)}"
+              next_cursor << "#{key}:#{records.last.send(key).rfc3339(9)}"
+              next
+            end
 
-          if context.is_a?(Hash) || context.is_a?(ActiveSupport::OrderedHash)
-            context.count
-          else
-            context.respond_to?(:count) ? context.count(*args) : context
+            prev_cursor << "#{key}:#{records.first.send(key)}"
+            next_cursor << "#{key}:#{records.last.send(key)}"
           end
         end
+
+        return ['', encode(next_cursor.join(','))] if (@after.nil? && @before.nil?) && collection.left_over?
+        return [encode(prev_cursor.join(',')), ''] if !collection.left_over?
+
+        [encode(prev_cursor.join(',')), encode(next_cursor.join(','))]
       end
     end
   end

data/lib/rb_pager/version.rb

@@ -1,3 +1,3 @@
 module RbPager
-  VERSION = "0.1.0"
+  VERSION = "0.2.3"
 end

data/rb_pager.gemspec

@@ -7,8 +7,10 @@ Gem::Specification.new do |spec|
   spec.email         = ["mejbambang@gmail.com"]
 
   spec.summary       = "Cursor based pagination for active_record currently"
-  spec.description   = %q{ActiveRecord plugin for cursor based pagination for Ruby on Rails. \n
-    Cursor-based pagination (aka keyset pagination) is a common pagination strategy that avoids many of the pitfalls of “offset–limit” pagination.}
+  spec.description   = <<~DESC
+    ActiveRecord plugin for cursor based pagination for Ruby on Rails.
+    Cursor-based pagination (aka keyset pagination) is a common pagination strategy that avoids many of the pitfalls of “offset–limit” pagination.
+  DESC
   spec.homepage      = "https://github.com/BambangSinaga/rb_pager"
   spec.license       = "MIT"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
@@ -19,9 +21,10 @@ Gem::Specification.new do |spec|
   spec.metadata["source_code_uri"] = "https://github.com/BambangSinaga/rb_pager"
   # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
 
-  spec.add_development_dependency "sqlite3"
-  spec.add_development_dependency "activerecord"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "activerecord", ">= 5.2"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pg"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.

metadata

@@ -1,45 +1,59 @@
 --- !ruby/object:Gem::Specification
 name: rb_pager
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.3
 platform: ruby
 authors:
 - BambangSinaga
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-03 00:00:00.000000000 Z
+date: 2020-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: sqlite3
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '5.2'
 - !ruby/object:Gem::Dependency
-  name: activerecord
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '13.0'
 - !ruby/object:Gem::Dependency
   name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -52,19 +66,21 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: |-
-  ActiveRecord plugin for cursor based pagination for Ruby on Rails. \n
-      Cursor-based pagination (aka keyset pagination) is a common pagination strategy that avoids many of the pitfalls of “offset–limit” pagination.
+description: |
+  ActiveRecord plugin for cursor based pagination for Ruby on Rails.
+  Cursor-based pagination (aka keyset pagination) is a common pagination strategy that avoids many of the pitfalls of “offset–limit” pagination.
 email:
 - mejbambang@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
@@ -72,7 +88,9 @@ files:
 - bin/setup
 - lib/config/rb_pager.rb
 - lib/rb_pager.rb
+- lib/rb_pager/base64_encoder.rb
 - lib/rb_pager/configuration.rb
+- lib/rb_pager/orm/active_record_relation_methods.rb
 - lib/rb_pager/orm/pager_active_record.rb
 - lib/rb_pager/version.rb
 - rb_pager.gemspec
@@ -98,7 +116,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Cursor based pagination for active_record currently