beanstalk_farmer 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+Gemfile.lock
+doc/
+.yardoc/
+pkg/*.gem

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+
+#
+# The following is cribbed directly from the rvm-site project. It's a more
+# convenient way of ensuring we're using the correct gemset, or initializing it
+# if need be.
+#
+
+ruby_name="ruby-1.9.2"
+gemset_name="farmer"
+environment_id="$ruby_name@$gemset_name"
+
+#
+# First we attempt to load the desired environment directly from the environment
+# file, this is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+#
+
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]] ; then
+    \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  rvm --create use "$environment_id"
+fi

data/.yardopts

@@ -0,0 +1,5 @@
+--no-private
+--title "Farmer: a Beanstalk Job Queue Gem"
+lib/**/*.rb -
+README.md
+LICENSE

data/Gemfile

@@ -0,0 +1,7 @@
+source "http://rubygems.org"
+gemspec
+
+group :documentation do
+  gem "yard", "~> 0.6.8"
+  gem "bluecloth"
+end

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2011 James F. Herdman
+
+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,29 @@
+# Beanstalk Farmer
+
+Farmer is a simple library that helps you manage your Beanstalk job queue. Its
+API is heavily inspired by [Stalker](https://github.com/han/stalker), to help
+you get done as quickly as possible, but whilst allowing you to use plain old
+Ruby classes to ensure testability.
+
+## Setting up Jobs
+
+Jobs are handled by any object whose instances respond to a `#call` method, à
+la Rack (e.g. `Proc`s, `procs`s). The payload of the job will be passed into
+the arguments of this method. Bear in mind that the payload for a Beanstalk job
+is de-serialized JSON.
+
+### Example
+
+    BeanstalkFarmer::Runner.register_handlers do
+      # You can use objects
+      tube 'email.welcome_message', WelcomeMessageHandler
+
+      # You can use Procs
+      tube 'push.message', Proc.new { |args| PushService.send_message(args) }
+    end
+
+    BeanstalkFarmer::Runner.run!
+
+## Configuration
+
+Easy as pie! See `BeanstalkFarmer::Config` for all available options.

data/Rakefile

@@ -0,0 +1,19 @@
+require 'bundler'
+require 'bundler/setup'
+require 'bundler/gem_helper'
+
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w[--color]
+  t.verbose = false
+end
+
+require 'yard'
+require 'yard/rake/yardoc_task'
+
+YARD::Rake::YardocTask.new do |t|
+  # Options managed by .yardopts
+end

data/beanstalk_farmer.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$:.unshift(lib) unless $:.include?(lib)
+
+require 'beanstalk_farmer/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'beanstalk_farmer'
+  s.version     = BeanstalkFarmer::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['James Herdamn']
+  s.email       = ['james.herdman@me.com']
+  s.homepage    = 'https://github.com/jherdman/beanstalk_farmer'
+  s.summary     = 'A nice little kit to manage a Beanstalk job queue'
+  s.description = 'Farmer is a nice little kit to manage a Beanstalk job queue'
+
+  s.required_rubygems_version = '>= 1.3.6'
+  s.rubyforge_project         = 'farmer'
+
+  s.add_dependency 'beanstalk-client', ['~> 1.1.0']
+  s.add_dependency 'multi_json',       ['~> 1.0.2']
+
+  s.add_development_dependency 'rake',  ['~> 0.8.7']
+  s.add_development_dependency 'rspec', ['~> 2.6']
+
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- {spec}/*`.split("\n")
+  s.require_path = ['lib']
+end

data/example/echo.rb

@@ -0,0 +1,18 @@
+##
+# This is a simple echo worker example. To use this, you must have the Farmer
+# gem installed, or built.
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'farmer'
+
+BeanstalkFarmer::Runner.register_handlers do
+  tube 'echo.small_proc', proc { |args| BeanstalkFarmer.logger.info "Small proc says: #{args.inspect}" }
+  tube 'echo.big_proc', Proc.new { |args| BeanstalkFarmer.logger.info "Big Proc says: #{args.inspect}" }
+end
+
+trap 'INT' do
+  puts "\rExiting"
+  exit
+end
+
+BeanstalkFarmer::Runner.run!

data/lib/beanstalk_farmer/config.rb

@@ -0,0 +1,53 @@
+module BeanstalkFarmer
+  # Manages configuration settings and defaults.
+  #
+  # @example
+  #   BeanstalkFarmer::Config.logger = Rails.logger
+  #   BeanstalkFarmer::Config.json_engine = :yajl
+  module Config
+    extend self
+
+    DEFAULT_HOST = '0.0.0.0'
+    DEFAULT_PORT = 11300
+
+    attr_accessor :settings
+    @settings = {}
+
+    # Define a configuration option with a default.
+    #
+    # @example Define the option.
+    #   Config.option(:persist_in_safe_mode, :default => false)
+    #
+    # @param [Symbol] name The name of the configuration option.
+    # @param [Hash] options Extras for the option.
+    #
+    # @option options [Object] :default The default value.
+    #
+    # @note Copied from Mongoid. Thank you!
+    #
+    # @private
+    def option(name, options = {})
+      define_method(name) do
+        settings.has_key?(name) ? settings[name] : options[:default]
+      end
+      define_method("#{name}=") { |value| settings[name] = value }
+      define_method("#{name}?") { send(name) }
+    end
+
+    option :host, default: DEFAULT_HOST
+
+    option :port, default: DEFAULT_PORT
+
+    option :logger, default: ::Logger.new($stdout)
+
+    # @see MultiJson.default_engine
+    def json_engine
+      MultiJson.engine
+    end
+
+    # @see MultiJson.engine=
+    def json_engine=(json_engine)
+      MultiJson.engine = json_engine
+    end
+  end
+end

data/lib/beanstalk_farmer/dsl.rb

@@ -0,0 +1,14 @@
+module BeanstalkFarmer
+  # @private Provides a clean slate object that we can safely instance eval on.
+  class DSL
+    def tube(tube_name, job_handler)
+      Job.handler_pool[tube_name] = job_handler
+    end
+
+    def self.execute!(&block)
+      new.tap do |dsl|
+        dsl.instance_eval(&block)
+      end
+    end
+  end
+end

data/lib/beanstalk_farmer/job.rb

@@ -0,0 +1,50 @@
+require 'multi_json'
+require 'timeout'
+
+module BeanstalkFarmer
+  class Job
+    # Raised when a job cannot complete in time
+    class OutOfTimeError < Timeout::Error; end
+
+    attr_accessor :name, :args, :job
+
+    # @param [Beanstalk::Job] job A Beanstalk job that has been reserved to be
+    #   worked upon
+    def initialize(job)
+      self.job = job
+      set_name_and_arguments
+    end
+
+    # Performs work for this job
+    def work
+      # Stalker, the inspiration for this project, subtracted 1 from the job's
+      # TTR value. I'm not sure why at this point in time. Maybe to compensate
+      # for Job setup time.
+      Timeout.timeout(job.ttr) do
+        handler = self.class.handler_pool[name]
+        handler.call(args)
+      end
+    rescue Timeout::Error
+      raise OutOfTimeError, "#{name} could not finish in #{job.ttr} seconds"
+    ensure
+      job.delete
+    end
+
+    # A pool of job handlers that can work on jobs in our queue
+    #
+    # @param [Boolean] reset (false) When true, our collection of job handlers
+    #   will be purged from memory
+    #
+    # @return [Hash] the collection of job handlers
+    def self.handler_pool(reset=false)
+      @pool   = nil if reset
+      @pool ||= Hash.new
+    end
+
+    private
+
+    def set_name_and_arguments
+      self.name, self.args = MultiJson.decode(job.body)
+    end
+  end
+end

data/lib/beanstalk_farmer/runner.rb

@@ -0,0 +1,51 @@
+require 'singleton'
+
+module BeanstalkFarmer
+  # Maps tube names to job handlers, and manages the run loop
+  class Runner
+    include Singleton
+
+    # @see Farmer::Job.handler_pool
+    def handler_pool
+      Job.handler_pool
+    end
+
+    # @return [Farmer::BeanstalkService] a connection to the Beanstalk queue
+    def service
+      @service ||= Service.new
+    end
+
+    # Prepares tubes for watching
+    def prep_tubes
+      service.prep(handler_pool.keys)
+    end
+
+    # Reserves a job, and works it
+    def reserve_and_work_job
+      job = service.reserve
+      job.work
+    end
+
+    # Runs a loop looking for jobs to reserve and run
+    def work_jobs
+      loop { reserve_and_work_job }
+    end
+
+    # @yield block A DSL to define jobs for your queue
+    #
+    # @example
+    #   Farmer::Runner.register_handlers do
+    #     tube 'sms',   proc { |args| puts args }
+    #     tube 'mine',  Proc.new { |args| puts args }
+    #   end
+    def self.register_handlers(&block)
+      DSL.execute!(&block)
+    end
+
+    # Looks for jobs to reserve, and applies handlers to them
+    def self.run!
+      instance.prep_tubes
+      instance.work_jobs
+    end
+  end
+end

data/lib/beanstalk_farmer/service.rb

@@ -0,0 +1,83 @@
+require 'beanstalk-client'
+require 'multi_json'
+
+module BeanstalkFarmer
+  ##
+  # Provides an abstraction against our Beanstalk client to buffer us against
+  # changes in their API.
+  #
+  # @todo Abstract all 3rd party errors
+  # @todo Catch all 3rd party errors, and re-raise our own
+  #
+  # @private
+  class Service
+    DEFAULT_DELAY    = 0
+    DEFAULT_PRIORITY = 65536
+    DEFAULT_TTR      = 120
+
+    # Raised when we cannot connect to the Beanstalk queue
+    class NotConnectedError < Beanstalk::NotConnected; end
+
+    attr_accessor :uri
+
+    # Sets the URI of your Beanstalk queue.
+    #
+    # @param [String] host (DEFAULT_HOST) the host name to of your Beanstalk queue
+    #
+    # @param [String] port (DEFAULT_PORT) the port that your Beanstalk queue is on
+    def initialize(host=Config.host, port=Config.port)
+      self.uri = build_uri(host, port)
+    end
+
+    # @return [Beanstalk::Pool] a connection to Beanstalk
+    def connection
+      @connection ||= Beanstalk::Pool.new([uri])
+    end
+
+    # Closes the Beanstalk connection
+    #
+    # @return [nil] Nothing. Absolutely nothing.
+    def close
+      @connection.close
+      @connection = nil
+    end
+
+    # @param [Array<String>] tube_names The tube names to be watched
+    def prep(tube_names)
+      watch_tubes(tube_names)
+      ignore_unwatched_tubes(tube_names)
+    end
+
+    # @param [Array<String>] tube_names The tube names to be watched
+    def watch_tubes(tube_names)
+      tube_names.each { |tube_name| connection.watch(tube_name) }
+    end
+
+    # Ignores any tubes that aren't of interest, excluding the default tube.
+    def ignore_unwatched_tubes(watched_tube_names)
+      connection.list_tubes_watched.values do |tube_name|
+        connection.ignore(tube_name) unless watched_tube_names.include?(tube_name)
+      end
+    end
+
+    # Helper method. Used when testing to see if our queue works
+    def enqueue(tube_name, args={})
+      connection.use(tube_name)
+      connection.put MultiJson.encode([tube_name, args]), DEFAULT_PRIORITY, DEFAULT_DELAY, DEFAULT_TTR
+    end
+
+    # @param [Integer, nil] timeout When nil, a job is reserved indefinitely,
+    #   otherwise for the number of seconds provided
+    #
+    # @return [Farmer::Job] a Farmer Job to work
+    def reserve(timeout=nil)
+      Job.new(connection.reserve(timeout))
+    end
+
+    private
+
+    def build_uri(host, port)
+      [host, port].join(':')
+    end
+  end
+end

data/lib/beanstalk_farmer/version.rb

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

data/lib/farmer.rb

@@ -0,0 +1,33 @@
+require 'logger'
+
+##
+# Automatically loads classes as needed, provides logger, etc.
+module BeanstalkFarmer
+  autoload :Config,  'beanstalk_farmer/config'
+  autoload :Service, 'beanstalk_farmer/service'
+  autoload :DSL,     'beanstalk_farmer/dsl'
+  autoload :Job,     'beanstalk_farmer/job'
+  autoload :Runner,  'beanstalk_farmer/runner'
+
+  # @param [String] host The host name where your beanstalkd connection is
+  #   located. Defaults to `DEFAULT_PORT`.
+  #
+  # @param [#to_s] port The port number where your beanstalkd connection may
+  #   be accessed. Defaults to `DEFAULT_PORT`.
+  def self.connection(host=Config.host, port=Config.port)
+    @service ||= Service.new(host, port)
+    @service.connection
+  end
+
+  # Close Beanstalk connection
+  def self.close_connection
+    @service.close
+    @service = nil
+  end
+
+  # @return [Logger] the logger, defaulting to a STDOUT logger
+  def self.logger
+    @logger ||= Config.logger
+    @logger
+  end
+end

data/spec/beanstalk_farmer/config_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe BeanstalkFarmer::Config do
+  describe ".option" do
+    before(:all) do
+      described_class.option(:test_setting, default: true)
+    end
+
+    it "creates a getter for an option" do
+      described_class.should respond_to(:test_setting)
+    end
+
+    it "creates a setter for the option" do
+      described_class.should respond_to(:test_setting=)
+    end
+
+    it "creates a conditional for the option" do
+      described_class.should respond_to(:test_setting?)
+    end
+
+    it "allows the setting of a default value" do
+      described_class.test_setting.should == true
+    end
+  end
+end

data/spec/beanstalk_farmer/dsl_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe BeanstalkFarmer::DSL do
+  describe '#tube' do
+    let(:tube_name) { 'my_tube' }
+    let(:handler)   { Proc.new { |args| args } }
+
+    after(:each) do
+      BeanstalkFarmer::Job.handler_pool(true)
+    end
+
+    it 'correctly adds job handlers for some tube' do
+      subject.tube(tube_name, handler)
+      BeanstalkFarmer::Job.handler_pool[tube_name].should == handler
+    end
+  end
+end

data/spec/beanstalk_farmer/job_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe BeanstalkFarmer::Job do
+  let(:job) {
+    double('job', body: "[\"bacon\",{\"msg\":\"Hello\"}]", name: 'bacon', args: { 'msg' => 'Hello' }, ttr: 56, delete: true)
+  }
+
+  describe '.new' do
+    it 'sets the job' do
+      described_class.new(job).job.should == job
+    end
+
+    it 'decodes the name of the job' do
+      described_class.new(job).name.should == job.name
+    end
+
+    it 'decodes the arguments for the job' do
+      described_class.new(job).args.should == job.args
+    end
+  end
+
+  describe '.handler_pool' do
+    it 'is a Hash of job handlers' do
+      described_class.handler_pool.should be_a_kind_of(Hash)
+    end
+
+    it 'can reset the Hash of job hanlders' do
+      described_class.handler_pool['bacon'] = lambda { |args| args }
+      described_class.handler_pool(true)
+      described_class.handler_pool.should be_empty
+    end
+  end
+
+  describe '#work' do
+    let(:handler) { proc { |args| args } }
+
+    subject { described_class.new(job) }
+
+    before(:each) do
+      described_class.handler_pool[job.name] = handler
+    end
+
+    it 'performs some work for the handler' do
+      subject.work.should == job.args
+    end
+
+    it 'times out if the job has run out of time' do
+      Timeout.should_receive(:timeout).with(job.ttr) { raise Timeout::Error }
+      expect { subject.work }.to raise_error(BeanstalkFarmer::Job::OutOfTimeError)
+    end
+
+    it 'deletes the job' do
+      subject.job.should_receive(:delete)
+      subject.work
+    end
+  end
+end

data/spec/beanstalk_farmer/runner_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe BeanstalkFarmer::Runner do
+  subject { described_class.instance }
+
+  it 'is a singleton' do
+    described_class.included_modules.should include(Singleton)
+  end
+
+  its(:service) { should be_a_kind_of(BeanstalkFarmer::Service) }
+
+  describe '#handler_pool' do
+    it 'is the job handler pool' do
+      BeanstalkFarmer::Job.should_receive(:handler_pool)
+      subject.handler_pool
+    end
+  end
+
+  describe '#prep_tubes' do
+    it 'prepares tubes for watching'  do
+      subject.service.should_receive(:prep).with(subject.handler_pool.keys)
+      subject.prep_tubes
+    end
+  end
+
+  describe '#reserve_and_work_job' do
+    let(:job) { double('Farmer::Job', work: true) }
+
+    before(:each) do
+      subject.stub_chain(:service, :reserve) { job }
+    end
+
+    it 'reserves a job' do
+      subject.service.should_receive(:reserve) { job }
+      subject.reserve_and_work_job
+    end
+
+    it 'works the job' do
+      job.should_receive(:work)
+      subject.reserve_and_work_job
+    end
+  end
+
+  describe '.run!' do
+    before(:each) do
+      subject.stub(:prep_tubes)
+      subject.stub(:work_jobs)
+    end
+
+    it 'prepares tubes for watching' do
+      subject.should_receive(:prep_tubes)
+      described_class.run!
+    end
+
+    it 'works jobs' do
+      subject.should_receive(:work_jobs)
+      described_class.run!
+    end
+  end
+end

data/spec/beanstalk_farmer/service_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe BeanstalkFarmer::Service do
+  describe '.new' do
+    it 'sets the `uri` attribute' do
+      described_class.new.uri.should =~ /\A#{BeanstalkFarmer::Config.host}:#{BeanstalkFarmer::Config.port}\z/
+    end
+  end
+
+  describe '#connection' do
+    after(:each) do
+      subject.close
+    end
+
+    it 'establishes a connection to Beanstalk' do
+      expect {
+        subject.connection.put 'Hello'
+      }.to_not raise_error(BeanstalkFarmer::Service::NotConnectedError)
+    end
+  end
+
+  describe '#close' do
+    it 'closes the Beanstalk connection' do
+      connection = subject.connection # ensure we're connected
+      subject.close
+      connection.open_connections.should be_empty
+    end
+  end
+
+  describe '#watch_tubes' do
+    it 'adds a tube to the list of watched tubes' do
+      subject.watch_tubes(%w[bacon])
+      subject.connection.list_tubes_watched.should have_tube_named('bacon')
+    end
+  end
+
+  describe '#ignore_unwatched_tubes' do
+    it 'ignores tubes that are not being watched' do
+      pending 'a creative way to test this problem'
+    end
+  end
+
+  describe '#reserve' do
+    let(:job) {
+      double('job', body: "[\"bacon\",{\"msg\":\"Hello\"}]", name: 'bacon', args: { 'msg' => 'Hello' }, ttr: 56)
+    }
+
+    before(:each) do
+      subject.connection.stub(:reserve) { job }
+    end
+
+    it 'builds a Farmer::Job' do
+      subject.reserve.should be_a_kind_of(BeanstalkFarmer::Job)
+    end
+
+    it 'reserves a job indefinitely' do
+      subject.connection.should_receive(:reserve).with(nil) { job }
+      subject.reserve
+    end
+
+    it 'reserves a job for the specified number of seconds' do
+      subject.connection.should_receive(:reserve).with(30) { job }
+      subject.reserve(30)
+    end
+  end
+end

data/spec/beastalk_farmer_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe BeanstalkFarmer do
+  describe '.connection' do
+    it 'initializes a new Beanstalk connection' do
+      described_class::Service.any_instance.should_receive(:connection)
+      described_class.connection
+    end
+  end
+
+  describe '.close_connection' do
+    before(:each) do
+      described_class::Service.any_instance.stub(:connection)
+      described_class::Service.any_instance.stub(:close)
+
+      described_class.connection # sets up a connection
+    end
+
+    it 'closes all connections to Beanstalk' do
+      described_class::Service.any_instance.should_receive(:close)
+      described_class.close_connection
+    end
+  end
+
+  its(:logger) { should be_a_kind_of(Logger) }
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'farmer'
+
+Dir['./spec/support/**/*.rb'].each { |support_file| require support_file }
+
+RSpec.configure do |config|
+end

data/spec/support/have_tube_named.rb

@@ -0,0 +1,7 @@
+RSpec::Matchers.define :have_tube_named do |expected_tube_name|
+  match do |watched_tubes_hash|
+    watched_tubes_hash.values.flatten.include?(expected_tube_name)
+  end
+
+  diffable
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification 
+name: beanstalk_farmer
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- James Herdamn
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-16 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: beanstalk-client
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: multi_json
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "2.6"
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+description: Farmer is a nice little kit to manage a Beanstalk job queue
+email: 
+- james.herdman@me.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- .rvmrc
+- .yardopts
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- beanstalk_farmer.gemspec
+- example/echo.rb
+- lib/beanstalk_farmer/config.rb
+- lib/beanstalk_farmer/dsl.rb
+- lib/beanstalk_farmer/job.rb
+- lib/beanstalk_farmer/runner.rb
+- lib/beanstalk_farmer/service.rb
+- lib/beanstalk_farmer/version.rb
+- lib/farmer.rb
+- spec/beanstalk_farmer/config_spec.rb
+- spec/beanstalk_farmer/dsl_spec.rb
+- spec/beanstalk_farmer/job_spec.rb
+- spec/beanstalk_farmer/runner_spec.rb
+- spec/beanstalk_farmer/service_spec.rb
+- spec/beastalk_farmer_spec.rb
+- spec/spec_helper.rb
+- spec/support/have_tube_named.rb
+has_rdoc: true
+homepage: https://github.com/jherdman/beanstalk_farmer
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: -1506406479877648838
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: farmer
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A nice little kit to manage a Beanstalk job queue
+test_files: []
+