actionable 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 35e414933341959d1347c1cb41e4e2bae53e880d
+  data.tar.gz: 19d6241afa6343d0a0e69033fafe1600fa54655e
+SHA512:
+  metadata.gz: 4e3ca8e2f1875fd0a5301f96e6293ca62c60dcb835cd21442779995489730c0056ea2d14d81dad33110ea450964707c459d0bc22f179ce59b94b80bd37d1fb56
+  data.tar.gz: 9815bef64be1a7d64100144278bf6d8404551915f618f9215e4f5910178c77b736de4eefb6f69b44f5741bd99646cdc6d1e312f0cee3d9507b4a0f0611944302

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+gem 'resque', github: 'defunkt/resque', branch: 'master'
+gem 'redis'
+gem 'redis-namespace'
+
+gem 'mongoid', github: 'mongoid/mongoid', branch: 'master'
+gem 'moped'
+gem 'origin'
+
+gemspec

data/Guardfile

@@ -0,0 +1,7 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :rspec do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})                           { |m| "spec/lib/#{m[1]}_spec.rb" }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Daniel Luxemburg
+
+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,29 @@
+# Actionable
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'actionable'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install actionable
+
+## Usage
+
+TODO: Write usage instructions here
+
+## 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,16 @@
+require "bundler/gem_tasks"
+require 'actionable/tasks'
+require 'resque/tasks'
+
+task "resque:setup" do
+  puts File.expand_path('../spec/support/*.rb', __FILE__)
+  Dir[File.expand_path('../spec/support/*.rb', __FILE__)].each do |f| 
+    puts f
+    require f
+  end
+
+  puts TestJob.class.to_s
+  Mongoid.configure do |config|
+    config.connect_to('actionable_test')
+  end
+end

data/actionable.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'actionable/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "actionable"
+  spec.version       = Actionable::VERSION
+  spec.authors       = ["Daniel Luxemburg"]
+  spec.email         = ["daniel.luxemburg@gmail.com"]
+  spec.description   = %q{Better jobs. Good jobs.}
+  spec.summary       = %q{Store stuff in Mongo, keep track of it in Redis, log lots of stuff, include test help}
+  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_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "timecop"
+  spec.add_development_dependency "guard-rspec"
+  spec.add_development_dependency "rb-fsevent"
+  spec.add_development_dependency "terminal-notifier-guard"
+
+  spec.add_dependency "resque"
+  spec.add_dependency "mongoid"
+  spec.add_dependency "rufus-scheduler"
+
+
+end
+
+

data/lib/actionable.rb

@@ -0,0 +1,31 @@
+require "mongoid"
+require "resque"
+
+require "actionable/version"
+
+require "actionable/memory_store"
+require "actionable/memory_store/action"
+
+require "actionable/mongoid_store"
+require "actionable/mongoid_store/action"
+
+require "actionable/target"
+require "actionable/sweep"
+require "actionable/job"
+
+module Actionable
+  def self.store
+    self.const_get(store_name)
+  end
+
+  def self.set_store(name)
+    @store_name = name
+  end
+
+  def self.store_name
+    @store_name ||= "MongoidStore"
+  end
+
+  Action = SimpleDelegator.new(MongoidStore::Action)
+
+end

data/lib/actionable/job.rb

@@ -0,0 +1,35 @@
+module Actionable
+  class Job
+  
+    attr_reader :actionable
+
+    def self.queue
+      @queue ||= 'actionable'
+    end
+
+    def self.after_enqueue(id)
+      actionable = Actionable::Action.find(id)
+      actionable.update_attributes(status: :enqueued)
+    end
+
+    def self.perform(id)
+      actionable = Actionable::Action.find(id)
+      actionable.update_attributes(status: :working)
+      new(actionable).perform
+      actionable.update_attributes(status: :complete)
+    end
+
+    def initialize(actionable)
+      @actionable = actionable
+    end
+
+    def target
+      @target ||= actionable.target
+    end
+
+    def payload
+      @payload ||= HashWithIndifferentAccess.new(actionable.payload)
+    end
+
+  end
+end

data/lib/actionable/memory_store.rb

@@ -0,0 +1,49 @@
+module Actionable
+  module MemoryStore
+    
+    def self.insert(model)
+      key = (model[:id] ||= Moped::BSON::ObjectId.new.to_s)
+      set(key,model)
+      add(hash["target_#{model[:target_id]}"],model) if model[:target_id].present?
+      model
+    end
+
+    def self.find(key)
+      model = hash[key]
+    end
+
+    def self.find_by_target_id(target_id)
+      hash["target_#{target_id}"]
+    end
+
+    private
+
+    def self.hash
+      @hash ||= {}
+    end
+
+    def self.set(key,value)
+      hash[key] = value
+    end
+
+    def self.get(key)
+      hash[key]
+    end
+
+    def self.clear
+      @hash = {}
+    end
+
+    def self.count
+      hash.length
+    end
+
+    def self.add(key,model)
+      list = (hash[key] ||= [])
+      list << model
+      set(key,list)
+    end
+
+
+  end
+end

