rufus-scheduler 3.0.9 → 3.1.0

data/spec/job_cron_spec.rb

@@ -102,5 +102,27 @@ describe Rufus::Scheduler::CronJob do
       end
     end
   end
+
+  describe '.next_time' do
+
+    it 'returns the next trigger time' do
+
+      n = Time.now
+      nt = Time.parse("#{n.year}-#{n.month + 1}-01")
+
+      expect(
+        @scheduler.schedule_cron('* * 1 * *', lambda {}).next_time
+      ).to eq(nt)
+    end
+
+    it 'returns the next trigger time (first_at => Time)' do
+
+      ft = Time.parse('2100-12-31')
+
+      job = @scheduler.schedule_cron('* * 1 * *', :first_at => ft) {}
+
+      expect(job.next_time).to eq(ft)
+    end
+  end
 end
 

data/spec/job_every_spec.rb

@@ -49,6 +49,20 @@ describe Rufus::Scheduler::EveryJob do
     expect(times[2] - times[1]).to be < 3.4
   end
 
+  context 'summer time' do
+
+    it 'triggers correctly through a DST transition' do
+
+      job = Rufus::Scheduler::EveryJob.new(@scheduler, '1m', {}, lambda {})
+      t1 = ltz('America/Los_Angeles', 2015, 3, 8, 1, 55)
+      t2 = ltz('America/Los_Angeles', 2015, 3, 8, 3, 05)
+      job.next_time = t1
+      occurrences = job.occurrences(t1, t2)
+
+      expect(occurrences.length).to eq(11)
+    end
+  end
+
   context 'first_at/in' do
 
     it 'triggers for the first time at first_at' do

data/spec/job_repeat_spec.rb

@@ -189,6 +189,7 @@ describe Rufus::Scheduler::RepeatJob do
 
         sleep 0.7
 
+        #p Time.now.to_f
         #p n.to_f
         #p job.first_at.to_f
         #p ft.to_f

data/spec/parse_spec.rb

@@ -12,53 +12,51 @@ describe Rufus::Scheduler do
 
   describe '.parse' do
 
-    def parse(s, opts={})
-      Rufus::Scheduler.parse(s, opts)
-    end
+    def pa(s, opts={}); Rufus::Scheduler.parse(s, opts); end
 
     it 'parses duration strings' do
 
-      expect(parse('1.0d1.0w1.0d')).to eq(777600.0)
+      expect(pa('1.0d1.0w1.0d')).to eq(777600.0)
     end
 
     it 'parses datetimes' do
 
       # local
 
-      expect(parse('Sun Nov 18 16:01:00 2012').strftime('%c')).to eq(
+      expect(pa('Sun Nov 18 16:01:00 2012').strftime('%c')).to eq(
         'Sun Nov 18 16:01:00 2012'
       )
     end
 
     it 'parses datetimes with timezones' do
 
-      expect(parse('Sun Nov 18 16:01:00 2012 Japan').getutc.strftime('%c')).to eq(
-        'Sun Nov 18 07:01:00 2012'
-      )
+      expect(
+        pa('Sun Nov 18 16:01:00 2012 Asia/Singapore').getutc.strftime('%c %z')
+      ).to eq('Sun Nov 18 08:01:00 2012 +0000')
 
-      expect(parse('Sun Nov 18 16:01:00 2012 Zulu').getutc.strftime('%c')).to eq(
+      expect(pa('Sun Nov 18 16:01:00 2012 Zulu').getutc.strftime('%c')).to eq(
         'Sun Nov 18 16:01:00 2012'
       )
 
-      expect(parse('Sun Nov 18 16:01:00 Japan 2012').getutc.strftime('%c')).to eq(
-        'Sun Nov 18 07:01:00 2012'
-      )
+      expect(
+        pa('Sun Nov 18 16:01:00 Asia/Singapore 2012').getutc.strftime('%c %z')
+      ).to eq('Sun Nov 18 08:01:00 2012 +0000')
 
-      expect(parse('Japan Sun Nov 18 16:01:00 2012').getutc.strftime('%c')).to eq(
-        'Sun Nov 18 07:01:00 2012'
-      )
+      expect(
+        pa('Asia/Singapore Sun Nov 18 16:01:00 2012').getutc.strftime('%c %z')
+      ).to eq('Sun Nov 18 08:01:00 2012 +0000')
 
-      expect(parse('Sun Nov 18 16:01:00 2012 America/New_York').getutc.strftime('%c')).to eq(
-        'Sun Nov 18 21:01:00 2012'
-      )
+      expect(
+        pa('Sun Nov 18 16:01:00 2012 America/New_York').getutc.strftime('%c %z')
+      ).to eq('Sun Nov 18 21:01:00 2012 +0000')
     end
 
     it 'parses datetimes with named timezones' do
 
-      expect(parse(
+      expect(pa(
         'Sun Nov 18 16:01:00 2012 Europe/Berlin'
       ).strftime('%c %z')).to eq(
-        'Sun Nov 18 15:01:00 2012 +0000'
+        'Sun Nov 18 16:01:00 2012 +0100'
       )
     end
 
@@ -66,32 +64,32 @@ describe Rufus::Scheduler do
 
       localzone = Time.now.strftime('%z')
 
-      expect(parse('Sun Nov 18 16:01:00 2012').strftime('%c %z')).to eq(
-        "Sun Nov 18 16:01:00 2012 #{localzone}"
-      )
+      expect(
+        pa('Nov 18 16:01:00 2012').strftime('%c %z')
+      ).to eq("Sun Nov 18 16:01:00 2012 #{localzone}")
     end
 
     it 'parses cronlines' do
 
-      out = parse('* * * * *')
+      out = pa('* * * * *')
 
       expect(out.class).to eq(Rufus::Scheduler::CronLine)
       expect(out.original).to eq('* * * * *')
 
-      expect(parse('10 23 * * *').class).to eq(Rufus::Scheduler::CronLine)
-      expect(parse('* 23 * * *').class).to eq(Rufus::Scheduler::CronLine)
+      expect(pa('10 23 * * *').class).to eq(Rufus::Scheduler::CronLine)
+      expect(pa('* 23 * * *').class).to eq(Rufus::Scheduler::CronLine)
     end
 
     it 'raises on unparseable input' do
 
       expect {
-        parse('nada')
+        pa('nada')
       }.to raise_error(ArgumentError, 'couldn\'t parse "nada"')
     end
 
     it 'does not use Chronic if not present' do
 
-      t = parse('next monday 7 PM')
+      t = pa('next monday 7 PM')
 
       n = Time.now
 
@@ -104,7 +102,7 @@ describe Rufus::Scheduler do
 
       with_chronic do
 
-        t = parse('next monday 7 PM')
+        t = pa('next monday 7 PM')
 
         expect(t.wday).to eq(1)
         expect(t.hour).to eq(19)
@@ -117,7 +115,7 @@ describe Rufus::Scheduler do
 
       with_chronic do
 
-        t = parse('monday', :context => :past)
+        t = pa('monday', :context => :past)
 
         expect(t.wday).to eq(1)
         expect(t).to be < Time.now

data/spec/schedule_at_spec.rb

@@ -107,7 +107,7 @@ describe Rufus::Scheduler do
 
       job = @scheduler.at('2050-12-12 20:30 Europe/Berlin', :job => true) {}
 
-      expect(job.time.strftime('%c %z')).to eq('Mon Dec 12 19:30:00 2050 +0000')
+      expect(job.time.strftime('%c %z')).to eq('Mon Dec 12 20:30:00 2050 +0100')
     end
 
     it 'accepts a Chronic string (if Chronic is present)' do

data/spec/scheduler_spec.rb

@@ -602,7 +602,10 @@ describe Rufus::Scheduler do
 
       j0 = @scheduler.schedule_every '1m', :times => 10 do; end
 
-      h = @scheduler.occurrences(Time.now + 4 * 60, Time.now + 16 * 60)
+      t0 = Time.parse((Time.now + 5 * 60).strftime('%Y-%m-%d %H:%M:01'))
+      t1 = t0 + 12 * 60 - 1
+
+      h = @scheduler.occurrences(t0, t1)
 
       expect(h[j0].size).to eq(6)
     end

data/spec/spec_helper.rb

@@ -107,7 +107,7 @@ RSpec::Matchers.define :be_within_1s_of do |expected|
     end
   end
 
-  failure_message_for_should do |actual|
+  failure_message do |actual|
 
     if actual.respond_to?(:asctime)
       "expected #{actual.inspect} to be within 1 second of #{expected}"

data/spec/zotime_spec.rb

@@ -0,0 +1,396 @@
+
+#
+# Specifying rufus-scheduler
+#
+# Wed Mar 11 21:17:36 JST 2015, quatre ans...
+#
+
+require 'spec_helper'
+
+
+describe Rufus::Scheduler::ZoTime do
+
+  describe '.new' do
+
+    it 'accepts an integer' do
+
+      zt = Rufus::Scheduler::ZoTime.new(1234567890, 'America/Los_Angeles')
+
+      expect(zt.seconds.to_i).to eq(1234567890)
+    end
+
+    it 'accepts a float' do
+
+      zt = Rufus::Scheduler::ZoTime.new(1234567890.1234, 'America/Los_Angeles')
+
+      expect(zt.seconds.to_i).to eq(1234567890)
+    end
+
+    it 'accepts a Time instance' do
+
+      zt =
+        Rufus::Scheduler::ZoTime.new(
+          Time.utc(2007, 11, 1, 15, 25, 0),
+          'America/Los_Angeles')
+
+      expect(zt.seconds.to_i).to eq(1193930700)
+    end
+  end
+
+  #it "flips burgers" do
+  #  puts "---"
+  #  t0 = ltz('America/New_York', 2004, 10, 31, 0, 30, 0)
+  #  t1 = ltz('America/New_York', 2004, 10, 31, 1, 30, 0)
+  #  p t0
+  #  p t1
+  #  puts "---"
+  #  zt0 = Rufus::Scheduler::ZoTime.new(t0, 'America/New_York')
+  #  zt1 = Rufus::Scheduler::ZoTime.new(t1, 'America/New_York')
+  #  p zt0.time
+  #  p zt1.time
+  #  puts "---"
+  #  zt0.add(3600)
+  #  p [ zt0.time, zt0.time.zone ]
+  #  p [ zt1.time, zt1.time.zone ]
+  #  #puts "---"
+  #  #zt0.add(3600)
+  #  #zt1.add(3600)
+  #  #p [ zt0.time, zt0.time.zone ]
+  #  #p [ zt1.time, zt1.time.zone ]
+  #end
+
+  describe '#time' do
+
+    it 'returns a Time instance in with the right offset' do
+
+      zt = Rufus::Scheduler::ZoTime.new(1193898300, 'America/Los_Angeles')
+      t = zt.time
+
+      expect(t.strftime('%Y/%m/%d %H:%M:%S %Z')
+        ).to eq('2007/10/31 23:25:00 PDT')
+    end
+
+    # New York      EST: UTC-5
+    # summer (dst)  EDT: UTC-4
+
+    it 'chooses the non DST time when there is ambiguity' do
+
+      t = ltz('America/New_York', 2004, 10, 31, 0, 30, 0)
+      zt = Rufus::Scheduler::ZoTime.new(t, 'America/New_York')
+      zt.add(3600)
+      ztt = zt.time
+
+      expect(ztt.to_i).to eq(1099204200)
+
+      if ruby18?
+        expect(ztt.strftime('%Y/%m/%d %H:%M:%S %Z %z')
+          ).to eq('2004/10/31 01:30:00 EST -0500')
+      else
+        expect(ztt.strftime('%Y/%m/%d %H:%M:%S %Z %z')
+          ).to eq('2004/10/31 01:30:00 EST -0500')
+      end
+    end
+  end
+
+  describe '#utc' do
+
+    it 'returns an UTC Time instance' do
+
+      zt = Rufus::Scheduler::ZoTime.new(1193898300, 'America/Los_Angeles')
+      t = zt.utc
+
+      expect(t.to_i).to eq(1193898300)
+
+      if ruby18?
+        expect(t.strftime('%Y/%m/%d %H:%M:%S %Z %z')
+          ).to eq('2007/11/01 06:25:00 GMT +0000')
+      else
+        expect(t.strftime('%Y/%m/%d %H:%M:%S %Z %z')
+          ).to eq('2007/11/01 06:25:00 UTC +0000')
+      end
+    end
+  end
+
+  describe '#add' do
+
+    it 'adds seconds' do
+
+      zt = Rufus::Scheduler::ZoTime.new(1193898300, 'Europe/Paris')
+      zt.add(111)
+
+      expect(zt.seconds).to eq(1193898300 + 111)
+    end
+
+    it 'goes into DST' do
+
+      zt =
+        Rufus::Scheduler::ZoTime.new(
+          Time.gm(2015, 3, 8, 9, 59, 59),
+          'America/Los_Angeles')
+
+      t0 = zt.time
+      zt.add(1)
+      t1 = zt.time
+
+      st0 = t0.strftime('%Y/%m/%d %H:%M:%S %Z') + " #{t0.isdst}"
+      st1 = t1.strftime('%Y/%m/%d %H:%M:%S %Z') + " #{t1.isdst}"
+
+      expect(t0.to_i).to eq(1425808799)
+      expect(t1.to_i).to eq(1425808800)
+      expect(st0).to eq('2015/03/08 01:59:59 PST false')
+      expect(st1).to eq('2015/03/08 03:00:00 PDT true')
+    end
+
+    it 'goes out of DST' do
+
+      zt =
+        Rufus::Scheduler::ZoTime.new(
+          ltz('Europe/Berlin', 2014, 10, 26, 01, 59, 59),
+          'Europe/Berlin')
+
+      t0 = zt.time
+      zt.add(1)
+      t1 = zt.time
+      zt.add(3600)
+      t2 = zt.time
+      zt.add(1)
+      t3 = zt.time
+
+      st0 = t0.strftime('%Y/%m/%d %H:%M:%S %Z') + " #{t0.isdst}"
+      st1 = t1.strftime('%Y/%m/%d %H:%M:%S %Z') + " #{t1.isdst}"
+      st2 = t2.strftime('%Y/%m/%d %H:%M:%S %Z') + " #{t2.isdst}"
+      st3 = t3.strftime('%Y/%m/%d %H:%M:%S %Z') + " #{t3.isdst}"
+
+      expect(t0.to_i).to eq(1414281599)
+      expect(t1.to_i).to eq(1414285200)
+      expect(t2.to_i).to eq(1414285200)
+      expect(t3.to_i).to eq(1414285201)
+
+      expect(st0).to eq('2014/10/26 01:59:59 CEST true')
+      expect(st1).to eq('2014/10/26 02:00:00 CET false')
+      expect(st2).to eq('2014/10/26 02:00:00 CET false')
+      expect(st3).to eq('2014/10/26 02:00:01 CET false')
+
+      expect(t1 - t0).to eq(3601)
+      expect(t2 - t1).to eq(0)
+      expect(t3 - t2).to eq(1)
+    end
+  end
+
+  describe '#to_f' do
+
+    it 'returns the @seconds' do
+
+      zt = Rufus::Scheduler::ZoTime.new(1193898300, 'Europe/Paris')
+
+      expect(zt.to_f).to eq(1193898300)
+    end
+  end
+
+  describe '.envtzable?' do
+
+    def etza?(s); Rufus::Scheduler::ZoTime.envtzable?(s); end
+
+    it 'matches' do
+
+      expect(etza?('Asia/Tokyo')).to eq(true)
+      expect(etza?('America/Los_Angeles')).to eq(true)
+      expect(etza?('Europe/Paris')).to eq(true)
+      expect(etza?('UTC')).to eq(true)
+
+      expect(etza?('Japan')).to eq(true)
+      expect(etza?('Turkey')).to eq(true)
+    end
+
+    it 'does not match' do
+
+      expect(etza?('14:00')).to eq(false)
+      expect(etza?('14:00:14')).to eq(false)
+      expect(etza?('2014/12/11')).to eq(false)
+      expect(etza?('2014-12-11')).to eq(false)
+      expect(etza?('+25:00')).to eq(false)
+
+      expect(etza?('+09:00')).to eq(false)
+      expect(etza?('-01:30')).to eq(false)
+      expect(etza?('-0200')).to eq(false)
+
+      expect(etza?('Wed')).to eq(false)
+      expect(etza?('Sun')).to eq(false)
+      expect(etza?('Nov')).to eq(false)
+
+      expect(etza?('PST')).to eq(false)
+      expect(etza?('Z')).to eq(false)
+
+      expect(etza?('YTC')).to eq(false)
+      expect(etza?('Asia/Paris')).to eq(false)
+      expect(etza?('Nada/Nada')).to eq(false)
+    end
+
+    #it 'returns true for all entries in the tzinfo list' do
+    #  File.readlines(
+    #    File.join(File.dirname(__FILE__), '../misc/tz_all.txt')
+    #  ).each do |tz|
+    #    tz = tz.strip
+    #    if tz.length > 0 && tz.match(/^[^#]/)
+    #      p tz
+    #      expect(llat?(tz)).to eq(true)
+    #    end
+    #  end
+    #end
+  end
+
+  describe '.is_timezone?' do
+
+    def is_timezone?(o); Rufus::Scheduler::ZoTime.is_timezone?(o); end
+
+    it 'returns true when passed a string describing a timezone' do
+
+      expect(is_timezone?('Asia/Tokyo')).to eq(true)
+      expect(is_timezone?('Europe/Paris')).to eq(true)
+      expect(is_timezone?('UTC')).to eq(true)
+      expect(is_timezone?('GMT')).to eq(true)
+      expect(is_timezone?('Z')).to eq(true)
+      expect(is_timezone?('Zulu')).to eq(true)
+      expect(is_timezone?('PST')).to eq(true)
+      expect(is_timezone?('+09:00')).to eq(true)
+      expect(is_timezone?('-01:30')).to eq(true)
+      expect(is_timezone?('Japan')).to eq(true)
+      expect(is_timezone?('Turkey')).to eq(true)
+    end
+
+    it 'returns false when it cannot make sense of the timezone' do
+
+      expect(is_timezone?('Asia/Paris')).to eq(false)
+      #expect(is_timezone?('YTC')).to eq(false)
+      expect(is_timezone?('Nada/Nada')).to eq(false)
+      expect(is_timezone?('7')).to eq(false)
+      expect(is_timezone?('06')).to eq(false)
+      expect(is_timezone?('sun#3')).to eq(false)
+    end
+
+    #it 'returns true for all entries in the tzinfo list' do
+    #  File.readlines(
+    #    File.join(File.dirname(__FILE__), '../misc/tz_all.txt')
+    #  ).each do |tz|
+    #    tz = tz.strip
+    #    if tz.length > 0 && tz.match(/^[^#]/)
+    #      #p tz
+    #      expect(is_timezone?(tz)).to eq(true)
+    #    end
+    #  end
+    #end
+  end
+
+  describe '.parse' do
+
+    it 'parses a time string without a timezone' do
+
+      zt =
+        in_zone('Europe/Moscow') {
+          Rufus::Scheduler::ZoTime.parse('2015/03/08 01:59:59')
+        }
+
+      t = zt.time
+      u = zt.utc
+
+      expect(t.to_i).to eq(1425769199)
+      expect(u.to_i).to eq(1425769199)
+
+      expect(t.strftime('%Y/%m/%d %H:%M:%S %Z %z') + " #{t.isdst}"
+        ).to eq('2015/03/08 01:59:59 MSK +0300 false')
+
+      if ruby18?
+        expect(u.strftime('%Y/%m/%d %H:%M:%S %Z %z') + " #{u.isdst}"
+          ).to eq('2015/03/07 22:59:59 GMT +0000 false')
+      else
+        expect(u.strftime('%Y/%m/%d %H:%M:%S %Z %z') + " #{u.isdst}"
+          ).to eq('2015/03/07 22:59:59 UTC +0000 false')
+      end
+    end
+
+    it 'parses a time string with a full name timezone' do
+
+      zt =
+        Rufus::Scheduler::ZoTime.parse(
+          '2015/03/08 01:59:59 America/Los_Angeles')
+
+      t = zt.time
+      u = zt.utc
+
+      expect(t.to_i).to eq(1425808799)
+      expect(u.to_i).to eq(1425808799)
+
+      expect(t.strftime('%Y/%m/%d %H:%M:%S %Z %z') + " #{t.isdst}"
+        ).to eq('2015/03/08 01:59:59 PST -0800 false')
+
+      if ruby18?
+        expect(u.strftime('%Y/%m/%d %H:%M:%S %Z %z') + " #{u.isdst}"
+          ).to eq('2015/03/08 09:59:59 GMT +0000 false')
+      else
+        expect(u.strftime('%Y/%m/%d %H:%M:%S %Z %z') + " #{u.isdst}"
+          ).to eq('2015/03/08 09:59:59 UTC +0000 false')
+      end
+    end
+
+    it 'parses a time string with a delta timezone' do
+
+      zt =
+        in_zone('Europe/Berlin') {
+          Rufus::Scheduler::ZoTime.parse('2015-12-13 12:30 -0200')
+        }
+
+      t = zt.time
+      u = zt.utc
+
+      expect(t.to_i).to eq(1450017000)
+      expect(u.to_i).to eq(1450017000)
+
+      expect(t.strftime('%Y/%m/%d %H:%M:%S %Z %z') + " #{t.isdst}"
+        ).to eq('2015/12/13 15:30:00 CET +0100 false')
+
+      if ruby18?
+        expect(u.strftime('%Y/%m/%d %H:%M:%S %Z %z') + " #{u.isdst}"
+          ).to eq('2015/12/13 14:30:00 GMT +0000 false')
+      else
+        expect(u.strftime('%Y/%m/%d %H:%M:%S %Z %z') + " #{u.isdst}"
+          ).to eq('2015/12/13 14:30:00 UTC +0000 false')
+      end
+    end
+
+    it 'parses a time string with a delta (:) timezone' do
+
+      zt =
+        in_zone('Europe/Berlin') {
+          Rufus::Scheduler::ZoTime.parse('2015-12-13 12:30 -02:00')
+        }
+
+      t = zt.time
+      u = zt.utc
+
+      expect(t.to_i).to eq(1450017000)
+      expect(u.to_i).to eq(1450017000)
+
+      expect(t.strftime('%Y/%m/%d %H:%M:%S %Z %z') + " #{t.isdst}"
+        ).to eq('2015/12/13 15:30:00 CET +0100 false')
+
+      if ruby18?
+        expect(u.strftime('%Y/%m/%d %H:%M:%S %Z %z') + " #{u.isdst}"
+          ).to eq('2015/12/13 14:30:00 GMT +0000 false')
+      else
+        expect(u.strftime('%Y/%m/%d %H:%M:%S %Z %z') + " #{u.isdst}"
+          ).to eq('2015/12/13 14:30:00 UTC +0000 false')
+      end
+    end
+
+    it 'takes the local TZ when it does not know the timezone' do
+
+      in_zone 'Europe/Moscow' do
+
+        zt = Rufus::Scheduler::ZoTime.parse('2015/03/08 01:59:59 Nada/Nada')
+
+        expect(zt.time.zone).to eq('MSK')
+      end
+    end
+  end
+end
+