qmin 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5c2e896aee9f13d55b90c872e085fc5299d557d7
+  data.tar.gz: e5b1d269a78af22367a6e88d937554dfea633d9b
+SHA512:
+  metadata.gz: 6eb6b7b525f97a928e87861df48c8d9687216f5f72441b4e4afd4642ca1ec2be447d9828d6ecfcba18ec68d46dc888c304c1a9521eeb65b4d5cab6e52c75b43d
+  data.tar.gz: 5bdd3ac3c1f885257ad8c243b10462ac07c931f6952eb29e0ba2c37f3bc6635090794a846e36c55a5dc6ce7d76bb69f1c56c84703b71475024f79881cbb9e524

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+.rvmrc
+.ruby-version
+.ruby-gemset
+/bin
+.idea

data/.rspec

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 the-architect
+
+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,50 @@
+# Qmin
+
+Enables your application to handle method calls in the background without the need to write a worker for every task.
+
+
+## Assumptions
+
+You can transparently call methods on instances that adhere to some assumptions Qmin makes about your code:
+
+* Classes (i.e. ActiveRecord Models) have a #find class method that takes an ID as an argument and instantiates an instance of that class.
+* Instances of that class have a public #id method that returns a value which can be used by the #find class method to instantiate that instance.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'qmin'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install qmin
+
+## Usage
+
+### Qmin::Strategy
+
+Currently these strategies are implemented:
+
+* Noop (does nothing)
+* Inline (calls the method inline, helpful for testing or development)
+* Resque (moves the work off to the resque queue)
+
+## Todo
+
+* better documentation :)
+* Qmin::Strategy::DelayedJob
+* Qmin::Strategy::Sidekiq
+
+## 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,11 @@
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc 'Run specs'
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+end

data/lib/qmin/core_ext/class.rb

@@ -0,0 +1,24 @@
+# Extends class with #background_method(method_name)
+# The annotated method will be handled by Qmin and it's current strategy
+class Class
+  # @param method_name
+  # Decorates a method to be handled by Qmin's #background_call method
+  # Calls to the method will then be handled by the configured Qmin::Strategy#background_call method
+  # The original method is still available through "<method_name>_without_qmin"
+  def background_method(method_name)
+    return if respond_to?("#{method_name}_without_qmin") || !!method_name.to_s.match(/_without_qmin$/)
+
+    alias_method "#{method_name}_without_qmin", method_name
+
+    define_method method_name do
+      ::Qmin::Qmin.background_call(self, method_name)
+    end
+  end
+
+  # @param *method_names
+  # annotates all methods as background_methods
+  # see #background_method for more information
+  def background_methods(*method_names)
+    method_names.map(&:to_s).each{|method_name| background_method method_name }
+  end
+end

data/lib/qmin/core_ext/string.rb

@@ -0,0 +1,34 @@
+unless String.instance_methods.include?(:snake_case)
+
+  class String
+    def snake_case
+      self.to_s.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr('-', '_').
+        downcase
+    end
+  end
+
+end
+
+unless String.instance_methods.include?(:constantize)
+
+  class String
+    def constantize
+      Kernel.const_get(self)
+    end
+  end
+
+end
+
+
+unless String.instance_methods.include?(:to_queue_name)
+
+  class String
+    def to_queue_name
+      gsub('::','').snake_case
+    end
+  end
+
+end

data/lib/qmin/qmin.rb

@@ -0,0 +1,38 @@
+module Qmin
+  # Handles configuration and dispatches method calls to configured strategy
+  class Qmin
+    # configure default strategy
+    def self.default_strategy=(strategy)
+      @@default_strategy = strategy
+    end
+
+    def self.current
+      @@current ||= new
+    end
+
+    def self.enqueue(worker_class, *args)
+      current.enqueue worker_class, *args
+    end
+
+    def self.background_call(instance, method_name)
+      current.background_call(instance, method_name)
+    end
+
+    def initialize(strategy = nil)
+      begin
+        @strategy = (strategy || @@default_strategy).new
+      rescue NameError
+        raise MustDefineStrategyError.new
+      end
+      @@current = self
+    end
+
+    def enqueue(worker_class, *args)
+      @strategy.enqueue worker_class, *args
+    end
+
+    def background_call(instance, method_name)
+      @strategy.background_call(instance, method_name)
+    end
+  end
+end

data/lib/qmin/resque/background_call_job.rb

@@ -0,0 +1,22 @@
+module Qmin
+  module Resque
+    class BackgroundCallJob
+
+      def self.perform(*args)
+        new(*args).perform
+      end
+
+      def initialize(klass, method_name, id)
+        @klass = klass.is_a?(Class) ? klass : klass.constantize
+        @method_name = method_name
+        @id = id
+      end
+
+      def perform
+        instance = @klass.find(@id)
+        instance.send(::Qmin.method_name_for_instance(instance, @method_name))
+      end
+    end
+  end
+end
+

data/lib/qmin/resque/base_job.rb

@@ -0,0 +1,53 @@
+module Qmin
+  module Resque
+    # Defines a handy base class for Resque workers for the following pattern:
+    # * Find an instance of a model by id
+    # * call a method on the instance
+    #
+    class BaseJob
+      MustRespondToFindMethodError = Class.new(StandardError) do
+        @message = 'Model must respond to #find method!'
+      end
+
+      ImplementationMissing = Class.new(StandardError)
+
+      # delegate perform to job instance
+      def self.perform(*args)
+        new(*args).perform
+      end
+
+      def self.model(model)
+        if model.respond_to? :find
+          @@model = model
+        else
+          raise MustRespondToFindMethodError
+        end
+      end
+
+      def initialize(id, *args)
+        @id = id
+      end
+
+      def perform
+        raise ImplementationMissing.new("Please implement #perform instance method for job: #{self.class.name}")
+      end
+
+      def instance
+        @instance ||= find_instance(@id)
+      end
+
+      def find_instance(id)
+        model.find(id)
+      end
+
+      def model
+        @@model
+      end
+
+      def self.queue
+        # automatic queue naming
+        @queue ||= self.name.to_queue_name
+      end
+    end
+  end
+end

data/lib/qmin/strategy/inline.rb

@@ -0,0 +1,15 @@
+module Qmin
+  module Strategy
+    class Inline
+      # handle job in process
+      def enqueue(worker_class, *args)
+        worker_class.send :perform, *args
+      end
+
+      # call method directly
+      def background_call(instance, method_name)
+        instance.send(::Qmin.method_name_for_instance(instance, method_name))
+      end
+    end
+  end
+end

data/lib/qmin/strategy/noop.rb

@@ -0,0 +1,11 @@
+module Qmin
+  module Strategy
+    class Noop
+      def enqueue(*args)
+      end
+
+      def background_call(*args)
+      end
+    end
+  end
+end

data/lib/qmin/strategy/resque.rb

@@ -0,0 +1,48 @@
+module Qmin
+  module Strategy
+    # Strategy to handle background calls and queuing of worker jobs with Resque
+    # This will only be available if the Resque constant is defined when you require 'qmin'
+    # If somehow this is not working for you, add:
+    #    require 'qmin/resque/background_call_job'
+    #    require 'qmin/resque/base_job'
+    #    require 'qmin/strategy/resque'
+    # where needed
+    #
+    # Methods that are annotated with "background_method" will be handled by
+    # the generic Qmin::Resque::BackgroundCallJob worker.
+    # It will automatically create a queue name based on the class and method it is working on.
+    #
+    # So for example:
+    #
+    # * Jobs::Profile#update_facebook_friends is annotated to be a background_method
+    # * 'qmin_resque_background_call_job_jobs_profile_update_facebook_friends' will be the queue name
+    #
+    class Resque
+      # Just passes
+      def enqueue(worker_class, *args)
+        ::Resque.enqueue worker_class, *args
+      end
+
+      # @param klass
+      # Queue name is based on worker class and method name
+      # By default Qmin::Resque::BackgroundCallJob will handle jobs
+      def background_call(instance, method_name)
+        ::Resque.enqueue_to(queue_name(instance.class.name, method_name), self.class.job_class, instance.class.name, method_name, instance.id)
+      end
+
+      protected
+
+      def queue_name(klass_name, method_name)
+        [
+          self.class.job_class.name.to_queue_name,
+          klass_name.to_queue_name,
+          method_name
+        ].join('_')
+      end
+
+      def self.job_class
+        ::Qmin::Resque::BackgroundCallJob
+      end
+    end
+  end
+end

data/lib/qmin/version.rb

@@ -0,0 +1,3 @@
+module Qmin
+  VERSION = '0.0.1'
+end

data/lib/qmin.rb

