rufus-scheduler 3.0.0 → 3.0.9

data/spec/parse_spec.rb

@@ -12,70 +12,116 @@ describe Rufus::Scheduler do
 
   describe '.parse' do
 
-    def parse(s)
-      Rufus::Scheduler.parse(s)
+    def parse(s, opts={})
+      Rufus::Scheduler.parse(s, opts)
     end
 
     it 'parses duration strings' do
 
-      parse('1.0d1.0w1.0d').should == 777600.0
+      expect(parse('1.0d1.0w1.0d')).to eq(777600.0)
     end
 
     it 'parses datetimes' do
 
       # local
 
-      parse('Sun Nov 18 16:01:00 2012').strftime('%c').should ==
+      expect(parse('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
 
-      parse('Sun Nov 18 16:01:00 2012 Japan').getutc.strftime('%c').should ==
+      expect(parse('Sun Nov 18 16:01:00 2012 Japan').getutc.strftime('%c')).to eq(
         'Sun Nov 18 07:01:00 2012'
+      )
 
-      parse('Sun Nov 18 16:01:00 2012 Zulu').getutc.strftime('%c').should ==
+      expect(parse('Sun Nov 18 16:01:00 2012 Zulu').getutc.strftime('%c')).to eq(
         'Sun Nov 18 16:01:00 2012'
+      )
 
-      parse('Sun Nov 18 16:01:00 Japan 2012').getutc.strftime('%c').should ==
+      expect(parse('Sun Nov 18 16:01:00 Japan 2012').getutc.strftime('%c')).to eq(
         'Sun Nov 18 07:01:00 2012'
+      )
 
-      parse('Japan Sun Nov 18 16:01:00 2012').getutc.strftime('%c').should ==
+      expect(parse('Japan Sun Nov 18 16:01:00 2012').getutc.strftime('%c')).to eq(
         'Sun Nov 18 07:01:00 2012'
+      )
+
+      expect(parse('Sun Nov 18 16:01:00 2012 America/New_York').getutc.strftime('%c')).to eq(
+        'Sun Nov 18 21:01:00 2012'
+      )
     end
 
     it 'parses datetimes with named timezones' do
 
-      parse(
+      expect(parse(
         'Sun Nov 18 16:01:00 2012 Europe/Berlin'
-      ).strftime('%c %z').should ==
+      ).strftime('%c %z')).to eq(
         'Sun Nov 18 15:01:00 2012 +0000'
+      )
     end
 
     it 'parses datetimes (with the local timezone implicitely)' do
 
       localzone = Time.now.strftime('%z')
 
-      parse('Sun Nov 18 16:01:00 2012').strftime('%c %z').should ==
+      expect(parse('Sun 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.class.should == Rufus::Scheduler::CronLine
-      out.original.should == '* * * * *'
+      expect(out.class).to eq(Rufus::Scheduler::CronLine)
+      expect(out.original).to eq('* * * * *')
 
-      parse('10 23 * * *').class.should == Rufus::Scheduler::CronLine
-      parse('* 23 * * *').class.should == Rufus::Scheduler::CronLine
+      expect(parse('10 23 * * *').class).to eq(Rufus::Scheduler::CronLine)
+      expect(parse('* 23 * * *').class).to eq(Rufus::Scheduler::CronLine)
     end
 
     it 'raises on unparseable input' do
 
-      lambda {
+      expect {
         parse('nada')
-      }.should raise_error(ArgumentError, 'couldn\'t parse "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')
+
+      n = Time.now
+
+      expect(t.strftime('%Y-%m-%d %H:%M:%S')).to eq(
+        n.strftime('%Y-%m-%d') + ' 19:00:00'
+      )
+    end
+
+    it 'uses Chronic if present' do
+
+      with_chronic do
+
+        t = parse('next monday 7 PM')
+
+        expect(t.wday).to eq(1)
+        expect(t.hour).to eq(19)
+        expect(t.min).to eq(0)
+        expect(t).to be > Time.now
+      end
+    end
+
+    it 'passes options to Chronic' do
+
+      with_chronic do
+
+        t = parse('monday', :context => :past)
+
+        expect(t.wday).to eq(1)
+        expect(t).to be < Time.now
+      end
     end
   end
 
@@ -87,54 +133,70 @@ describe Rufus::Scheduler do
 
     it 'parses duration strings' do
 
-      pd('-1.0d1.0w1.0d').should == -777600.0
-      pd('-1d1w1d').should == -777600.0
-      pd('-1w2d').should == -777600.0
-      pd('-1h10s').should == -3610.0
-      pd('-1h').should == -3600.0
-      pd('-5.').should == -5.0
-      pd('-2.5s').should == -2.5
-      pd('-1s').should == -1.0
-      pd('-500').should == -500
-      pd('').should == 0.0
-      pd('5.0').should == 5.0
-      pd('0.5').should == 0.5
-      pd('.5').should == 0.5
-      pd('5.').should == 5.0
-      pd('500').should == 500
-      pd('1000').should == 1000
-      pd('1').should == 1.0
-      pd('1s').should == 1.0
-      pd('2.5s').should == 2.5
-      pd('1h').should == 3600.0
-      pd('1h10s').should == 3610.0
-      pd('1w2d').should == 777600.0
-      pd('1d1w1d').should == 777600.0
-      pd('1.0d1.0w1.0d').should == 777600.0
-
-      pd('.5m').should == 30.0
-      pd('5.m').should == 300.0
-      pd('1m.5s').should == 60.5
-      pd('-.5m').should == -30.0
-
-      pd('1').should == 1
-      pd('0.1').should == 0.1
-      pd('1s').should == 1
+      expect(pd('-1.0d1.0w1.0d')).to eq(-777600.0)
+      expect(pd('-1d1w1d')).to eq(-777600.0)
+      expect(pd('-1w2d')).to eq(-777600.0)
+      expect(pd('-1h10s')).to eq(-3610.0)
+      expect(pd('-1h')).to eq(-3600.0)
+      expect(pd('-5.')).to eq(-5.0)
+      expect(pd('-2.5s')).to eq(-2.5)
+      expect(pd('-1s')).to eq(-1.0)
+      expect(pd('-500')).to eq(-500)
+      expect(pd('')).to eq(0.0)
+      expect(pd('5.0')).to eq(5.0)
+      expect(pd('0.5')).to eq(0.5)
+      expect(pd('.5')).to eq(0.5)
+      expect(pd('5.')).to eq(5.0)
+      expect(pd('500')).to eq(500)
+      expect(pd('1000')).to eq(1000)
+      expect(pd('1')).to eq(1.0)
+      expect(pd('1s')).to eq(1.0)
+      expect(pd('2.5s')).to eq(2.5)
+      expect(pd('1h')).to eq(3600.0)
+      expect(pd('1h10s')).to eq(3610.0)
+      expect(pd('1w2d')).to eq(777600.0)
+      expect(pd('1d1w1d')).to eq(777600.0)
+      expect(pd('1.0d1.0w1.0d')).to eq(777600.0)
+
+      expect(pd('.5m')).to eq(30.0)
+      expect(pd('5.m')).to eq(300.0)
+      expect(pd('1m.5s')).to eq(60.5)
+      expect(pd('-.5m')).to eq(-30.0)
+
+      expect(pd('1')).to eq(1)
+      expect(pd('0.1')).to eq(0.1)
+      expect(pd('1s')).to eq(1)
     end
 
     it 'calls #to_s on its input' do
 
-      pd(0.1).should == 0.1
+      expect(pd(0.1)).to eq(0.1)
     end
 
     it 'raises on wrong duration strings' do
 
-      lambda { pd('-') }.should raise_error(ArgumentError)
-      lambda { pd('h') }.should raise_error(ArgumentError)
-      lambda { pd('whatever') }.should raise_error(ArgumentError)
-      lambda { pd('hms') }.should raise_error(ArgumentError)
+      expect { pd('-') }.to raise_error(ArgumentError)
+      expect { pd('h') }.to raise_error(ArgumentError)
+      expect { pd('whatever') }.to raise_error(ArgumentError)
+      expect { pd('hms') }.to raise_error(ArgumentError)
+
+      expect { pd(' 1h ') }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '.parse_time_string -> .parse_duration' do
+
+    it 'is still around for libs using it out there' do
+
+      expect(Rufus::Scheduler.parse_time_string('1d1w1d')).to eq(777600.0)
+    end
+  end
+
+  describe '.parse_duration_string -> .parse_duration' do
+
+    it 'is still around for libs using it out there' do
 
-      lambda { pd(' 1h ') }.should raise_error(ArgumentError)
+      expect(Rufus::Scheduler.parse_duration_string('1d1w1d')).to eq(777600.0)
     end
   end
 
@@ -146,32 +208,32 @@ describe Rufus::Scheduler do
 
     it 'turns integers into duration strings' do
 
-      td(0).should == '0s'
-      td(60).should == '1m'
-      td(61).should == '1m1s'
-      td(3661).should == '1h1m1s'
-      td(24 * 3600).should == '1d'
-      td(7 * 24 * 3600 + 1).should == '1w1s'
-      td(30 * 24 * 3600 + 1).should == '4w2d1s'
+      expect(td(0)).to eq('0s')
+      expect(td(60)).to eq('1m')
+      expect(td(61)).to eq('1m1s')
+      expect(td(3661)).to eq('1h1m1s')
+      expect(td(24 * 3600)).to eq('1d')
+      expect(td(7 * 24 * 3600 + 1)).to eq('1w1s')
+      expect(td(30 * 24 * 3600 + 1)).to eq('4w2d1s')
     end
 
     it 'ignores seconds and milliseconds if :drop_seconds => true' do
 
-      td(0, :drop_seconds => true).should == '0m'
-      td(5, :drop_seconds => true).should == '0m'
-      td(61, :drop_seconds => true).should == '1m'
+      expect(td(0, :drop_seconds => true)).to eq('0m')
+      expect(td(5, :drop_seconds => true)).to eq('0m')
+      expect(td(61, :drop_seconds => true)).to eq('1m')
     end
 
     it 'displays months if :months => true' do
 
-      td(1, :months => true).should == '1s'
-      td(30 * 24 * 3600 + 1, :months => true).should == '1M1s'
+      expect(td(1, :months => true)).to eq('1s')
+      expect(td(30 * 24 * 3600 + 1, :months => true)).to eq('1M1s')
     end
 
     it 'turns floats into duration strings' do
 
-      td(0.1).should == '100'
-      td(1.1).should == '1s100'
+      expect(td(0.1)).to eq('100')
+      expect(td(1.1)).to eq('1s100')
     end
   end
 
@@ -183,20 +245,20 @@ describe Rufus::Scheduler do
 
     it 'turns integers duration hashes' do
 
-      tdh(0).should == {}
-      tdh(60).should == { :m => 1 }
+      expect(tdh(0)).to eq({})
+      expect(tdh(60)).to eq({ :m => 1 })
     end
 
     it 'turns floats duration hashes' do
 
-      tdh(0.128).should == { :ms => 128 }
-      tdh(60.127).should == { :m => 1, :ms => 127 }
+      expect(tdh(0.128)).to eq({ :ms => 128 })
+      expect(tdh(60.127)).to eq({ :m => 1, :ms => 127 })
     end
 
     it 'drops seconds and milliseconds if :drop_seconds => true' do
 
-      tdh(61.127).should == { :m => 1, :s => 1, :ms => 127 }
-      tdh(61.127, :drop_seconds => true).should == { :m => 1 }
+      expect(tdh(61.127)).to eq({ :m => 1, :s => 1, :ms => 127 })
+      expect(tdh(61.127, :drop_seconds => true)).to eq({ :m => 1 })
     end
   end
 end

data/spec/schedule_at_spec.rb

@@ -21,9 +21,9 @@ describe Rufus::Scheduler do
 
     it 'raises if the block to schedule is missing' do
 
-      lambda {
+      expect {
         @scheduler.at(Time.now + 3600)
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
 
     it 'returns a job id' do
@@ -32,8 +32,8 @@ describe Rufus::Scheduler do
         @scheduler.at(Time.now + 3600) do
         end
 
-      job_id.class.should == String
-      job_id.should match(/^at_/)
+      expect(job_id.class).to eq(String)
+      expect(job_id).to match(/^at_/)
     end
 
     it 'returns a job if :job => true' do
@@ -42,7 +42,7 @@ describe Rufus::Scheduler do
         @scheduler.at(Time.now + 3600, :job => true) do
         end
 
-      job.class.should == Rufus::Scheduler::AtJob
+      expect(job.class).to eq(Rufus::Scheduler::AtJob)
     end
 
     it 'adds a job' do
@@ -52,9 +52,9 @@ describe Rufus::Scheduler do
       @scheduler.at(t) do
       end
 
-      @scheduler.jobs.size.should == 1
-      @scheduler.jobs.first.class.should == Rufus::Scheduler::AtJob
-      @scheduler.jobs.first.time.should == t
+      expect(@scheduler.jobs.size).to eq(1)
+      expect(@scheduler.jobs.first.class).to eq(Rufus::Scheduler::AtJob)
+      expect(@scheduler.jobs.first.time).to eq(t)
     end
 
     it 'triggers a job' do
@@ -67,7 +67,7 @@ describe Rufus::Scheduler do
 
       sleep 0.4
 
-      a.should == true
+      expect(a).to eq(true)
     end
 
     it 'removes the job after execution' do
@@ -77,7 +77,7 @@ describe Rufus::Scheduler do
 
       sleep 0.4
 
-      @scheduler.jobs.size.should == 0
+      expect(@scheduler.jobs.size).to eq(0)
     end
 
     it 'accepts a Time instance' do
@@ -86,31 +86,60 @@ describe Rufus::Scheduler do
 
       job = @scheduler.at(t, :job => true) {}
 
-      job.time.should == t
+      expect(job.time).to eq(t)
     end
 
     it 'accepts a time string' do
 
       job = @scheduler.at('2100-12-12 20:30', :job => true) {}
 
-      job.time.should == Time.parse('2100-12-12 20:30')
+      expect(job.time).to eq(Time.parse('2100-12-12 20:30'))
     end
 
     it 'accepts a time string with a delta timezone' do
 
       job = @scheduler.at('2100-12-12 20:30 -0200', :job => true) {}
 
-      job.time.should == Time.parse('2100-12-12 20:30 -0200')
+      expect(job.time).to eq(Time.parse('2100-12-12 20:30 -0200'))
     end
 
     it 'accepts a time string with a named timezone' do
 
       job = @scheduler.at('2050-12-12 20:30 Europe/Berlin', :job => true) {}
 
-      job.time.strftime('%c %z').should == 'Mon Dec 12 19:30:00 2050 +0000'
+      expect(job.time.strftime('%c %z')).to eq('Mon Dec 12 19:30:00 2050 +0000')
+    end
+
+    it 'accepts a Chronic string (if Chronic is present)' do
+
+      with_chronic do
+
+        job = @scheduler.schedule_at('next tuesday at 12:00') {}
+
+        expect(job.time.wday).to eq(2)
+        expect(job.time.hour).to eq(12)
+        expect(job.time.min).to eq(0)
+        expect(job.time).to be > Time.now
+      end
+    end
+
+    it 'accepts a Chronic string and Chronic options (if Chronic present)' do
+
+      with_chronic do
+
+        job =
+          @scheduler.schedule_at(
+            'may 27th at 12:00', :now => Time.local(Time.now.year + 2, 1, 1)
+          ) {}
+
+        expect(job.time.year).to eq(Time.now.year + 2)
+        expect(job.time.month).to eq(5)
+        expect(job.time.day).to eq(27)
+        expect(job.time.hour).to eq(12)
+        expect(job.time.min).to eq(0)
+      end
     end
 
-    it 'accepts a Chronic time string (if Chronic is present)'
     it 'accepts an ActiveSupport time thinggy'
   end
 
@@ -121,8 +150,8 @@ describe Rufus::Scheduler do
       job = @scheduler.schedule_at(Time.now + 3600) do
       end
 
-      job.class.should == Rufus::Scheduler::AtJob
-      job.id.should match(/^at_/)
+      expect(job.class).to eq(Rufus::Scheduler::AtJob)
+      expect(job.id).to match(/^at_/)
     end
   end
 end

data/spec/schedule_cron_spec.rb

@@ -38,16 +38,16 @@ describe Rufus::Scheduler do
       sleep_until_next_second
       sleep 0.3 # be sure to be well into the second
 
-      counter.should == 2
+      expect(counter).to eq(2)
     end
 
     it 'raises if the job frequency is higher than the scheduler frequency' do
 
       @scheduler.frequency = 10
 
-      lambda {
+      expect {
         @scheduler.cron '* * * * * *' do; end
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
   end
 
@@ -57,9 +57,9 @@ describe Rufus::Scheduler do
 
       job = @scheduler.schedule_cron '* * * * *' do; end
 
-      job.class.should == Rufus::Scheduler::CronJob
-      job.original.should == '* * * * *'
-      job.job_id.should match(/^cron_/)
+      expect(job.class).to eq(Rufus::Scheduler::CronJob)
+      expect(job.original).to eq('* * * * *')
+      expect(job.job_id).to match(/^cron_/)
     end
   end
 end

data/spec/schedule_every_spec.rb

@@ -24,8 +24,8 @@ describe Rufus::Scheduler do
       @scheduler.every(10) do
       end
 
-      @scheduler.jobs.size.should == 1
-      @scheduler.jobs.first.class.should == Rufus::Scheduler::EveryJob
+      expect(@scheduler.jobs.size).to eq(1)
+      expect(@scheduler.jobs.first.class).to eq(Rufus::Scheduler::EveryJob)
     end
 
     it 'triggers a job (2 times)' do
@@ -38,7 +38,7 @@ describe Rufus::Scheduler do
 
       sleep 2.0
 
-      counter.should > 2
+      expect(counter).to be > 2
     end
 
     it 'does not remove the job after execution' do
@@ -48,23 +48,23 @@ describe Rufus::Scheduler do
 
       sleep 0.9
 
-      @scheduler.jobs.size.should == 1
+      expect(@scheduler.jobs.size).to eq(1)
     end
 
     it 'raises on negative frequencies' do
 
-      lambda {
+      expect {
         @scheduler.every(-1) do
         end
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
 
     it 'raises on zero frequencies' do
 
-      lambda {
+      expect {
         @scheduler.every(0) do
         end
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
 
     it 'does not reschedule if the job was unscheduled' do
@@ -83,16 +83,16 @@ describe Rufus::Scheduler do
 
       sleep 1.6
 
-      counter.should == c
+      expect(counter).to eq(c)
     end
 
     it 'raises if the job frequency is higher than the scheduler frequency' do
 
       @scheduler.frequency = 10
 
-      lambda {
+      expect {
         @scheduler.every '1s' do; end
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
   end
 
@@ -102,7 +102,7 @@ describe Rufus::Scheduler do
 
       job = @scheduler.schedule_every('1h') do; end
 
-      job.frequency.should == 3600.0
+      expect(job.frequency).to eq(3600.0)
     end
   end
 end

data/spec/schedule_in_spec.rb

@@ -24,8 +24,8 @@ describe Rufus::Scheduler do
       @scheduler.in(3600) do
       end
 
-      @scheduler.jobs.size.should == 1
-      @scheduler.jobs.first.class.should == Rufus::Scheduler::InJob
+      expect(@scheduler.jobs.size).to eq(1)
+      expect(@scheduler.jobs.first.class).to eq(Rufus::Scheduler::InJob)
     end
 
     it 'triggers a job' do
@@ -38,7 +38,7 @@ describe Rufus::Scheduler do
 
       sleep 0.9
 
-      a.should == true
+      expect(a).to eq(true)
     end
 
     it 'removes the job after execution' do
@@ -48,7 +48,7 @@ describe Rufus::Scheduler do
 
       sleep 0.700
 
-      @scheduler.jobs.size.should == 0
+      expect(@scheduler.jobs.size).to eq(0)
     end
   end
 
@@ -58,16 +58,16 @@ describe Rufus::Scheduler do
 
       job = @scheduler.schedule_in(3600) {}
 
-      job.original.should == 3600
+      expect(job.original).to eq(3600)
     end
 
     it 'accepts a duration string' do
 
       job = @scheduler.schedule_in('1h') {}
 
-      job.original.should == '1h'
-      job.time.should >= job.scheduled_at + 3509
-      job.time.should <= job.scheduled_at + 3601
+      expect(job.original).to eq('1h')
+      expect(job.time).to be >= job.scheduled_at + 3509
+      expect(job.time).to be <= job.scheduled_at + 3601
     end
 
     it 'accepts an ActiveSupport .from_now thinggy'