data/lib/actionable/memory_store/action.rb

@@ -0,0 +1,83 @@
+require 'active_model'
+
+module Actionable
+  module MemoryStore
+    class Action
+
+      include ActiveModel::Model
+      attr_accessor :id, :execution_time, :payload, :job_class_name 
+      attr_accessor :target, :target_id, :target_class_name, :status
+
+      def self.create(data)
+        this = new(data)
+        this.status = :new
+        this
+      end
+
+      def self.build(data)
+        this = new(data)
+        this.status = :new
+        this
+      end
+
+      def target
+        @target ||= get_target_from_definition
+      end
+
+      def save
+        Actionable::MemoryStore.insert(for_save)
+      end
+
+      def enqueue
+        Resque.enqueue(job_class,id.to_s)
+      end
+
+      def cancel
+        update_attributes(status: :cancelled)
+      end
+
+      def reschedule_for(execution_time)
+        update_attributes(execution_time: execution_time)
+      end
+
+      protected
+
+      def set_target_definition
+        target_class = target.class.to_s
+        target_id = target.id
+      end
+
+      def get_target_from_definition
+        return nil unless target_class.present? && target_id.present?
+        target_class.find(target_id)
+      end
+
+      def job_class
+        job_class_name.constantize if job_class_name.present?
+      end
+
+      def target_class
+        target_class_name.constantize if target_class_name.present?
+      end
+
+      def update_attributes(hash)
+        hash.each_pair do |key,value|
+          instance_variable_set(:"@#{key}",value)
+        end
+      end
+
+      private
+
+      def for_save
+        if @target.present? && (@target_id.nil? || @target_class.nil?)
+          set_target_definition
+        end
+        json = as_json
+        json.delete(:target)
+        json
+      end
+
+    end
+  end
+end
+

data/lib/actionable/mongoid_store.rb

@@ -0,0 +1,27 @@
+require 'mongoid'
+
+module Actionable
+  module MongoidStore
+    
+    def self.find(key)
+      Action.find(key)
+    end
+
+    def self.find_by_target_id(target_id)
+      Action.where(target_id:target_id)
+    end
+
+    def self.count
+      Action.count
+    end
+
+    def self.create(*args)
+      Action.create(*args)
+    end
+
+    def self.build(*args)
+      Action.build(*args)
+    end
+
+  end
+end

data/lib/actionable/mongoid_store/action.rb

@@ -0,0 +1,31 @@
+require 'mongoid'
+
+module Actionable
+  module MongoidStore
+    class Action < MemoryStore::Action
+
+      include Mongoid::Document
+
+      store_in(collection: 'actionables')
+   
+      field :execution_time,    type: DateTime
+      field :payload,           type: Hash
+      field :job_class_name,    type: String
+      field :status,            type: Symbol,     default: :new
+      field :target_id,         type: Moped::BSON::ObjectId
+      field :target_class_name, type: String
+
+      scope :scheduled, where(status: :scheduled)
+      scope :scheduled_for_between, ->(from,to){ 
+        between(execution_time:[from,to])
+      }
+      scope :scheduled_for_before, ->(to){ where(:execution_time.lt => to) }
+
+      def self.to_do
+        scheduled.scheduled_for_before(Time.now.to_datetime)
+      end
+
+    end
+  end
+end
+

data/lib/actionable/resque.rb

@@ -0,0 +1,17 @@
+require 'actionable/sweep'
+
+module Resque
+  class MultiQueue
+  
+    alias :default_poll :poll
+
+    def poll(t)
+      default_poll(t) || sweep
+    end
+
+    def sweep
+      Resque.enqueue(Actionable::Sweep)
+    end
+
+  end
+end

data/lib/actionable/sweep.rb

@@ -0,0 +1,16 @@
+module Actionable
+  class Sweep
+
+    @queue = 'actionable_sweep'
+
+    def self.queue
+      @queue
+    end
+
+    def self.perform
+      Actionable::Action.to_do.each(&:enqueue)
+    end
+
+  end
+
+end

data/lib/actionable/target.rb

