delayed_cron 0.2.9 → 0.2.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5ff17f816e19f148c452438b48c45bbc1f9c30fc
-  data.tar.gz: 7fcc1e2435d54c239893f281a10fd0561ad5f11f
+  metadata.gz: d7a2942e092055795c248a6eb82433c760c26733
+  data.tar.gz: 195e7f6a46052e687611a825afede8ab3d4ef4f5
 SHA512:
-  metadata.gz: 4356a31a22fb9713486ccc55d77998d0487c27424c6bfe68b8bfee2124e31d52c112fa883216546e4dd0b4db16c1a20159c06349e56471f6f851202cb4b36a47
-  data.tar.gz: d40f0c45bec851dc5e0985a50eee5b114ff409b137818377c80f822c7019a07f8da408fb54736fee6ce1763ce956191463c07b85734b51f6ba191234d1485bca
+  metadata.gz: 596b466d8708c44a8023995a0df0ff7c6fa87b2c74b1d2e42521f5671e6d1b41147525fde9e1bdaecfc981978efcadcbf503a01e49d3fc4f1243765586d60f6a
+  data.tar.gz: f2c640b98de5f67f384a54b7c493715b4b14a1a7024ad52c903bb103fc004810a1de8c33c1f259df4efb4ca571774de81d89a3ba15832022a68539c30d5e8fd2

data/.ruby-version

@@ -1 +1 @@
-ruby-2.0.0-p247
+2.2.5

data/CHANGES.md

@@ -1,3 +1,8 @@
+# 0.2.10
+
+- Add ability to set a job time zone and also allow running a job at a specific minute of each hour.
+  - PR https://github.com/sellect/delayed_cron/pull/17
+
 # 0.2.9
 
 - fix scheduling

data/README.md

@@ -23,12 +23,22 @@ class Product < ActiveRecord::Base
   # * this is an alternative to the cron_jobs array in config
   #
   # OPTIONS: *optional
-  # - interval - override default_inteveral from setup
-  # - at       - set time of day the cron should be run, timezone and seconds are optional
-  cron_job :some_method_to_run_as_cron, interval: 3.days, at: "00:00:00 -0400"
+  # - interval  - override default_interval from setup
+  # - at        - set time of day the cron should be run, timezone and seconds are optional
+  # - time_zone - override default time zone for this job
+  # - precision - set to :hourly to run job at an hourly interval instead of daily
+  #
+  # NOTE: only one of interval or at will be used, at will take precedence if
+  # both are specified
+  cron_job :some_method_to_run_as_cron, at: "00:00:00 -0400"
+  cron_job :some_hourly_job, at: "15:00", precision: :hourly
 
   def self.some_method_to_run_as_cron
-    # this method will be run every 3 days at midnight
+    # this method will be run every every day at midnight
+  end
+
+  def self.some_hourly_job
+    # this method will be run hourly at fifteen minutes past the hour
   end
 
   ...
@@ -43,6 +53,11 @@ DelayedCron.setup do |config|
   # default interval to run cron jobs
   config.default_interval = 10.minutes
 