@@ -0,0 +1,25 @@
+require 'qmin/qmin'
+require 'qmin/core_ext/class'
+require 'qmin/core_ext/string'
+require 'qmin/strategy/inline'
+require 'qmin/strategy/noop'
+
+if defined? Resque
+  require 'qmin/resque/background_call_job'
+  require 'qmin/resque/base_job'
+  require 'qmin/strategy/resque'
+end
+
+module Qmin
+  MustDefineStrategyError = Class.new(StandardError)
+
+  protected
+
+  def self.method_name_for_instance(instance, method_name)
+    if instance.respond_to? :"#{method_name}_without_qmin"
+      :"#{method_name}_without_qmin"
+    else
+      method_name
+    end
+  end
+end

data/qmin.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'qmin/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'qmin'
+  spec.version       = Qmin::VERSION
+  spec.authors       = ['the-architect']
+  spec.email         = ['marcel.scherf@epicteams.com']
+  spec.description   = %q{Simple framwork to coordinate background tasks}
+  spec.summary       = %q{Simple framwork to coordinate background tasks}
+  spec.homepage      = 'https://github.com/the-architect/qmin'
+  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_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'debugger'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'mocha'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'simplecov-html'
+  spec.add_development_dependency 'metric_fu'
+end

data/spec/qmin/core_ext/class_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path '../../spec_helper', File.dirname(__FILE__)
+
+describe Class do
+  it 'responds to background_method' do
+    Class.new.should respond_to(:background_method)
+  end
+
+  it 'annotates methods' do
+    klass = Class.new do
+      def foo; end
+      background_method :foo
+
+      def bar; end
+      background_method :bar
+    end
+
+    subject = klass.new
+
+    subject.should.respond_to? :foo
+    subject.should.respond_to? :foo_without_qmin
+
+    subject.should.respond_to? :bar
+    subject.should.respond_to? :bar_without_qmin
+  end
+
+
+  it 'annotates many methods' do
+    klass = Class.new do
+      def foo; end
+      def bar; end
+
+      background_methods :foo, :bar
+    end
+
+    subject = klass.new
+
+    subject.should.respond_to? :foo
+    subject.should.respond_to? :foo_without_qmin
+
+    subject.should.respond_to? :bar
+    subject.should.respond_to? :bar_without_qmin
+  end
+
+  it 'does not annotate method twice' do
+    klass = Class.new do
+      def foo; end
+      background_method :foo
+      background_method :foo
+    end
+
+    subject = klass.new
+
+    subject.should.respond_to? :foo
+    subject.should.respond_to? :foo_without_qmin
+  end
+
+  it 'does not annotate original method' do
+    klass = Class.new do
+      def foo; end
+      background_method :foo
+      background_method :foo_without_qmin
+    end
+
+    subject = klass.new
+
+    subject.should.respond_to? :foo
+    subject.should.respond_to? :foo_without_qmin
+    subject.should_not.respond_to? :foo_without_qmin_without_qmin
+  end
+end

data/spec/qmin/core_ext/string_spec.rb

@@ -0,0 +1,18 @@
+require File.expand_path '../../spec_helper', File.dirname(__FILE__)
+
+describe String do
+  it '.snake_case' do
+    'MyClassName'.snake_case.should eql 'my_class_name'
+    'Module::MyClassName'.snake_case.should eql 'module/my_class_name'
+  end
+
+  it '.constantize' do
+    'TestClass'.constantize.should eql TestClass
+  end
+
+  it '.to_queue_name' do
+    'MyClassName'.to_queue_name.should eql 'my_class_name'
+    'Module::MyClassName'.to_queue_name.should eql 'module_my_class_name'
+  end
+
+end

data/spec/qmin/qmin_spec.rb

@@ -0,0 +1,60 @@
+require File.expand_path '../spec_helper', File.dirname(__FILE__)
+
+describe Qmin do
+
+  it 'loads strategies' do
+    defined?(Qmin::Strategy::Inline).should eql('constant')
+    defined?(Qmin::Strategy::Noop).should eql('constant')
+    defined?(Qmin::Strategy::Resque).should eql('constant')
+  end
+
+  describe 'initialize' do
+    it 'raises error if no strategy defined' do
+      Qmin::Qmin.default_strategy = nil
+
+      -> {
+        Qmin::Qmin.new
+      }.should raise_error(Qmin::MustDefineStrategyError)
+    end
+
+    it 'raises error for current if no strategy defined' do
+      Qmin::Qmin.default_strategy = nil
+      Qmin::Qmin.class_variable_set(:@@current, nil)
+
+      -> {
+        Qmin::Qmin.current
+      }.should raise_error(Qmin::MustDefineStrategyError)
+    end
+  end
+
+  describe 'background_method' do
+    it 'aliases background methods'do
+      subject = BackgroundTestClass.new
+
+      subject.should respond_to(:action)
+      subject.should respond_to(:action_without_qmin)
+    end
+
+    it 'calls aliased method' do
+      subject = BackgroundTestClass.new
+
+      Qmin::Qmin.expects(:background_call).with(subject, :action)
+      subject.action
+    end
+
+    it 'calls original method with inline strategy' do
+      subject = BackgroundTestClass.new
+      subject.action
+    end
+  end
+
+  describe 'enqueue' do
+    it 'enqueues job' do
+      Qmin::Qmin.new(Qmin::Strategy::Inline)
+
+      TestJob.expects(:perform).with(1,2,3)
+      Qmin::Qmin.enqueue TestJob, 1,2,3
+    end
+  end
+
+end

