jinrai 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2a92fa21d25f7ac12d4a77d0ede116fb8712608c
-  data.tar.gz: 776eeeed260c5a79bfdbef5007042a84696602bc
+  metadata.gz: f90cbb057b2d8ed397a95afbd1be11e53f9a12ee
+  data.tar.gz: 262d9de132390d3eb80e4641f38372950ac02967
 SHA512:
-  metadata.gz: 0d92800fd47ee98b909ea62d3405835afb274ab0ee0a4ea4c88df8809397401963bbfdc254c1f97917e6fe1868478cf7d959d00e774378ef66b9868f679fa9d7
-  data.tar.gz: 3afc42adc4c5ba2aad592df04e8f3082fa31ce1c49be6ba131c26e0cc4c8af15985c4eefac29a6f4b66ea3a9426cd75969d8f0101dd7e6383f43f44144652d18
+  metadata.gz: 2bce5e4bc9d332e8d3e3921296d624622dd347cfbfc402b426396c15704a207622e378fc4b31af93232f1e458f29f233f19e34a619d9ce394d649cdeacecb436
+  data.tar.gz: 0141f31333eef1a456fe15edec0feaa0b761fe3d32310d996072aaed5c80bfe7cf28c9f503ccd77db8b0c9b23b522a2ff2718a5ecde409e019aae58503a5345c

data/lib/jinrai.rb

@@ -9,3 +9,6 @@ ActiveSupport.on_load :active_record do
   ActiveRecord::Relation.send(:prepend, Jinrai::ActiveRecord::Result)
   ActiveRecord::Base.send(:include, Jinrai::ActiveRecord::Core)
 end
+
+module Jinrai
+end

data/lib/jinrai/active_record/core.rb

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

@@ -1,34 +1,36 @@
 require 'jinrai/config'
 
-module Jinrai::ActiveRecord
-  module CursorMethods
-    include Jinrai::ConfigurationMethods
+module Jinrai
+  module ActiveRecord
+    module CursorMethods
+      include Jinrai::ConfigurationMethods
 
-    def since_cursor
-      encode_cursor(first)
-    end
+      def since_cursor
+        encode_cursor(first)
+      end
 
-    def till_cursor
-      encode_cursor(last)
-    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)
+      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
-    end
 
-    private
+      private
 
-    def encode_cursor(record)
-      attributes = default_cursor_format.map do |attr|
-        record.send(attr)
+      def encode_cursor(record)
+        attributes = default_cursor_format.map do |attr|
+          record.send(attr)
+        end
+        Base64.urlsafe_encode64(attributes.join("_"))
       end
-      Base64.urlsafe_encode64(attributes.join("_"))
     end
   end
 end

data/lib/jinrai/active_record/finder_methods.rb

@@ -1,82 +1,84 @@
 require 'jinrai/active_record/cursor_methods'
 
-module Jinrai::ActiveRecord #:nodoc:
-  module FinderMethods
-    extend ActiveSupport::Concern
+module Jinrai
+  module ActiveRecord #:nodoc:
+    module FinderMethods
+      extend ActiveSupport::Concern
 
-    included do
-      include Jinrai::ConfigurationMethods
+      included do
+        include Jinrai::ConfigurationMethods
 
-      def to_cursor
-        cursor_format = self.class.default_cursor_format
-        attributes = cursor_format.map do |attribute|
-          self.send(attribute)
+        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
-        Base64.urlsafe_encode64(attributes.join("_"))
       end
-    end
 
-    module ClassMethods
+      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 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 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 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 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
+        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))
+            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 = where(arel_table[primary_key].send(rank, id))
+            relation = all
           end
-        else
-          relation = all
+          relation.order(sort_at => default_cursor_sort_order)
         end
-        relation.order(sort_at => default_cursor_sort_order)
-      end
 
-      private
+        private
 
-      def decode_cursor(cursor)
-        attributes = Base64.urlsafe_decode64(cursor).split("_")
-        default_cursor_format.zip(attributes).to_h
+        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

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

data/lib/jinrai/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jinrai
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - atomiyama
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-14 00:00:00.000000000 Z
+date: 2018-12-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails