rekiq 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 512f24c5f3a752e5df2fec6362c7f4b527303eee
-  data.tar.gz: 8cd79188800b644ecfa72b9d9a1a7e37b4e39f57
+  metadata.gz: 8c02fc37de00489fe1195f4cb22ed4bf1700ab13
+  data.tar.gz: 073c844c1ee5f5c671ce71b15d6ef9fe8fd5aa3c
 SHA512:
-  metadata.gz: a864ed822e261ac6cbcdfdc32bcfd8a187d9845d922911e882e57e876249120c403a383c880b464355b4f04624042a8ffbf8cb31f53ecd2bb6f0b10803ed21ef
-  data.tar.gz: 22d22ab155bd60846184e9b60d9dba60f483ffd3529e391cb609a5e83724b5a75c5b607079b35eeee215713788a95538ba4511732fc54a3767d016453676dd9d
+  metadata.gz: 4e7aa8af8e713b349c90d0f1519c8532e5fd22cb7d6ec6eb16ec844e912af72d698a735ae0e07739191de5864486f0aaa313e392e51b0444286fbdcda2331ed3
+  data.tar.gz: 19fb11a43f48c45e730b361c439d0a5df6f0bf281c61906051c72f01168110886740f99bfdf17f894e5dc80a5f1664efdebdb0dfa26332369655723f0e2b5d6c

data/README.md

@@ -1,5 +1,6 @@
 # Rekiq
 
+[![Gem Version](https://badge.fury.io/rb/rekiq.svg)](http://badge.fury.io/rb/rekiq)
 [![Build Status](https://travis-ci.org/junhanamaki/rekiq.svg?branch=master)](https://travis-ci.org/junhanamaki/rekiq)
 [![Code Climate](https://codeclimate.com/github/junhanamaki/rekiq.png)](https://codeclimate.com/github/junhanamaki/rekiq)
 [![Test Coverage](https://codeclimate.com/github/junhanamaki/rekiq/coverage.png)](https://codeclimate.com/github/junhanamaki/rekiq)
@@ -10,9 +11,9 @@
 
 Rekiq extends Sidekiq and adds functionality to schedule recurring workers.
 
-Sidekiq is an amazing gem that allows us delegate time consuming work to a
-worker, or even to schedule a time for the worker to start. Now wouldn't it be
-nice if it also allowed us to schedule a worker to do work recurringly? That's
+Sidekiq is an amazing gem that allows us to execute work asynchronous, or
+even schedule that work to be run at a given time. Now, wouldn't it be
+nice if it also allowed us to schedule a worker to do recurring work? That's
 what rekiq purposes to do.
 
 For example, rekiq allows you to schedule a worker to repeat the same
@@ -23,6 +24,7 @@ work every friday at 23:00.
 Tested with:
 
   * ruby 2.1.1, 2.0.0 and 1.9.3
+
   * sidekiq 3.2.1
 
 ## Installation
@@ -69,8 +71,10 @@ For our example we'll be using the gem [ice_cube](https://github.com/seejohnrun/
         # now just start your worker
         ExampleWorker.perform_recurringly(schedule, 'argument_1', 'argument_2')
 
-    You can use your own schedule object, configure worker to reschedule before or
-after work is done, set margin, and much more! So please check
+    And that's it! Now the worker will run every friday as 2am.
+
+You can use your own schedule object, configure worker to schedule before or
+after work is done, set a margin, and much more! So please feel free to check
 [wiki](https://github.com/junhanamaki/rekiq/wiki) for more details.
 
 ## Contributing

data/lib/rekiq.rb

@@ -6,14 +6,14 @@ unless defined?(Sidekiq)
         'sidekiq must be required before requiring rekiq'
 end
 
-require 'rekiq/middleware/work_overseer'
-require 'rekiq/middleware/utils'
-require 'rekiq/worker'
-
 module Rekiq
 
 end
 
+require 'rekiq/worker'
+require 'rekiq/middleware/work_overseer'
+require 'rekiq/middleware/utils'
+
 Sidekiq.configure_server do |config|
   config.server_middleware do |chain|
     chain.add Rekiq::Middleware::Utils

data/lib/rekiq/exceptions.rb

@@ -2,4 +2,5 @@ module Rekiq
   class StandardError < ::StandardError; end
   class SidekiqNotLoaded < StandardError; end
   class InvalidAttributeValue < StandardError; end
+  class CancellerMethodMissing < StandardError; end
 end

data/lib/rekiq/job.rb

@@ -1,4 +1,6 @@
 require 'yaml'
+require 'rekiq/validator'
+require 'rekiq/configuration'
 
 module Rekiq
   class Job

data/lib/rekiq/middleware/work_overseer.rb

@@ -1,6 +1,5 @@
 require 'sidekiq'
 require 'sidekiq/util'
-require 'rekiq/configuration'
 require 'rekiq/job'
 require 'rekiq/scheduler'
 
@@ -9,35 +8,45 @@ module Rekiq
     class WorkOverseer
       include ::Sidekiq::Util
 
-      attr_accessor :worker_name, :queue, :args, :job, :addon,
-                    :scheduled_work_time
-
       def call(worker, msg, queue)
         return yield unless msg['rq:job'] and msg['retry_count'].nil?
 
-        self.worker_name = worker.class.name
-        self.queue       = queue
-        self.args        = msg['args']
-        self.job         = Job.from_array(msg['rq:job'])
-        self.addon       = msg['rq:addon']
-        self.scheduled_work_time = Time.at(msg['rq:at'].to_f)
+        setup_vars(worker, msg, queue)
+
+        if !@canceller_name.nil? and
+           worker.send(@canceller_name, *@canceller_args)
+           return logger.info 'worker canceled by rekiq_canceller'
+        end
 
         begin
-          reschedule unless job.schedule_post_work?
+          reschedule unless @job.schedule_post_work?
           yield
         ensure
-          reschedule if job.schedule_post_work?
+          reschedule if @job.schedule_post_work?
         end
       end
 
+    protected
+
+      def setup_vars(worker, msg, queue)
+        @canceller_name = worker.rekiq_canceller_name
+        @canceller_args = msg['rq:ca']
+        @worker_name = worker.class.name
+        @queue       = queue
+        @args        = msg['args']
+        @job         = Job.from_array(msg['rq:job'])
+        @addon       = msg['rq:addon']
+        @scheduled_work_time = Time.at(msg['rq:at'].to_f)
+      end
+
       def reschedule
         jid, work_time =
           Rekiq::Scheduler
-            .new(worker_name, queue, args, job, addon)
-            .schedule_from_work_time(scheduled_work_time)
+            .new(@worker_name, @queue, @args, @job, @addon, @canceller_args)
+            .schedule_from_work_time(@scheduled_work_time)
 
         unless jid.nil?
-          logger.info "recurring work for #{worker_name} scheduled for " \
+          logger.info "recurring work for #{@worker_name} scheduled for " \
                       "#{work_time} with jid #{jid}"
         else
           logger.info 'recurrence terminated, job terminated'

data/lib/rekiq/scheduler.rb

@@ -1,39 +1,39 @@
 module Rekiq
   class Scheduler
-    attr_accessor :worker_name, :queue, :args, :job, :addon, :work_time
-
-    def initialize(worker_name, queue, args, job, addon)
-      self.worker_name = worker_name
-      self.queue       = queue
-      self.args        = args
-      self.job         = job
-      self.addon       = addon
+    def initialize(worker_name, queue, args, job, addon, canceller_args)
+      @worker_name = worker_name
+      @queue       = queue
+      @args        = args
+      @job         = job
+      @addon       = addon
+      @canceller_args = canceller_args
     end
 
     def schedule(from = Time.now)
-      self.work_time = job.next_work_time(from)
+      @work_time = @job.next_work_time(from)
 
-      work_time.nil? ? nil : [schedule_work, work_time]
+      @work_time.nil? ? nil : [schedule_work, @work_time]
     end
 
     def schedule_from_work_time(from)
-      self.work_time = job.next_work_time_from_work_time(from)
+      @work_time = @job.next_work_time_from_work_time(from)
 
-      work_time.nil? ? nil : [schedule_work, work_time]
+      @work_time.nil? ? nil : [schedule_work, @work_time]
     end
 
   private
 
     def schedule_work
       client_args = {
-          'at'     => work_time.to_f,
-          'queue'  => queue,
-          'class'  => worker_name,
-          'args'   => args,
-          'rq:job' => job.to_array,
-          'rq:at'  => work_time.to_f
+          'at'     => @work_time.to_f,
+          'queue'  => @queue,
+          'class'  => @worker_name,
+          'args'   => @args,
+          'rq:job' => @job.to_array,
+          'rq:at'  => @work_time.to_f,
         }.tap do |hash|
-          hash['rq:addon'] = addon unless addon.nil?
+          hash['rq:addon'] = @addon unless @addon.nil?
+          hash['rq:ca'] = @canceller_args unless @canceller_args.nil?
         end
 
       Sidekiq::Client.push(client_args)

data/lib/rekiq/validator.rb

@@ -1,3 +1,5 @@
+require 'rekiq/exceptions'
+
 module Rekiq
   module Validator
     module ClassMethods

data/lib/rekiq/version.rb

@@ -1,3 +1,3 @@
 module Rekiq
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

data/lib/rekiq/worker.rb

@@ -6,21 +6,33 @@ module Rekiq
   module Worker
     class Configuration
       attr_accessor :shift, :schedule_post_work, :schedule_expired,
-                    :expiration_margin, :addon
+                    :expiration_margin, :addon, :canceller_args
+
+      def rekiq_canceller_args(*args)
+        self.canceller_args = args
+      end
     end
 
     module ClassMethods
+      attr_reader :canceller_name
+
+      def rekiq_canceller(method_name)
+        @canceller_name = method_name
+      end
+
       def perform_recurringly(schedule, *args)
-        config = Configuration.new
-        yield config if block_given?
+        @config = Configuration.new
+        yield @config if block_given?
+
+        validate!
 
         job =
           Rekiq::Job
             .new 'schedule'           => schedule,
-                 'shift'              => config.shift,
-                 'schedule_post_work' => config.schedule_post_work,
-                 'schedule_expired'   => config.schedule_expired,
-                 'expiration_margin'  => config.expiration_margin
+                 'shift'              => @config.shift,
+                 'schedule_post_work' => @config.schedule_post_work,
+                 'schedule_expired'   => @config.schedule_expired,
+                 'expiration_margin'  => @config.expiration_margin
 
         job.validate!
 
@@ -28,16 +40,29 @@ module Rekiq
 
         jid, work_time =
           Rekiq::Scheduler
-            .new(name, queue, args, job, config.addon)
+            .new(name, queue, args, job, @config.addon, @config.canceller_args)
             .schedule
 
-        return if jid.nil?
-
-        ::Sidekiq.logger.info "recurring work for #{name} scheduled for " \
-                              "#{work_time} with jid #{jid}"
+        if jid.nil?
+          return ::Sidekiq.logger.info \
+                   "recurring work for #{name} scheduled for " \
+                   "#{work_time} with jid #{jid}"
+        end
 
         jid
       end
+
+    protected
+
+      def validate!
+        unless canceller_name.nil? or
+               self.method_defined?(canceller_name)
+          raise CancellerMethodMissing,
+                "rekiq_canceller method defined as #{canceller_name} " \
+                'but worker does not have a method with that name, either ' \
+                'remove rekiq_canceller or define missing method'
+        end
+      end
     end
   end
 end
@@ -52,5 +77,9 @@ module Sidekiq
       original_included_method.call(base)
       base.extend(Rekiq::Worker::ClassMethods)
     end
+
+    def rekiq_canceller_name
+      self.class.canceller_name
+    end
   end
 end

data/spec/rekiq/middleware/work_overseer_spec.rb

@@ -7,59 +7,101 @@ describe Rekiq::Middleware::WorkOverseer do
     sidekiq_options queue: 'work_overseer_test_worker'
   end
 
+  class WorkOverseerCancelTestWorker
+    include Sidekiq::Worker
+
+    sidekiq_options queue: 'work_overseer_test_worker'
+    rekiq_canceller :cancel
+
+    def cancel(bool)
+      bool
+    end
+  end
+
   describe '#call' do
-    let(:worker)   { WorkOverseerTestWorker.new }
-    let(:queue)    { WorkOverseerTestWorker.get_sidekiq_options['queue'] }
     let(:args)     { [] }
     let(:schedule) { IceCube::Schedule.new(Time.new + 3600) }
+    let(:job)      { build(:job, schedule: schedule) }
+    let(:overseer) { Rekiq::Middleware::WorkOverseer.new }
+
+    context 'worker does not have rekiq_canceller set' do
+      let(:worker)   { WorkOverseerTestWorker.new }
+      let(:queue)    { WorkOverseerTestWorker.get_sidekiq_options['queue'] }
 
-    context 'msg with rq:job key (existing job)' do
-      let(:job) { build(:job, schedule: schedule) }
-      let(:msg) { { 'rq:job' => job.to_array, 'args' => args } }
+      context 'msg with rq:job key (existing job)' do
+        let(:msg) { { 'rq:job' => job.to_array, 'args' => args } }
 
-      it 'yields once' do
-        expect do |b|
-          Rekiq::Middleware::WorkOverseer.new
-            .call(worker, msg, queue, &b)
-        end.to yield_control.once
+        it 'yields once' do
+          expect do |b|
+            overseer.call(worker, msg, queue, &b)
+          end.to yield_control.once
+        end
+
+        it 'schedules job' do
+          overseer.call(worker, msg, queue) {}
+
+          expect(WorkOverseerTestWorker.jobs.count).to eq(1)
+        end
       end
 
-      it 'schedules job' do
-        Rekiq::Middleware::WorkOverseer.new
-          .call(worker, msg, queue) {}
+      context 'msg without rq:job key' do
+        let(:msg) { {} }
 
-        expect(WorkOverseerTestWorker.jobs.count).to eq(1)
+        it 'yields once' do
+          expect do |b|
+            overseer.call(worker, msg, queue, &b)
+          end.to yield_control.once
+        end
       end
-    end
 
-    context 'msg without rq:job key' do
-      let(:msg) { {} }
+      context 'msg with job retry info and rq:job (existing job)' do
+        let(:msg) { { 'rq:job' => job.to_array, 'retry_count' => 0,
+                      'args' => args } }
+
+        it 'yields once' do
+          expect do |b|
+            overseer.call(worker, msg, queue, &b)
+          end.to yield_control.once
+        end
 
-      it 'yields once' do
-        expect do |b|
-          Rekiq::Middleware::WorkOverseer.new
-            .call(worker, msg, queue, &b)
-        end.to yield_control.once
+        it 'does not schedule work' do
+          overseer.call(worker, msg, queue) {}
+
+          expect(WorkOverseerTestWorker.jobs.count).to eq(0)
+        end
       end
     end
 
-    context 'msg with job retry info and rq:job (existing job)' do
-      let(:job) { build(:job, schedule: schedule) }
-      let(:msg) { { 'rq:job' => job.to_array, 'retry_count' => 0,
-                    'args' => args } }
+    context 'worker has rekiq_canceller method set' do
+      let(:worker) { WorkOverseerCancelTestWorker.new }
+      let(:queue)  { WorkOverseerCancelTestWorker.get_sidekiq_options['queue'] }
+
+      context 'msg with rq:ca key with value to cancel worker' do
+        let(:msg) do
+          { 'rq:job' => job.to_array, 'args' => args, 'rq:ca' => true }
+        end
+
+        it 'does not yield' do
+          expect do |b|
+            overseer.call(worker, msg, queue, &b)
+          end.not_to yield_control
+        end
 
-      it 'yields once' do
-        expect do |b|
-          Rekiq::Middleware::WorkOverseer.new
-            .call(worker, msg, queue, &b)
-        end.to yield_control.once
+        it 'does not scheduler worker' do
+          expect(WorkOverseerCancelTestWorker.jobs.count).to eq(0)
+        end
       end
 
-      it 'does not schedule work' do
-        Rekiq::Middleware::WorkOverseer.new
-          .call(worker, msg, queue) {}
+      context 'msg with rq:ca key with value that does not cancel worker' do
+        let(:msg) do
+          { 'rq:job' => job.to_array, 'args' => args, 'rq:ca' => false }
+        end
 
-        expect(WorkOverseerTestWorker.jobs.count).to eq(0)
+        it 'does yield' do
+          expect do |b|
+            overseer.call(worker, msg, queue, &b)
+          end.to yield_control.once
+        end
       end
     end
   end

data/spec/rekiq/scheduler_spec.rb

@@ -10,49 +10,65 @@ describe Rekiq::Scheduler do
       let(:worker) { SchedulerTestWorker.name }
       let(:queue)  { 'test_queue' }
       let(:args)   { [] }
+      let(:addon)  { nil }
+      let(:c_args) { nil }
+      let(:scheduler) do
+        Rekiq::Scheduler.new(worker, queue, args, job, addon, c_args)
+      end
+      before { @jid, @work_time = scheduler.schedule }
 
       context 'given valid job' do
         let(:job) { build(:job) }
 
+        context 'give nil as addon argument' do
+          it 'creates sidekiq job' do
+            expect(SchedulerTestWorker.jobs.count).to eq(1)
+          end
+
+          it 'does not set key rq:addon in msg' do
+            expect(SchedulerTestWorker.jobs[0].key?('rq:addon')).to eq(false)
+          end
+        end
+
         context 'given not nil string as addon argument' do
           let(:addon) { { 'random_key' => Time.now.to_f } }
 
-          context 'given initialized scheduler instance' do
-            let(:scheduler) do
-              Rekiq::Scheduler.new(worker, queue, args, job, addon)
-            end
-            before { @jid, @work_time = scheduler.schedule }
+          it 'creates sidekiq job' do
+            expect(SchedulerTestWorker.jobs.count).to eq(1)
+          end
+
+          it 'add key rq:addon in msg' do
+            expect(SchedulerTestWorker.jobs[0].key?('rq:addon')).to eq(true)
+          end
 
-            it 'creates sidekiq job' do
-              expect(SchedulerTestWorker.jobs.count).to eq(1)
-            end
+          it 'sets addon value in key rq:addon' do
+            expect(SchedulerTestWorker.jobs[0]['rq:addon']).to eq(addon)
+          end
+        end
 
-            it 'add key rq:addon in msg' do
-              expect(SchedulerTestWorker.jobs[0].key?('rq:addon')).to eq(true)
-            end
+        context 'given nil as canceller_args' do
+          it 'creates sidekiq job' do
+            expect(SchedulerTestWorker.jobs.count).to eq(1)
+          end
 
-            it 'sets addon value in key rq:addon' do
-              expect(SchedulerTestWorker.jobs[0]['rq:addon']).to eq(addon)
-            end
+          it 'does not set key rq:ca in msg' do
+            expect(SchedulerTestWorker.jobs[0].key?('rq:ca')).to eq(false)
           end
         end
 
-        context 'give nil as addon argument' do
-          let(:addon) { nil }
+        context 'given non empty array as canceller_args' do
+          let(:c_args) { [1, 2, 3] }
 
-          context 'given initialized scheduler instance' do
-            let(:scheduler) do
-              Rekiq::Scheduler.new(worker, queue, args, job, addon)
-            end
-            before { @jid, @work_time = scheduler.schedule }
+          it 'creates sidekiq job' do
+            expect(SchedulerTestWorker.jobs.count).to eq(1)
+          end
 
-            it 'creates sidekiq job' do
-              expect(SchedulerTestWorker.jobs.count).to eq(1)
-            end
+          it 'sets key rq:ca in msg' do
+            expect(SchedulerTestWorker.jobs[0].key?('rq:ca')).to eq(true)
+          end
 
-            it 'does not set key addon in msg' do
-              expect(SchedulerTestWorker.jobs[0].key?('addon')).to eq(false)
-            end
+          it 'sets key rq:ca in msg with passed value' do
+            expect(SchedulerTestWorker.jobs[0]['rq:ca']).to eq(c_args)
           end
         end
       end

data/spec/rekiq/worker_spec.rb

@@ -7,6 +7,19 @@ describe Rekiq::Worker do
     include Sidekiq::Worker
   end
 
+  class CancellerUndefinedExampleWorker
+    include Sidekiq::Worker
+    rekiq_canceller :cancel
+  end
+
+  class CancellerDefinedExampleWorker
+    include Sidekiq::Worker
+    rekiq_canceller :cancel
+
+    def cancel
+    end
+  end
+
   context 'Class includes Sidekiq::Worker module' do
     it 'responds to perform_recurringly' do
       ExampleWorker.respond_to? :perform_recurringly
@@ -16,56 +29,100 @@ describe Rekiq::Worker do
       context 'scheduled one hour from now' do
         let(:time)     { Time.now + 3600 }
         let(:schedule) { IceCube::Schedule.new(time) }
-        before do
-          @jid = ExampleWorker.perform_recurringly(schedule)
-        end
 
-        it 'returns created jid' do
-          expect(@jid).not_to be_nil
-        end
+        context 'for worker with rekiq_canceller set with non defined method' do
+          before do
+            begin
+              @jid =
+                CancellerUndefinedExampleWorker.perform_recurringly(schedule)
+            rescue
+            end
+          end
 
-        it 'schedules worker' do
-          expect(ExampleWorker.jobs.count).to eq(1)
-        end
+          it 'raises error' do
+            expect do
+              CancellerUndefinedExampleWorker.perform_recurringly(schedule)
+            end.to raise_error
+          end
 
-        it 'schedules worker for one hour from now' do
-          expect(ExampleWorker.jobs[0]['at']).to eq(time.to_f)
+          it 'does not schedule worker' do
+            expect(CancellerUndefinedExampleWorker.jobs.count).to eq(0)
+          end
         end
-      end
 
-      context 'scheduled one hour from now ' \
-              'shift set to minus 5 minutes' do
-        let(:time)     { Time.now + 3600 }
-        let(:schedule) { IceCube::Schedule.new(time) }
-        let(:shift)    { -5 * 60 }
-        before do
-          @jid = ExampleWorker.perform_recurringly(schedule) do |options|
-              options.shift = shift
-            end
-        end
+        context 'for worker with rekiq_canceller set with defined method' do
+          before do
+            @jid = CancellerDefinedExampleWorker.perform_recurringly(schedule)
+          end
 
-        it 'returns created job id' do
-          expect(@jid).not_to be_nil
-        end
+          it 'does not raise error' do
+            expect do
+              CancellerDefinedExampleWorker.perform_recurringly(schedule)
+            end.not_to raise_error
+          end
 
-        it 'schedules worker' do
-          expect(ExampleWorker.jobs.count).to eq(1)
-        end
+          it 'returns created jid' do
+            expect(@jid).not_to be_nil
+          end
+
+          it 'schedules worker' do
+            expect(CancellerDefinedExampleWorker.jobs.count).to eq(1)
+          end
 
-        it 'yields once' do
-          expect do |b|
-            ExampleWorker.perform_recurringly(schedule, &b)
-          end.to yield_control.once
+          it 'schedules worker for one hour from now' do
+            expect(CancellerDefinedExampleWorker.jobs[0]['at']).to eq(time.to_f)
+          end
         end
 
-        it 'sets shift in rq:job' do
-          array = ExampleWorker.jobs[0]['rq:job']
+        context 'invoked without config' do
+          before do
+            @jid = ExampleWorker.perform_recurringly(schedule)
+          end
+
+          it 'returns created jid' do
+            expect(@jid).not_to be_nil
+          end
 
-          expect(array[1]).to eq(shift)
+          it 'schedules worker' do
+            expect(ExampleWorker.jobs.count).to eq(1)
+          end
+
+          it 'schedules worker for one hour from now' do
+            expect(ExampleWorker.jobs[0]['at']).to eq(time.to_f)
+          end
         end
 
-        it 'schedules worker for one hour minus 5 minutes from now' do
-          expect(ExampleWorker.jobs[0]['at']).to eq(time.to_f + shift)
+        context 'shift set to minus 5 minutes' do
+          let(:shift)    { -5 * 60 }
+          before do
+            @jid = ExampleWorker.perform_recurringly(schedule) do |config|
+                config.shift = shift
+              end
+          end
+
+          it 'returns created job id' do
+            expect(@jid).not_to be_nil
+          end
+
+          it 'schedules worker' do
+            expect(ExampleWorker.jobs.count).to eq(1)
+          end
+
+          it 'yields once' do
+            expect do |b|
+              ExampleWorker.perform_recurringly(schedule, &b)
+            end.to yield_control.once
+          end
+
+          it 'sets shift in rq:job' do
+            array = ExampleWorker.jobs[0]['rq:job']
+
+            expect(array[1]).to eq(shift)
+          end
+
+          it 'schedules worker for one hour minus 5 minutes from now' do
+            expect(ExampleWorker.jobs[0]['at']).to eq(time.to_f + shift)
+          end
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rekiq
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - junhanamaki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-20 00:00:00.000000000 Z
+date: 2014-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler