queue_classic_batches 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f4efc7cc0a30ae0cbe1aaef21e52f0e04f1c4e4b
+  data.tar.gz: e7cf187ff93fd137e2b1c34c930ad1b47305e0c1
+SHA512:
+  metadata.gz: d03b53bc8f5400d2099c9f2f16c991b8b2f76c363dd01173011a38d444766df640a610ed70768c631fd369c1832f22517cbab26a9d2e2d44190c88645abde100
+  data.tar.gz: 87bef6b26296dd98c915f8d77403f04bf9b7c8c7fb4b10354706c1e0af38d4bc80521fac07da274b64abb45ecf49e105151d72838730e07526dc5e142c7a74ac

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Shane Blazek
+
+MIT License
+
+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,66 @@
+# queue_classic_batches
+
+Adds support to queue_classic to enable queuing another job when a group of jobs have all completed.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'queue_classic_batches'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install queue_classic_batches
+
+Ruby on Rails Setup
+
+Declare dependencies in Gemfile.
+
+source "http://rubygems.org"
+gem "queue_classic_batches", "0.0.1"
+
+Add the database tables and columns.
+
+rails generate queue_classic_batches:install
+rake db:migrate
+
+## Usage
+
+1. Create a batch
+2. Queue jobs on the batch
+3. Mark queuing complete
+
+Here is an example:
+
+    batch = QC::Batches::Batch.create(complete_method:'MyCompleteJob.perform', 
+                                      complete_args: [123, 'abc'], 
+                                      complete_q_name: 'optional-queue-name')
+    (1..20) do |i| 
+      batch.enqueue("MyJob.perform", i, "Job #{i}")
+    end
+    batch.queuing_complete
+
+
+Make sure your worker deletes or re-queues failed jobs or else queue_classic will leave the job in the jobs table and the batch won't know it has been completed.
+
+    FailedQueue = QC::Queue.new("failed_jobs")
+    class MyWorker < QC::Worker
+
+      def handle_failure(job, e)
+        FailedQueue.enqueue(job[:method], *job[:args])
+        QC.delete job[:id]
+      end
+      
+    end
+
+## Contributing
+
+1. Fork it
+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. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/generators/queue_classic_batches/install_generator.rb

@@ -0,0 +1,24 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+require 'active_record'
+
+module QueueClassicBatches
+  class InstallGenerator < Rails::Generators::Base
+    include Rails::Generators::Migration
+
+    namespace "queue_classic_batches:install"
+    self.source_paths << File.join(File.dirname(__FILE__), 'templates')
+    desc 'Generates (but does not run) a migration to add batch functionality to the queue_classic table.'
+
+    def self.next_migration_number(dirname)
+      next_migration_number = current_migration_number(dirname) + 1
+      ActiveRecord::Migration.next_migration_number(next_migration_number)
+    end
+
+    def create_migration_file
+      if self.class.migration_exists?('db/migrate', 'add_queue_classic_batches').nil?
+        migration_template 'add_queue_classic_batches.rb', 'db/migrate/add_queue_classic_batches.rb'
+      end
+    end
+  end
+end

data/lib/generators/queue_classic_batches/templates/add_queue_classic_batches.rb

@@ -0,0 +1,12 @@
+require 'active_record'
+require 'queue_classic_batches'
+
+class AddQueueClassicBatches < ActiveRecord::Migration
+  def self.up
+    QC::Batches::Setup.add_batches
+  end
+
+  def self.down
+    QC::Batches::Setup.remove_batches
+  end
+end

data/lib/queue_classic_batches.rb

@@ -0,0 +1,15 @@
+require "queue_classic_batches/version"
+require "queue_classic_batches/queue"
+require "queue_classic_batches/setup"
+require "queue_classic_batches/queries"
+require "queue_classic_batches/batch"
+require "queue_classic_batches/worker"
+
+module QC
+  module Batches
+    # Why do you want to change the table name?
+    # Just deal with the default OK?
+    # Come on. Don't do it.... Just stick with the default.
+    TABLE_NAME = "queue_classic_batches"
+  end
+end

data/lib/queue_classic_batches/batch.rb

