rb_pager 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08d892ce787fddafc76730efd1e2712da4424f483cfb93d17ec217e70530cefc'
-  data.tar.gz: 1cbe5622d6f768047495fcc4a86eb87aabcab41cfc835a6e312d4c63acff9114
+  metadata.gz: bdd82410767649de7ec56d84ba2c311a08555eb4e53ca47e0974f8e54540cf02
+  data.tar.gz: fcc26daca9475701f37e4e5f259e8921edb2fd961ce64e874df1cf3cca84e33a
 SHA512:
-  metadata.gz: abf2b7864075d88dc03fc3e615033cb428ca773e972338013199f0bf0490dbb5d6c8e8b95917b910b522499339c240756324ffab15a1475f8b6b5d1bf9a7d79f
-  data.tar.gz: 2995f411fa986b57b746ffee5c5148a3fab4241cdd22e0f6b09ba60e575a1e5179244c577e2ee44289f1cc7f1defc1b76b0914e2814ad4f476145cce673af782
+  metadata.gz: 335ff86d22e237f2f14826edaf9357b220e0b48019dc9f0534b7f611370ae7f15fdff6956da2a552c25a9fe316de7b5215079a690485c95a08171dd6d633a9d3
+  data.tar.gz: 12bc348e3abd3f82bfaee15fbd52a8ea15ca4ab9aca9da92cc0e3ba9e3345cb205bda27e4e1b9b05ae44fae84c330a77e978d2e3273027dec25e5eed4089720c

data/.github/workflows/ruby.yml

@@ -18,6 +18,16 @@ jobs:
 
     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
@@ -29,8 +39,12 @@ jobs:
         ruby-version: 2.6
     - name: Setup System
       run: |
-          sudo apt-get install libsqlite3-dev
+          sudo apt-get -y install libpq-dev
     - name: Install dependencies
       run: bundle install
     - name: Run tests
-      run: bundle exec rake
+      env:
+        DATABASE_URL: postgres://postgres:password@localhost:5432/rb_pager_test
+      run: |
+          bundle exec rake db:create
+          bundle exec rspec

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rb_pager (0.1.0)
+    rb_pager (0.2.0)
 
 GEM
   remote: https://rubygems.org/
@@ -17,16 +17,12 @@ GEM
       minitest (~> 5.1)
       tzinfo (~> 1.1)
       zeitwerk (~> 2.2, >= 2.2.2)
-    coderay (1.1.3)
     concurrent-ruby (1.1.6)
     diff-lcs (1.4.4)
     i18n (1.8.3)
       concurrent-ruby (~> 1.0)
-    method_source (1.0.0)
     minitest (5.14.1)
-    pry (0.13.1)
-      coderay (~> 1.1)
-      method_source (~> 1.0)
+    pg (1.2.3)
     rake (13.0.1)
     rspec (3.9.0)
       rspec-core (~> 3.9.0)
@@ -41,7 +37,6 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-support (3.9.3)
-    sqlite3 (1.4.2)
     thread_safe (0.3.6)
     tzinfo (1.2.7)
       thread_safe (~> 0.1)
@@ -52,11 +47,10 @@ PLATFORMS
 
 DEPENDENCIES
   activerecord (>= 5.2)
-  pry
+  pg
   rake (~> 13.0)
   rb_pager!
   rspec (~> 3.0)
-  sqlite3
 
 BUNDLED WITH
    2.1.4

data/README.md

@@ -38,24 +38,37 @@ 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.pager(after:  'w33t44==', limit:  10, sort:  'name,id')
+
+# on EmployeesController
+records, meta = Employee.pager(limit:  15)
+# meta => { next_cursor => 'uahOI==' }
+render  json: EmployeeSerializer.new(records, meta: meta).serialized_json, status:  :ok
 ```
 
+## On progress
+
+ - [ ] implement  `before`  cursor
+ - [ ] meta url for first, last, next and previous page, collection size
+ - [ ] [error-cases](https://jsonapi.org/profiles/ethanresnick/cursor-pagination/#auto-id-error-cases)
+ - [ ] custom encoder
+ - [ ] ui helper
+
 ## 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/rb_pager.rb

@@ -1,7 +1,6 @@
 require 'active_record'
 require 'rb_pager/version'
 require 'rb_pager/configuration'
-require 'pry'
 
 module RbPager
   class InvalidLimitValueError < StandardError; end

data/lib/rb_pager/orm/pager_active_record.rb

@@ -4,99 +4,124 @@ module RbPager
 
     module ClassMethods
       AR_ORDER = { '+' => :asc, '-' => :desc }
-      AREL_ORDER = { asc: :gt, desc: :lt }
-
-      def pager(after: nil, limit: nil, sort: nil)
-        page_limit = limit || RbPager.configuration.limit
-        sort_params = sort
 
+      def pager(after: nil, before: nil, limit: nil, sort: nil)
         raise InvalidLimitValueError if limit && limit < 1
+        instance_variable_set(:@sorted_columns, nil)
 
-        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)
+        page_limit = limit || RbPager.configuration.limit
+        @sort = sort
+        @after = decode(after)
+        @before = decode(before)
+        @direction = :next
+
+        collection = where(apply_after)
+        collection = collection.where(apply_before)
+        collection = collection.order(sorted_columns)
+                               .extending(ActiveRecordRelationMethods)
+                               .limit(page_limit)
+
+        create_paginate_meta(collection)
       end
 
       private
 
-      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?
+      def decode(cursor)
+        return nil if cursor.nil?
 
-        filter_ordered_columns = filter_with_ordered_columns(decode_cursor_params, sorted_columns)
-        filter_primary_key = filter_with_primary_key(decode_cursor_params)
-
-        filter_ordered_columns.or(filter_primary_key)
+        decode = Base64.strict_decode64(cursor)
+        Hash[
+          decode.split(',').map do |pair|
+            k, v = pair.split(':', 2)
+          end
+        ]
       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
+      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
-
-        result
       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(collection)
+        cursor = cursor(collection)
 
-        meta = { next_cursor: next_cursor }
+        meta = { prev_cursor: cursor.first, next_cursor: cursor.last }
         [collection, meta]
       end
 
-      def next_cursor(collection, sorted_columns)
-        return '' unless collection.left_over?
+      def cursor(collection)
+        return ['', ''] if collection.total_size.zero?
 
-        next_cursor = { 'id': collection.last.id }
+        prev_cursor, next_cursor = [], []
 
-        sorted_columns.each do |key, _value|
-          next_cursor.merge!(Hash[key, collection.last.send(key)])
+        if sorted_columns.blank?
+          prev_cursor = ["#{primary_key}:#{collection.first.send(primary_key)}"]
+          next_cursor = ["#{primary_key}:#{collection.last.send(primary_key)}"]
+        else
+          sorted_columns.each do |key, _value|
+            if type_for_attribute(key).type.eql? :datetime
+              prev_cursor << "#{key}:#{collection.first.send(key).rfc3339(9)}"
+              next_cursor << "#{key}:#{collection.last.send(key).rfc3339(9)}"
+              next
+            end
+
+            prev_cursor << "#{key}:#{collection.first.send(key)}"
+            next_cursor << "#{key}:#{collection.last.send(key)}"
+          end
         end
 
-        Base64.strict_encode64(next_cursor.to_json)
+        return ['', Base64.strict_encode64(next_cursor.join(','))] if (@after.nil? && @before.nil?) || @direction.eql?(:prev) && !collection.left_over?
+        return [Base64.strict_encode64(prev_cursor.join(',')), ''] if @direction.eql?(:next) && !collection.left_over?
+
+        [Base64.strict_encode64(prev_cursor.join(',')), Base64.strict_encode64(next_cursor.join(','))]
       end
     end
 

data/lib/rb_pager/version.rb

@@ -1,3 +1,3 @@
 module RbPager
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/rb_pager.gemspec

@@ -24,8 +24,7 @@ Gem::Specification.new do |spec|
   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 "sqlite3"
-  spec.add_development_dependency "pry"
+  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,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rb_pager
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - BambangSinaga
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-07-07 00:00:00.000000000 Z
+date: 2020-07-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -53,21 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
-  name: sqlite3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: pry
+  name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="