@@ -0,0 +1,55 @@
+require 'active_support'
+
+module Actionable 
+  module Target
+  
+    extend ActiveSupport::Concern
+
+    attr_accessor :actionable_ids
+    attr_accessor :actionable_errors
+
+    def actionables
+      @actionables ||= Actionable::Action.where(target_id: id)
+    end
+
+    def actionable_errors
+      @actionable_errors
+    end
+
+
+    def schedule_actionable(execution_time,job_class_name,payload={})
+      
+      # force memoized values to refresh
+      @actionables = nil
+      @actionable_errors = nil
+
+      # set model values
+      actionable = Actionable::Action.build(
+        target_id:id,
+        target_class_name: self.class.to_s,
+        payload: payload,
+        execution_time: execution_time,
+        job_class_name: job_class_name
+      )
+
+      # yield the model to a block for 
+      # situation-specific adjustments
+      yield(actionable) if block_given?
+
+      # set status to saved now that 
+      # initialization is complete
+      actionable.status = :scheduled
+
+      # save the new model record
+      unless actionable.save
+
+        # keep error values around for inspection
+        @actionable_errors = actionable.errors
+        false
+      end
+      true
+
+    end
+
+  end
+end

data/lib/actionable/tasks.rb

@@ -0,0 +1,2 @@
+require "actionable"
+require "actionable/resque"

data/lib/actionable/version.rb

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

data/spec/action_spec.rb

@@ -0,0 +1,71 @@
+require "spec_helper"
+
+describe Actionable::MemoryStore::Action do
+
+  it "should be be defined" do
+    expect(defined?(Actionable::MemoryStore::Action)).to be_true
+  end
+
+end
+
+describe Actionable::MemoryStore do
+
+  let(:payload) {
+    {payload: {name: 'daniel', number: 37}}
+  }
+
+  it "should not persist data when not saved" do
+    j = Actionable::MemoryStore::Action.new(payload)
+    expect(Actionable::MemoryStore.count).to eq(0)
+  end
+
+  it "should persist data when inserted" do
+    j = Actionable::MemoryStore::Action.new(payload).save
+    expect(Actionable::MemoryStore.count).to eq(1)
+  end
+
+end
+
+describe Actionable::MongoidStore do
+
+  let(:payload) {
+    {payload: {name: 'daniel', number: 37}}
+  }
+
+  it "should not persist data when not saved" do
+    j = Actionable::MongoidStore::Action.new(payload)
+    expect(Actionable::MongoidStore.count).to eq(0)
+  end
+
+  it "should persist data when inserted" do
+    j = Actionable::MongoidStore::Action.new(payload).save
+    expect(Actionable::MongoidStore.count).to eq(1)
+  end
+
+  context "scheduled for one hour from now" do
+
+    let(:payload){
+      {payload: {name: 'daniel', number: 37}, execution_time: 1.hour.from_now }
+    }
+
+    before do
+      j = Actionable::MongoidStore::Action.new(payload).save
+    end
+
+    it "should be available during the correct time window" do
+      expect(Actionable::MongoidStore::Action.between(execution_time:[
+        30.minutes.from_now,
+        90.minutes.from_now
+      ]).count).to eq(1)    
+    end
+
+    it "should not be available during the incorrect time window" do
+      expect(Actionable::MongoidStore::Action.between(execution_time:[
+        15.minutes.from_now,
+        45.minutes.from_now
+      ]).count).to eq(0)    
+    end
+
+  end
+
+end

data/spec/schedule_spec.rb

@@ -0,0 +1,42 @@
+require "spec_helper"
+
+describe Actionable::Target do
+
+  context "given an actionable for an hour from now" do
+
+    let(:target) {
+      TestModel.create({
+        color:'blue',
+        shape:'square',
+        number:3
+      })
+    }
+
+    before do
+      target.schedule_actionable(1.hour.from_now,TestJob,{number:3})
+    end
+
+    it "should be added to the database" do
+      expect(Actionable::MongoidStore.count).to eq(1)
+    end
+
+    it "should not be included as a 'to do'" do
+      expect(Actionable::Action.to_do.count).to eq(0)
+    end
+
+    it "should not be included as a 'scheduled'" do
+      expect(Actionable::Action.scheduled.count).to eq(1)
+    end
+
+    context "2 hours later" do
+
+      it "should be included as a 'to do'" do
+        Timecop.travel(2.hours.from_now)
+        expect(Actionable::Action.to_do.count).to eq(1)
+      end
+
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,28 @@
+require "bundler"
+Bundler.require(:default,:development)
+  
+Dir[File.expand_path('../support/*.rb', __FILE__)].each {|f| require f}
+
+Mongoid.configure do |config|
+  config.connect_to('actionable_test')
+end
+
+Resque.redis = Redis.new
+Resque.redis.namespace = "resque:actionable_test:"
+
+module Resque
+  def self.purge!
+    self.redis.keys('*')
+    self.redis.del(*keys) unless keys.count == 0
+  end
+end
+
+RSpec.configure do |config|
+
+  config.before(:each) do
+    Resque.purge!
+    Mongoid.purge!
+    Timecop.return
+  end
+
+end