@@ -0,0 +1,97 @@
+module QC
+  module Batches
+    class Batch
+      attr_accessor :id
+      attr_accessor :queue
+      attr_accessor :created_at
+      attr_accessor :complete_q_name
+      attr_accessor :complete_method
+      attr_accessor :complete_args
+
+      def initialize(args=nil)
+        args.each { |k,v|
+          instance_variable_set("@#{k}", v) unless v.nil?
+        } if args.is_a?(Hash)
+        @queuing_complete = args[:queuing_complete] || false
+      end
+
+      def enqueue(method, *args)
+        (self.queue || QC).enqueue_batch method, self.id, args
+      end
+
+      def queuing_complete? 
+        return @queuing_complete
+      end
+
+      def queuing_complete 
+        @queuing_complete = true
+        Queries.save_queuing_complete(self.id)
+        Batch.complete_if_finished self.id
+      end
+
+      def self.complete_if_finished(batch_id)
+
+        if Batch.finished?(batch_id)
+          QC.default_conn_adapter.connection.transaction do |conn|
+            batch = Batch.find(batch_id, lock: true)
+            return unless batch
+            batch.complete
+          end
+        end
+
+      end
+
+      def complete
+        return unless queuing_complete? && finished?  
+        if complete_method
+          queue = complete_q_name ? Queue.new(queue) : QC
+          queue.enqueue complete_method, *complete_args
+        end
+        delete
+
+        time_to_complete = Integer((Time.now - created_at) * 1000)
+        QC.log(:'time-to-complete-batch'=>time_to_complete, :source=>id)
+      end
+
+      def delete
+        Queries.delete_batch(self.id)
+      end
+
+      def self.create(attributes = nil)
+        attributes ||= {}
+        complete_method = attributes[:complete_method]
+        complete_args = attributes[:complete_args]
+        if complete_args && !complete_method; raise 'args was passed but no method' end
+        
+        id = Queries.create_batch(attributes)
+        new_attributes = attributes.clone
+        new_attributes[:id] = id
+
+        Batch.new(new_attributes)
+      end
+
+      def self.find(id, lock=false)
+        if attributes = QC::Batches::Queries.find_batch(id, lock)
+          return Batch.new(attributes)
+        end
+      end
+
+      def finished?
+        Batch.finished?(self.id)
+      end
+
+      def self.finished?(id)
+        !QC::Batches::Queries.has_pending_jobs?(id)
+      end
+
+      def self.perform_job(method, batch_id, args=nil) 
+        receiver_str, _, message = method.rpartition('.')
+        receiver = eval(receiver_str)
+        result = receiver.send(message, *args)
+
+        return result
+      end
+
+    end
+  end
+end

data/lib/queue_classic_batches/queries.rb

@@ -0,0 +1,50 @@
+require 'queue_classic'
+
+module QC
+  module Batches
+    module Queries
+      extend self
+
+      def create_batch(attributes)
+        s="INSERT INTO #{TABLE_NAME} (complete_q_name, complete_method, complete_args, queuing_complete) VALUES ($1, $2, $3, $4) returning id"
+        res = QC.default_conn_adapter.execute(s, attributes[:complete_q_name], attributes[:complete_method], attributes.has_key?(:complete_args) ? JSON.dump(attributes[:complete_args]) : nil, attributes[:queuing_complete])
+        res['id'].to_i
+      end
+
+      def delete_batch(id)
+        s="DELETE FROM #{TABLE_NAME} WHERE id=$1"
+        res = QC.default_conn_adapter.execute(s, id)
+      end
+
+      def save_queuing_complete(id)
+        s="UPDATE #{TABLE_NAME} SET queuing_complete = true WHERE id=$1"
+        res = QC.default_conn_adapter.execute(s, id)
+      end
+
+      def find_batch(id, lock=false)
+        s = "SELECT * FROM #{TABLE_NAME} WHERE id = $1"
+        s << " FOR UPDATE" if lock
+        if r = QC.default_conn_adapter.execute(s, id) 
+          {}.tap do |batch|
+            batch[:id] = r['id'].to_i
+            batch[:complete_method] = r['complete_method']
+            batch[:complete_args] = JSON.parse(r['complete_args']) if r['complete_args']
+            batch[:complete_queue] = r['complete_queue']
+            batch[:queuing_complete] = r['queuing_complete'] == 't'
+            if r['created_at']
+              batch[:created_at] = Time.parse(r['created_at'])
+            end
+          end
+        end
+      end
+
+      def has_pending_jobs?(batch_id) 
+        s="SELECT count(id) from #{QC::TABLE_NAME} WHERE batch_id = $1 LIMIT 1"
+        res = QC.default_conn_adapter.execute(s, batch_id)
+
+        return res['count'].to_i != 0
+      end
+
+    end
+  end
+end

data/lib/queue_classic_batches/queue.rb

