rekiq 0.0.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bc545471fb04e687f4cf1cc9e9289db9060b579c
-  data.tar.gz: 74cc308381099f8711c6a27b16f3875c2d29168f
+  metadata.gz: 512f24c5f3a752e5df2fec6362c7f4b527303eee
+  data.tar.gz: 8cd79188800b644ecfa72b9d9a1a7e37b4e39f57
 SHA512:
-  metadata.gz: fae12ce36fd971421f930c9195434b186c968cc8a82cec9c546a332f9551500635ca30f0d83d35426d25ea0b844596a89ef06e48400bef1d5d988cc01b77ab18
-  data.tar.gz: 730dbbba9558c1a9d80e30f2f8707ad102de3faf272e404c9ff65ea155fafd803ae01d99548725645176d1011087ade597e7032d0351913432548bf30cc9c538
+  metadata.gz: a864ed822e261ac6cbcdfdc32bcfd8a187d9845d922911e882e57e876249120c403a383c880b464355b4f04624042a8ffbf8cb31f53ecd2bb6f0b10803ed21ef
+  data.tar.gz: 22d22ab155bd60846184e9b60d9dba60f483ffd3529e391cb609a5e83724b5a75c5b607079b35eeee215713788a95538ba4511732fc54a3767d016453676dd9d

data/README.md

@@ -15,59 +15,61 @@ 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
 what rekiq purposes to do.
 
-In pratical means, rekiq allows you to schedule a worker to repeat the same
-work friday at 23:00, for example.
+For example, rekiq allows you to schedule a worker to repeat the same
+work every friday at 23:00.
 
-## Requirements
+## Dependencies
 
 Tested with:
 
-  * Ruby version 2.1.1, 2.0.0 and 1.9.3
-  * Sidekiq 3.2.1
-  * ice_cube 0.12.1
+  * ruby 2.1.1, 2.0.0 and 1.9.3
+  * sidekiq 3.2.1
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
-    gem 'rekiq', git: 'https://github.com/junhanamaki/rekiq'
+    gem 'rekiq'
 
 And then execute:
 
     $ bundle
 
-Or compile source by hand, since for now it's not published.
+Or install it yourself as:
 
-## Usage
+    $ gem install rekiq
 
-Require rekiq after sidekiq:
+## Basic usage
 
-    require 'sidekiq'
-    require 'rekiq'
+1. Require rekiq after sidekiq:
 
-We need a 'schedule' object (responsible for returning the time at which the
+        require 'sidekiq'
+        require 'rekiq'
+
+2. We need a 'schedule' object (responsible for returning the time at which the
 worker should start) which must respond to method next_occurrence and
-receives one argument of type Time more at [schedule](). For our example we'll use gem
-[ice_cube](https://github.com/seejohnrun/ice_cube) (don't forget to require it):
+receives one argument of type Time (more at [The schedule object](https://github.com/junhanamaki/rekiq/wiki/The-schedule-object)).
+For our example we'll be using the gem [ice_cube](https://github.com/seejohnrun/ice_cube)
+(don't forget to require it):
 
-    # define worker as normal
-    class ExampleWorker
-      include Sidekiq::Worker
+        # define worker as normal
+        class ExampleWorker
+          include Sidekiq::Worker
 
-      def perform(arg1, arg2)
-        # Do some work
-      end
-    end
+          def perform(arg1, arg2)
+            # Do some work
+          end
+        end
 
-    # create schedule for worker to repeat every friday at 2am
-    schedule = IceCube::Schedule.new do |s|
-        s.rrule IceCube::Rule.daily.day(:friday).hour_of_day(2)
-      end
+        # create schedule for worker to repeat every friday at 2am
+        schedule = IceCube::Schedule.new do |s|
+            s.rrule IceCube::Rule.daily.day(:friday).hour_of_day(2)
+          end
 
-    # now just start your worker
-    ExampleWorker.perform_recurringly(schedule, 'argument_1', 'argument_2')
+        # 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
+    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
 [wiki](https://github.com/junhanamaki/rekiq/wiki) for more details.
 

data/lib/rekiq/configuration.rb

@@ -1,25 +1,38 @@
+require 'rekiq/validator'
+
 module Rekiq
   class Configuration
-    attr_accessor :reschedule_post_work, :schedule_expired,
+    include Validator
+
+    attr_accessor :shift, :schedule_post_work, :schedule_expired,
                   :expiration_margin
 
+    validate :shift, :numeric
+    validate :schedule_post_work, :bool
+    validate :expiration_margin, :numeric, greater_than_or_equal_to: 0
+    validate :schedule_expired, :bool
+
     def initialize
-      # if work is rescheduled after or before the worker completes
-      self.reschedule_post_work = false
+      # the value of the shift to apply relative to time returned by schedule
+      self.shift = 0
 
-      # if expired works are to be scheduled
-      # an expired work is a work that has a time bellow current_time - margin
-      self.schedule_expired = false
+      # if next work is scheduled after or before the worker completes
+      self.schedule_post_work = false
 
       # indicates the margin after which a work is considered expired
       # default to 0
       self.expiration_margin = 0
+
+      # if expired works are to be scheduled
+      # an expired work is a work that has a time bellow current_time - margin
+      self.schedule_expired = false
     end
   end
 
   class << self
     def configure
       yield configuration
+      configuration.validate!
     end
 
     def configuration

data/lib/rekiq/exceptions.rb

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

data/lib/rekiq/job.rb

@@ -1,66 +1,65 @@
 require 'yaml'
-require 'rekiq/schedule_format_validator'
 
 module Rekiq
   class Job
-    include ActiveModel::Validations
-    include ActiveModel::Validations::Callbacks
+    include Validator
 
-    attr_accessor :schedule, :shift, :reschedule_post_work, :schedule_expired,
+    attr_accessor :schedule, :shift, :schedule_post_work, :schedule_expired,
                   :expiration_margin
 
-    validates :schedule, 'rekiq::_schedule_format' => true
-    validates :shift, numericality: true
-    validates :reschedule_post_work, :schedule_expired,
-              inclusion: { in: [true, false], allow_nil: true }
-    validates :expiration_margin,
-              numericality: { greater_than_or_equal_to: 0, allow_nil: true }
-
-    def self.from_short_key_hash(hash)
-      hash['schedule']             = YAML::load(hash['sch'])
-      hash['shift']                = hash['sft']
-      hash['reschedule_post_work'] = hash['rpw']
-      hash['schedule_expired']     = hash['se']
-      hash['expiration_margin']    = hash['em']
-
-      new(hash)
+    validate :schedule, :schedule
+    validate :shift, :numeric, allow_nil: true
+    validate :schedule_post_work, :bool, allow_nil: true
+    validate :schedule_expired, :numeric, allow_nil: true
+    validate :expiration_margin, :bool, allow_nil: true
+
+    def self.from_array(array)
+      attributes = {}.tap do |hash|
+          hash['schedule']           = YAML::load(array[0])
+          hash['shift']              = array[1]
+          hash['schedule_post_work'] = array[2]
+          hash['schedule_expired']   = array[3]
+          hash['expiration_margin']  = array[4]
+        end
+
+      new(attributes)
     end
 
     def initialize(attributes = {})
-      self.schedule             = attributes['schedule']
-      self.shift                = attributes['shift'] || 0
-      self.reschedule_post_work = attributes['reschedule_post_work']
-      self.schedule_expired     = attributes['schedule_expired']
-      self.expiration_margin    = attributes['expiration_margin']
+      self.schedule           = attributes['schedule']
+      self.shift              = attributes['shift']
+      self.schedule_post_work = attributes['schedule_post_work']
+      self.schedule_expired   = attributes['schedule_expired']
+      self.expiration_margin  = attributes['expiration_margin']
     end
 
-    def to_short_key_hash
-      {
-        'sch' => YAML::dump(schedule),
-        'sft' => shift,
-        'rpw' => reschedule_post_work,
-        'se'  => schedule_expired,
-        'em'  => expiration_margin
-      }
+    def to_array
+      [
+        YAML::dump(schedule),
+        shift,
+        schedule_post_work,
+        schedule_expired,
+        expiration_margin
+      ]
     end
 
     def next_work_time(from = Time.now)
-      shifted_from = shift > 0 ? from - shift : from
+      from_with_shift = shift_val > 0 ? from - shift_val : from
 
-      search_next_work_time(shifted_from)
+      search_next_work_time(from_with_shift)
     end
 
     def next_work_time_from_work_time(from)
-      shifted_from = from - shift
+      from_with_shift = from - shift_val
 
-      search_next_work_time(shifted_from)
+      search_next_work_time(from_with_shift)
     end
 
-    def reschedule_post_work?
-      unless reschedule_post_work.nil?
-        reschedule_post_work
+    def schedule_post_work?
+      unless schedule_post_work.nil?
+        schedule_post_work
       else
-        Rekiq.configuration.reschedule_post_work
+        Rekiq.configuration.schedule_post_work
       end
     end
 
@@ -69,11 +68,11 @@ module Rekiq
     def search_next_work_time(from)
       if schedule_expired?
         from = schedule.next_occurrence(from)
-        work_time = from.nil? ? nil : from + shift
+        work_time = from.nil? ? nil : from + shift_val
       else
         begin
           from = schedule.next_occurrence(from)
-          work_time = from.nil? ? nil : from + shift
+          work_time = from.nil? ? nil : from + shift_val
         end until work_time.nil? || work_time > expiration_time
       end
 
@@ -96,6 +95,14 @@ module Rekiq
       end
     end
 
+    def shift_val
+      unless shift.nil?
+        shift
+      else
+        Rekiq.configuration.shift
+      end
+    end
+
     def expiration_time
       Time.now - expiration_margin_val
     end

data/lib/rekiq/middleware/work_overseer.rb

@@ -13,30 +13,20 @@ module Rekiq
                     :scheduled_work_time
 
       def call(worker, msg, queue)
-        return yield unless msg['rq:job']
+        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_short_key_hash(msg['rq:job'])
+        self.job         = Job.from_array(msg['rq:job'])
         self.addon       = msg['rq:addon']
+        self.scheduled_work_time = Time.at(msg['rq:at'].to_f)
 
-        if msg['retry_count'].nil?
-          self.scheduled_work_time = Time.at(msg['rq:at'].to_f)
-          reschedule_post_work = job.reschedule_post_work?
-
-          if reschedule_post_work
-            begin
-              yield
-            ensure
-              reschedule
-            end
-          else
-            reschedule
-            yield
-          end
-        else
+        begin
+          reschedule unless job.schedule_post_work?
           yield
+        ensure
+          reschedule if job.schedule_post_work?
         end
       end
 

data/lib/rekiq/scheduler.rb

@@ -30,7 +30,7 @@ module Rekiq
           'queue'  => queue,
           'class'  => worker_name,
           'args'   => args,
-          'rq:job' => job.to_short_key_hash,
+          'rq:job' => job.to_array,
           'rq:at'  => work_time.to_f
         }.tap do |hash|
           hash['rq:addon'] = addon unless addon.nil?

data/lib/rekiq/validator.rb

@@ -0,0 +1,68 @@
+module Rekiq
+  module Validator
+    module ClassMethods
+      attr_accessor :for_validation
+
+      def validate(attribute_name, type, options = {})
+        options[:allow_nil] = true if options[:allow_nil].nil?
+
+        self.for_validation << {
+            attribute_name: attribute_name,
+            type:    type,
+            options: options
+          }
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.for_validation = []
+    end
+
+    NUMERIC_OPTIONS = {
+        greater_than_or_equal_to: :>=
+      }
+
+    def validate!
+      self.class.for_validation.each do |v|
+        attribute_name = v[:attribute_name]
+        type    = v[:type]
+        options = v[:options]
+        value   = send(attribute_name)
+
+        unless options[:allow_nil] and send(attribute_name).nil?
+          send("validate_#{type}!", attribute_name, value, options)
+        end
+      end
+    end
+
+    def validate_numeric!(attribute_name, value, options)
+      unless value.is_a?(Numeric)
+        raise InvalidAttributeValue, "#{attribute_name} must be numeric"
+      end
+
+      options.each do |key, option_value|
+        if NUMERIC_OPTIONS.key?(key) and
+           !value.send(NUMERIC_OPTIONS[key], option_value)
+          raise InvalidAttributeValue, "#{attribute_name} must be greater " \
+                                       'or equal to 0'
+        end
+      end
+    end
+
+    def validate_bool!(attribute_name, value, options)
+      unless [true, false].include?(value)
+        raise InvalidAttributeValue, "#{attribute_name} must be either true " \
+                                     'or false'
+      end
+    end
+
+    def validate_schedule!(attribute_name, value, options)
+      unless value.respond_to?(:next_occurrence) and
+             value.method(:next_occurrence).arity.abs == 1
+        raise InvalidConf, '#attribute_name must respond to next_occurrence ' \
+                           'and receive one argument of type Time'
+      end
+    end
+  end
+end

data/lib/rekiq/version.rb

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

data/lib/rekiq/worker.rb

@@ -5,12 +5,8 @@ require 'rekiq/scheduler'
 module Rekiq
   module Worker
     class Configuration
-      attr_accessor :shift, :reschedule_post_work, :schedule_expired,
+      attr_accessor :shift, :schedule_post_work, :schedule_expired,
                     :expiration_margin, :addon
-
-      def append_to_msg(addon)
-        self.addon = addon
-      end
     end
 
     module ClassMethods
@@ -20,11 +16,13 @@ module Rekiq
 
         job =
           Rekiq::Job
-            .new 'schedule'             => schedule,
-                 'shift'                => config.shift,
-                 'reschedule_post_work' => config.reschedule_post_work,
-                 'schedule_expired'     => config.schedule_expired,
-                 'expiration_margin'    => config.expiration_margin
+            .new 'schedule'           => schedule,
+                 'shift'              => config.shift,
+                 'schedule_post_work' => config.schedule_post_work,
+                 'schedule_expired'   => config.schedule_expired,
+                 'expiration_margin'  => config.expiration_margin
+
+        job.validate!
 
         queue = get_sidekiq_options['queue']
 
@@ -39,10 +37,6 @@ module Rekiq
                               "#{work_time} with jid #{jid}"
 
         jid
-      rescue StandardError => e
-        raise Rekiq::StandardError,
-              'unable to schedule worker',
-              e.backtrace
       end
     end
   end

data/rekiq.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.email         = ["jun.hanamaki@gmail.com"]
   spec.summary       = %q{recurring worker extension for sidekiq}
   spec.description   = %q{}
-  spec.homepage      = ""
+  spec.homepage      = "https://github.com/junhanamaki/rekiq"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files -z`.split("\x0")
@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.required_ruby_version = '>= 1.9.3'
+
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'simplecov', '~> 0.9'
@@ -26,6 +28,4 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'jazz_hands', '~> 0.5'
   spec.add_development_dependency 'ice_cube', '~> 0.12'
   spec.add_development_dependency 'sidekiq', '~> 3.2'
-
-  spec.add_runtime_dependency 'activemodel', '~> 4.1'
 end

data/spec/factories/configuration.rb

@@ -0,0 +1,8 @@
+FactoryGirl.define do
+  factory :configuration, class: Rekiq::Configuration do
+    shift { [*-100..100].sample }
+    schedule_post_work { [true, false].sample }
+    expiration_margin  { [*0..100].sample }
+    schedule_expired   { [true, false].sample }
+  end
+end

data/spec/factories/job.rb

@@ -6,10 +6,10 @@ FactoryGirl.define do
     schedule { IceCube::Schedule.new(Time.now + 3600) }
 
     trait :randomized_attributes do
-      shift                { [*0..100].sample }
-      reschedule_post_work { [nil, false, true].sample }
-      schedule_expired     { [nil, false, true].sample }
-      expiration_margin    { [*0..100].sample }
+      shift              { [*0..100].sample }
+      schedule_post_work { [nil, false, true].sample }
+      schedule_expired   { [nil, false, true].sample }
+      expiration_margin  { [*0..100].sample }
     end
   end
 end

data/spec/rekiq/configuration_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe Rekiq::Configuration do
+  describe '.new' do
+    context 'for created Configuration instance' do
+      before { @configuration = Rekiq::Configuration.new }
+
+      it 'sets shift as 0 by default' do
+        expect(@configuration.shift).to eq(0)
+      end
+
+      it 'sets schedule_post_work as false by default' do
+        expect(@configuration.schedule_post_work).to eq(false)
+      end
+
+      it 'sets expiration_margin as 0 by default' do
+        expect(@configuration.expiration_margin).to eq(0)
+      end
+
+      it 'sets schedule_expired as false by default' do
+        expect(@configuration.schedule_expired).to eq(false)
+      end
+    end
+  end
+
+  describe '#validate!' do
+    context 'for instance with non numeric shift' do
+      before { @configuration = build(:configuration, shift: [1]) }
+
+      it 'raises error' do
+        expect do
+          @configuration.validate!
+        end.to raise_error
+      end
+    end
+
+    context 'for instance with numeric shift' do
+      before { @configuration = build(:configuration) }
+
+      it 'does not raise error' do
+        expect do
+          @configuration.validate!
+        end.not_to raise_error
+      end
+    end
+
+    context 'for instance with non bool schedule_post_work' do
+      before do
+        @configuration = build(:configuration, schedule_post_work: 'true')
+      end
+
+      it 'raises error' do
+        expect do
+          @configuration.validate!
+        end.to raise_error
+      end
+    end
+
+    context 'for instance with bool schedule_post_work' do
+      before { @configuration = build(:configuration) }
+
+      it 'does not raise error' do
+        expect do
+          @configuration.validate!
+        end.not_to raise_error
+      end
+    end
+
+    context 'for instance with non numeric expiration_margin' do
+      before { @configuration = build(:configuration, expiration_margin: '1') }
+
+      it 'raises error' do
+        expect do
+          @configuration.validate!
+        end.to raise_error
+      end
+    end
+
+    context 'for instance with negative expiration_margin' do
+      before { @configuration = build(:configuration, expiration_margin: -1) }
+
+      it 'raises error' do
+        expect do
+          @configuration.validate!
+        end.to raise_error
+      end
+    end
+
+    context 'for instance with 0 or positive expiration_margin' do
+      before { @configuration = build(:configuration) }
+
+      it 'does not raise error' do
+        expect do
+          @configuration.validate!
+        end.not_to raise_error
+      end
+    end
+
+    context 'for instance with non bool schedule_expired' do
+      before do
+        @configuration = build(:configuration, schedule_expired: 'false')
+      end
+
+      it 'raises error' do
+        expect do
+          @configuration.validate!
+        end.to raise_error
+      end
+    end
+
+    context 'for instance with bool schedule_expired' do
+      before { @configuration = build(:configuration) }
+
+      it 'does not raise error' do
+        expect do
+          @configuration.validate!
+        end.not_to raise_error
+      end
+    end
+  end
+end

data/spec/rekiq/job_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe Rekiq::Job do
-  describe '#new' do
+  describe '.new' do
     context 'when no args' do
       before { @job = Rekiq::Job.new }
 
@@ -9,12 +9,12 @@ describe Rekiq::Job do
         expect(@job).not_to be_nil
       end
 
-      it 'sets attribute shift as 0' do
-        expect(@job.shift).to eq(0)
+      it 'sets attribute shift as nil' do
+        expect(@job.shift).to eq(nil)
       end
 
-      it 'sets reschedule_post_work as nil' do
-        expect(@job.reschedule_post_work).to eq(nil)
+      it 'sets schedule_post_work as nil' do
+        expect(@job.schedule_post_work).to eq(nil)
       end
 
       it 'sets schedule_expired as nil' do
@@ -33,19 +33,19 @@ describe Rekiq::Job do
       end
     end
 
-    context 'when reschedule_post_work and ' \
+    context 'when schedule_post_work and ' \
             'schedule_expired passed as true' do
-      let(:reschedule_post_work) { true }
+      let(:schedule_post_work) { true }
       let(:schedule_expired) { true }
       before do
         @job =
           Rekiq::Job.new \
-            'reschedule_post_work' => reschedule_post_work,
+            'schedule_post_work' => schedule_post_work,
             'schedule_expired'     => schedule_expired
       end
 
-      it 'sets reschedule_post_work to true' do
-        expect(@job.reschedule_post_work).to eq(true)
+      it 'sets schedule_post_work to true' do
+        expect(@job.schedule_post_work).to eq(true)
       end
 
       it 'sets schedule_expired to true' do
@@ -54,11 +54,11 @@ describe Rekiq::Job do
     end
   end
 
-  describe '#from_short_key_hash' do
-    context 'hash returned from Job#to_short_key_hash' do
+  describe '.from_array' do
+    context 'array returned from Job#to_array' do
       let(:job)  { build(:job, :randomized_attributes) }
-      let(:hash) { job.to_short_key_hash }
-      before     { @job = Rekiq::Job.from_short_key_hash(hash) }
+      let(:array) { job.to_array }
+      before     { @job = Rekiq::Job.from_array(array) }
 
       it 'returns job instance' do
         expect(@job.class).to eq(Rekiq::Job)
@@ -68,8 +68,8 @@ describe Rekiq::Job do
         expect(@job.shift).to eq(job.shift)
       end
 
-      it 'returns job with reschedule_post_work value before serialization' do
-        expect(@job.reschedule_post_work).to eq(job.reschedule_post_work)
+      it 'returns job with schedule_post_work value before serialization' do
+        expect(@job.schedule_post_work).to eq(job.schedule_post_work)
       end
 
       it 'returns job with schedule_expired value before serialization' do
@@ -86,40 +86,39 @@ describe Rekiq::Job do
 
       it 'returns job with working schedule' do
         time = Time.now
-        expect(@job.schedule.next_occurrence(time)).to(
-          eq(job.schedule.next_occurrence(time))
-        )
+        expect(@job.schedule.next_occurrence(time))
+          .to eq(job.schedule.next_occurrence(time))
       end
     end
   end
 
-  describe '.to_short_key_hash' do
+  describe '#to_array' do
     context 'given job instance' do
       let(:job) { build(:job, :randomized_attributes) }
-      before { @val = job.to_short_key_hash }
+      before { @val = job.to_array }
 
-      it 'returns an hash' do
-        expect(@val.class).to eq(Hash)
+      it 'returns an array' do
+        expect(@val.class).to eq(Array)
       end
 
-      it 'returns hash with key sft with shift value' do
-        expect(@val['sft']).to eq(job.shift)
+      it 'returns array with YAML::dump(schedule) value at index 0' do
+        expect(@val[0]).to eq(YAML::dump(job.schedule))
       end
 
-      it 'returns hash with key rpw with reschedule_post_work value' do
-        expect(@val['rpw']).to eq(job.reschedule_post_work)
+      it 'returns array with shift value at index 1' do
+        expect(@val[1]).to eq(job.shift)
       end
 
-      it 'returns hash with key sh with schedule_expired value' do
-        expect(@val['se']).to eq(job.schedule_expired)
+      it 'returns array with schedule_post_work value at index 2' do
+        expect(@val[2]).to eq(job.schedule_post_work)
       end
 
-      it 'returns hash with key em with expiration_margin value' do
-        expect(@val['em']).to eq(job.expiration_margin)
+      it 'returns array with schedule_expired value at index 3' do
+        expect(@val[3]).to eq(job.schedule_expired)
       end
 
-      it 'returns hash with sch key with schedule serialized with YAML::dump' do
-        expect(@val['sch']).to eq(YAML::dump(job.schedule))
+      it 'returns array with expiration_margin value at index 4' do
+        expect(@val[4]).to eq(job.expiration_margin)
       end
     end
   end

data/spec/rekiq/middleware/work_overseer_spec.rb

@@ -15,7 +15,7 @@ describe Rekiq::Middleware::WorkOverseer do
 
     context 'msg with rq:job key (existing job)' do
       let(:job) { build(:job, schedule: schedule) }
-      let(:msg) { { 'rq:job' => job.to_short_key_hash, 'args' => args } }
+      let(:msg) { { 'rq:job' => job.to_array, 'args' => args } }
 
       it 'yields once' do
         expect do |b|
@@ -45,7 +45,7 @@ describe Rekiq::Middleware::WorkOverseer do
 
     context 'msg with job retry info and rq:job (existing job)' do
       let(:job) { build(:job, schedule: schedule) }
-      let(:msg) { { 'rq:job' => job.to_short_key_hash, 'retry_count' => 0,
+      let(:msg) { { 'rq:job' => job.to_array, 'retry_count' => 0,
                     'args' => args } }
 
       it 'yields once' do

data/spec/rekiq/worker_spec.rb

@@ -58,10 +58,10 @@ describe Rekiq::Worker do
           end.to yield_control.once
         end
 
-        it 'sets shift in job' do
-          hash = ExampleWorker.jobs[0]['rq:job']
+        it 'sets shift in rq:job' do
+          array = ExampleWorker.jobs[0]['rq:job']
 
-          expect(hash['sft']).to eq(shift)
+          expect(array[1]).to eq(shift)
         end
 
         it 'schedules worker for one hour minus 5 minutes from now' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rekiq
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.5.0
 platform: ruby
 authors:
 - junhanamaki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-19 00:00:00.000000000 Z
+date: 2014-07-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,20 +122,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.2'
-- !ruby/object:Gem::Dependency
-  name: activemodel
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.1'
 description: ''
 email:
 - jun.hanamaki@gmail.com
@@ -160,19 +146,21 @@ files:
 - lib/rekiq/job.rb
 - lib/rekiq/middleware/utils.rb
 - lib/rekiq/middleware/work_overseer.rb
-- lib/rekiq/schedule_format_validator.rb
 - lib/rekiq/scheduler.rb
+- lib/rekiq/validator.rb
 - lib/rekiq/version.rb
 - lib/rekiq/worker.rb
 - rekiq.gemspec
+- spec/factories/configuration.rb
 - spec/factories/job.rb
+- spec/rekiq/configuration_spec.rb
 - spec/rekiq/job_spec.rb
 - spec/rekiq/middleware/utils_spec.rb
 - spec/rekiq/middleware/work_overseer_spec.rb
 - spec/rekiq/scheduler_spec.rb
 - spec/rekiq/worker_spec.rb
 - spec/spec_helper.rb
-homepage: ''
+homepage: https://github.com/junhanamaki/rekiq
 licenses:
 - MIT
 metadata: {}
@@ -184,7 +172,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -197,7 +185,9 @@ signing_key:
 specification_version: 4
 summary: recurring worker extension for sidekiq
 test_files:
+- spec/factories/configuration.rb
 - spec/factories/job.rb
+- spec/rekiq/configuration_spec.rb
 - spec/rekiq/job_spec.rb
 - spec/rekiq/middleware/utils_spec.rb
 - spec/rekiq/middleware/work_overseer_spec.rb

data/lib/rekiq/schedule_format_validator.rb

@@ -1,16 +0,0 @@
-require 'active_model'
-
-module Rekiq
-  class ScheduleFormatValidator < ActiveModel::EachValidator
-    def validate_each(record, attribute, value)
-      unless value.respond_to?(:next_occurrence) and
-             value.method(:next_occurrence).arity.abs > 0
-        record.errors[attribute] <<
-          "invalid value for #{attribute}, value must be an object that " \
-          'responds to next_occurrence, and that receives at least one ' \
-          'argument of type Time, representing Time from which to calculate ' \
-          'next occurrence time'
-      end
-    end
-  end
-end