data/spec/support/test_job.rb

@@ -0,0 +1,10 @@
+class TestJob < Actionable::Job
+
+  def perform
+    target.name = target.say_something
+    target.number = target.number * payload[:number]
+    target.save
+  end
+
+
+end

data/spec/support/test_model.rb

@@ -0,0 +1,15 @@
+class TestModel
+  include Mongoid::Document
+  include Actionable::Target
+
+  field :id
+  field :name
+  field :color
+  field :shape
+  field :number
+
+  def say_something
+    return "#{color} #{shape}"
+  end
+
+end

data/spec/sweep_spec.rb

@@ -0,0 +1,36 @@
+require "spec_helper"
+
+describe Actionable::Sweep do
+
+  let(:target) {
+    TestModel.create
+  }
+
+  before do
+    target.schedule_actionable(1.hour.from_now,TestJob)
+    Timecop.travel(2.hours.from_now)
+  end
+
+  it "should leave one job in the to do list before being performed" do
+    expect(Resque.size('actionables')).to eq(0)
+    expect(Actionable::Action.to_do.count).to eq(1)
+  end
+
+  it "should move one job from the to do list to the queue after being performed" do
+    Actionable::Sweep.perform
+    expect(Actionable::Action.to_do.count).to eq(0)
+    expect(Resque.size('actionables')).to eq(1)
+  end
+
+  pending "should enqueue a job that knows the id for its target" do
+    Actionable::Sweep.perform
+    expect(Resque.queue('actionables').pop['args'].first).to eq(target.actionables.first.id.to_s)
+  end
+
+  it "should update the actionable's status to 'enqueued'" do
+    expect(target.actionables.first.status).to eq(:scheduled)    
+    Actionable::Sweep.perform
+    expect(target.actionables.first.status).to eq(:enqueued)
+  end
+
+end

data/spec/work_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+
+def start_test_worker
+  spawn('bundle exec rake resque:work PIDFILE=resque.pid QUEUES=actionable,actionable_sweep INTERVAL=1')
+end
+
+def kill_test_worker
+  pid = File.new(File.expand_path("../../resque.pid",__FILE__)).read
+  system("kill -9 #{pid}")
+  system("rm resque.pid")
+end
+
+def run_test_worker
+  start_test_worker
+  sleep(5)
+  kill_test_worker
+end
+
+describe Actionable::Job do
+
+  context "scheduled for one minute ago" do
+
+    let(:target) {
+      TestModel.create({
+        color:'blue',
+        shape:'square',
+        number:3
+      })
+    }
+
+    before do
+     target.schedule_actionable(1.minute.ago,TestJob,{number:2})    
+    end
+
+    it "should be executed by a worker manually" do
+      Resque.inline = true
+      id = target.id
+      Actionable::Sweep.perform
+      expect(TestModel.find(id).number).to eq(6)
+      expect(TestModel.find(id).name).to eq('blue square')
+      Resque.inline = false
+    end
+
+    it "should be executed by a worker in another processes" do
+      id = target.id
+      run_test_worker
+      expect(TestModel.find(id).number).to eq(6)
+      expect(TestModel.find(id).name).to eq('blue square')
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,231 @@
+--- !ruby/object:Gem::Specification
+name: actionable
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Daniel Luxemburg
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-23 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: 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: pry
+  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: timecop
+  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: guard-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: rb-fsevent
+  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: terminal-notifier-guard
+  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: resque
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rufus-scheduler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Better jobs. Good jobs.
+email:
+- daniel.luxemburg@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- actionable.gemspec
+- lib/actionable.rb
+- lib/actionable/job.rb
+- lib/actionable/memory_store.rb
+- lib/actionable/memory_store/action.rb
+- lib/actionable/mongoid_store.rb
+- lib/actionable/mongoid_store/action.rb
+- lib/actionable/resque.rb
+- lib/actionable/sweep.rb
+- lib/actionable/target.rb
+- lib/actionable/tasks.rb
+- lib/actionable/version.rb
+- spec/action_spec.rb
+- spec/schedule_spec.rb
+- spec/spec_helper.rb
+- spec/support/test_job.rb
+- spec/support/test_model.rb
+- spec/sweep_spec.rb
+- spec/work_spec.rb
+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.0.0
+signing_key: 
+specification_version: 4
+summary: Store stuff in Mongo, keep track of it in Redis, log lots of stuff, include
+  test help
+test_files:
+- spec/action_spec.rb
+- spec/schedule_spec.rb
+- spec/spec_helper.rb
+- spec/support/test_job.rb
+- spec/support/test_model.rb
+- spec/sweep_spec.rb
+- spec/work_spec.rb