@@ -0,0 +1,35 @@
+require "queue_classic"
+
+module QC
+  class Queue
+    def enqueue_batch(method, batch_id, *args)
+      batch_method = 'QC::Batches::Batch.perform_job'
+      args = args.unshift(batch_id)
+      args = args.unshift(method)
+      QC.log_yield(:measure => 'queue.enqueue_batch') do
+        s="INSERT INTO #{TABLE_NAME} (q_name, method, batch_id, args) VALUES ($1, $2, $3, $4)"
+        res = conn_adapter.execute(s, name, batch_method, batch_id, JSON.dump(args))
+      end
+    end
+
+    def lock
+      #we have to patch the entire lock method to get it to return batch_id
+      QC.log_yield(:measure => 'queue.lock') do
+        s = "SELECT * FROM lock_head($1, $2)"
+        if r = conn_adapter.execute(s, name, top_bound)
+          {}.tap do |job|
+            job[:id] = r["id"]
+            job[:method] = r["method"]
+            job[:batch_id] = r["batch_id"]
+            job[:args] = JSON.parse(r["args"])
+            if r["created_at"]
+              job[:created_at] = Time.parse(r["created_at"])
+              ttl = Integer((Time.now - job[:created_at]) * 1000)
+              QC.measure("time-to-lock=#{ttl}ms source=#{name}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/queue_classic_batches/setup.rb

@@ -0,0 +1,26 @@
+require 'active_record'
+
+module QC
+  module Batches
+  module Setup
+    Root = File.expand_path("../..", File.dirname(__FILE__))
+    AddColumns = File.join(Root, "/sql/add_columns.sql")
+    CreateBatches = File.join(Root, "/sql/create_batches.sql")
+
+    def self.add_batches(c = QC::default_conn_adapter.connection)
+      conn = QC::ConnAdapter.new(c)
+      conn.execute(File.read(AddColumns))
+      conn.execute(File.read(CreateBatches))
+      conn.disconnect if c.nil? #Don't close a conn we didn't create.
+    end
+
+    def self.remove_batches(c = QC::default_conn_adapter.connection)
+      conn = QC::ConnAdapter.new(c)
+      conn.execute("DROP TABLE IF EXISTS queue_classic_batches CASCADE")
+      #todo: remove the batch_id column
+      conn.disconnect if c.nil? #Don't close a conn we didn't create.
+    end
+
+  end
+  end
+end

data/lib/queue_classic_batches/version.rb

@@ -0,0 +1,3 @@
+module QueueClassicBatches
+  VERSION = "0.0.1"
+end

data/lib/queue_classic_batches/worker.rb

@@ -0,0 +1,15 @@
+require "queue_classic"
+module QC
+  class Worker
+    alias_method :qc_base_process, :process
+
+    def process(queue, job)
+      result = qc_base_process queue, job
+      if job[:batch_id]
+        #note, for errors if the worker doesn't delete the job in handle_failure, this never fires
+        QC::Batches::Batch.complete_if_finished job[:batch_id]
+      end
+      return result
+    end
+  end
+end

data/queue_classic_batches.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'queue_classic_batches/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "queue_classic_batches"
+  spec.version       = QueueClassicBatches::VERSION
+  spec.authors       = ["shanewho"]
+  spec.description   = %q{Adds batch functionality to the queue_classic gem}
+  spec.summary       = %q{Adds batch functionality to the queue_classic gem}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "queue_classic", "~> 3.0.0rc"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0.0.beta"
+  spec.add_development_dependency "activerecord", "~> 4"
+end

data/spec/batch_spec.rb

@@ -0,0 +1,139 @@
+require 'helper'
+
+module QC
+  module Batches
+
+    describe Batch do
+      include_context "init database"
+      let(:batch) { Batch.create(complete_method: '"abcd".insert', complete_args: [0, 'a']) }
+
+      context '#create' do
+        it 'returns an id' do
+          expect(batch.id).to be > 0
+        end
+
+        it 'doesnt require args' do
+          expect(Batch.create.id).to be > 0
+        end
+
+        context 'with complete job' do
+          context 'without args' do
+            it 'doesnt error' do
+              Batch.create(complete_method: '"abcd".insert') 
+            end
+          end
+          context 'with args and no method' do
+            it 'raises an error' do
+              expect{Batch.create(complete_args: [1,'a'])}.to raise_error
+            end
+          end
+        end
+      end
+
+      context '#find' do
+        it 'returns a batch' do
+          expect(Batch.find(batch.id).id).to eq(batch.id)
+        end
+
+        it 'returns a batch created without args' do
+          id = Batch.create.id
+          expect(Batch.find(id).id).to eq(id)
+        end
+      end
+
+      context '#delete' do
+        it 'deletes a batch' do
+          batch.delete
+          expect(Batch.find(batch.id)).to eq(nil)
+        end
+      end
+
+      context '#enqueue' do
+        context 'with default queue' do
+          it 'queues a job with batch id' do
+            expect_any_instance_of(Queue).to receive(:enqueue_batch).with('"abcd".insert', batch.id, [0, 'x']).once
+            batch.enqueue '"abcd".insert', 0, 'x'
+          end
+        end
+
+        context 'with a specified queue' do
+          it 'queues a job with batch id' do
+            queue = Queue.new 'test queue'
+            batch.queue = queue
+            expect(queue).to receive(:enqueue_batch).with('"abcd".insert', batch.id, [0, 'x']).once
+            batch.enqueue '"abcd".insert', 0, 'x'
+          end
+        end
+      end
+
+      context '#queuing_complete' do
+        context 'with uncompleted jobs' do
+          before(:each) { batch.enqueue 'Time.now' }
+
+          it 'marks queuing complete' do
+            batch.queuing_complete
+            b = Batch.find(batch.id)
+            expect(batch.queuing_complete?).to eq(true) 
+            expect(b.queuing_complete?).to eq(true) 
+          end
+
+          it 'doesnt queue the complete job' do
+            expect(QC).not_to receive(:enqueue)
+            batch.queuing_complete
+          end
+
+          it 'doesnt delete' do
+            expect(Batch.find(batch.id)).not_to eq(nil)
+            batch.queuing_complete
+          end
+
+        end
+
+        context 'with no more jobs' do
+          it 'queues the complete job' do
+            expect(QC).to receive(:enqueue)
+            batch.queuing_complete
+          end
+
+          it 'deletes the batch' do
+            batch.queuing_complete
+            expect(Batch.find(batch.id)).to eq(nil)
+          end
+        end
+      end
+
+      context '#finished?' do
+          context 'with no jobs' do
+            it 'returns true' do
+              expect(Batch.finished?(batch.id)).to eq(true)
+            end
+          end
+          context 'with jobs' do
+            it 'returns false' do
+              batch.enqueue 'Time.now'
+              expect(Batch.finished?(batch.id)).to eq(false)
+            end
+          end
+      end
+
+      context '#perform job' do
+        it 'performs the job' do
+          expect(Batch.perform_job '"abcd".insert', batch.id, [0, 'x']).to eq('xabcd');
+        end
+      end
+    end
+
+  end
+end
+
+
+    #context '#create' do
+      #it 'creates a batch' do
+        #batch = Batch.create(complete_method: '"abcd".insert', complete_args: [0, 'a'])
+        #batch.enqueue '"abcd".insert', 0, 'x'
+        #batch.enqueue '"abcd".insert', 1, 'y'
+        #batch.enqueue '"abcd".insert', 2, 'z'
+
+        #expect(Batch.find(batch.id).id).to eq(batch.id)
+      #end
+    #end

data/spec/helper.rb

@@ -0,0 +1,26 @@
+require "queue_classic"
+require "queue_classic_batches"
+require "stringio"
+
+module QC
+  module Batches
+
+    ENV["DATABASE_URL"] ||= "postgres://localhost/queue_classic_batches_test"
+
+    shared_context "init database" do
+      before(:all) do 
+          setup_db
+      end
+      def setup_db
+        c = QC::ConnAdapter.new
+        c.execute("SET client_min_messages TO 'warning'")
+        QC::Setup.drop(c.connection)
+        QC::Setup.create(c.connection)
+        QC::Batches::Setup.remove_batches
+        QC::Batches::Setup.add_batches
+        c.disconnect
+      end
+    end
+
+  end
+end

data/spec/queue_spec.rb

@@ -0,0 +1,29 @@
+require "helper"
+
+module QC
+  module Batches
+    describe Queue do
+      include_context "init database"
+
+      describe '#enqueue_batch' do
+        before(:each) do
+          QC.enqueue_batch('"abcd".insert', 'abc-123', 0, "x")
+        end
+
+        subject{QC.lock}
+
+        it 'adds a batch_id column' do
+          expect(subject[:batch_id]).to eq('abc-123');
+        end
+
+        it 'saves the original method' do
+          expect(subject[:args]).to eq(['"abcd".insert', 'abc-123', 0, 'x']);
+        end
+
+        it 'queues call to BatchJob.perform' do
+          expect(subject[:method]).to eq('QC::Batches::Batch.perform_job');
+        end
+      end
+    end
+  end
+end

data/spec/worker_spec.rb

@@ -0,0 +1,70 @@
+require "helper"
+
+module QC
+  module Batches
+    describe Worker do
+      include_context "init database"
+
+      describe '#process' do
+        before(:each) do
+        end
+        let(:worker){ Worker.new }
+        let(:queue){ Queue.new 'default' }
+        let(:batch) { Batch.create(queuing_complete: true, complete_method: '"abcd".insert', complete_args: [0, 'a']) }
+        let(:job){ {id: 1, method: 'Time.now', batch_id: batch.id} }
+
+        context 'with complete job' do
+          context 'with jobs complete' do
+#let(:batch) { Batch.create(complete_method: '"abcd".insert', complete_args: [0, 'a']) }
+
+            context 'with queuing complete' do
+
+              it 'queues the complete job' do
+                expect(QC).to receive(:enqueue).with('"abcd".insert', 0, 'a').once
+                worker.process queue, job
+              end
+
+              it 'deletes the batch' do
+                worker.process queue, job
+                expect(Batch.find(batch.id)).to eq(nil)
+              end
+            end
+
+            context 'but not done queuing' do
+              let(:batch) { Batch.create(complete_method: '"abcd".insert', complete_args: [0, 'a']) }
+
+              it 'doesnt queues the complete job' do
+                expect(QC).not_to receive(:enqueue)
+                worker.process queue, job
+              end
+              it 'doesnt delete the batch' do
+                worker.process queue, job
+                expect(Batch.find(batch.id)).not_to eq(nil)
+              end
+            end
+          end
+        end
+
+        context 'without complete job' do
+          let(:batch) { Batch.create }
+          context 'with queuing complete' do
+            before(:each) { batch.queuing_complete }
+            it 'deletes the batch' do
+              worker.process queue, job
+              expect(Batch.find(batch.id)).to eq(nil)
+            end
+          end
+
+          context 'but not done queuing' do
+            it 'doesnt delete the batch' do
+              worker.process queue, job
+              expect(Batch.find(batch.id)).not_to eq(nil)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end
+

data/sql/add_columns.sql

@@ -0,0 +1,4 @@
+--do $$ begin
+ALTER TABLE queue_classic_jobs ADD COLUMN batch_id varchar(128);
+
+--CREATE INDEX idx_qc_on_name_only_unlocked ON queue_classic_jobs (q_name, id) WHERE locked_at IS NULL;

data/sql/create_batches.sql

@@ -0,0 +1,20 @@
+do $$ begin
+
+CREATE TABLE queue_classic_batches (
+  id bigserial PRIMARY KEY,
+  complete_q_name text, --Allow null - batches without complete jobs can be useful
+  complete_method text,
+  complete_args   text,
+  queuing_complete boolean,
+  created_at timestamptz default now()
+);
+
+-- If json type is available, use it for the complete_args column.
+perform * from pg_type where typname = 'json';
+if found then
+  alter table queue_classic_batches alter column complete_args type json using (complete_args::json);
+end if;
+
+end $$ language plpgsql;
+
+--todo: CREATE INDEX idx_qc_on_name_only_unlocked ON queue_classic_jobs (q_name, id) WHERE locked_at IS NULL;

metadata

@@ -0,0 +1,138 @@
+--- !ruby/object:Gem::Specification
+name: queue_classic_batches
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- shanewho
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: queue_classic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0rc
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0rc
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4'
+description: Adds batch functionality to the queue_classic gem
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/generators/queue_classic_batches/install_generator.rb
+- lib/generators/queue_classic_batches/templates/add_queue_classic_batches.rb
+- lib/queue_classic_batches.rb
+- lib/queue_classic_batches/batch.rb
+- lib/queue_classic_batches/queries.rb
+- lib/queue_classic_batches/queue.rb
+- lib/queue_classic_batches/setup.rb
+- lib/queue_classic_batches/version.rb
+- lib/queue_classic_batches/worker.rb
+- queue_classic_batches.gemspec
+- spec/batch_spec.rb
+- spec/helper.rb
+- spec/queue_spec.rb
+- spec/worker_spec.rb
+- sql/add_columns.sql
+- sql/create_batches.sql
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Adds batch functionality to the queue_classic gem
+test_files:
+- spec/batch_spec.rb
+- spec/helper.rb
+- spec/queue_spec.rb
+- spec/worker_spec.rb