sidekiq_simple_delay 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8828bf73cab33678a8f4f1e0d8a2c51328fa74fd252737e9789ee7447f238e1c
-  data.tar.gz: da61b4f204e3cfa49cec35d02689b9bc5fb19da5be5fcd67377508dc85945f80
+  metadata.gz: ec1fe6b079ffe00f678759842aabf1c0b541e963559ef96ffebd2a2ed320c8f1
+  data.tar.gz: a1539286fa1b0a82e25596d9a69741c601f5392c2a3372e811486f5adcd3af45
 SHA512:
-  metadata.gz: e08fd24c781ae84862392ded431873e98fd519190331bf003f74bffc5ce43c64a83c72f3eb584eb8ada3196b157d2e519de733e7384d696bdc87a66d1a53bcf6
-  data.tar.gz: e9f028312cbfc01d1f5d6219ac3ef6e8e09bf1936d042880da45142296306bbb385cc91a93dc53a014ac79350a00ef17c843ff391c8381c4432548a883e67a1e
+  metadata.gz: 6dd22a43966e73eb3adfdc5b9d3cd91158fa705f587368603a4edae954aedf713d619d32a03f1102002ae1f593eca25fba178d3984a0208e49b6973a7636ebc3
+  data.tar.gz: 024d186c564d19b6298bedddc0e5b0c2dd73ec7925c9c02a2fe04d706785354fab9162153284c8b14670329827ccf637a743d33b50b4fc375d1d009db9204a53

data/.circleci/config.yml

@@ -26,7 +26,7 @@ spec_shared: &spec_shared
                           --format RspecJunitFormatter \
                           --out /tmp/test-results/rspec-basic.xml \
                           --format progress \
-                          spec --tag ~enable_delay:true
+                          spec --tag ~run_tag
 
     - run:
         name: Run enable_delay specs
@@ -35,7 +35,60 @@ spec_shared: &spec_shared
                           --format RspecJunitFormatter \
                           --out /tmp/test-results/rspec-basic.xml \
                           --format progress \
-                          spec --tag enable_delay:true
+                          spec --tag run_tag:enable_delay
+
+    - run:
+        name: Run active_record_base specs
+        command: |
+          bundle exec rspec --format progress \
+                          --format RspecJunitFormatter \
+                          --out /tmp/test-results/rspec-basic.xml \
+                          --format progress \
+                          spec --tag run_tag:active_record_base
+
+    - run:
+        name: Run application_record specs
+        command: |
+          bundle exec rspec --format progress \
+                          --format RspecJunitFormatter \
+                          --out /tmp/test-results/rspec-basic.xml \
+                          --format progress \
+                          spec --tag run_tag:application_record
+
+    - run:
+        name: Run active_record_single specs
+        command: |
+          bundle exec rspec --format progress \
+                          --format RspecJunitFormatter \
+                          --out /tmp/test-results/rspec-basic.xml \
+                          --format progress \
+                          spec --tag run_tag:active_record_single
+
+    - run:
+        name: Run action_mailer specs
+        command: |
+          bundle exec rspec --format progress \
+                          --format RspecJunitFormatter \
+                          --out /tmp/test-results/rspec-basic.xml \
+                          --format progress \
+                          spec --tag run_tag:action_mailer_base
+
+    - run:
+        name: Run application_mailer specs
+        command: |
+          bundle exec rspec --format progress \
+                          --format RspecJunitFormatter \
+                          --out /tmp/test-results/rspec-basic.xml \
+                          --format progress \
+                          spec --tag run_tag:application_mailer
+    - run:
+        name: Run action_mailer_single specs
+        command: |
+          bundle exec rspec --format progress \
+                          --format RspecJunitFormatter \
+                          --out /tmp/test-results/rspec-basic.xml \
+                          --format progress \
+                          spec --tag run_tag:action_mailer_single
 
     # collect reports
     - store_test_results:

data/CHANGELOG.md

@@ -0,0 +1,11 @@
+# 0.2.0
+
+* `simple_delay_spread`
+* `ActiveRecord` integration
+* `ActionMailer` integration
+
+# 0.1.0
+
+* `simple_delay`
+* `simple_delay_for`
+* `simple_delay_until`

data/Gemfile.lock

@@ -1,12 +1,34 @@
 PATH
   remote: .
   specs:
-    sidekiq_simple_delay (0.1.0)
+    sidekiq_simple_delay (0.2.0)
       sidekiq
 
 GEM
   remote: https://rubygems.org/
   specs:
+    actionmailer (5.2.1.1)
+      actionpack (= 5.2.1.1)
+      actionview (= 5.2.1.1)
+      activejob (= 5.2.1.1)
+      mail (~> 2.5, >= 2.5.4)
+      rails-dom-testing (~> 2.0)
+    actionpack (5.2.1.1)
+      actionview (= 5.2.1.1)
+      activesupport (= 5.2.1.1)
+      rack (~> 2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (5.2.1.1)
+      activesupport (= 5.2.1.1)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.3)
+    activejob (5.2.1.1)
+      activesupport (= 5.2.1.1)
+      globalid (>= 0.3.6)
     activemodel (5.2.1.1)
       activesupport (= 5.2.1.1)
     activerecord (5.2.1.1)
@@ -20,18 +42,33 @@ GEM
       tzinfo (~> 1.1)
     arel (9.0.0)
     ast (2.4.0)
+    builder (3.2.3)
     bundler-audit (0.6.0)
       bundler (~> 1.2)
       thor (~> 0.18)
     concurrent-ruby (1.1.3)
     connection_pool (2.2.2)
+    crass (1.0.4)
+    database_cleaner (1.7.0)
     diff-lcs (1.3)
+    erubi (1.7.1)
     fakeredis (0.7.0)
       redis (>= 3.2, < 5.0)
+    globalid (0.4.1)
+      activesupport (>= 4.2.0)
     i18n (1.1.1)
       concurrent-ruby (~> 1.0)
     jaro_winkler (1.5.1)
+    loofah (2.2.3)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
+    mail (2.7.1)
+      mini_mime (>= 0.1.1)
+    mini_mime (1.0.1)
+    mini_portile2 (2.3.0)
     minitest (5.11.3)
+    nokogiri (1.8.5)
+      mini_portile2 (~> 2.3.0)
     parallel (1.12.1)
     parser (2.5.3.0)
       ast (~> 2.4.0)
@@ -39,6 +76,13 @@ GEM
     rack (2.0.6)
     rack-protection (2.0.4)
       rack
+    rack-test (1.1.0)
+      rack (>= 1.0, < 3)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.0.4)
+      loofah (~> 2.2, >= 2.2.2)
     rainbow (3.0.0)
     rake (10.5.0)
     redis (4.0.3)
@@ -82,10 +126,12 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  actionmailer (> 3.0)
   activerecord (> 3.0)
   activesupport (> 3.0)
   bundler (~> 1.16)
   bundler-audit
+  database_cleaner
   fakeredis
   rake (~> 10.0)
   rspec (~> 3.0)

data/README.md

@@ -49,6 +49,8 @@ end
 # ...
 
 User.simple_delay.greeting
+User.simple_delay_for(10.minutes).greeting
+User.simple_delay_until(1.day.from_now).greeting
 ```
 
 To add delay functionality to the instances of a class:
@@ -73,6 +75,31 @@ Three methods are provided that map to the three main invocations for Sidekiq.
 * `simple_delay_for` -> `perform_in`
 * `simple_delay_until` -> `perform_at`
 
+### Simple Delay Spread
+
+Often we want to enqueue a bunch of jobs, but need to spread them out over some period of time to prevent swampping our resources. We use a similar API to [`sidekiq_spread`](https://github.com/Latermedia/sidekiq_spread) to evenly distribute job execution.
+
+```ruby
+class User
+  extend SidekiqSimpleDelay::DelayMethods
+
+  def greeting(name)
+    "Hello, #{name}"
+  end
+end
+
+# ...
+
+spread_options = {
+  spread_duration: 3.hours,
+  spread_in: 15.minutes
+}
+
+# Randomly enqueues a job sometime between 15 minutes and 3 hours
+# and 15 minutes from now
+User.simple_delay_spread(spread_options).greeting('Les')
+```
+
 ### Devops
 
 A few conveniences are provided that allow you enable this functionality from the command line.
@@ -120,7 +147,7 @@ One use case of these methods would be for delaying methods on an `ActiveRecord`
 ```ruby
 class ApplicationRecord < ActiveRecord::Base
   def initialize_args
-    [id]
+    [send(self.class.primary_key)]
   end
 
   def self.simple_delay_initialize(*args)
@@ -144,6 +171,33 @@ User.where(column1: true).find_each do |user|
 end
 ```
 
+In fact, this is exactly what `sidekiq_delay` does with its `ActiveRecord` integration. To enable it,
+
+```ruby
+SidekiqSimpleDelay.enable_delay_active_record!
+```
+
+This will try to add the methods to `ApplicationRecord` first if it exists, but falls back to `ActiveRecord::Base` if it doesn't. You can also add it a single class if you want.
+
+```ruby
+SidekiqSimpleDelay.enable_delay_active_record!(User)
+```
+To spread these jobs out over an interval of time:
+```ruby
+  spread_options = {
+    spread_duration: 8.hours,
+    spread_at: 3.hours.from_now,
+    spread_method: :mod,
+    spread_mod_method: :id
+  }
+
+  User.where(column1: true).find_each do |user|
+    user.simple_delay_spread(spread_options).long_running_user_task('things')
+  end
+```
+
+By modding on the id of the `User` object, we can be sure that if we run this script with the same options, each user job will be executed at about the same relative time. This is useful if you have recurring jobs where having a deterministic offset for a user is beneficial.
+
 ### Simple Objects
 
 `SidekiqSimpleDelay` only allows simple objects to be used as parameters to the delayed method. These objects are:

data/lib/sidekiq_simple_delay.rb

@@ -9,20 +9,90 @@ module SidekiqSimpleDelay
     # Adds simple_delay class methods to all classes
     def enable_delay!
       enable_delay_instance!(Module)
+
+      return unless defined?(::ActiveSupport)
+
+      ActiveSupport.on_load(:active_record) do
+        SidekiqSimpleDelay.enable_delay_active_record!
+      end
+
+      ActiveSupport.on_load(:action_mailer) do
+        SidekiqSimpleDelay.enable_delay_application_mailer!
+      end
     end
 
-    # Adds simple_delay class methods to klass
+    # Adds simple_delay class methods to a class
+    #
+    # @param klass [Class] Class to add simple_delay class methods to
     def enable_delay_class!(klass)
       raise ArgumentError, 'klass must be a Class' unless klass.class.is_a?(Class)
 
+      return if klass.singleton_class.included_modules.include?(SidekiqSimpleDelay::DelayMethods)
+
       klass.__send__(:extend, SidekiqSimpleDelay::DelayMethods)
     end
 
-    # Adds simple_delay instance methods to klass
+    # Adds simple_delay instance methods to class
+    #
+    # @param klass [Class] Class to add simple_delay instance methods to
     def enable_delay_instance!(klass)
       raise ArgumentError, 'klass must be a Class' unless klass.class.is_a?(Class)
 
+      return if klass.included_modules.include?(SidekiqSimpleDelay::DelayMethods)
+
       klass.__send__(:include, SidekiqSimpleDelay::DelayMethods)
     end
+
+    # Adds simple_delay functionality to ActiveRecord objects. Attempts to add to {ApplicationRecord} first,
+    # the falls back to adding to {ActiveRecord::Base}.
+    #
+    # @param klass [Class] Class to add simple_delay functionality to. Must inherit from {ActiveRecord::Base}.
+    def enable_delay_active_record!(klass = nil)
+      klass =
+        if !klass.nil?
+          klass
+        elsif defined?(::ApplicationRecord)
+          ::ApplicationRecord
+        elsif defined?(::ActiveRecord::Base)
+          ::ActiveRecord::Base
+        end
+
+      raise ArgumentError, 'klass must be supplied' if klass.nil?
+      raise ArgumentError, 'klass must be a class' unless klass.class.is_a?(Class)
+      raise ArgumentError, 'klass must inherit from ActiveRecord::Base' unless klass.ancestors.any? { |c| c.name == 'ActiveRecord::Base' }
+
+      ar_file = 'sidekiq_simple_delay/extensions/active_record'
+      require ar_file unless defined? SidekiqSimpleDelay::ActiveRecord
+
+      return if klass.included_modules.include?(SidekiqSimpleDelay::ActiveRecord)
+
+      klass.__send__(:include, SidekiqSimpleDelay::ActiveRecord)
+    end
+
+    # Adds simple_delay functionality to ActionMailer objects. Attempts to add to {ApplicationMailer} first,
+    # the falls back to adding to {ActionMailer::Base}.
+    #
+    # @param klass [Class] Class to add simple_delay functionality to. Must inherit from {ActionMailer::Base}.
+    def enable_delay_application_mailer!(klass = nil)
+      klass =
+        if !klass.nil?
+          klass
+        elsif defined?(::ApplicationMailer)
+          ::ApplicationMailer
+        elsif defined?(::ActionMailer::Base)
+          ::ActionMailer::Base
+        end
+
+      raise ArgumentError, 'klass must be supplied' if klass.nil?
+      raise ArgumentError, 'klass must be a class' unless klass.class.is_a?(Class)
+      raise ArgumentError, 'klass must inherit from ActionMailer::Base' unless klass.ancestors.any? { |c| c.name == 'ActionMailer::Base' }
+
+      ar_file = 'sidekiq_simple_delay/extensions/action_mailer'
+      require ar_file unless defined? SidekiqSimpleDelay::ActionMailer
+
+      return if klass.included_modules.include?(SidekiqSimpleDelay::ActionMailer)
+
+      klass.__send__(:include, SidekiqSimpleDelay::ActionMailer)
+    end
   end
 end

data/lib/sidekiq_simple_delay/delay_methods.rb

@@ -2,24 +2,113 @@
 
 require 'sidekiq_simple_delay/delay_worker'
 require 'sidekiq_simple_delay/generic_proxy'
+require 'sidekiq_simple_delay/utils'
 
 module SidekiqSimpleDelay
   # Aliased class methods to be added to Class
   module DelayMethods
+    # Immediately enqueue a job to handle the delayed action
+    #
+    # @param options [Hash] options similar to Sidekiq's `perform_async`
     def simple_sidekiq_delay(options = {})
-      Proxy.new(SimpleDelayedWorker, self, options)
+      Proxy.new(simple_delayed_worker, self, options)
     end
 
+    # Enqueue a job to handle the delayed action after an elapsed interval
+    #
+    # @param interval [#to_f] Number of seconds to wait. `to_f` will be called on
+    #   this argument to convert to seconds.
+    # @param options [Hash] options similar to Sidekiq's `perform_in`
     def simple_sidekiq_delay_for(interval, options = {})
-      Proxy.new(SimpleDelayedWorker, self, options.merge('at' => Time.now.to_f + interval.to_f))
+      Proxy.new(simple_delayed_worker, self, options.merge('at' => Time.now.to_f + interval.to_f))
     end
 
+    # Enqueue a job to handle the delayed action after at a certain time
+    #
+    # @param timestamp [#to_f] Timestamp to execute job at. `to_f` will be called on
+    #   this argument to convert to a timestamp.
+    # @param options [Hash] options similar to Sidekiq's `perform_at`
     def simple_sidekiq_delay_until(timestamp, options = {})
-      Proxy.new(SimpleDelayedWorker, self, options.merge('at' => timestamp.to_f))
+      Proxy.new(simple_delayed_worker, self, options.merge('at' => timestamp.to_f))
+    end
+
+    # Enqueue a job to handle the delayed action in a given timeframe
+    #
+    # @param timestamp [#to_f] Timestamp to execute job at. `to_f` will be called on
+    #   this argument to convert to a timestamp.
+    # @param options [Hash] options similar to Sidekiq's `perform_at`
+    # @option options [Number] :spread_duration Size of window to spread workers out over
+    # @option options [Number] :spread_in Start of window offset from now
+    # @option options [Number] :spread_at Start of window offset timestamp
+    # @option options [rand|mod] :spread_method perform either a random or modulo spread,
+    #   default: *:rand*
+    # @option options [Number] :spread_mod_value value to use for determining mod offset
+    # @option options [Symbol] :spread_mod_method method to call to get the value to use
+    #   for determining mod offset
+    def simple_sidekiq_delay_spread(options = {})
+      spread_duration = Utils.extract_option(options, :spread_duration, 1.hour).to_f
+      spread_in = Utils.extract_option(options, :spread_in, 0).to_f
+      spread_at = Utils.extract_option(options, :spread_at)
+      spread_method = Utils.extract_option(options, :spread_method, :rand)
+      spread_mod_value = Utils.extract_option(options, :spread_mod_value)
+      spread_mod_method = Utils.extract_option(options, :spread_mod_method)
+
+      spread_duration = 0 if spread_duration < 0
+      spread_in = 0 if spread_in < 0
+
+      spread =
+        # kick of immediately if the duration is 0
+        if spread_duration.zero?
+          0
+        else
+          case spread_method.to_sym
+          when :rand
+            Utils.random_number(spread_duration)
+          when :mod
+            mod_value =
+              # The mod value has been supplied
+              if !spread_mod_value.nil?
+                spread_mod_value
+              # Call the supplied method on the target object to get mod value
+              elsif !spread_mod_method.nil?
+                send(spread_mod_method)
+              # Call `spread_mod_method` on target object to get mod value
+              elsif respond_to?(:spread_mod_method)
+                send(send(:spread_mod_method))
+              else
+                raise ArgumentError, 'must specify `spread_mod_value` or `spread_mod_method` or taget must respond to `spread_mod_method`'
+              end
+
+            # calculate the mod based offset
+            mod_value % spread_duration
+          else
+            raise ArgumentError, "spread_method must :rand or :mod, `#{spread_method} is invalid`"
+          end
+        end
+
+      t =
+        if !spread_at.nil?
+          # add spread to a timestamp
+          spread_at.to_f + spread
+        elsif !spread_in.nil?
+          # add spread to no plus constant offset
+          Time.now.to_f + spread_in.to_f + spread
+        else
+          # add spread to current time
+          Time.now.to_f + spread
+        end
+
+      Proxy.new(SimpleDelayedWorker, self, options.merge('at' => t))
+    end
+
+    # Tell {DelayMethods} which delayed worker to use
+    def simple_delayed_worker
+      SimpleDelayedWorker
     end
 
     alias simple_delay simple_sidekiq_delay
     alias simple_delay_for simple_sidekiq_delay_for
     alias simple_delay_until simple_sidekiq_delay_until