data/spec/qmin/resque/background_call_job_spec.rb

@@ -0,0 +1,28 @@
+require File.expand_path '../../spec_helper', File.dirname(__FILE__)
+
+describe Qmin::Resque::BackgroundCallJob do
+  let(:id){ 123 }
+
+  before do
+    Qmin::Qmin.new(Qmin::Strategy::Resque)
+  end
+
+  it 'calls method on instance' do
+    ::Qmin::Resque::BackgroundCallJob.new(TestClass, :action, id).perform.should eql id
+  end
+
+  it 'calls method on instance wrapped in background_call_job' do
+    Qmin::Qmin.new(Qmin::Strategy::Resque)
+
+    BackgroundTestClass.new(id).action
+    ::Resque.queue['qmin_resque_background_call_job_background_test_class_action'][0].should eql ({:class => Qmin::Resque::BackgroundCallJob, :args => ['BackgroundTestClass', :action, 123]})
+  end
+
+  it 'delegates perform to instance' do
+    Qmin::Qmin.new(Qmin::Strategy::Resque)
+
+    Qmin::Resque::BackgroundCallJob.any_instance.expects(:perform)
+    Qmin::Resque::BackgroundCallJob.perform(BackgroundTestClass, 'action', 123)
+  end
+
+end

data/spec/qmin/resque/base_job_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path '../../spec_helper', File.dirname(__FILE__)
+
+describe Qmin::Resque::BaseJob do
+
+  it 'performs test job' do
+    Qmin::Qmin.new(Qmin::Strategy::Resque)
+    TestJob.perform(10).should eql 10
+  end
+
+  it 'demands find method on model class' do
+    Qmin::Qmin.new(Qmin::Strategy::Resque)
+    -> {
+      Class.new(Qmin::Resque::BaseJob) do
+        model Class
+      end
+    }.should raise_error(Qmin::Resque::BaseJob::MustRespondToFindMethodError)
+  end
+
+  it 'demands implementation of perform method' do
+    instance = Class.new(Qmin::Resque::BaseJob).new(TestClass, :action, 123)
+    -> {
+      instance.perform
+    }.should raise_error(Qmin::Resque::BaseJob::ImplementationMissing)
+
+  end
+
+  it 'supplies instance' do
+    TestJob.new(10).instance.should be_a_kind_of(TestClass)
+  end
+
+end

data/spec/qmin/strategy/inline_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path '../../spec_helper', File.dirname(__FILE__)
+
+describe Qmin::Strategy::Inline do
+  subject{ Qmin::Strategy::Inline.new }
+
+  it 'enqueues job' do
+    WorkerClass.expects(:perform).with(1,2,3)
+    subject.enqueue(WorkerClass, 1,2,3)
+  end
+
+  it 'calls background call method' do
+    subject.background_call(BackgroundTestClass.new, :action).should eql 123
+  end
+end

data/spec/qmin/strategy/noop_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path '../../spec_helper', File.dirname(__FILE__)
+
+describe Qmin::Strategy::Noop do
+  subject{ Qmin::Strategy::Noop.new }
+
+  it 'enqueues job' do
+    WorkerClass.expects(:perform).never
+    subject.enqueue(WorkerClass, 1,2,3)
+  end
+
+  it 'calls background call method' do
+    BackgroundTestClass.expects(:action).never
+    subject.background_call(BackgroundTestClass, :action, 123).should
+  end
+end

data/spec/qmin/strategy/resque_spec.rb

