each_in_batches 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 28acf126d324e3a7c48d91337598cd629b8d543b
+  data.tar.gz: 2ae38eab8fd980bef8d56eebd47f24004832d67c
+SHA512:
+  metadata.gz: c23c43b348d6cc63bee83a1edf31002c56e17a5ede1adcb8a9fc546f20214b67480c9c5432f7464d0a49a0f733ed32f17d49dfbf17ab9b7ee2d2d718f143f954
+  data.tar.gz: 056a77ad490cf78fb6d1c3d847cf9a8f66fdca7794eca941becef1ffb9bf79d14c8fb0ce4a5b42742c89d6d3f8d215a68531de8afbb30ee8ded053800a73e056

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+/.idea

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.2

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in each_in_batches.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Peter H. Boling
+
+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,158 @@
+# EachInBatches
+
+(Originally BolingForBatches)
+
+### NOTE:
+I am resurrecting this code because I still have this recurring need, and Rail's native batching doesn't cut mustard.  
+It is some of my most ancient code, and it isn't pretty, but I hope to improve it over time.
+
+I often need to execute really large computations on really large data sets.
+I usually end up writing a rake task to do it, which calls methods in my models.
+But something about the process bugged me.  Each time I had to re-implement my
+'batching code' that allowed me to not chew up GB after GB of memory due to
+klass.find(:all, :include => [:everything_under_the_sun]). Re-implementation of
+the same logic over and over across many projects is not very DRY, so I got out
+my blow torch and lit it up.  The difficulty was that the part that was different
+each time I batched was at the center of the code, right in the middle of the
+batch loop.  But I didn't let that stop me!
+
+## Why this plugin is way better than standard Rails batching
+1. I've been doing batching in Rails a lot longer than Rails has.
+2. Metrics.  I measure stuff.
+3. I can batch from the top down (a.k.a backwards), making it possible to DELETE things in batches.
+		A. If you've never tried using the built-in rails batching for deleting millions of records... don't start now.  Use this gem instead.
+4. Exception Handling.  Exceptions occurring within the batching can be rescued, in a customizable fashion, which means that the process doesn't need to die on batch 309,675 of 402,540.
+5. Merged in the EachInBatches fork (from Brian Kidd):
+    I needed to iterate over the results and perform more actions than a single
+    method would provide.  I didn't want to write a method in my app that performed
+    the needed functionality as I felt the plugin should support this directly.
+    I modified the original plugin so that it takes a block instead of a method.
+    It will pass the object instance to the block.  It works pretty much the same
+    as Class.find(:all).each {|x| do something}, except in batches n that you
+    specify with :batch_size.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'each_in_batches'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install each_in_batches
+
+## Usage
+
+To create a new Batch, call `Batch#new` pass it the class and any additional arguments (all as a hash).
+
+    batch = EachInBatches::Batch.new(:arel => Payment.canceled.order("transaction_id ASC"), :batch_size => 50)
+
+To process the batched data, pass a block to `Batch#run` the same way you would to an object in a block like `Klass.all.each {|x| x.do_something }`.
+`Batch#run` will pass the data to your block, one at a time, in batches set by the :batch_size argument.
+
+    batch.run {|x| puts x.id; puts x.transaction_id}
+
+Print the results!
+
+    batch.print_results
+
+Or...
+
+Consolidate your code if you prefer
+
+    EachInBatches::Batch.new(:arel => Payment.canceled.order("transaction_id ASC"), batch_size => 50, :show_results => true).run{|x| puts x.id; puts x.transaction_id}
+
+## Configuration
+
+Arguements for the initializer (Batch.new) method are:
+
+    Required:
+
+      :arel          - Usage: :arel => Payment.canceled.order("transaction_id ASC")
+                        Required, as this is the class that will be batched
+
+    Optional:
+
+      :verbose       - Usage: :verbose => true or false
+                        Sets verbosity of output
+                        Default: false (if not provided)
+
+      :batch_size    - Usage: :batch_size => x
+                        Where x is some number.
+                        How many AR Objects should be processed at once?
+                        Default: 50 (if not provided)
+
+      :last_batch    - Usage: :last_batch => x
+                        Where x is some number.
+                        Only process up to and including batch #x.
+                          Batch numbers start at 0 for the first batch.
+                        Default: won't be used (no limit if not provided)
+
+      :first_batch   - Usage: first_batch => x
+                        Where x is some number.
+                        Begin processing batches beginning at batch #x.
+                          Batch numbers start at 0 for the first batch.
+                        Default: won't be used (no offset if not provided)
+
+      :show_results  - Usage: :show_results => true or false
+                        Prints statistics about the results of Batch#run.
+                        Default: true if verbose is set to true and :show_results is not provided, otherwise false
+
+## Output
+
+Interpreting the output:
+
+    '[O]' means the batch was skipped due to an offset.
+    '[L]' means the batch was skipped due to a limit.
+    '[P]' means the batch is processing.
+    '[C]' means the batch is complete.
+    and yes... it was a coincidence.  This class is not affiliated with 'one laptop per child'
+
+## License
+
+Copyright ©2008-2015 Peter H. Boling, Brian Kidd, released under the MIT license
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Maintenance
+
+To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Versioning
+
+This library aims to adhere to [Semantic Versioning 2.0.0](http://semver.org/).
+Violations of this scheme should be reported as bugs. Specifically,
+if a minor or patch version is released that breaks backward
+compatibility, a new version should be immediately released that
+restores compatibility. Breaking changes to the public API will
+only be introduced with new major versions.
+
+As a result of this policy, you can (and should) specify a
+dependency on this gem using the [Pessimistic Version Constraint](http://docs.rubygems.org/read/chapter/16#page74) with two digits of precision.
+
+For example:
+
+    spec.add_dependency 'each_in_batches', '~> 0.0'
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/each_in_batches/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Make sure to add tests!
+6. Create a new Pull Request
+
+## Contributors
+
+See the [Network View](https://github.com/pboling/each_in_batches/network)

data/Rakefile

@@ -0,0 +1,11 @@
+require "bundler/gem_tasks"
+
+begin
+  require "rspec/core/rake_task"
+  desc 'Run specs'
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.ruby_opts = '-w'
+  end
+  task :default => :spec
+rescue LoadError
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "each_in_batches"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/each_in_batches.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'each_in_batches/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "each_in_batches"
+  spec.version       = EachInBatches::VERSION
+  spec.authors       = ["Peter Boling"]
+  spec.email         = ["peter.boling@gmail.com"]
+
+  spec.summary       = "Batch Processing of Records with Blocks in Rails"
+  spec.description   = "Batch Processing of Records with Blocks in Rails"
+  spec.homepage      = "https://github.com/pboling/boling_for_batches"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", "~> 3.2"
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+end

data/lib/each_in_batches.rb

@@ -0,0 +1,272 @@
+# BolingForBatches
+# Copyright ©2008-2015 Peter H. Boling, Brian Kidd, released under the MIT license
+# Gem Plugin for Rails: A Better Way To Run Heavy Queries
+# License:  MIT License
+# Labels:   Ruby, Rails, Gem
+# Project owners:
+#    Peter Boling, Brian Kidd
+require "each_in_batches/version"
+require "active_record"
+
+module EachInBatches
+
+  class Batch
+
+    attr_accessor :arel
+    attr_accessor :verbose
+    attr_accessor :batch_size
+    attr_accessor :backwards
+    attr_accessor :last_batch
+    attr_accessor :first_batch
+    attr_accessor :offset_array
+    attr_accessor :total_records
+    attr_accessor :size_of_last_run
+    attr_accessor :extra_run
+    attr_accessor :num_runs
+    attr_accessor :total_time
+    attr_accessor :elapsed_time
+    attr_accessor :start_time
+    attr_accessor :end_time
+    attr_accessor :overhead_time
+    attr_accessor :completion_times
+    attr_accessor :show_results
+
+    def print_debug
+      print "verbose: #{verbose}\nbatch_size: #{batch_size}\nbackwards: #{backwards}\nlast_batch: #{last_batch}\nfirst_batch: #{first_batch}\noffset_array: #{offset_array}\ntotal_records: #{total_records}\nsize_of_last_run: #{size_of_last_run}\nextra_run: #{extra_run}\nnum_runs: #{num_runs}\ntotal_time: #{total_time}\nelapsed_time: #{elapsed_time}\nstart_time: #{start_time}\nend_time: #{end_time}\noverhead_time: #{overhead_time}\ncompletion_times: #{completion_times.inspect}\nshow_results: #{show_results.inspect}\n"
+    end
+
+    def self.help_text
+      <<-HEREDOC
+          Arguments for the initializer (Batch.new) method are:
+
+        Required:
+
+          :arel         - Usage: :arel => MyClass.some_scope.order("some_column ASC")
+                            Required, as this is the class that will be batched
+
+        Optional:
+
+          :backwards     - Usage: :backwards => true or false
+                            Whether or not the batches should be processed in reverse order or not.
+                            NOTE: deletions must be processed backwards or you eat the set as you process
+                                  and end the run half way through
+                            Default: false (if not provided)
+
+          :verbose       - Usage: :verbose => true or false
+                            Sets verbosity of output
+                            Default: false (if not provided)
+
+          :batch_size    - Usage: :batch_size => x
+                            Where x is some number.
+                            How many AR Objects should be processed at once?
+                            Default: 50 (if not provided)
+
+          :last_batch    - Usage: :last_batch => x
+                            Where x is some number.
+                            Only process up to and including batch #x.
+                              Batch numbers start at 0 for the first batch.
+                            Default: won't be used (no limit if not provided)
+
+          :first_batch   - Usage: first_batch => x
+                            Where x is some number.
+                            Begin processing batches beginning at batch #x.
+                              Batch numbers start at 0 for the first batch.
+                            Default: won't be used (no offset if not provided)
+
+          :show_results  - Usage: :show_results => true or false
+                            Prints statistics about the results of Batch#run.
+                            Default: true if verbose is set to true and :show_results is not provided, otherwise false
+
+       EXAMPLE:
+
+         To create a new Batch, call Batch#new and pass it the class and any additional arguements (all as a hash).
+
+           batch = EachInBatches::Batch.new(:arel => Payment.canceled.order("transaction_id ASC"), :batch_size => 50)
+
+         To process the batched data, pass a block to Batch#run the same way you would to an object returned by
+
+           Klass.all.each {|x| x.method}
+
+         Batch#run will pass the data to your block, one at a time, in batches set by the :batch_size argument.
+
+           batch.run {|x| puts x.id; puts x.transaction_id}
+
+         Print the results!
+
+           batch.print_results
+
+         Or...
+
+         Consolidate your code if you prefer
+
+           EachInBatches::Batch.new(:arel => Payment.canceled.order("transaction_id ASC"), :batch_size => 50, :show_results => true).run{|x| puts x.id; puts x.transaction_id}
+
+       Interpreting the output:
+         '[O]' means the batch was skipped due to an offset.
+         '[L]' means the batch was skipped due to a limit.
+         '[P]' means the batch is processing.
+         '[C]' means the batch is complete.
+         and yes... it was a coincidence.  This class is not affiliated with 'one laptop per child'
+      HEREDOC
+    end
+
+    def self.check(*args)
+      if args.empty?
+        puts self.help_text and return false
+        #Are the values of these parameters going to be valid integers?
+      elsif args.first[:batch_size] && (args.first[:batch_size].to_s.gsub(/\d/,'foo') == args.first[:batch_size].to_s)
+        puts self.help_text and return false
+      elsif args.first[:last_batch] && (args.first[:last_batch].to_s.gsub(/\d/,'foo') == args.first[:last_batch].to_s)
+        puts self.help_text and return false
+      elsif args.first[:first_batch] && (args.first[:first_batch].to_s.gsub(/\d/,'foo') == args.first[:first_batch].to_s)
+        puts self.help_text and return false
+      else
+        return true
+      end
+    end
+
+    def initialize(*args)
+      return false unless Batch.check(*args)
+      @arel = args.first[:arel]
+      @verbose = args.first[:verbose].blank? ? false : args.first[:verbose]
+      @backwards = args.first[:backwards].nil? ? false : !(args.first[:backwards] == 'false' || args.first[:backwards] == false)
+      @batch_size = args.first[:batch_size] ? args.first[:batch_size].is_a?(Integer) ? args.first[:batch_size] : args.first[:batch_size].to_i : 50
+      @last_batch = args.first[:last_batch] ? args.first[:last_batch].is_a?(Integer) ? args.first[:last_batch] : args.first[:last_batch].to_i : false
+      @first_batch = args.first[:first_batch] ? args.first[:first_batch].is_a?(Integer) ? args.first[:first_batch] : args.first[:first_batch].to_i : 0
+      @show_results = case
+        when args.first[:show_results].blank? && @verbose.blank?; false
+        when args.first[:show_results].blank? && @verbose == true; true
+        else args.first[:show_results]
+      end
+      @total_time = 0
+      @skipped_batches = []
+
+      puts "Counting Records..." if self.verbose
+      @total_records = @arel.count
+      @num_runs = @total_records / @batch_size
+      @size_of_last_run = @total_records.modulo(@batch_size)
+
+      if @size_of_last_run > 0
+        @num_runs += 1
+        @extra_run = true
+      else
+        @extra_run = false
+      end
+
+      puts "Records: #{@total_records}, Batches: #{@num_runs}" if @verbose
+
+      @last_batch = @num_runs - 1 unless @num_runs == 0 || @last_batch #because batch numbers start at 0 like array indexes, but only if it was not set in *args
+
+      current_batch = 0
+      @offset_array = Array.new
+      if @verbose
+        puts "Batch Numbering Begins With 0 (ZERO) and counts up"
+        puts "Batch Size (SQL Limit): #{@batch_size}" #This is the SQL Limit
+        puts "First Batch # to run: #{@first_batch}" #This is the number of the first batch to run
+        puts "Last Batch # to run: #{@last_batch}" # This is the number of the last batch to run
+        puts "Batches Before First and After Last will be skipped."
+        puts "Creating Batches:\n"
+      end
+      while current_batch < @num_runs
+        @offset_array << (current_batch * @batch_size)
+        print "." if @verbose
+        current_batch += 1
+      end
+      puts " #{@num_runs} Batches Created" if @verbose
+      #in order to use batching for record deletion, the offsets need to start with largest first
+      if @backwards
+        @offset_array.reverse!
+        puts "Backwards Mode:" if @verbose
+      else
+        puts "Normal Mode:" if @verbose
+      end
+      if @verbose
+        puts "  First Offset: #{@offset_array.first}"
+        puts "  Last Offset: #{@offset_array.last}"
+        # technically the last run doesn't need a limit, and we don't technically use a limit on the last run,
+        #  but there are only that many records left to process,
+        #  so the effect is the same as if a limit were applied.
+        # We do need the limit when running the batches backwards, however
+        if @extra_run
+          if @backwards
+            puts "  Limit of first run: #{@size_of_last_run}"
+          else
+            puts "  Size of Last Run: #{@size_of_last_run}"
+          end
+        end
+        puts "  Limit of all #{@extra_run ? "other" : ""} runs: #{@batch_size}" #This is the SQL Limit
+      end
+    end
+
+    def is_first_run?
+      #if no batches have been completed then we are in a first run situation
+      self.completion_times.empty?
+    end
+
+    def run(&block)
+      return false unless block_given?
+      self.start_time = Time.current
+      puts "There are no batches to run" and return false unless self.num_runs > 0
+      self.total_time = 0
+      self.completion_times = Array.new
+      self.offset_array.each_with_index do |offset, current_batch|
+        if self.backwards && self.is_first_run?
+          limite = self.size_of_last_run
+        else
+          limite = self.batch_size
+        end
+        if self.first_batch > current_batch
+          print "[O] #{show_status(current_batch, limite)} skipped" if self.verbose
+          self.skipped_batches << current_batch
+        elsif self.last_batch && self.last_batch < current_batch
+          print "[L] #{show_status(current_batch, limite)} skipped" if self.verbose
+          self.skipped_batches << current_batch
+        else
+          print "[P] #{show_status(current_batch, limite)}" if self.verbose
+
+          #start the timer
+          beg_time = Time.current
+
+          self.arel.limit(limite).offset(offset).each {|obj| yield obj}
+
+          #stop the timer
+          fin_time = Time.current
+
+          this_time = fin_time.to_i - beg_time.to_i
+          self.total_time += this_time unless extra_run && current_batch == self.num_runs
+          puts "[C] #{show_status(current_batch, limite)} in #{this_time} seconds" if self.verbose
+          self.completion_times << [current_batch, {:elapsed => this_time, :begin_time => beg_time, :end_time => fin_time}]
+        end
+      end
+      self.num_runs -= 1 if self.extra_run
+      self.end_time = Time.current
+      self.elapsed_time = (self.end_time.to_i - self.start_time.to_i)
+      self.overhead_time = self.elapsed_time - self.total_time
+      print_results if self.show_results
+      return "Process Complete"
+    end
+
+    def show_status(current_batch, limite)
+      "{#{current_batch} / #{self.last_batch} / #{limite}}"
+    end
+
+    # Allow caller to override verbosity when called from console
+    def print_results(verbose = self.verbose)
+      printf "Results..."
+      printf "Average time per complete batch was %.1f seconds\n", (self.total_time/Float(self.num_runs)) unless self.num_runs < 1
+      printf "Total time elapsed was %.1f seconds, about #{self.elapsed_time/60} minute(s)\n", (self.elapsed_time)
+      if self.backwards # When backwards might be deleting records
+        puts "Total # of #{self.arel.table} - Before: #{self.total_records}"
+        puts "Total # of #{self.arel.table} - After : #{self.arel.count}"
+      end
+      # With a large number of batches this is far too verbose, but don't want to introduce a more complicated verbosity setting.
+      # if verbose
+      #   puts "Completion times for each batch:"
+      #   self.completion_times.each do |x|
+      #     puts "Batch #{x[0]}: Time Elapsed: #{x[1][:elapsed]}s, Begin: #{x[1][:begin_time].strftime("%m.%d.%Y %I:%M:%S %p")}, End: #{x[1][:end_time].strftime("%m.%d.%Y %I:%M:%S %p")}"
+      #   end
+      # end
+    end
+
+  end
+end

data/lib/each_in_batches/version.rb

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

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: each_in_batches
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Peter Boling
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-06-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !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.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: Batch Processing of Records with Blocks in Rails
+email:
+- peter.boling@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- MIT-LICENSE
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- each_in_batches.gemspec
+- lib/each_in_batches.rb
+- lib/each_in_batches/version.rb
+homepage: https://github.com/pboling/boling_for_batches
+licenses: []
+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.4.2
+signing_key: 
+specification_version: 4
+summary: Batch Processing of Records with Blocks in Rails
+test_files: []