+    alias simple_delay_spread simple_sidekiq_delay_spread
   end
 end

data/lib/sidekiq_simple_delay/delay_worker.rb

@@ -1,10 +1,9 @@
 # frozen_string_literal: true
 
 require 'sidekiq'
-require 'sidekiq_simple_delay/generic_proxy'
 
 module SidekiqSimpleDelay
-  # Worker that handles the delayed functionality
+  # Worker that handles the simple_delayed functionality
   class SimpleDelayedWorker
     include Sidekiq::Worker
 

data/lib/sidekiq_simple_delay/delayed_mailer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'sidekiq'
+
+module SidekiqSimpleDelay
+  # Worker that handles the simple_delayed functionality for ActionMailers
+  class SimpleDelayedMailer
+    include Sidekiq::Worker
+
+    def perform(args)
+      target_klass = Object.const_get(args.fetch('target_klass'))
+
+      method_name = args['m']
+      method_args = args['args']
+
+      msg = target_klass.__send__(method_name, *method_args)
+
+      # The email method can return nil, which causes ActionMailer to return
+      # an undeliverable empty message.
+      raise "#{target.name}##{method_name} returned an undeliverable mail object" unless msg
+
+      deliver(msg)
+    end
+
+    private
+
+    def deliver(msg)
+      if msg.respond_to?(:deliver_now)
+        # Rails 4.2/5.0
+        msg.deliver_now
+      else
+        # Rails 3.2/4.0/4.1
+        msg.deliver
+      end
+    end
+  end
+end

