activerecord-collections 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 94403cc736dd576a2be4ca9e465eb22766bf8890
-  data.tar.gz: 0ebfc8a5da14a0f36fb9a5bfb262725f92ff0bb6
+  metadata.gz: 0d6b4baa140c325ec88e2c55175e2bae0d55566c
+  data.tar.gz: 3a463c83e5790a296d570eabedaa1d30bde7085e
 SHA512:
-  metadata.gz: ab2f87844ce73790ca91a9c74231f3f4adbbfb1bd958f67b5fe2a0ab36e84fef9c1f23f78583c1b4f5a29f3a9dab152ac0f85a142a847299f6cc95bc3514467e
-  data.tar.gz: f9bf87d4ca6d010c642b77c31383e865438f2b7a0c00d87fb4f8f20f3b81bd8ac2ee405a2c44a96d3e11e410fb720b963828bc02ee6174bd18e0cdbb42277bd7
+  metadata.gz: 7ce87631a746258bb7ae4fbeead8deec3c55c547b04fcc1c668314fbf1db11e9cfd81432b4a2ae09932269351ae4ce76c6374ac531b13c300a7a906006dad098
+  data.tar.gz: 285370a57bbff5c61496987e14417c835b748c8c535ee8f26bfe644c06f092f6525d04cb98821168ead1ff8f19cef607049109c0a03efbdba39c81dab280bb76

data/lib/active_record/collection.rb

@@ -76,10 +76,11 @@ module ActiveRecord
     end
 
     def initialize_copy(old)
+      @collectable = old.collectable
       @options = old.options.dup
       @records = @relation = old.relation.dup
-      @total_records = old.total_records if !old.is_batch? && old.instance_variable_get(:@total_records).to_i > 0
-      page!(old.current_page).per!(old.per_page) if old.is_batch? || old.batched?(false)
+      @total_records = old.instance_variable_get(:@total_records)
+      batch!(batch: old.current_batch, batch_size: old.batch_size) if old.is_batch? || old.batched?(false)
       is_batch! if old.is_batch?
     end
   end

data/lib/active_record/collections/batching.rb

@@ -24,15 +24,13 @@ module ActiveRecord
           @batch_by_default || false
         end
 
-        def page(*num)
-          new.page(*num)
+        def batch(*num)
+          new.batch(*num)
         end
-        alias_method :batch, :page
 
-        def per(num)
-          new.per(num)
+        def batch_size(num)
+          new.batch_size(num)
         end
-        alias_method :batch_size, :per
       end
 
       def default_batch_size
@@ -70,7 +68,7 @@ module ActiveRecord
       end
 
       def as_next_batch
-        next_page!.as_batch
+        next_batch!.as_batch
       end
 
       def to_batches
@@ -97,37 +95,33 @@ module ActiveRecord
       end
       alias_method :in_batches, :as_batches
 
-      # TODO Mark need to either depend on kaminari or check for it before using page/per
-      def page(*num)
-        dup.page!(*num)
+      def batch(batch: 1, batch_size: nil)
+        dup.batch!(batch: batch, batch_size: batch_size)
       end
-      alias_method :batch, :page
 
-      def page!(*num)
+      def batch!(batch: 1, batch_size: nil)
         reset!(false, false)
-        @page = num[0] || 1
-        @per ||= default_batch_size
-        @relation = relation.page(@page).per(@per)
+        @current_batch = batch
+        @batch_size = batch_size unless batch_size.nil?
+        @batch_size ||= default_batch_size
+        @relation = relation.limit(@batch_size).offset((@current_batch - 1) * @batch_size)
         self
       end
-      alias_method :batch!, :page!
 
-      def per(num=nil)
-        dup.per!(num)
+      def per_batch(num=nil)
+        dup.per_batch!(num)
       end
-      alias_method :batch_size, :per
 
-      def per!(num)
+      def per_batch!(num=nil)
         reset!(false, false)
-        @page ||= 1
-        @per = num
-        @relation = relation.page(@page).per(@per)
+        @current_batch ||= 1
+        @batch_size = num || default_batch_size
+        @relation = relation.limit(@batch_size).offset((@current_batch - 1) * @batch_size)
         self
       end
-      alias_method :batch_size!, :per!
 
-      def paginated?(check_if_should=false)
-        return true if !(@page.nil? && @per.nil?)
+      def batched?(check_if_should=false)
+        return true if !(@current_batch.nil? && @batch_size.nil?)
         if check_if_should && should_batch?(false)
           batch!
           true
@@ -135,116 +129,99 @@ module ActiveRecord
           false
         end
       end
-      alias_method :batched?, :paginated?
 
-      def current_page
-        @page || 1
+      def current_batch
+        @current_batch || 1
       end
-      alias_method :current_batch, :current_page
 
-      def per_page
-        @per || total_count
+      def batch_size
+        @batch_size || total_count
       end
-      alias_method :per_batch, :per_page
 
-      def total_pages
+      def total_batches
         return 1 if is_batch?
-        (total_count.to_f / per_page.to_f).ceil
+        (total_count.to_f / batch_size.to_f).ceil
       end
-      alias_method :total_batches, :total_pages
 
-      def each_page(&block)
+      def each_batch(&block)
         batch! if should_batch?
 
-        if total_pages <= 1
+        if total_batches <= 1
           yield to_a if block_given?
           return [to_a]
         end
 
-        first_page!
-        paged = []
-        total_pages.times do
-          paged << to_a
+        first_batch!
+        batched = []
+        total_batches.times do
+          batched << to_a
           yield to_a if block_given?
-          next_page!
+          next_batch!
         end
-        first_page!
-        paged
+        first_batch!
+        batched
       end
-      alias_method :each_batch, :each_page
 
-      def page_map(&block)
+      def batch_map(&block)
         batch! if should_batch?
 
-        if total_pages <= 1
+        if total_batches <= 1
           return (block_given? ? yield(to_a) : to_a)
         end
 
-        first_page!
-        paged = []
-        total_pages.times do
-          paged << (block_given? ? yield(to_a) : to_a)
-          next_page!
+        first_batch!
+        batched = []
+        total_batches.times do
+          batched << (block_given? ? yield(to_a) : to_a)
+          next_batch!
         end
-        first_page!
-        paged
+        first_batch!
+        batched
       end
-      alias_method :batch_map, :page_map
 
-      def flat_page_map(&block)
-        page_map(&block).flatten
+      def flat_batch_map(&block)
+        batch_map(&block).flatten
       end
-      alias_method :flat_batch_map, :flat_page_map
 
-      def first_page
-        dup.first_page!
+      def first_batch
+        dup.first_batch!
       end
-      alias_method :first_batch, :first_page
 
-      def first_page!
-        page!(1)
+      def first_batch!
+        batch!(batch: 1)
       end
-      alias_method :first_batch!, :first_page!
 
-      def next_page?
-        current_page < total_pages
+      def next_batch?
+        current_batch < total_batches
       end
-      alias_method :next_batch?, :next_page?
 
-      def next_page
-        dup.next_page!
+      def next_batch
+        dup.next_batch!
       end
-      alias_method :next_batch, :next_page
 
-      def next_page!
-        page!(current_page + 1) if next_page?
+      def next_batch!
+        batch!(batch: current_batch + 1) if next_batch?
       end
-      alias_method :next_batch!, :next_page!
 
-      def prev_page?
-        current_page > 1
+      def prev_batch?
+        current_batch > 1
       end
-      alias_method :prev_batch?, :prev_page?
 
-      def prev_page
-        dup.prev_page!
+      def prev_batch
+        dup.prev_batch!
       end
-      alias_method :prev_batch, :prev_page
 
-      def prev_page!
-        page!(current_page - 1) if prev_page?
+      def prev_batch!
+        batch!(batch: current_batch - 1) if prev_batch?
       end
-      alias_method :prev_batch!, :prev_page!
 
-      def last_page
-        dup.last_page!
+      def last_batch
+        dup.last_batch!
       end
-      alias_method :last_batch, :last_page
 
-      def last_page!
-        page!(total_pages)
+      def last_batch!
+        batch!(batch: total_batches)
       end
-      alias_method :last_batch!, :last_page!
     end
   end
 end

data/lib/active_record/collections/delegation.rb

@@ -66,7 +66,7 @@ module ActiveRecord
       protected
 
       def call_on_records(meth, *args)
-        return page_map do |batch|
+        return batch_map do |batch|
           if model.columns.map(&:name).include?(meth.to_s) && !batch.loaded?
             batch.pluck(meth)
           else
@@ -83,8 +83,13 @@ module ActiveRecord
 
       def call_on_relation(meth, *args)
         reset!
-        @relation = relation.send(meth, *args)
-        self
+        returned = relation.send(meth, *args)
+        if returned.is_a?(ActiveRecord::Relation)
+          @relation = returned
+          self
+        else
+          returned
+        end
       end
     end
   end

data/lib/active_record/collections/records.rb

@@ -41,7 +41,7 @@ module ActiveRecord
       end
 
       def each_in_batches(batch_size=nil, &block)
-        batch_size!(batch_size)
+        per_batch!(batch_size)
         flat_batch_map.each { |record| block_given? ? yield(record) : record }
       end
 
@@ -50,7 +50,7 @@ module ActiveRecord
       end
 
       def map_in_batches(batch_size=nil, &block)
-        batch_size!(batch_size)
+        per_batch!(batch_size)
         flat_batch_map.map { |record| block_given? ? yield(record) : record }
       end
 
@@ -59,7 +59,7 @@ module ActiveRecord
       end
 
       def flat_map_in_batches(batch_size=nil, &block)
-        batch_size!(batch_size)
+        per_batch!(batch_size)
         flat_batch_map.map { |record| block_given? ? yield(record) : record }
       end
     end

data/lib/active_record/collections/relation.rb

@@ -40,7 +40,7 @@ module ActiveRecord
       end
 
       def all
-        reset.limit!(nil)
+        reset
       end
 
       def load
@@ -118,6 +118,16 @@ module ActiveRecord
         self
       end
 
+      def offset(*args, &block)
+        dup.offset!(*args, &block)
+      end
+
+      def offset!(*args, &block)
+        reset!
+        relation.offset!(*args, &block)
+        self
+      end
+
       def joins(*args)
         dup.joins!(*args)
       end
@@ -148,15 +158,18 @@ module ActiveRecord
         self
       end
 
-      def reset(clear_total=true, clear_pages=true)
-        dup.reset!(clear_total, clear_pages)
+      def reset(clear_total=true, clear_batches=true)
+        dup.reset!(clear_total, clear_batches)
       end
 
-      def reset!(clear_total=true, clear_pages=true)
+      def reset!(clear_total=true, clear_batches=true)
         @records = @record_ids = @size = nil
-        @page = @per = nil if clear_pages
         @total_records = nil if clear_total
         relation.reset
+        if clear_batches
+          @current_batch = @batch_size = nil
+          relation.limit!(nil).offset!(nil)
+        end
         self
       end
     end

data/lib/active_record/collections/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Collections
-    VERSION = '0.0.4'
+    VERSION = '0.0.5'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-collections
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Mark Rebec