delayed_cron 0.2.6 → 0.2.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: af92ec64204d2a7f01c4dbb31c511603e87b43f0
-  data.tar.gz: ec7ea779e56c8f82e2112eb19799beac0f1327e7
+  metadata.gz: 1793dcbe15524332e26770ae9e5951961a3730d4
+  data.tar.gz: 6886b240e7ccf4f709782367348bde6239d2b515
 SHA512:
-  metadata.gz: 827a3222ad6c991c8a6ffb542ce3376efce3f43a922bf2fc8560b6de8f65db923d354b50c456716860bb1029aab773adb48c68ee2fd73979241c56aaca867631
-  data.tar.gz: 6f5a6750da95164b5531e4f5e4d9570888099a4482a8e3a1b7f1b2e2d25a87f68ea80d000fa56e80ef400a90c8302a7b6b264769024dfc79ac75a20873f6c6e9
+  metadata.gz: 6dcef7ec119d6b38aa6ed8aecd10c78bd85c667853e85e0575399cf4abfcdca8259c8cf7338f37ee9b88c245bea3e7beb114c854490e5a4050afcc535c9cb0ec
+  data.tar.gz: 339aa0bca689fe888371edef9567c92199622258d25b378032eaac3573973626acd6697df05a78d931b4974579f2344ff0ad1912c94a4cf814b2be90ed50f954

data/.gitignore

@@ -1,3 +1,3 @@
 *.DS_Store
 pkg
-Gemfile.lock
+Gemfile.lock

data/delayed_cron.gemspec

@@ -20,6 +20,8 @@ Gem::Specification.new do |s|
   s.add_development_dependency "timecop"
   s.add_development_dependency "rspec-sidekiq"
   s.add_development_dependency "codeclimate-test-reporter"
+  s.add_development_dependency "hashie"
+  s.add_development_dependency "debugger"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

data/lib/delayed_cron/jobs/sidekiq.rb

@@ -8,38 +8,48 @@ module DelayedCron
       sidekiq_options :queue => :cron_job
 
       def self.enqueue_delayed_cron(klass, method_name, options)
-        unless do_not_enqueue?(klass, method_name)
-          options.symbolize_keys!
+        options.symbolize_keys!
+        unless do_not_enqueue?(klass, method_name, options)
           perform_in(options[:interval], klass, method_name, options)
         end
       end
 
-      def self.do_not_enqueue?(klass, method_name)
-        scheduled?(klass, method_name) ||
-        enqueued?(klass, method_name)  ||
-        retrying?(klass, method_name)
+      def self.do_not_enqueue?(klass, method_name, options)
+        scheduled?(klass, method_name, options) ||
+        enqueued?(klass, method_name, options)  ||
+        retrying?(klass, method_name, options)
       end
 
-      def self.retrying?(klass, method_name)
+      def self.retrying?(klass, method_name, options)
         ::Sidekiq::RetrySet.new.collect(&:item).select do |item|
-          matches_kass_and_method?(item, klass, method_name)
+          matches?(item, klass, method_name, options)
         end.present?
       end
 
-      def self.scheduled?(klass, method_name)
+      def self.scheduled?(klass, method_name, options)
         ::Sidekiq::ScheduledSet.new.collect(&:item).select do |item|
-          matches_kass_and_method?(item, klass, method_name)
+          matches?(item, klass, method_name, options)
         end.present?
       end
 
-      def self.enqueued?(klass, method_name)
+      def self.enqueued?(klass, method_name, options)
         ::Sidekiq::Queue.new("cron_job").collect(&:item).select do |item|
-          matches_kass_and_method?(item, klass, method_name)
+          matches?(item, klass, method_name, options)
         end.present?
       end
 
-      def self.matches_kass_and_method?(item, klass, method_name)
-        item["args"][0] == klass && item["args"][1] == method_name.to_s
+      def self.matches?(item, klass, method_name, options)
+        class_and_method_match?(item["args"], klass, method_name) &&
+        at_match?(item["args"][2], options)
+      end
+
+      def self.at_match?(arg_options, options)
+        return true unless !!arg_options["at"] && !!options[:at]
+        arg_options["at"] == options[:at]
+      end
+
+      def self.class_and_method_match?(args, klass, method_name)
+        args[0] == klass && args[1] == method_name.to_s
       end
 
       def perform(klass, method_name, options)

data/lib/delayed_cron/scheduling.rb

@@ -0,0 +1,72 @@
+module DelayedCron
+  module Scheduling
+
+    def schedule(klass, method_name, options)
+      parsed_options = parse_options(options)
+      if parsed_options.is_a?(Array)
+        parsed_options.each do |opts|
+          processor.enqueue_delayed_cron(klass, method_name, opts)
+        end
+      else
+        processor.enqueue_delayed_cron(klass, method_name, parsed_options)
+      end
+    end
+
+    def parse_options(options)
+      original_options = options
+      if at = options[:at]
+        options = if at.is_a?(Array)
+          at.map do |at_option|
+            add_interval(original_options.merge(at: at_option))
+          end
+        else
+          add_interval(options)
+        end
+      end
+      options
+    end
+
+    def add_interval(options)
+      date = beginning_of_day(options[:interval].to_i)
+      options[:interval] = adjust_interval(date, options[:at])
+      options
+    end
+
+    def timing_opts(interval, options_at)
+      timing_opts = { interval: interval }
+      timing_opts.merge!(at: options_at) if options_at.present?
+      timing_opts
+    end
+
+    def beginning_of_day(seconds)
+      (Time.now + seconds).beginning_of_day
+    end
+
+    def adjust_interval(date, time_string)
+      adjusted_date(date, time_string).to_i - Time.now.to_i
+    end
+
+    def adjusted_date(date, time_string)
+      time = parse_time(time_string.split(/:|\ /).map(&:to_i))
+      DateTime.civil(
+        date.year,
+        date.month,
+        date.day,
+        time[:hours],
+        time[:mins],
+        time[:secs],
+        Rational(time[:tz], 2400)
+      )
+    end
+
+    def parse_time(time_array)
+      {
+        hours: time_array[0],
+        mins:  time_array[1],
+        secs:  time_array[2] || 0,
+        tz:    time_array[3] || Time.now.strftime("%z").to_i
+      }
+    end
+
+  end
+end

data/lib/delayed_cron/version.rb

@@ -1,3 +1,3 @@
 module DelayedCron
-  VERSION = "0.2.6"
+  VERSION = "0.2.7"
 end

data/lib/delayed_cron.rb

@@ -1,4 +1,5 @@
 require 'delayed_cron/jobs'
+require 'delayed_cron/scheduling'
 require 'delayed_cron/railtie'
 
 module DelayedCron
@@ -7,6 +8,8 @@ module DelayedCron
 
   class << self
 
+    include DelayedCron::Scheduling
+
     def setup
       yield self
       define_cron_jobs
@@ -34,47 +37,12 @@ module DelayedCron
       return DelayedCron::Jobs::SuckerPunch if defined? ::SuckerPunch
     end
 
-    def schedule(klass, method_name, options)
-      if options[:at]
-        options[:interval] = adjust_interval(beginning_of_day(options[:interval].to_i), options[:at])
-      end
-      processor.enqueue_delayed_cron(klass, method_name, options)
-    end
-
-    def timing_opts(interval, options_at)
-      timing_opts = { interval: interval }
-      timing_opts.merge!(at: options_at) if options_at.present?
-      timing_opts
-    end
-
     def process_job(klass, method_name, options)
       # TODO: add ability to send args to klass method
       klass.constantize.send(method_name)
       schedule(klass, method_name, options)
     end
 
-    def beginning_of_day(seconds)
-      (Time.now + seconds).beginning_of_day
-    end
-
-    def adjust_interval(date, time_string)
-      adjusted_date(date, time_string).to_i - Time.now.to_i
-    end
-
-    def adjusted_date(date, time_string)
-      time = parse_time(time_string.split(/:|\ /).map(&:to_i))
-      DateTime.civil(date.year, date.month, date.day, time[:hours], time[:mins], time[:secs], Rational(time[:tz], 2400))
-    end
-
-    def parse_time(time_array)
-      {
-        hours: time_array[0],
-        mins:  time_array[1],
-        secs:  time_array[2] || 0,
-        tz:    time_array[3] || Time.now.strftime("%z").to_i
-      }
-    end
-
   end
 
   module Glue

data/spec/delayed_cron_spec.rb

@@ -61,28 +61,6 @@ describe DelayedCron do
 
   end
 
-  describe ".schedule" do
-    it "schedules cron jobs" do
-      DelayedCron.schedule("SomeClass", "long_method", { interval: 1.hour })
-      expect(DelayedCron.processor).to be_processed_in :cron_job
-      expect(DelayedCron.processor.jobs.size).to eq(1)
-    end
-  end
-
-  describe ".timing_opts" do 
-
-    let(:options) do
-      { interval: 1.day, at: "05:00:00 -0400" }
-    end
-
-    it "collects the timing options" do 
-      interval = { interval: 1.day }
-      timing_opts = DelayedCron.timing_opts(options[:interval], options[:at])
-      expect(timing_opts).to eq(options)
-      expect(timing_opts).not_to eq(interval)
-    end
-  end
-
   describe ".process_job" do
 
     it "should call the cron jobs method" do
@@ -100,27 +78,6 @@ describe DelayedCron do
 
   end
 
-  describe ".beginning_of_day" do
-    it "returns the beginning of the day for the interval" do
-      seconds = 2.days.to_i
-      beginning_of_day_2_days_from_now = DelayedCron.beginning_of_day(seconds)
-      expect(beginning_of_day_2_days_from_now).to be <  2.days.from_now
-      expect(beginning_of_day_2_days_from_now).to be >  1.day.from_now
-    end
-  end
-
-  describe ".adjust_interval" do
-    it "adjusts the interval based on the :at option" do
-      # Set Time.now to January 1, 2014 12:00:00 PM
-      Timecop.freeze(Time.local(2014, 1, 1, 12, 0, 0))
-      interval = 9.days
-      adjusted_interval = interval - 12.hours
-      DelayedCron.processor.should_receive(:enqueue_delayed_cron)
-                 .with("SomeClass", "long_method", { interval: adjusted_interval.to_i, at: "00:00" })
-      DelayedCron.schedule("SomeClass", "long_method", { interval: interval, at: "00:00" })
-    end
-  end
-
   describe "cron_job" do
     context 'if not present' do
       it "schedules cron jobs found in a model" do

data/spec/jobs/sidekiq_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'timecop'
+require 'rspec-sidekiq'
+require 'hashie'
+
+describe DelayedCron::Jobs::Sidekiq do
+  let(:options)       { { interval: 123, at: "00:00:00 -0500" } }
+  let(:options_1)     { { interval: 123, at: "11:00:00 -0500" } }
+  let(:item_hash)     { { "args" => ["SomeClass", "some_method", options] } }
+  let(:item)          { Hashie::Mash.new(item: item_hash) }
+  let(:item_response) { [item] }
+  let(:sidekiq)       { DelayedCron::Jobs::Sidekiq }
+
+  before do
+    allow(Sidekiq::RetrySet).to receive(:new).and_return(item_response)
+    allow(Sidekiq::ScheduledSet).to receive(:new).and_return(item_response)
+    allow(Sidekiq::Queue).to receive(:new).with("cron_job").and_return(item_response)
+  end
+
+  describe ".enqueue_delayed_cron" do
+  end
+
+  describe ".do_not_enqueue?" do
+  end
+
+  describe ".retrying?" do
+    it "returns true if a job is retrying" do
+      retrying = sidekiq.retrying?("SomeClass", "some_method", options)
+      expect(retrying).to eq(true)
+    end
+
+    it "returns false if a job is not retrying" do
+      not_retrying = sidekiq.retrying?("NotClass", "some_method", options)
+      expect(not_retrying).to eq(false)
+    end
+
+    it "returns false if a job is retrying, but for a different time" do
+      not_retrying = sidekiq.retrying?("SomeClass", "some_method", options_1)
+      expect(not_retrying).to eq(false)
+    end
+  end
+
+  describe ".scheduled?" do
+    it "returns true if a job is scheduled" do
+      scheduled = sidekiq.scheduled?("SomeClass", "some_method", options)
+      expect(scheduled).to eq(true)
+    end
+
+    it "returns false if a job is not scheduled" do
+      not_scheduled = sidekiq.scheduled?("NotClass", "some_method", options)
+      expect(not_scheduled).to eq(false)
+    end
+
+    it "returns false if a job is scheduled, but for a different time" do
+      not_scheduled = sidekiq.scheduled?("SomeClass", "some_method", options_1)
+      expect(not_scheduled).to eq(false)
+    end
+  end
+
+  describe ".enqueued?" do
+    it "returns true if a job is already enqueued" do
+      enqueued = sidekiq.enqueued?("SomeClass", "some_method", options)
+      expect(enqueued).to eq(true)
+    end
+
+    it "returns false if a job is not enqueued" do
+      not_enqueued = sidekiq.enqueued?("NotClass", "some_method", options)
+      expect(not_enqueued).to eq(false)
+    end
+
+    it "returns false if a job is enqueued, but for a different time" do
+      not_enqueued = sidekiq.enqueued?("SomeClass", "some_method", options_1)
+      expect(not_enqueued).to eq(false)
+    end
+  end
+
+  describe ".matches?" do
+  end
+
+  describe ".at_match?" do
+  end
+
+  describe ".class_and_method_match?" do
+  end
+
+  describe "#perform" do
+  end
+
+end

data/spec/scheduling_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'timecop'
+require 'rspec-sidekiq'
+
+describe DelayedCron::Scheduling do
+
+  describe ".schedule" do
+    it "schedules cron jobs" do
+      DelayedCron.schedule("SomeClass", "long_method", { interval: 1.hour })
+      expect(DelayedCron.processor).to be_processed_in :cron_job
+      expect(DelayedCron.processor.jobs.size).to eq(1)
+    end
+  end
+
+  describe ".parse_options" do
+    let(:at_string) { { interval: 1.day, at: "00:00:00 -0500" } }
+    let(:at_array)  { { interval: 1.day, at: ["00:00:00 -0500", "01:00:00 -0500"]} }
+    let(:no_at)     { { interval: 1.day } }
+
+    it "parses options `at` option as string" do
+      expect(DelayedCron.parse_options(at_string)[:at]).to eq("00:00:00 -0500")
+    end
+
+    it "parses options `at` option as array" do
+      expected_options_array = [
+        { interval: 123, at: "00:00:00 -0500" },
+        { interval: 123, at: "01:00:00 -0500" }
+      ]
+      expect(DelayedCron.parse_options(at_array)[0][:at]).to eq("00:00:00 -0500")
+      expect(DelayedCron.parse_options(at_array)[1][:at]).to eq("01:00:00 -0500")
+    end
+
+    it "does not change options if `at` is not present" do
+      expect(DelayedCron.parse_options(no_at)).to eq(no_at)
+    end
+  end
+
+  describe ".timing_opts" do
+
+    let(:options) do
+      { interval: 1.day, at: "05:00:00 -0400" }
+    end
+
+    it "collects the timing options" do
+      interval = { interval: 1.day }
+      timing_opts = DelayedCron.timing_opts(options[:interval], options[:at])
+      expect(timing_opts).to eq(options)
+      expect(timing_opts).not_to eq(interval)
+    end
+  end
+
+  describe ".beginning_of_day" do
+    it "returns the beginning of the day for the interval" do
+      seconds = 2.days.to_i
+      beginning_of_day_2_days_from_now = DelayedCron.beginning_of_day(seconds)
+      expect(beginning_of_day_2_days_from_now).to be <  2.days.from_now
+      expect(beginning_of_day_2_days_from_now).to be >  1.day.from_now
+    end
+  end
+
+  describe ".adjust_interval" do
+    it "adjusts the interval based on the :at option" do
+      # Set Time.now to January 1, 2014 12:00:00 PM
+      Timecop.freeze(Time.local(2014, 1, 1, 12, 0, 0))
+      interval = 9.days
+      adjusted_interval = interval - 12.hours
+      DelayedCron.processor.should_receive(:enqueue_delayed_cron)
+                 .with("SomeClass", "long_method", { interval: adjusted_interval.to_i, at: "00:00" })
+      DelayedCron.schedule("SomeClass", "long_method", { interval: interval, at: "00:00" })
+    end
+  end
+
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delayed_cron
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.2.7
 platform: ruby
 authors:
 - Justin Grubbs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-30 00:00:00.000000000 Z
+date: 2016-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: delayed_job
@@ -136,6 +136,34 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  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: debugger
+  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'
 description: Run your cron jobs with sidekiq, delayed_job, resque, or sucker_punch.
 email: justin@sellect.com
 executables: []
@@ -158,9 +186,12 @@ files:
 - lib/delayed_cron/jobs/sidekiq.rb
 - lib/delayed_cron/jobs/sucker_punch.rb
 - lib/delayed_cron/railtie.rb
+- lib/delayed_cron/scheduling.rb
 - lib/delayed_cron/version.rb
 - rails/init.rb
 - spec/delayed_cron_spec.rb
+- spec/jobs/sidekiq_spec.rb
+- spec/scheduling_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/sellect/delayed_cron
 licenses: []
@@ -181,10 +212,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: Run your cron jobs with sidekiq, delayed_job, resque, or sucker_punch.
 test_files:
 - spec/delayed_cron_spec.rb
+- spec/jobs/sidekiq_spec.rb
+- spec/scheduling_spec.rb
 - spec/spec_helper.rb