patella 0.0.3 → 0.9.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 898fb00ebab781d6f6555848aa4989d1b98b3df8
+  data.tar.gz: 0a498e97477cbe9a2e0acb93d233c65069421682
+SHA512:
+  metadata.gz: 75684d6e4e9b761b3dbf67e0aaf56e236cc42ce69352c416b97a12f4c5fe8e8cae111c628cbe8ce86fc598976bd171d3b12034c48c4497fb0fe52dd1be52fafa
+  data.tar.gz: cf372a903fcf87d0a669f802961b0bf036c2e1f1d18ee8ca74d0e6c4a458bc3a37d6d8a5749ada59951ee5434243e955d606565917a5d706743dec70dc78ead0

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+.tddium*

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 Keenan Brock
+Copyright (c) 2012-2014 PatientsLikeMe, Inc.
 
 MIT License
 

data/README.md

@@ -1,7 +1,15 @@
 # Patella
 
-Gem for the RailsConf 2012 talk Patella: It's Memoization into Memcached calculated in the background with Resque.
-[www.slideshare.net/jdwyah/patella-railsconf-2012](http://www.slideshare.net/jdwyah/patella-railsconf-2012)
+Patella is a robust implementation of send_later for Rails applications using Resque.  It supports:
+
+* Sending to specific queues on a per-call basis
+* A global on/off switch for send_later
+* Sensible defaults for the default Rails environments (send_later is disabled in development and test)
+
+# What happened to memoization into memcached etc?
+
+Patella was originally a gem for memoizing expensive method calls in Rails apps in the background and loading them
+asynchronously.  Jeff Dwyer did a RailsConf 2012 talk about it: [www.slideshare.net/jdwyah/patella-railsconf-2012](http://www.slideshare.net/jdwyah/patella-railsconf-2012)
 
 ## Installation
 
@@ -20,13 +28,23 @@ Or install it yourself as:
 ## Usage
 
 ```ruby
-  def self.my_slow_method(user_id)
-    all_notifications_for(User.find(user_id))
-  end
-  patella_reflex :notification_unread_count, :expires_in => 3.minutes, :class_method => true
+post = Post.find(params[:id])
+post.send_later(:slow_calculation)
+post.send_later(:slow_calculation_with_two_parameters, 5, "jdwyah!")
+post.send_later_on_queue(:hashing, :hash_content, 8675309)
+
+Post.send_later(:class_method)
+Post.send_later_on_queue(:high_priority, :class_method_with_a_parameter, 50)
 ```
 
-See the tests for more [examples](https://github.com/kbrock/patella/blob/master/test/patella_test.rb)
+`Patella::SendLater` is the module that provides the `send_later` and `send_later_on_queue` methods.  It's included by default
+in all `ActiveRecord::Base` subclasses, but you can include it in any class that implements the `#id` and `.find` methods.
+
+By default, `send_later` will enqueue jobs on a queue called "send_later".  You can alter this default:
+
+```ruby
+Patella::SendLaterWorker.default_queue = :my_custom_queue
+```
 
 ## Contributing
 

data/config/tddium.yml

@@ -0,0 +1,5 @@
+:tddium:
+  :ruby_version: ruby-1.9.3-p194
+  :test_pattern:
+    - test/*_test.rb
+    - test/**/*_test.rb

data/lib/patella.rb

@@ -1,8 +1,15 @@
 require "patella/version"
-require "patella/patella"
 require "patella/send_later"
 require "patella/send_later_worker"
+require "active_record"
 
 module Patella
+  ::Patella::SendLater.send_now = case ::Rails.env.try(:to_s)
+  when 'development', 'test'
+    true
+  else
+    false
+  end
+  
   ActiveRecord::Base.send :include, ::Patella::SendLater
 end

data/lib/patella/patella.rb

@@ -1,130 +0,0 @@
-require 'active_support'
-require 'json'
-
-module Patella::Patella
-
-  def self.included(base)
-    base.extend ClassMethods
-    base.send :include, Patella::SendLater
-  end
-
-  def patella_key(symbol, args)
-    id_param = respond_to?(:id) ? self.id : nil
-    "patella/#{self.class.to_s}/#{id_param}/#{symbol}/#{Digest::MD5.hexdigest(args.to_json)}"
-  end
-
-  module ClassMethods
-    def patella_key(symbol, args)
-      "patella/#{self.to_s}//#{symbol}/#{Digest::MD5.hexdigest(args.to_json)}"
-    end
-
-    def patella_reflex(symbol, options = {})      
-      options[:expires_in] ||= 30*60
-      options[:soft_expiration] ||= 0
-      options[:no_backgrounding] ||= false
-      is_class = options[:class_method]
-
-      original_method = :"_unpatellaed_#{symbol}"
-
-      method_definitions = <<-EOS, __FILE__, __LINE__ + 1
-
-        if method_defined?(:#{original_method})
-          raise "Already patella'd #{symbol}"
-        end
-        alias #{original_method} #{symbol}
-
-        def caching_#{symbol}(args)
-          cache_key = self.patella_key('#{symbol}',args)
-          result = args.any? ? #{original_method}(*args) : #{original_method}()
-          json = {'result' => result, 'soft_expiration' => Time.now + #{options[:expires_in]} - #{ options[:soft_expiration]}}.to_json
-          Rails.cache.write(cache_key, json, :expires_in => #{options[:expires_in]})
-          result
-        end
-
-        def clear_#{symbol}(*args)
-          cache_key = self.patella_key('#{symbol}',args)
-          Rails.cache.delete(cache_key)
-        end
-
-        def #{symbol}(*args)
-          patella_#{symbol}(args, {:no_backgrounding => #{options[:no_backgrounding]}})
-        end 
-
-        def patella_#{symbol}(args, opts)
-          cache_key = self.patella_key('#{symbol}',args)
-          promise = { 'promise' => true }
-
-          json = Rails.cache.fetch(cache_key, :expires_in => #{options[:expires_in]}, :force => !Rails.caching?) do
-            if opts[:no_backgrounding]
-              promise['result'] = self.send(:caching_#{symbol}, args)
-              promise.delete('promise')
-            else
-              promise['result'] = self.send_later(:caching_#{symbol}, args)   #send_later sends_later when Rails.caching? otherwise sends_now
-              promise.delete('promise') unless Rails.caching?
-            end
-            promise.to_json
-          end
-
-          if promise['promise'] && opts[:no_backgrounding]
-            promise['result'] = self.send(:caching_#{symbol}, args)
-            promise.delete('promise')
-            json = promise.to_json
-          end
-
-          val = JSON.parse(json)
-          if val and !val['promise']
-            loading = false
-            soft_expiration = Time.parse(val['soft_expiration']) rescue nil
-            json_val = val
-            val = val['result']
-          else
-            val = promise
-            loading = true
-          end
-
-          if !loading and soft_expiration and Time.now > soft_expiration
-            expires = #{options[:soft_expiration]} + 10*60
-            json_val['soft_expiration'] = (Time.now - expires).to_s
-            Rails.cache.write(cache_key, json_val, :expires_in => expires)
-            self.send_later(:caching_#{symbol}, args)
-          end
-
-          PatellaResult.new val, loading
-        end
-
-        if private_method_defined?(#{original_method.inspect})                   # if private_method_defined?(:_unmemoized_mime_type)
-          private #{symbol.inspect}                                              #   private :mime_type
-        elsif protected_method_defined?(#{original_method.inspect})              # elsif protected_method_defined?(:_unmemoized_mime_type)
-          protected #{symbol.inspect}                                            #   protected :mime_type
-        end                                                                      # end
-      EOS
-
-      if is_class
-        (class << self; self; end).class_eval *method_definitions
-      else
-        class_eval *method_definitions
-      end
-    end
-  end
-end
-
-class PatellaResult < ActiveSupport::BasicObject
-
-  def initialize(target=nil, loading=false)
-    @target = target
-    @loading = loading
-  end
-
-  def loading?
-    @loading
-  end
-
-  def loaded?
-    !@loading
-  end
-
-  def method_missing(method, *args, &block)
-    @target.send(method, *args, &block)
-  end
-end
-

data/lib/patella/send_later.rb

@@ -1,24 +1,45 @@
+require 'active_support/core_ext'
+
 module Patella::SendLater
 
+  # If send_now is true, Object.send_later will run the command in-process rather than
+  # putting it on the queue.
+  mattr_accessor :send_now
+
   def self.included(base)
     base.extend ClassMethods
   end
 
   def send_later method_name, *args
-    #in dev mode, run the command in process
-    if Rails.caching?
-      Patella::SendLaterWorker.perform_later self.class.to_s, self.id, method_name, *args
+    if ::Patella::SendLater.send_now      
+      self.send method_name, *args
     else
+      Patella::SendLaterWorker.perform_later self.class.to_s, self.id, method_name, *args
+    end
+  end
+  
+  def send_later_on_queue queue, method_name, *args
+    if ::Patella::SendLater.send_now      
       self.send method_name, *args
+    else
+      Patella::SendLaterWorker.perform_later_on_queue queue, self.class.to_s, self.id, method_name, *args
     end
   end
 
   module ClassMethods
     def send_later method_name, *args
-      if Rails.caching?
-        Patella::SendLaterWorker.perform_later self.to_s, nil, method_name, *args
+      if ::Patella::SendLater.send_now
+        self.send method_name, *args
       else
+        Patella::SendLaterWorker.perform_later self.to_s, nil, method_name, *args
+      end
+    end
+    
+    def send_later_on_queue queue, method_name, *args
+      if ::Patella::SendLater.send_now
         self.send method_name, *args
+      else
+        Patella::SendLaterWorker.perform_later_on_queue queue, self.to_s, nil, method_name, *args
       end
     end
   end

data/lib/patella/send_later_worker.rb

@@ -1,27 +1,27 @@
+require 'resque'
+require 'resque/plugins/meta'
+
 module Patella
   class SendLaterWorker
     extend ::Resque::Plugins::Meta
-    @@default_queue = :send_later
-    cattr_accessor :queues
-    @@queues = {}
+    cattr_accessor :default_queue
+    self.default_queue = :send_later
 
-    def self.perform_later(*args)
-      # args[0] is class name of invoking class, args[2] is method
-      queue = self.queue_for(args[0], args[2])
-      Resque::Job.create(queue, 'Patella::SendLaterWorker', *args)
+    def self.perform_later(class_name, instance_id, method_name, *args)
+      perform_later_on_queue default_queue, class_name, instance_id, method_name, *args
     end
-
-    def self.queue_for(class_name, method_name)
-      @@queues[class_name.to_s].try(:[],method_name.to_s) || @@default_queue
+    
+    def self.perform_later_on_queue(queue, class_name, instance_id, method_name, *args)
+      Resque::Job.create(queue, 'Patella::SendLaterWorker', class_name, instance_id, method_name, *args)      
     end
 
     def self.perform(class_name, instance_id, method_name, *args)
       o = class_name.constantize
-      o = o.find_by_id instance_id if instance_id
+      o = o.find(instance_id) if instance_id
 
       o.send(method_name, *args)
     rescue => e
       raise e, "#{e.message} \nWith SendLater: #{class_name}#{':'+instance_id.to_s if instance_id}##{method_name}(#{args.map(&:to_s).join(',')})", e.backtrace
     end
   end
-end
+end

data/lib/patella/version.rb

@@ -1,3 +1,3 @@
 module Patella
-  VERSION = "0.0.3" unless defined?(Patella::VERSION)
+  VERSION = "0.9.0" unless defined?(Patella::VERSION)
 end

data/patella.gemspec

@@ -2,10 +2,14 @@
 require File.expand_path('../lib/patella/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Jeff Dwyer"]
-  gem.email         = ["jdwyer@patientslikeme.com"]
-  gem.description   = "It's Memoization into Memcached calculated in the background with Resque."
-  gem.summary       = "DSL to add memoization on any method into Memcached calculated in the background with Resque."
+  gem.authors       = ["Jeff Dwyer", "Nat Budin"]
+  gem.email         = ["jdwyer@patientslikeme.com", "nbudin@patientslikeme.com"]
+  gem.description   = "A robust implementation of send_later for Rails apps using Resque."
+  gem.summary       = <<-EOF
+  Patella provides an ActiveRecord-friendly send_later implementation for Resque that allows sending
+  to specific queues as well as a global on/off switch for send_later, and sensible defaults for
+  the default Rails environments.
+  EOF
   gem.homepage      = "https://github.com/patientslikeme/patella"
 
   gem.files         = `git ls-files`.split($\)
@@ -16,11 +20,10 @@ Gem::Specification.new do |gem|
   gem.version       = Patella::VERSION
   gem.add_dependency 'resque', '~>1.16'
   gem.add_dependency 'resque-meta', '~>1.0.0'
-  gem.add_dependency 'activesupport', '~>2.3' #, :require => 'active_support'
-  gem.add_dependency 'rails', '~>2.3' #, :require => 'active_support'
-  gem.add_dependency 'json'
+  gem.add_dependency 'rails', '>= 2.3'
   gem.add_development_dependency 'bundler'
   gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'mocha', "~>0.9.8"
+  gem.add_development_dependency 'mocha', ">= 0.9.8"
   gem.add_development_dependency 'bourne'
+  gem.add_development_dependency 'pry'
 end

data/test/patella_test.rb

@@ -1,7 +1,6 @@
 require 'test_helper'
 
 class Dummy
-  include Patella::Patella
   include Patella::SendLater
 
   attr_accessor :id
@@ -9,136 +8,90 @@ class Dummy
     self.id = id
   end
 
-  def self.find_by_id id
+  def self.find id
     new id
   end
+end
 
-  def foo
-    5
+class PatellaTest < ActiveSupport::TestCase
+  setup do
+    @dummy = Dummy.new(5)
   end
-  patella_reflex :foo
-
-  def bar(a,b)
-    a+b
+  
+  teardown do
+    Resque.redis.flushall
   end
-  patella_reflex :bar
-
-  def baz(add)
-    self.id + add
+  
+  def test_send_now_to_instance
+    assert_equal 5, @dummy.send_later(:id)
   end
-  patella_reflex :baz
-
-  def self.bing
-    3
+  
+  def test_send_now_to_class
+    assert_equal 6, Dummy.send_later(:find, 6).id
   end
-  patella_reflex :bing, :class_method => true
-
-  def no_background_add(a,b)
-    a + b
-  end
-  patella_reflex :no_background_add, :no_backgrounding => true
-end
-
-class PatellaTest < ActiveSupport::TestCase
-
-  def test_patella_basics
-    # foreground
-    f = Dummy.new 6
-    f.stubs :caching_foo => 5
-    assert_equal 5, f.foo
-    assert_received(f, :caching_foo)
-
-    #background
-    with_caching do
-      Patella::SendLaterWorker.stubs :perform_later => 'loading'
-      f1 = Dummy.new 5
-      assert f1.foo.loading?
-      assert_received(Patella::SendLaterWorker, :perform_later) do |ex|
-        ex.once
-        ex.with 'Dummy', f1.id, :caching_foo, []
-      end
+  
+  def test_send_later_to_instance
+    sending_later do
+      @dummy.send_later(:id)
     end
-  end
 
-  def test_turning_off_background
-    #background
-    with_caching do
-      Patella::SendLaterWorker.expects(:perform_later).never
-      Dummy.any_instance.expects('caching_no_background_add').once.returns(9)
-      d = Dummy.new(1)
-      result = d.no_background_add(4,5)
-      assert result.loaded?
-      assert_equal 9, result
-    end
+    assert job = Resque.peek(:send_later)
+    assert_equal ["Dummy", 5, "id"], job["args"]
   end
-
-  def cache_clearing
-    d = Dummy.new(1)
-    result = d.bar(4,5)  #load it by turning caching off
-    assert result.loaded?
-    assert_equal 9, result
-
-    with_caching do
-      result = d.bar(4,5)  #still here
-      assert result.loaded?
-      assert_equal 9, result
-
-      d.clear_bar(4,5)
-      result = d.bar(4,5)  #cleared
-      assert result.loading?
-
+  
+  def test_send_later_on_queue_to_instance
+    sending_later do
+      @dummy.send_later_on_queue(:unimportant, :id)
     end
-  end
-
-  def test_patella_for_instance_objs
-    four = Dummy.new 4
-    assert_equal(8, four.baz(4))
-    assert_equal(13, four.baz(9))
-  end
 
-  def test_patella_for_class_methods
-    assert Dummy.bing.loaded?
-    assert_equal(3, Dummy.bing)
+    assert job = Resque.peek(:unimportant)
+    assert_equal ["Dummy", 5, "id"], job["args"]
   end
-
-  def test_keys
-    d = Dummy.new 2
-    assert_equal "patella/Dummy/2/foo/#{md5 [].to_json}", d.patella_key(:foo,[])
-    assert_equal "patella/Dummy/2/foo/#{md5 [1].to_json}", d.patella_key(:foo,[1])
-    assert_equal "patella/Dummy/2/foo/#{md5 [1,3].to_json}", d.patella_key(:foo,[1,3])
-    assert_equal "patella/Dummy/2/foo/#{md5 [1,"asdf"].to_json}", d.patella_key(:foo,[1,"asdf"])
-    assert_equal "patella/Dummy/2/foo/#{md5 [1,"asdf"*1000].to_json}", d.patella_key(:foo,[1, ("asdf"*1000)])
-
-    d3 = Dummy.new 3
-    assert_equal "patella/Dummy/3/foo/#{md5 [].to_json}", d3.patella_key(:foo,[])
-    assert_equal "patella/Dummy/3/foo/#{md5 [1].to_json}", d3.patella_key(:foo,[1])
-    assert_equal "patella/Dummy/3/foo/#{md5 [1,3].to_json}", d3.patella_key(:foo,[1,3])
-    assert_equal "patella/Dummy/3/foo/#{md5 [1,"asdf" * 1000].to_json}", d3.patella_key(:foo,[1,"asdf" * 1000])
+  
+  def test_send_later_to_class
+    sending_later do
+      Dummy.send_later(:find, 6)
+    end
+    
+    assert job = Resque.peek(:send_later)
+    assert_equal ["Dummy", nil, "find", 6], job["args"]
+  end
+  
+  def test_send_later_on_queue_to_class
+    sending_later do
+      Dummy.send_later_on_queue(:object_finding, :find, 6)
+    end
+    
+    assert job = Resque.peek(:object_finding)
+    assert_equal ["Dummy", nil, "find", 6], job["args"]
   end
-
-  def test_soft_expiration
-    dummy = Dummy.new 1
-    ::Rails.cache.stubs( :fetch => { 'result' => "loads of data", 'soft_expiration' => Time.now-1.minute }.to_json )
-    ::Rails.cache.stubs( :write => true )
-    dummy.stubs :send_later => 'loading'
-    dummy.foo
-    assert_received(Rails.cache, :write) { |ex| ex.once }
-    assert_received(dummy, :send_later) { |ex| ex.once }
+  
+  def test_changing_default_queue
+    default_queue = Patella::SendLaterWorker.default_queue
+    begin
+      Patella::SendLaterWorker.default_queue = :new_default
+      
+      sending_later do
+        @dummy.send_later(:id)
+        Dummy.send_later(:find, 6)
+      end
+      
+      job1, job2 = Resque.pop(:new_default), Resque.pop(:new_default)
+      assert_equal ["Dummy", 5, "id"], job1["args"]
+      assert_equal ["Dummy", nil, "find", 6], job2["args"]
+    ensure
+      Patella::SendLaterWorker.default_queue = default_queue
+    end
   end
 
 private
-  def md5(str)
-    Digest::MD5.hexdigest(str)
-  end
-
-  def with_caching(&block)
-    #previous_caching = ActionController::Base.perform_caching
+  def sending_later(&block)
+    previous_send_now = Patella::SendLater.send_now
     begin
-      Rails.stubs(:caching? => true)
-      #ActionController::Base.perform_caching = true
+      Patella::SendLater.send_now = false
       yield
     ensure
-      #ActionController::Base.perform_caching = previous_caching
+      Patella::SendLater.send_now = previous_send_now
     end
   end
 end

data/test/test_helper.rb

@@ -1,34 +1,20 @@
 require 'rubygems'
 require 'bundler/setup'
 
+module Rails
+  def self.env
+    'test'
+  end
+end
+
 Bundler.require
 require 'patella'
-require 'test/unit'
+require 'minitest'
 require 'active_support'
 require 'active_support/test_case'
 require 'json'
-require 'mocha'
+require 'mocha/setup'
 require 'bourne'
+require 'pry'
 
-unless defined?(Rails)
-module Rails
-  class MockCache
-    def fetch(*args)
-      yield
-    end
-    def write(*args)
-    end
-  end
-
-  def self.caching=(value)
-    @caching=value
-  end
-
-  def self.caching?
-    @caching
-  end
-  def self.cache
-    @cache ||= MockCache.new
-  end
-end
-end
+Minitest.autorun

metadata

@@ -1,172 +1,142 @@
 --- !ruby/object:Gem::Specification
 name: patella
 version: !ruby/object:Gem::Version
-  version: 0.0.3
-  prerelease: 
+  version: 0.9.0
 platform: ruby
 authors:
 - Jeff Dwyer
+- Nat Budin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-25 00:00:00.000000000 Z
+date: 2014-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: resque
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.16'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.16'
 - !ruby/object:Gem::Dependency
   name: resque-meta
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.0.0
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '2.3'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: '2.3'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.3'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
         version: '2.3'
 - !ruby/object:Gem::Dependency
-  name: json
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: bundler
+  name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: mocha
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.8
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.9.8
 - !ruby/object:Gem::Dependency
-  name: mocha
+  name: bourne
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.8
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 0.9.8
+        version: '0'
 - !ruby/object:Gem::Dependency
-  name: bourne
+  name: pry
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: It's Memoization into Memcached calculated in the background with Resque.
+description: A robust implementation of send_later for Rails apps using Resque.
 email:
 - jdwyer@patientslikeme.com
+- nbudin@patientslikeme.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
+- ".gitignore"
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
+- config/tddium.yml
 - lib/patella.rb
 - lib/patella/patella.rb
 - lib/patella/send_later.rb
@@ -177,29 +147,30 @@ files:
 - test/test_helper.rb
 homepage: https://github.com/patientslikeme/patella
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.2.0
 signing_key: 
-specification_version: 3
-summary: DSL to add memoization on any method into Memcached calculated in the background
-  with Resque.
+specification_version: 4
+summary: Patella provides an ActiveRecord-friendly send_later implementation for Resque
+  that allows sending to specific queues as well as a global on/off switch for send_later,
+  and sensible defaults for the default Rails environments.
 test_files:
 - test/patella_test.rb
 - test/test_helper.rb
+has_rdoc: