jinrai 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2a92fa21d25f7ac12d4a77d0ede116fb8712608c
+  data.tar.gz: 776eeeed260c5a79bfdbef5007042a84696602bc
+SHA512:
+  metadata.gz: 0d92800fd47ee98b909ea62d3405835afb274ab0ee0a4ea4c88df8809397401963bbfdc254c1f97917e6fe1868478cf7d959d00e774378ef66b9868f679fa9d7
+  data.tar.gz: 3afc42adc4c5ba2aad592df04e8f3082fa31ce1c49be6ba131c26e0cc4c8af15985c4eefac29a6f4b66ea3a9426cd75969d8f0101dd7e6383f43f44144652d18

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2018 atomiyama
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,93 @@
+# Jinrai
+Jinrai is a awesome cursor based paginator
+
+## Usage
+```ruby
+# config/initializers/jinrai.rb
+
+Jinrai.configure do |config|
+  config.default_cursor_per = 20 #=> User.cursor.count == 20
+  config.default_cursor_format = :id, :name #=> cursor format will be "#{user.id}_#{user.name}"
+  config.cursor_sort_order = :desc
+end
+```
+
+```ruby
+# app/model/user.rb
+
+class User < ApplicationRecord
+  cursor_per 100
+  cursor_format :name, :age
+  cursor_order :asc # default: :desc
+end
+
+User.cursor.count #=> 100
+User.cursor.since_format #=> generate cursor fomatted "#{user.name}_#{user.age}"
+```
+
+```ruby
+User.cursor #=> get latest 20 records.
+User.cursor.count #=> 20
+```
+
+`.cursor` has two arguments, `till` and `since`, and by passing them we can get record collection of arbitrary interval.
+```ruby
+since_cursor = User.cursor.till_cursor
+User.cursor(since: since_cursor) # return records older than the record pointed by the cursor
+
+till_cursor = User.cursor.since_cursor
+User.cursor(till: till_cursor) # return records newer than the record pointed by the cursor
+
+User.cursor(since: since_cursor, till: till_cursor) # return records newer than the record pointed by the since cursor and older than the record pointed by the till cursor.
+```
+
+Get cursor by calling `since_cursor` or `till_cursor`.
+```ruby
+users = User.cursor
+users.since_cursor # this cursor points first record of User collection
+users.till_cursor # this cursor points last record of User collection
+```
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'jinrai'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install jinrai
+```
+
+## Contributing
+1. Fork then clone this repo:
+```bash
+git clone git@github.com:YOUR_USERNAME/jinrai.git
+```
+
+1. setup dependencies via bundler:
+```bash
+bundle install
+```
+
+1. Make sure the spec pass:
+```bash
+bundle exec rspec
+```
+
+1. Make your change, and write spec, make sure test pass:
+```bash
+bandle exec rspec
+```
+
+1. write a good commit message, push to your fork, then submit PullRequest.
+
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,20 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Jinrai'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+task default: :spec
+require 'bundler/gem_tasks'

data/lib/jinrai.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal:true
+
+require 'jinrai/active_record/result'
+require 'jinrai/config'
+require 'jinrai/configuration_methods'
+
+ActiveSupport.on_load :active_record do
+  require 'jinrai/active_record/core'
+  ActiveRecord::Relation.send(:prepend, Jinrai::ActiveRecord::Result)
+  ActiveRecord::Base.send(:include, Jinrai::ActiveRecord::Core)
+end

data/lib/jinrai/active_record/core.rb

@@ -0,0 +1,21 @@
+require 'jinrai/active_record/finder_methods'
+
+module Jinrai::ActiveRecord
+  module Core
+    extend ActiveSupport::Concern
+
+
+    module ClassMethods
+      def inherited(kls)
+        super
+        kls.send(:include, Jinrai::ActiveRecord::FinderMethods) if kls.superclass == ::ActiveRecord::Base
+      end
+    end
+
+    included do
+      descendants.each do |kls|
+        kls.send(:include, Jinrai::ActiveRecord::FinderMethods) if kls.superclass == ::ActiveRecord::Base
+      end
+    end
+  end
+end

data/lib/jinrai/active_record/cursor_methods.rb

@@ -0,0 +1,34 @@
+require 'jinrai/config'
+
+module Jinrai::ActiveRecord
+  module CursorMethods
+    include Jinrai::ConfigurationMethods
+
+    def since_cursor
+      encode_cursor(first)
+    end
+
+    def till_cursor
+      encode_cursor(last)
+    end
+
+    def per(num = nil)
+      num ||= default_cursor_per
+      if (n = num.to_i).negative? || !(/^\d/ =~ num.to_s)
+        self
+      else
+        self.is_cursored = true
+        limit(n)
+      end
+    end
+
+    private
+
+    def encode_cursor(record)
+      attributes = default_cursor_format.map do |attr|
+        record.send(attr)
+      end
+      Base64.urlsafe_encode64(attributes.join("_"))
+    end
+  end
+end

data/lib/jinrai/active_record/finder_methods.rb

@@ -0,0 +1,83 @@
+require 'jinrai/active_record/cursor_methods'
+
+module Jinrai::ActiveRecord #:nodoc:
+  module FinderMethods
+    extend ActiveSupport::Concern
+
+    included do
+      include Jinrai::ConfigurationMethods
+
+      def to_cursor
+        cursor_format = self.class.default_cursor_format
+        attributes = cursor_format.map do |attribute|
+          self.send(attribute)
+        end
+        Base64.urlsafe_encode64(attributes.join("_"))
+      end
+    end
+
+    module ClassMethods
+
+      def cursor(**options)
+        relation =
+          if default_cursor_sort_order == :desc
+            cursoring(:lt, :gt, options[:since], options[:sort_at]).cursoring(:gt, :lt, options[:till], options[:sort_at])
+          elsif default_cursor_sort_order == :asc
+            cursoring(:gt, :lt, options[:since], options[:sort_at]).cursoring(:lt, :gt, options[:till], options[:sort_at])
+          end
+        relation.extending_cursor
+      end
+
+      def after(cursor, **options)
+        relation =
+          if default_cursor_sort_order == :desc
+            cursoring(:lt, :gt, cursor, options[:sort_at])
+          elsif default_cursor_sort_order == :asc
+            cursoring(:gt, :lt, cursor, options[:sort_at])
+          end
+        relation.extending_cursor
+      end
+
+      def before(cursor, **options)
+        relation =
+          if default_cursor_sort_order == :desc
+            cursoring(:gt, :lt, cursor, options[:sort_at])
+          elsif default_cursor_sort_order == :asc
+            cursoring(:lt, :gt, cursor, options[:sort_at])
+          end
+        relation.extending_cursor
+      end
+
+      def extending_cursor
+        extending { include Jinrai::ActiveRecord::CursorMethods }.per
+      end
+
+
+      def cursoring(rank, rank_for_primary, cursor, sort_at)
+        sort_at ||= primary_key
+        if cursor
+          attributes = HashWithIndifferentAccess.new(decode_cursor(cursor))
+          id = find_by(attributes).id
+
+          if sort_at != primary_key
+            condition_1 = arel_table[sort_at].send(rank, attributes[sort_at])
+            condition_2 = arel_table.grouping(arel_table[sort_at].eq(attributes[sort_at]).and(arel_table[primary_key].send(rank_for_primary, id)))
+            relation = where(condition_1.or(condition_2))
+          else
+            relation = where(arel_table[primary_key].send(rank, id))
+          end
+        else
+          relation = all
+        end
+        relation.order(sort_at => default_cursor_sort_order)
+      end
+
+      private
+
+      def decode_cursor(cursor)
+        attributes = Base64.urlsafe_decode64(cursor).split("_")
+        default_cursor_format.zip(attributes).to_h
+      end
+    end
+  end
+end

data/lib/jinrai/active_record/result.rb

@@ -0,0 +1,14 @@
+module Jinrai::ActiveRecord
+  module Result
+    attr_writer :is_cursored
+
+    def initialize(*a)
+      @is_cursored = false
+      super(*a)
+    end
+
+    def cursored?
+      @is_cursored
+    end
+  end
+end

data/lib/jinrai/config.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal:true
+
+module Jinrai #:nodoc:
+  class << self
+    def config
+      @config ||= Config.new
+    end
+
+    def configure
+      yield config
+    end
+  end
+
+  class Config #:nodoc:
+    attr_accessor :default_cursor_per,
+                  :default_cursor_format,
+                  :default_cursor_sort_order
+
+    def initialize
+      @default_cursor_per = 20
+      @default_cursor_format = %i[created_at id]
+      @default_cursor_sort_order = :desc
+    end
+  end
+end

data/lib/jinrai/configuration_methods.rb

@@ -0,0 +1,32 @@
+module Jinrai #:nodoc:
+  module ConfigurationMethods #:nodoc:
+    extend ActiveSupport::Concern
+
+    module ClassMethods #:nodoc:
+
+      def cursor_per(num)
+        @_default_cursor_per = num.to_i
+      end
+
+      def cursor_format(*attributes)
+        @_default_cursor_format = attributes
+      end
+
+      def cursor_sort_order(rank)
+        @_default_cursor_sort_order = rank.to_sym
+      end
+
+      def default_cursor_per
+        @_default_cursor_per || Jinrai.config.default_cursor_per
+      end
+
+      def default_cursor_format
+        @_default_cursor_format || Jinrai.config.default_cursor_format
+      end
+
+      def default_cursor_sort_order
+        @_default_cursor_sort_order || Jinrai.config.default_cursor_sort_order
+      end
+    end
+  end
+end

data/lib/jinrai/version.rb

@@ -0,0 +1,3 @@
+module Jinrai
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: jinrai
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- atomiyama
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.1.0
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  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: rspec-rails
+  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-rails
+  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'
+description: Jinrai is a awesome Cursor type pagination Link.
+email:
+- akifumi.tomiyama@studyplus.jp
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/jinrai.rb
+- lib/jinrai/active_record/core.rb
+- lib/jinrai/active_record/cursor_methods.rb
+- lib/jinrai/active_record/finder_methods.rb
+- lib/jinrai/active_record/result.rb
+- lib/jinrai/config.rb
+- lib/jinrai/configuration_methods.rb
+- lib/jinrai/version.rb
+homepage: https://github.com/studyplus/jinrai
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: A cursor type pagination plugin for Rails
+test_files: []