data/lib/sidekiq_simple_delay/extensions/action_mailer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'sidekiq_simple_delay/delay_methods'
+require 'sidekiq_simple_delay/delayed_mailer'
+
+module SidekiqSimpleDelay
+  # Methods to enable simple_delay functionality to work with ActiveRecord
+  module ActionMailer
+    def self.included(base)
+      base.extend(SidekiqSimpleDelay::DelayMethods)
+      base.extend(ClassMethods)
+    end
+
+    # Tell {DelayMethods} which delayed worker to use
+    module ClassMethods
+      def simple_delayed_worker
+        SimpleDelayedMailer
+      end
+    end
+  end
+end

data/lib/sidekiq_simple_delay/extensions/active_record.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'sidekiq_simple_delay/delay_methods'
+
+module SidekiqSimpleDelay
+  # Methods to enable simple_delay functionality to work with ActiveRecord
+  module ActiveRecord
+    def self.included(base)
+      base.include(SidekiqSimpleDelay::DelayMethods)
+      base.extend(SidekiqSimpleDelay::DelayMethods)
+      base.extend(ClassMethods)
+    end
+
+    # Args required to fetch this object from the database
+    def initialize_args
+      [send(self.class.primary_key)]
+    end
+
+    # Class methods to enable simple_delay functionality to work with ActiveRecord
+    module ClassMethods
+      # Take delay worker args and fetch record from database
+      def simple_delay_initialize(*args)
+        find(args[0])
+      end
+    end
+  end
+end