+  # default time zone for scheduling `:at` jobs
+  # accepts an ActiveSupport or TZInfo time zone name
+  config.default_time_zone = "Eastern Time (US & Canada)"
+
+
   # array of methods to run at the above configured interval
   config.cron_jobs = [
     "SomeClass.expensive_task", # will run at default interval
@@ -56,7 +71,7 @@ end
 
 - when using with sidekiq and rails there can be a config/initializer load order issue. Below is a fix to insure sidekiq is loaded first
 ```ruby
-Rails.application.config.after_initialize do  
+Rails.application.config.after_initialize do
   DelayedCron.setup do |config|
     ...
   end

data/lib/delayed_cron.rb

@@ -4,7 +4,7 @@ require 'delayed_cron/railtie'
 
 module DelayedCron
 
-  mattr_accessor :default_interval, :cron_jobs
+  mattr_accessor :default_interval, :default_time_zone, :cron_jobs
 
   class << self
 
@@ -17,15 +17,12 @@ module DelayedCron
 
     def define_cron_jobs
       return false unless cron_jobs.present?
+
       cron_jobs.each do |job|
-        obj         = job
-        job_is_hash = job.is_a?(Hash)
-        job         = job_is_hash ? obj[:job] : job
-        interval    = job_is_hash ? obj[:interval] : default_interval
-        options_at  = job_is_hash ? obj[:at] : nil
-        klass, name = job.split(".")
+        job = job.is_a?(Hash) ? job : { job: job }
+        klass, name = job[:job].split(".")
         # TODO: raise error if interval is not set
-        options     = timing_opts(interval, options_at)
+        options     = timing_opts(job)
         DelayedCron.schedule(klass, name, options)
       end
     end
@@ -44,6 +41,10 @@ module DelayedCron
       schedule(klass, method_name, symbolized_options)
     end
 
+    def default_time_zone
+      @@default_time_zone || "Eastern Time (US & Canada)"
+    end
+
   end
 
   module Glue

data/lib/delayed_cron/cron_job.rb

@@ -0,0 +1,58 @@
+module DelayedCron
+  class CronJob
+
+    attr_accessor :klass, :method_name
+
+    def initialize(options)
+      self.klass = options.delete(:klass)
+      self.method_name = options.delete(:method_name)
+
+      self.raw_options = options
+    end
+
+    def enqueue(processor)
+      schedule.each do |opts|
+        processor.enqueue_delayed_cron(klass, method_name, opts)
+      end
+    end
+
+    private
+
+    attr_accessor :raw_options
+
+    def schedule
+      return [raw_options] if raw_options[:at].blank?
+
+      Array.wrap(raw_options[:at]).map do |at_option|
+        interval_from_at(raw_options.merge(at: at_option))
+      end
+    end
+
+    def interval_from_at(options)
+      interval = convert_time_string_to_seconds_interval(options[:at], options[:time_zone])
+      options.merge(interval: interval)
+    end
+
+    def convert_time_string_to_seconds_interval(scheduled_time_string, zone_name)
+      zone_name ||= DelayedCron.default_time_zone
+      zone = Time.find_zone!(zone_name)
+
+      if hourly?
+        period_in_seconds = 60 * 60
+        scheduled_time_string = "%H:#{scheduled_time_string}"
+      else
+        period_in_seconds = 60 * 60 * 24
+      end
+
+      scheduled_time = zone.now.strftime("%Y-%m-%d #{scheduled_time_string}")
+      scheduled_time = zone.parse(scheduled_time)
+      scheduled_time += period_in_seconds if zone.now >= scheduled_time
+      scheduled_time.to_i - zone.now.to_i
+    end
+
+    def hourly?
+      raw_options[:precision].to_s == "hourly"
+    end
+
+  end
+end

data/lib/delayed_cron/scheduling.rb

@@ -1,48 +1,20 @@
+require 'delayed_cron/cron_job'
+
 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)
-      options[:interval] = convert_time_string_to_seconds_interval(options[:at])
-      options
-    end
-
-    def convert_time_string_to_seconds_interval(scheduled_time_string)
-      day_in_seconds = 60 * 60 * 24
-      scheduled_time = Time.now.strftime("%Y-%m-%d #{scheduled_time_string}")
-      scheduled_time = DateTime.parse(scheduled_time, false).to_time
-      scheduled_time += day_in_seconds if Time.now >= scheduled_time
-      scheduled_time.to_i - Time.now.to_i
+      job = CronJob.new(options.merge(klass: klass, method_name: method_name))
+      job.enqueue(processor)
     end
 
-    def timing_opts(interval, options_at)
-      timing_opts = { interval: interval }
-      timing_opts.merge!(at: options_at) if options_at.present?
-      timing_opts
+    def timing_opts(job)
+      {
+        interval: job[:interval] || default_interval,
+        time_zone: job[:time_zone],
+        precision: job[:precision],
+        at: job[:at]
+      }.select { |_, value| !value.nil? }
     end
 
   end

data/lib/delayed_cron/version.rb

@@ -1,3 +1,3 @@
 module DelayedCron
-  VERSION = "0.2.9"
+  VERSION = "0.2.10"
 end

data/spec/cron_job_spec.rb

@@ -0,0 +1,139 @@
+require "spec_helper"
+
+module DelayedCron
+  RSpec.describe CronJob do
+    describe "#new" do
+      let(:job) { described_class.new(klass: "Foo", method_name: "bar") }
+
+      it "stores klass" do
+        expect(job.klass).to eq "Foo"
+      end
+
+      it "stores method_name" do
+        expect(job.method_name).to eq "bar"
+      end
+    end
+
+    describe "#enqueue" do
+      let(:job) { described_class.new(klass: "Foo", method_name: "bar", interval: 3600) }
+      let(:processor) { class_double(Jobs::Sidekiq) }
+
+      before { Timecop.freeze(Time.utc(2014, 1, 1, 12, 0, 0)) }
+
+      it "passes interval through for periodic jobs" do
+        job = described_class.new(klass: "Foo", method_name: "bar", interval: 3600)
+
+        expect(processor).to receive(:enqueue_delayed_cron)
+          .with("Foo", "bar", interval: 3600)
+
+        job.enqueue(processor)
+      end
+
+      it "converts :at to interval" do
+        job = described_class.new(klass: "Foo", method_name: "bar", interval: 3600, at: "10:00:00")
+
+        expect(processor).to receive(:enqueue_delayed_cron)
+          .with("Foo", "bar", interval: 10800, at: "10:00:00")
+
+        job.enqueue(processor)
+      end
+
+      it "enqueues multiple jobs from array of :at times" do
+        job = described_class.new(
+          klass: "Foo",
+          method_name: "bar",
+          interval: 3600,
+          at: ["10:00:00", "09:00:00"]
+        )
+
+        expect(processor).to receive(:enqueue_delayed_cron)
+          .with("Foo", "bar", interval: 10800, at: "10:00:00")
+        expect(processor).to receive(:enqueue_delayed_cron)
+          .with("Foo", "bar", interval: 7200, at: "09:00:00")
+
+        job.enqueue(processor)
+      end
+
+      it 'respects time zone parameter' do
+        job = described_class.new(
+          klass: "Foo",
+          method_name: "bar",
+          interval: 3600,
+          at: "13:00:00",
+          time_zone: "UTC"
+        )
+
+        expect(processor).to receive(:enqueue_delayed_cron)
+          .with("Foo", "bar", interval: 3600, at: "13:00:00", time_zone: "UTC")
+
+        job.enqueue(processor)
+      end
+    end
+
+    describe ".convert_time_string_to_seconds_interval" do
+      let(:job) { described_class.new({}) }
+
+      let(:next_occurrence) do
+        job.send(:convert_time_string_to_seconds_interval, scheduled_time, "Eastern Time (US & Canada)")
+      end
+      # Set Time.now to January 1, 2014 12:00:00 PM
+      before { Timecop.freeze(Time.utc(2014, 1, 1, 12, 0, 0)) }
+      context "next occurrence is today" do
+        let(:known_interval) { 21600 }
+        let(:scheduled_time) { "13:00:00 -0500" }
+        it "converts a time string to seconds" do
+          expect(next_occurrence).to be(known_interval)
+        end
+      end
+
+      context "next occurrence is tomorrow" do
+        let(:known_interval) { 14400 }
+        let(:scheduled_time) { "11:00:00 -0500" }
+        it "converts a time string to seconds" do
+          expect(next_occurrence).to be(known_interval)
+        end
+      end
+
+      context "with time zone" do
+        let(:known_interval) { 14400 }
+        let(:scheduled_time) { "11:00:00 Eastern Time (US & Canada)" }
+        it "converts a time string to seconds" do
+          expect(next_occurrence).to be(known_interval)
+        end
+      end
+
+      context "with DST" do
+        let(:known_interval) { 14400 }
+        let(:scheduled_time) { "11:00:00 -0500" }
+        it "converts a time string to seconds" do
+          Timecop.freeze(Time.utc(2014, 6, 1, 12, 0, 0))
+
+          expect(next_occurrence).to be(known_interval)
+        end
+      end
+
+      context "hourly interval" do
+        let(:job) { described_class.new(precision: :hourly) }
+        let(:known_interval) { 300 }
+
+        let(:scheduled_time) { "05:00 -0500" }
+        it "converts a time string to seconds" do
+          expect(next_occurrence).to be(known_interval)
+        end
+      end
+
+      context "next hour" do
+        let(:job) { described_class.new(precision: :hourly) }
+        let(:known_interval) { 300 }
+
+        let(:scheduled_time) { "00:00" }
+        it "converts a time string to seconds" do
+          Timecop.freeze(Time.utc(2014, 1, 1, 12, 55, 0))
+
+          expect(next_occurrence).to be(known_interval)
+        end
+      end
+
+    end
+  end
+end

data/spec/delayed_cron_spec.rb

@@ -26,6 +26,17 @@ describe DelayedCron do
       expect(DelayedCron.default_interval).not_to be_nil
     end
 
+    it "should have a default_time_zone" do
+      setup(default_time_zone: "UTC")
+      expect(DelayedCron.default_time_zone).to eq "UTC"
+    end
+
+    it "should default TZ to Eastern Time when not specified" do
+      setup(cron_jobs: [{job: "Test"}])
+
+      expect(DelayedCron.default_time_zone).to eq "Eastern Time (US & Canada)"
+    end
+
     it "should have an array of cron_jobs" do
       setup(default_interval: 1.hour)
       expect(DelayedCron.cron_jobs).to be_an(Array)

data/spec/scheduling_spec.rb

@@ -9,61 +9,10 @@ describe DelayedCron::Scheduling 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 ".add_interval" do
-    it 'adds an interval key and value to the options hash' do
-      options = DelayedCron.add_interval(at: '12:00:00 -0500')
-      expect(options).to include(:interval)
-    end
-  end
-
-  describe ".convert_time_string_to_seconds_interval" do
-    let(:next_occurrence) do
-      DelayedCron.convert_time_string_to_seconds_interval(scheduled_time)
-    end
-    # Set Time.now to January 1, 2014 12:00:00 PM
-    before { Timecop.freeze(Time.local(2014, 1, 1, 12, 0, 0)) }
-    context "next occurrence is today" do
-      let(:known_interval) { 3600 }
-      let(:scheduled_time) { "13:00:00 -0500" }
-      it "converts a time string to seconds" do
-        expect(next_occurrence).to be(known_interval)
-      end
-    end
 
-    context "next occurrence is tomorrow" do
-      let(:known_interval) { 82800 }
-      let(:scheduled_time) { "11:00:00 -0500" }
-      it "converts a time string to seconds" do
-        expect(next_occurrence).to be(known_interval)
-      end
+      expect(DelayedCron.processor.jobs.last["args"])
+        .to eq(["SomeClass", "long_method", { "interval" => 1.hour.to_s }])
     end
-
   end
 
   describe ".timing_opts" do
@@ -74,10 +23,22 @@ describe DelayedCron::Scheduling do
 
     it "collects the timing options" do
       interval = { interval: 1.day }
-      timing_opts = DelayedCron.timing_opts(options[:interval], options[:at])
+      timing_opts = DelayedCron.timing_opts(options)
       expect(timing_opts).to eq(options)
       expect(timing_opts).not_to eq(interval)
     end
+
+    it "passes time_zone through" do
+      options_with_zone = options.merge(time_zone: "UTC")
+      timing_opts = DelayedCron.timing_opts(options_with_zone)
+      expect(timing_opts).to eq(options_with_zone)
+    end
+
+    it "ignores unknown parameters" do
+      timing_opts = DelayedCron.timing_opts(foo: :bar)
+
+      expect(timing_opts).to_not have_key(:foo)
+    end
   end
 
 end

data/spec/spec_helper.rb

@@ -21,6 +21,7 @@ end
 def setup(options)
   DelayedCron.setup do |config|
     config.default_interval = options[:default_interval]
+    config.default_time_zone = options[:default_time_zone]
     config.cron_jobs = options[:cron_jobs] || []
   end
 end
@@ -44,6 +45,6 @@ def build_class(class_name, name, options = {})
     end
 
   end
-  
+
   klass
-end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delayed_cron
 version: !ruby/object:Gem::Version
-  version: 0.2.9
+  version: 0.2.10
 platform: ruby
 authors:
 - Justin Grubbs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-17 00:00:00.000000000 Z
+date: 2017-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: delayed_job
@@ -181,6 +181,7 @@ files:
 - delayed_cron.gemspec
 - init.rb
 - lib/delayed_cron.rb
+- lib/delayed_cron/cron_job.rb
 - lib/delayed_cron/jobs.rb
 - lib/delayed_cron/jobs/delayed_job.rb
 - lib/delayed_cron/jobs/resque.rb
@@ -190,6 +191,7 @@ files:
 - lib/delayed_cron/scheduling.rb
 - lib/delayed_cron/version.rb
 - rails/init.rb
+- spec/cron_job_spec.rb
 - spec/delayed_cron_spec.rb
 - spec/jobs/sidekiq_spec.rb
 - spec/scheduling_spec.rb
@@ -218,6 +220,7 @@ signing_key:
 specification_version: 4
 summary: Run your cron jobs with sidekiq, delayed_job, resque, or sucker_punch.
 test_files:
+- spec/cron_job_spec.rb
 - spec/delayed_cron_spec.rb
 - spec/jobs/sidekiq_spec.rb
 - spec/scheduling_spec.rb