each_batch 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bc3df7b193e7c5c46b83d7f3617a65b256b20f2cd1a048b8d00eb2e77758db39
+  data.tar.gz: f071dd5a74821d7b0b9d083a8878c5bd7c1b608c093b09eb9bea07448a893827
+SHA512:
+  metadata.gz: d3cef5618641b0311ce6df5511fbe72d4088b9de6ece536f96d6da65d8631a451258ea093fcda54d8adf47db1bcefe5acce41542ec4b2fbd9552e84d81beeca4
+  data.tar.gz: c224898ddf3f46655b44340ded2165539bb518becdfedb22b475e68a338170c80474449c9e6a7205db83363d8715a1570bf3e0f3e73b365dd918f2867dc7b8e8

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status
+
+/gemfiles
+Gemfile.lock
+
+.ruby-version

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,7 @@
+---
+sudo: false
+language: ruby
+cache: bundler
+rvm:
+  - 2.5.5
+before_install: gem install bundler -v 1.17.3

data/Appraisals

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+appraise "active_record_52" do
+  gem "activerecord", "~> 5.2.0", require: "active_record"
+end
+
+appraise "active_record_60" do
+  gem "activerecord", "~> 6.0.0", require: "active_record"
+end
+
+appraise "active_record_61" do
+  gem "activerecord", "~> 6.1.0", require: "active_record"
+end
+
+appraise "active_record_70" do
+  gem "activerecord", "~> 7.0.0", require: "active_record"
+end

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in each_batch.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Odysseas Doumas
+
+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,235 @@
+# EachBatch
+
+Improved batch processing in Rails.
+
+This gem provides a new method called `each_batch` to ActiveRecord relations, similar to the built-in `in_batches`.
+
+There are two main issues this gem attempts to tackle:
+
+- No custom ordering. Rails' default and only behaviour is to order the results by the primary key.
+- No proper use of indexes, because of the inability to set custom ordering.
+- No efficient pluck solution in batches.  
+
+## Example
+
+Suppose we have a huge products table:
+
+```ruby
+ActiveRecord::Schema.define(version: 1) do
+  create_table :products do |t|
+    t.datetime :enabled_at, index: true
+    t.integer :sales
+
+    t.timestamps
+  end
+end
+```
+
+And suppose we want to process a subset of the data based on the enabled_at value: In Rails, one can do this:
+
+```ruby
+Product.
+  where(enabled_at: a_date_range).
+  find_each { |product| product.do_something }
+```
+
+This would generate SQL similar to this:
+
+```SQL
+SELECT `products`.*
+FROM `products`
+WHERE `products`.`enabled_at` BETWEEN '2023-05-28 00:00:00' AND '2023-06-04 23:59:59'
+ORDER BY `products`.`id` ASC LIMIT 1000
+```
+
+And for subsequent batches something like this:
+
+```SQL
+SELECT `products`.*
+FROM `products`
+WHERE `products`.`enabled_at` BETWEEN '2023-05-28 00:00:00' AND '2023-06-04 23:59:59'
+AND `products`.`id` > 123456
+ORDER BY `products`.`id` ASC LIMIT 1000
+```
+
+The order clause here is what can kill performance! It doesn't utilize the index properly because of that.
+
+With this gem, one can write this instead:
+
+```ruby
+Product.
+  where(enabled_at: a_date_range).
+  each_batch(keys: [:enabled_at, :id]).
+  each_record { |product| product.do_something }
+```
+Which would generate something like the following:
+
+```SQL
+SELECT `products`.*
+FROM `products`
+WHERE `products`.`enabled_at` BETWEEN '2023-05-28 00:00:00' AND '2023-06-04 23:59:59'
+ORDER BY `products`.`enabled_at` ASC, `products`.`id` ASC LIMIT 1000
+```
+
+This order matches the index one and the index will be utilized properly.
+
+For subsequent batches:
+
+```SQL
+SELECT `products`.*
+FROM `products`
+WHERE `products`.`enabled_at` BETWEEN '2023-05-28 00:00:00' AND '2023-06-04 23:59:59'
+AND (`products`.`enabled_at`, `products`.`id`) > ('2023-05-29 00:00:00', 123456)
+ORDER BY `products`.`enabled_at` ASC, `products`.`id` ASC LIMIT 1000
+```
+
+which again, utilizes the index properly.
+
+Note: the generated query is not exactly like the above, see [where_row](https://github.com/odydoum/where_row) for more info.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'each_batch'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install each_batch
+
+## Usage
+
+### Iterating in batches
+
+To simply iterate a relation in batches:
+
+```ruby
+Product.each_batch do |batch|
+  # do something useful
+end 
+```
+
+By default the batch size is 1000. To override, use the `of` option:
+
+```ruby
+Product.each_batch(of: 500) do |batch|
+  # do something useful
+end 
+```
+
+Naturally, any relation can be batched, like so:
+
+```ruby
+Product.where(enabled_at: a_date_range).each_batch(of: 500) do |batch|
+  # do something useful
+end 
+```
+
+Assuming that `products` is a huge table with an index on `enabled_at`, it would make more sense to order the results by this date. And in order to have a deterministic order (many products could be updated on the same time), ordering by `enabled_at` and `id` could prove optimal. To do that, use the `keys` option:
+
+```ruby
+Product.where(enabled_at: a_date_range).each_batch(of: 500, keys: [:enabled_at, :id]) do |batch|
+  # do something useful
+end 
+```
+
+To change the order, use the `order` option (by default is accending):
+
+```ruby
+Product.where(enabled_at: a_date_range).each_batch(of: 500, order: :desc, keys: [:enabled_at, :id]) do |batch|
+  # do something useful
+end 
+```
+
+To access each record instead of the whole relation (this preloads the relation), use `each_record`:
+
+```ruby
+Product.where(enabled_at: a_date_range).each_batch(of: 500, keys: [:enabled_at, :id]).each_record do |record|
+  # do something useful
+end 
+```
+
+### Plucking in batches
+
+To simply iterate over pluck results in batches, use the `pluck` method:
+
+```ruby
+Product.where(enabled_at: a_date_range).each_batch(of: 500, keys: [:enabled_at, :id]).pluck(:id, :enabled_at) do |pluck_batch|
+  # do something useful
+end 
+```
+
+To iterate over each row instead, use the `each_row` method:
+
+```ruby
+Product.where(enabled_at: a_date_range).each_batch(of: 500, keys: [:enabled_at, :id]).pluck(:id, :enabled_at).each_row do |(id, enabled_at)|
+  # do something useful
+end 
+```
+
+### Enumerator usage
+
+Since these methods return an enumerator, they can be chained with regular enumerator methods:
+
+```ruby
+Product.
+  where(enabled_at: a_date_range).
+  each_batch(of: 500, keys: [:enabled_at, :id]).
+  pluck(:id, :enabled_at, :sales).
+  each_row.
+  sum(&:first)
+```
+
+## Caveats
+
+### Empty results
+
+By default, `each_batch` does not preload any records, it just build the necessary queries and yields the relation. This means that it can not know in advance
+whether there are any records for the specified conditions. In practice this means that it will **always** yield a relation, even if it's empty.
+
+This also applies if the result set is a multiple of the batch size. There is no way to deduce that no more results are present, so it will return an empty relation.
+
+`each_record`, `pluck` and `each_row` do not suffer from this since they preload the records/values necessary to deduce that.
+
+### Missing keys for select or pluck
+
+For the algorithm to work, we need the last values for each of the keys specified. This means that there must a exist a select clause with those columns:
+
+```ruby
+Product.each_batch(of: 500, keys: [:enabled_at, :id]) # ok
+Product.select(:id, :sales).each_batch(of: 500, keys: [:enabled_at, :id]) # ArgumentError
+Product.select(:id, :enabled_at, :sales).each_batch(of: 500, keys: [:enabled_at, :id]) # Ok
+
+Product.each_batch(of: 500, keys: [:enabled_at, :id]).pluck # Ok, plucks everything
+Product.each_batch(of: 500, keys: [:enabled_at, :id]).pluck(:id, :sales) # ArgumentError
+Product.each_batch(of: 500, keys: [:enabled_at, :id]).pluck(:id, :enabled_at) # Ok
+Product.each_batch(of: 500, keys: [:enabled_at, :id]).pluck(:enabled_at, :id) # Ok
+```
+### Can't omit primary key
+
+To make this method safer, we can not specify an ordering that doesn't have the primary key as the last order key. This is in order to always guarantee deterministic ordering. This could be relaxed, possible with an extra option `unsafe`, to make it explicit.
+
+### Race conditions
+
+This is inherent to batch processing in general.
+
+## Alternatives
+
+[pluck_in_batches](https://github.com/fatkodima/pluck_in_batches)
+[each_batched](https://github.com/dburry/each_batched)
+
+I am probably missing a lot here..
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/odydoum/each_batch.
+
+## 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,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/each_batch.gemspec

@@ -0,0 +1,36 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "each_batch/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "each_batch"
+  spec.version       = EachBatch::VERSION
+  spec.authors       = ["Odysseas Doumas"]
+  spec.email         = ["odydoum@gmail.com"]
+
+  spec.summary       = 'Improved batch processing in Rails'
+  spec.description   = 'Improved batch processing in Rails'
+  spec.homepage      = "https://github.com/odydoum/each_batch"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 2.5.0"
+
+
+  # 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.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "activerecord", ">= 5.2", "< 7.1"
+  spec.add_dependency "where_row", "~> 0.1.3"
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "appraisal"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "yard"
+  spec.add_development_dependency "gem-release"
+end

data/lib/each_batch/active_record/base.rb

@@ -0,0 +1,9 @@
+module EachBatch
+  module ActiveRecord
+    module Base
+      def each_batch(*args, **kwargs, &block)
+        all.each_batch(*args, **kwargs, &block)
+      end
+    end
+  end
+end

data/lib/each_batch/active_record/relation.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+require "each_batch/batch_enumerator"
+
+module EachBatch
+  module ActiveRecord
+    module Relation
+      #
+      # Process records in batches. Optionally specify the keys by which to
+      # calculate the batch offsets.
+      #
+      # @param [Integer] of 1000 The batch size
+      # @param [Boolean] load false Whether the batch records should be loaded
+      # @param [Symbol, String] order :asc The order of processing
+      # @param [Array<String, Symbol>] keys The keys used for the ordering
+      #
+      # @return [EachBatch::BatchEnumerator] The batch enumerator
+      #
+      # @yieldparam [ActiveRecord::Relation] x The relation that corresponds to the batch
+      def each_batch(of: 1000, load: false, order: :asc, keys: [primary_key], &block)
+        batch_enumerator = ::EachBatch::BatchEnumerator.new(
+          self,
+          of: of,
+          load: load,
+          order: order,
+          keys: keys
+        )
+
+        return batch_enumerator unless block_given?
+
+        batch_enumerator.each(&block)
+      end
+    end
+  end
+end

data/lib/each_batch/active_record.rb

@@ -0,0 +1 @@
+module WhereRow::ActiveRecord; end

data/lib/each_batch/batch_enumerator.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+require "where_row"
+require "each_batch/plucked_batch_enumerator"
+
+module EachBatch
+  class BatchEnumerator
+    include Enumerable
+
+    DEFAULT_BATCH_SIZE = 1000
+
+    attr_reader :relation, :order, :keys
+
+    def initialize(relation, of: DEFAULT_BATCH_SIZE, load: false, order: :asc, keys: nil)
+      raise ArgumentError, 'Batch size must be a positive integer' if of != of.to_i || of <= 0 
+      
+      order = order.to_s
+      raise ArgumentError, 'Invalid order' if !order.casecmp('desc').zero? && !order.casecmp('asc').zero?
+      
+      pk_name = relation.primary_key.to_s
+      keys = keys&.map(&:to_s) || [pk_name.to_s]
+
+      # TODO: This is for safety, since there is no easy way to determine whether the order
+      # is deterministic or not. PK guarantees that.
+      raise ArgumentError, 'Primary key must be that last key' if keys.last != pk_name
+
+      if relation.select_values.present? && (relation.select_values.map(&:to_s) & keys).to_set != keys.to_set
+        raise ArgumentError, 'Not all keys are included in the custom select clause'
+      end
+
+      @relation = relation
+      @of = of
+      @load = load
+      @order = order
+      @keys = keys
+    end
+
+    def batch_size
+      @of
+    end
+
+    def each
+      return self unless block_given?
+
+      batch_relation = relation.reorder(keys.product([order]).to_h).limit(batch_size)
+      batch_relation.skip_query_cache! # Retaining the results in the query cache would undermine the point of batching
+
+      yielded_relation = batch_relation
+      op = order.to_s.casecmp('desc').zero? ? :lt : :gt
+      pk = relation.primary_key.to_sym
+
+      loop do
+        # consistent with rails load behavior.
+        if @load
+          records = yielded_relation.records
+          yielded_relation = relation.where(pk => records.map(&pk))
+          yielded_relation.send(:load_records, records)
+        end
+
+        yield yielded_relation
+
+        offsets =
+          if @load || yielded_relation.loaded?
+            break if yielded_relation.length < batch_size
+
+            yielded_relation.last.attributes_before_type_cast&.values_at(*keys)
+          else
+            # we need an additional query to fetch the last key set
+            offsets = yielded_relation.offset(batch_size - 1).limit(1).pluck(*keys).first
+
+            break if offsets.nil?
+
+            Array.wrap(offsets)
+          end
+
+        yielded_relation = batch_relation.where_row(*keys).public_send(op, *offsets)
+      end
+    end
+
+    def each_record(&block)
+      return to_enum(:each_record) unless block_given?
+
+      each { |yielded_relation| yielded_relation.to_a.each(&block) }
+    end
+
+    #
+    # Pluck selected columns in batches. The batching is the one specified
+    # on the { BatchEnumerator } instance.
+    #
+    # @param [Array<Symbol, String>] pluck_keys The keys of the columns to pluck.
+    #
+    # @return [EachBatch::PluckedBatchEnumerator] The batch enumerator
+    #
+    # @yieldparam [Array<Object>] x The array of the plucked values
+    def pluck(*pluck_keys, &block)
+      plucked_batch_enumerator = ::EachBatch::PluckedBatchEnumerator.new(
+        relation,
+        of: batch_size,
+        order: order,
+        keys: keys,
+        pluck_keys: pluck_keys.map(&:to_s)
+      )
+
+      return plucked_batch_enumerator unless block_given?
+
+      plucked_batch_enumerator.each(&block)
+    end
+  end
+end

data/lib/each_batch/plucked_batch_enumerator.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+require "where_row"
+
+module EachBatch
+  class PluckedBatchEnumerator
+    include Enumerable
+
+    attr_reader :relation, :order, :keys
+
+    def initialize(relation, of:, order:, keys:, pluck_keys:)
+      if pluck_keys.present? && (pluck_keys & keys).to_set != keys.to_set
+        raise ArgumentError, 'Not all keys are included in the custom select clause for pluck'
+      end
+
+      @relation = relation
+      @of = of
+      @order = order
+      @keys = keys
+      @pluck_keys = pluck_keys
+      @key_indices = keys.map { |key| pluck_keys.index(key) }
+    end
+
+    def batch_size
+      @of
+    end
+
+    def each
+      return self unless block_given?
+
+      batch_relation = relation.reorder(keys.product([order]).to_h).limit(batch_size)
+      batch_relation.skip_query_cache! # Retaining the results in the query cache would undermine the point of batching
+
+      yielded_relation = batch_relation
+      op = order.to_s.casecmp('desc').zero? ? :lt : :gt
+      last_idx = batch_size - 1
+
+      pk = relation.primary_key.to_sym
+      single_pluck_key = @pluck_keys.length == 1
+
+
+      loop do
+        results = yielded_relation.pluck(*@pluck_keys)
+
+        break if results.empty?
+
+        yield results
+
+        # grab the offsets from the plucked results
+        offsets =
+          if single_pluck_key
+            results[last_idx]
+          else
+            results[last_idx]&.values_at(*@key_indices)
+          end
+
+        break if offsets.nil?
+
+        yielded_relation = batch_relation.where_row(*keys).public_send(op, *offsets)
+      end
+    end
+
+    def each_row(&block)
+      return to_enum(:each_row) unless block_given?
+
+      each { |row_batch| row_batch.each(&block) }
+    end
+  end
+end

data/lib/each_batch/version.rb

@@ -0,0 +1,3 @@
+module EachBatch
+  VERSION = "0.1.0"
+end

data/lib/each_batch.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+require "each_batch/version"
+require "each_batch/active_record/relation"
+require "each_batch/active_record/base"
+
+require "active_record"
+
+module EachBatch; end
+
+ActiveRecord::Relation.prepend ::EachBatch::ActiveRecord::Relation
+ActiveRecord::Base.extend ::EachBatch::ActiveRecord::Base

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: each_batch
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Odysseas Doumas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-06-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '5.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '7.1'
+- !ruby/object:Gem::Dependency
+  name: where_row
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.17'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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: appraisal
+  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: 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: yard
+  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: gem-release
+  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: Improved batch processing in Rails
+email:
+- odydoum@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Appraisals
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- each_batch.gemspec
+- lib/each_batch.rb
+- lib/each_batch/active_record.rb
+- lib/each_batch/active_record/base.rb
+- lib/each_batch/active_record/relation.rb
+- lib/each_batch/batch_enumerator.rb
+- lib/each_batch/plucked_batch_enumerator.rb
+- lib/each_batch/version.rb
+homepage: https://github.com/odydoum/each_batch
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Improved batch processing in Rails
+test_files: []