data/lib/sidekiq_simple_delay/utils.rb

@@ -30,6 +30,7 @@ module SidekiqSimpleDelay
           Set.new([Fixnum, Bignum, Float]).freeze
         end
 
+      # @private
       def simple_object?(obj)
         klass = obj.class
 
@@ -43,6 +44,27 @@ module SidekiqSimpleDelay
           false
         end
       end
+
+      # @private
+      def extract_option(opts, arg, default = nil)
+        [arg.to_sym, arg.to_s].each do |a|
+          next unless opts.key?(a)
+
+          return opts.delete(a)
+        end
+
+        default
+      end
+
+      if Gem::Version.new(RUBY_VERSION) >= Gem::Version.new('2.3.0')
+        def random_number(duration)
+          SecureRandom.random_number(duration)
+        end
+      else
+        def random_number(duration)
+          rand * duration
+        end
+      end
     end
   end
 end

data/lib/sidekiq_simple_delay/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module SidekiqSimpleDelay
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/run_specs

@@ -1,4 +1,10 @@
 #!/usr/bin/env bash
 
-bundle exec rspec spec --tag ~enable_delay:true
-bundle exec rspec spec --tag enable_delay:true
+bundle exec rspec spec --tag ~run_tag
+bundle exec rspec spec --tag run_tag:enable_delay
+bundle exec rspec spec --tag run_tag:active_record_base
+bundle exec rspec spec --tag run_tag:application_record
+bundle exec rspec spec --tag run_tag:active_record_single
+bundle exec rspec spec --tag run_tag:action_mailer_base
+bundle exec rspec spec --tag run_tag:application_mailer
+bundle exec rspec spec --tag run_tag:action_mailer_single

data/sidekiq_simple_delay.gemspec

@@ -24,10 +24,12 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency('sidekiq')
 
+  spec.add_development_dependency 'actionmailer', '> 3.0'
   spec.add_development_dependency 'activerecord', '> 3.0'
   spec.add_development_dependency 'activesupport', '> 3.0'
   spec.add_development_dependency 'bundler', '~> 1.16'
   spec.add_development_dependency 'bundler-audit'
+  spec.add_development_dependency 'database_cleaner'
   spec.add_development_dependency 'fakeredis'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidekiq_simple_delay
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Les Fletcher
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-12-01 00:00:00.000000000 Z
+date: 2018-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sidekiq
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: actionmailer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +94,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  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: fakeredis
   requirement: !ruby/object:Gem::Requirement
@@ -189,6 +217,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
@@ -200,6 +229,9 @@ files:
 - lib/sidekiq_simple_delay.rb
 - lib/sidekiq_simple_delay/delay_methods.rb
 - lib/sidekiq_simple_delay/delay_worker.rb
+- lib/sidekiq_simple_delay/delayed_mailer.rb
+- lib/sidekiq_simple_delay/extensions/action_mailer.rb
+- lib/sidekiq_simple_delay/extensions/active_record.rb
 - lib/sidekiq_simple_delay/generic_proxy.rb
 - lib/sidekiq_simple_delay/utils.rb
 - lib/sidekiq_simple_delay/version.rb