@@ -0,0 +1,21 @@
+require File.expand_path '../../spec_helper', File.dirname(__FILE__)
+
+describe Qmin::Strategy::Resque do
+  subject{ Qmin::Strategy::Resque.new }
+
+  it 'creates background_call_job' do
+    ::Resque.expects(:enqueue_to).with('qmin_resque_background_call_job_test_class_action', Qmin::Resque::BackgroundCallJob, 'TestClass', :action, 555)
+    subject.background_call(TestClass.new(555), :action)
+  end
+
+  it 'enqueues job' do
+    ::Resque.expects(:enqueue).with(TestClass, 1, 2, 3)
+    subject.enqueue(TestClass, 1, 2, 3)
+  end
+
+  it 'pushes to specified queue' do
+    subject.enqueue(TestJob, 1, 2, 3)
+    ::Resque.queue['test_job'].should eql [{:class=>TestJob, :args=>[1, 2, 3]}]
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,98 @@
+require 'simplecov'
+SimpleCov.start do
+  add_filter '/spec'
+end
+
+require 'rspec/autorun'
+
+# mock Resque behavior
+class Resque
+  def self.enqueue_to(queue_name, worker, *args)
+    queue[queue_name].push({ :class => worker, :args => args })
+  end
+
+  def self.enqueue(worker_class, *args)
+    queue[queue_for_class(worker_class)].push({ :class => worker_class, :args => args })
+  end
+
+  def self.queue_for_class(klass)
+    klass.instance_variable_get(:@queue) || (klass.respond_to?(:queue) and klass.queue)
+  end
+
+  def self.queue
+    @@queue ||= Hash.new{|h,k| h[k] = Array.new }
+  end
+
+  def self.reset_queue!
+    @@queue = Hash.new{|h,k| h[k] = Array.new }
+  end
+end
+
+require File.expand_path '../lib/qmin', File.dirname(__FILE__)
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+  config.order = 'random'
+
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.filter_run focus: true
+  config.filter_run_excluding :wip => true
+  config.run_all_when_everything_filtered = true
+
+  config.before(:each) do
+    Resque.reset_queue!
+    Qmin::Qmin.new(Qmin::Strategy::Inline)
+  end
+
+  config.after(:each) do
+    Qmin::Qmin.new(Qmin::Strategy::Inline)
+  end
+end
+
+class WorkerClass
+  def initialize(*args)
+  end
+
+  def self.perform(*args)
+    new(*args).perform
+  end
+
+  def perform
+
+  end
+end
+
+class TestClass
+  def action
+    @id
+  end
+
+  def self.name
+    'TestClass'
+  end
+
+  def self.find(id)
+    new(id)
+  end
+
+  def initialize(id = 123)
+    @id = id
+  end
+  attr_reader :id
+end
+
+class BackgroundTestClass < TestClass
+  def self.name
+    'BackgroundTestClass'
+  end
+
+  background_method :action
+end
+
+class TestJob < Qmin::Resque::BaseJob
+  model TestClass
+
+  def perform
+    instance.id
+  end
+end

metadata

@@ -0,0 +1,191 @@
+--- !ruby/object:Gem::Specification
+name: qmin
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- the-architect
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-02 00:00:00.000000000 Z
+dependencies:
+- !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: debugger
+  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: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  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: simplecov
+  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: simplecov-html
+  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: metric_fu
+  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: Simple framwork to coordinate background tasks
+email:
+- marcel.scherf@epicteams.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/qmin.rb
+- lib/qmin/core_ext/class.rb
+- lib/qmin/core_ext/string.rb
+- lib/qmin/qmin.rb
+- lib/qmin/resque/background_call_job.rb
+- lib/qmin/resque/base_job.rb
+- lib/qmin/strategy/inline.rb
+- lib/qmin/strategy/noop.rb
+- lib/qmin/strategy/resque.rb
+- lib/qmin/version.rb
+- qmin.gemspec
+- spec/qmin/core_ext/class_spec.rb
+- spec/qmin/core_ext/string_spec.rb
+- spec/qmin/qmin_spec.rb
+- spec/qmin/resque/background_call_job_spec.rb
+- spec/qmin/resque/base_job_spec.rb
+- spec/qmin/strategy/inline_spec.rb
+- spec/qmin/strategy/noop_spec.rb
+- spec/qmin/strategy/resque_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/the-architect/qmin
+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.0.2
+signing_key: 
+specification_version: 4
+summary: Simple framwork to coordinate background tasks
+test_files:
+- spec/qmin/core_ext/class_spec.rb
+- spec/qmin/core_ext/string_spec.rb
+- spec/qmin/qmin_spec.rb
+- spec/qmin/resque/background_call_job_spec.rb
+- spec/qmin/resque/base_job_spec.rb
+- spec/qmin/strategy/inline_spec.rb
+- spec/qmin/strategy/noop_spec.rb
+- spec/qmin/strategy/resque_spec.rb
+- spec/spec_helper.rb