cronos 0.4.0 → 0.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 10e6f846b422682bd216f2e943326d80629d76d3bbfcbed0450df8be2cdb9e38
+  data.tar.gz: 2b7b0f18357967bcfa562e8f9f7a7912bdfc9e1653043316bf0316c6aae78060
+SHA512:
+  metadata.gz: 3088cfae1d5a6ad8f92c7ae58ebd50cccbff394ff7fd69690c10270a09040aa406009a751713a6f799a8446941d57a140d08e8ede98aeae608ade0560faa94a3
+  data.tar.gz: 2e008c2ff0ff24647d20b3e283d1b06d5453b6b91de985967a30cc80e1d568bf26c7354415a5f69dc685cfb4b1b9bc61236397cd87212a446cba62ff425a3e34

data/TODO

@@ -1,3 +1,7 @@
 TODO:
 - more examples
 - more everything as its a start
+- default time setting, when time not explicit, instead of midnight
+- instantiate interval from cron string
+- say method to output English description as comment at end of cron interval
+

data/lib/cronos.rb

@@ -1,6 +1,6 @@
-module Cronos
+require 'cronos/version'
 
-  VERSION = '0.4.0'
+module Cronos
 
   def self.schedule(task)
     TaskInterval.new(task)
@@ -13,6 +13,10 @@ module Cronos
 
     DAYS = [:sun, :mon, :tue, :wed, :thu, :fri, :sat]
 
+    def initialize(interval=nil)
+      @min, @hour, @day, @month, @dow = *parse_cron(interval) if interval
+    end
+
     # Time:
     #   at(12)
     #   at(1.30)
@@ -23,14 +27,14 @@ module Cronos
     def at(time)
       @hour, @min, meridian = parse_time(time)
 
-      raise "invalid hour value for 'at'" if @hour > 12 && meridian
-      raise "invalid minute value for 'at'" if @min > 59
+      raise ArgumentError, "invalid hour value for 'at'" if @hour > 12 && meridian
+      raise ArgumentError, "invalid minute value for 'at'" if @min > 59
         
       case meridian
-        when 'am': @hour = 0 if @hour == 12 
-        when 'pm': @hour += 12 if @hour < 12
+        when 'am' then @hour = 0 if @hour == 12
+        when 'pm' then @hour += 12 if @hour < 12
       end
-      raise "invalid hour value for 'at'" if @hour > 23
+      raise ArgumentError, "invalid hour value for 'at'" if @hour > 23
       self
     end
 
@@ -47,14 +51,14 @@ module Cronos
     #   every('Feb'..'June')
     #
     def every(*multiple)
-      return RepeatInterval.new(multiple.first, self) if multiple.first.is_a?(Fixnum)
+      return RepeatInterval.new(multiple.first, self) if multiple.first.is_a?(Numeric)
 
       if multiple.all? {|abbr| is_month?(abbr) }
         of(*multiple)
       elsif multiple.all? {|abbr| is_day?(abbr) }
         days(*multiple)
       else
-        raise "Unknown interval type passed to #every"
+        raise ArgumentError, "Unknown interval type passed to #every"
       end
     end
 
@@ -92,7 +96,7 @@ module Cronos
       if args.first.is_a?(Range)
         @dow = format_range(args.first)
       else
-        list = args.map {|day| day_value(day) unless day.is_a?(Fixnum) }
+        list = args.map {|day| day_value(day) unless day.is_a?(Numeric) }
         @dow = list.join(',')
       end
       self
@@ -115,7 +119,7 @@ module Cronos
       if args.first.is_a?(Range)
         @month = format_range(args.first)
       else
-        list = args.map {|month| month_value(month) unless month.is_a?(Fixnum) }
+        list = args.map {|month| month_value(month) unless month.is_a?(Numeric) }
         @month = list.join(',')
       end
       self
@@ -185,6 +189,17 @@ module Cronos
       self
     end
 
+    def yearly 
+      @min   ||= 0
+      @hour  ||= 0
+      @day   ||= 1
+      @month ||= 1
+      @dow   = nil
+      self
+    end
+    alias once_a_year yearly
+    alias annually yearly
+
     def to_s
       "#{min || '*'} #{hour || '*'} #{day || '*'} #{month || '*'} #{dow || '*'}"
     end
@@ -201,6 +216,12 @@ module Cronos
 
     private
 
+    def parse_cron(string)
+      parts = string.squeeze(' ').split(' ')
+      parts.collect! {|p| Integer(p) rescue p == '*' ? nil : p }
+      parts[0..4]
+    end
+
     def parse_time(time)
       meridian = /pm|am/i.match(time.to_s)[0].downcase rescue nil
       hour, min = *time.to_s.split('.')
@@ -251,14 +272,16 @@ module Cronos
       end
 
       def minutes
-        raise 'Multiple of minutes will not fit into an hour' if (60 % @multiple) > 0
+        raise ArgumentError, 'Multiple of minutes will not fit into an hour' if (60 % @multiple) > 0
+
         calculate_intervals(60)
         @interval.min = self 
         @interval
       end
       
       def hours
-        raise 'Multiple of hours will not fit into a day' if (24 % @multiple) > 0
+        raise ArgumentError, 'Multiple of hours will not fit into a day' if (24 % @multiple) > 0
+
         calculate_intervals(24)
         @interval.min  = 0
         @interval.hour = self 
@@ -266,7 +289,8 @@ module Cronos
       end
 
       def months
-        raise 'Multiple of months will not fit into a year' if (12 % @multiple) > 0
+        raise ArgumentError, 'Multiple of months will not fit into a year' if (12 % @multiple) > 0
+
         calculate_intervals(12, 1)
         @interval.min  ||= 0
         @interval.hour ||= 0
@@ -303,6 +327,10 @@ module Cronos
     def to_s
       "#{super} #{@task}"
     end
+
+    def to_hash
+      super.merge(:command => task)
+    end
   end
 
 end

data/spec/cronos_spec.rb

@@ -3,343 +3,392 @@ require File.dirname(__FILE__) + '/spec_helper'
 describe Cronos do
 
   it "should return task interval instance from schedule method" do
-    Cronos.schedule('ls').should be_kind_of(Cronos::TaskInterval)
+    expect(Cronos.schedule('ls')).to be_kind_of(Cronos::TaskInterval)
   end
 
+  it "should return task interval hash with command" do
+    expect(Cronos.schedule('ls').at('8.00am').to_hash[:command]).to eq('ls')
+  end
 end
 
 describe Cronos::Interval do
 
   it "should return default interval for every minute" do
-    interval.to_s.should == '* * * * *'
+    expect(interval.to_s).to eq('* * * * *')
   end
 
   it "should return hash of values from to_hash method" do
-    interval.at(2.01).on_the('3rd').of(:april).to_hash.should == {:minute => '1', :hour => '2', :day => '3', :month => '4', :weekday => '*'}
+    expect(interval.at(2.01).on_the('3rd').of(:april).to_hash).to eq({:minute => '1', :hour => '2', :day => '3', :month => '4', :weekday => '*'})
+  end
+
+  it "should instantiate interval from cron string" do
+    cron_string = '30 12 * * 0'
+    expect(Cronos::Interval.new(cron_string).to_s).to eq(cron_string)
   end
 
   describe "at method" do
     it "should output interval from integer with hour as integer value and 0 minute" do
-      interval.at(8).to_s.should == '0 8 * * *'
+      expect(interval.at(8).to_s).to eq('0 8 * * *')
     end
 
     it "should output interval from a float with hour value from integer part and minute from decimal part" do
-      interval.at(8.21).to_s.should == '21 8 * * *'
+      expect(interval.at(8.21).to_s).to eq('21 8 * * *')
     end
     
     it "should output interval from a float with hour value from integer part and minute from decimal part left justified to 2 digits" do
-      interval.at(8.20).to_s.should == '20 8 * * *'
+      expect(interval.at(8.20).to_s).to eq('20 8 * * *')
     end
 
     it "should output interval from time string with pm meridian having hour adjusted 24 hour time" do
-      interval.at('8.21pm').to_s.should == '21 20 * * *'
+      expect(interval.at('8.21pm').to_s).to eq('21 20 * * *')
     end
     
     it "should output interval from time string with pm meridian having hour unadjusted if hour is 12" do
-      interval.at('12.21pm').to_s.should == '21 12 * * *'
+      expect(interval.at('12.21pm').to_s).to eq('21 12 * * *')
     end
 
     it "should output interval from time string with am meridian having hour adjusted to 0 if hour is 12" do
-      interval.at('12.21am').to_s.should == '21 0 * * *'
+      expect(interval.at('12.21am').to_s).to eq('21 0 * * *')
     end
 
     it "should raise error if hours out of range" do
-      lambda { interval.daily.at('24.21') }.should raise_error
+      expect { interval.daily.at('24.21') }.to raise_error(ArgumentError)
     end
 
     it "should raise error if minutes out of range" do
-      lambda { interval.daily.at('23.60') }.should raise_error
+      expect { interval.daily.at('23.60') }.to raise_error(ArgumentError)
     end
   end
   
   describe "on method" do
     it "should output interval from integer with day of month as value" do
-      interval.on(15).to_s.should == '* * 15 * *'
+      expect(interval.on(15).to_s).to eq('* * 15 * *')
     end
 
     it "should output interval from day string with ordinal suffix" do
-      interval.on('15th').to_s.should == '* * 15 * *'
+      expect(interval.on('15th').to_s).to eq('* * 15 * *')
     end
 
     it "should output interval from inclusive range as dashed day of month range " do
-      interval.on(15..17).to_s.should == '* * 15-17 * *'
+      expect(interval.on(15..17).to_s).to eq('* * 15-17 * *')
     end
     
     it "should output interval from string inclusive range as dashed day of month range " do
-      interval.on('15th'..'17th').to_s.should == '* * 15-17 * *'
+      expect(interval.on('15th'..'17th').to_s).to eq('* * 15-17 * *')
     end
 
     it "should output interval from exclusive range as dashed day of month range " do
-      interval.on(15...18).to_s.should == '* * 15-17 * *'
+      expect(interval.on(15...18).to_s).to eq('* * 15-17 * *')
     end
 
     it "should output interval from integer array as day number list" do
-      interval.on(15, 16, 17).to_s.should == '* * 15,16,17 * *'
+      expect(interval.on(15, 16, 17).to_s).to eq('* * 15,16,17 * *')
     end
 
     it "should output interval from day string array as day number list" do
-      interval.on('15th', '16th', '17th').to_s.should == '* * 15,16,17 * *'
+      expect(interval.on('15th', '16th', '17th').to_s).to eq('* * 15,16,17 * *')
     end
   end
 
   describe "of method" do
     it "should output interval with month number from a symbol month name" do
-      interval.of(:january).to_s.should == '* * * 1 *'
+      expect(interval.of(:january).to_s).to eq('* * * 1 *')
     end
 
     it "should output interval with month number from a symbol short month name" do
-      interval.of(:jan).to_s.should == '* * * 1 *'
+      expect(interval.of(:jan).to_s).to eq('* * * 1 *')
     end
 
     it "should output interval with month number from a strong month name" do
-      interval.of('January').to_s.should == '* * * 1 *'
+      expect(interval.of('January').to_s).to eq('* * * 1 *')
     end
 
     it "should output interval with comma seperated month numbers from array of symbol month names" do
-      interval.of(:january, :february, :march).to_s.should == '* * * 1,2,3 *'
+      expect(interval.of(:january, :february, :march).to_s).to eq('* * * 1,2,3 *')
     end
 
     it "should output interval with comma seperated month numbers from array of short symbol month names" do
-      interval.of(:jan, :feb, :mar).to_s.should == '* * * 1,2,3 *'
+      expect(interval.of(:jan, :feb, :mar).to_s).to eq('* * * 1,2,3 *')
     end
 
     it "should output interval with comma seperated month numbers from array of string month names" do
-      interval.of('January', 'February', 'March').to_s.should == '* * * 1,2,3 *'
+      expect(interval.of('January', 'February', 'March').to_s).to eq('* * * 1,2,3 *')
     end
 
     it "should output interval from integer inclusive range as dashed month range " do
-      interval.of(1..3).to_s.should == '* * * 1-3 *'
+      expect(interval.of(1..3).to_s).to eq('* * * 1-3 *')
     end
 
     it "should output interval from string inclusive range as dashed month range " do
-      interval.of('jan'..'mar').to_s.should == '* * * 1-3 *'
+      expect(interval.of('jan'..'mar').to_s).to eq('* * * 1-3 *')
     end
 
     it "should output interval from integer exclusive range as dashed month range " do
-      interval.of(1...4).to_s.should == '* * * 1-3 *'
+      expect(interval.of(1...4).to_s).to eq('* * * 1-3 *')
     end
   end
 
   describe "days method" do
     it "should output interval with day number from a symbol day name" do
-      interval.days(:monday).to_s.should == '* * * * 1'
+      expect(interval.days(:monday).to_s).to eq('* * * * 1')
     end
 
     it "should output interval with day number from a string day name" do
-      interval.days('Mondays').to_s.should == '* * * * 1'
+      expect(interval.days('Mondays').to_s).to eq('* * * * 1')
     end
 
     it "should output interval with day number from a symbol short day name" do
-      interval.days(:mon).to_s.should == '* * * * 1'
+      expect(interval.days(:mon).to_s).to eq('* * * * 1')
     end
 
     it "should output interval with day numbers from array of symbol day names" do
-      interval.days(:monday, :wednesday, :friday).to_s.should == '* * * * 1,3,5'
+      expect(interval.days(:monday, :wednesday, :friday).to_s).to eq('* * * * 1,3,5')
     end
 
     it "should output interval with day numbers from array of symbol short day names" do
-      interval.days(:mon, :wed, :fri).to_s.should == '* * * * 1,3,5'
+      expect(interval.days(:mon, :wed, :fri).to_s).to eq('* * * * 1,3,5')
     end
 
     it "should output interval with day numbers from array of string day names" do
-      interval.days('Monday', 'Wednesday', 'Friday').to_s.should == '* * * * 1,3,5'
+      expect(interval.days('Monday', 'Wednesday', 'Friday').to_s).to eq('* * * * 1,3,5')
     end
 
     it "should output interval from integer inclusive range as dashed dow range " do
-      interval.days(1..3).to_s.should == '* * * * 1-3'
+      expect(interval.days(1..3).to_s).to eq('* * * * 1-3')
     end
 
     it "should output interval from string inclusive range as dashed dow range " do
-      interval.days('mon'..'wed').to_s.should == '* * * * 1-3'
+      expect(interval.days('mon'..'wed').to_s).to eq('* * * * 1-3')
     end
 
     it "should output interval from integer exclusive range as dashed dow range " do
-      interval.days(1...4).to_s.should == '* * * * 1-3'
+      expect(interval.days(1...4).to_s).to eq('* * * * 1-3')
     end
   end
 
   describe "hourly method" do
     it "should output interval to run at start of every hour" do
-      interval.hourly.to_s.should == '0 * * * *'
+      expect(interval.hourly.to_s).to eq('0 * * * *')
     end
 
     it "should only affect the hour and minutes" do
       interval.day = 1
       interval.month = 1
       interval.dow = 1
-      interval.hourly.to_s.should == '0 * 1 1 1'
+      expect(interval.hourly.to_s).to eq('0 * 1 1 1')
     end
   end
 
   describe "daily method" do
     it "should output interval to run at 00:00 every day by default" do
-      interval.daily.to_s.should == '0 0 * * *'
+      expect(interval.daily.to_s).to eq('0 0 * * *')
     end
 
     it "should only affect the hour, minutes and day" do
       interval.month = 1
       interval.dow = 1
-      interval.daily.to_s.should == '0 0 * 1 1'
+      expect(interval.daily.to_s).to eq('0 0 * 1 1')
     end
 
     it "should preserve hour and minutes if set" do
       interval.min = 10
       interval.hour = 11
-      interval.daily.to_s.should == '10 11 * * *'
+      expect(interval.daily.to_s).to eq('10 11 * * *')
     end
   end
 
   describe "midnight method" do
     it "should output interval to run at 00:00" do
-      interval.midnight.to_s.should == '0 0 * * *'
+      expect(interval.midnight.to_s).to eq('0 0 * * *')
     end
   end
 
   describe "midday method" do
     it "should output interval to run at 12:00" do
-      interval.midday.to_s.should == '0 12 * * *'
+      expect(interval.midday.to_s).to eq('0 12 * * *')
     end
   end
 
   describe "weekly method" do
     it "should output interval to run on Sunday at 00:00 by default" do
-      interval.weekly.to_s.should == '0 0 * * 0'
+      expect(interval.weekly.to_s).to eq('0 0 * * 0')
     end
 
     it "should override day of month and month" do
       interval.day = 1
       interval.month = 1
-      interval.weekly.to_s.should == '0 0 * * 0'
+      expect(interval.weekly.to_s).to eq('0 0 * * 0')
     end
 
     it "should preserve hour, minute and day of week if set" do
       interval.min = 10
       interval.hour = 11
       interval.dow = 1
-      interval.daily.to_s.should == '10 11 * * 1'
+      expect(interval.daily.to_s).to eq('10 11 * * 1')
     end
   end
 
   describe "monthly method" do
     it "should output interval to run on the 1st day of every month at 00:00 by default" do
-      interval.monthly.to_s.should == '0 0 1 * *'
+      expect(interval.monthly.to_s).to eq('0 0 1 * *')
     end
 
     it "should override day of month and month" do
       interval.day = 1
       interval.month = 1
-      interval.monthly.to_s.should == '0 0 1 * *'
+      expect(interval.monthly.to_s).to eq('0 0 1 * *')
     end
 
     it "should preserve hour, minute and day if set" do
       interval.min = 10
       interval.hour = 11
       interval.day = 12
-      interval.monthly.to_s.should == '10 11 12 * *'
+      expect(interval.monthly.to_s).to eq('10 11 12 * *')
     end
   end
 
   describe "weekends method" do
     it "should output interval to run at 00:00 every Saturday and Sunday" do
-      interval.weekends.to_s.should == '0 0 * * 0,6'
+      expect(interval.weekends.to_s).to eq('0 0 * * 0,6')
     end
   end
 
   describe "weekdays method" do
     it "should output interval to run at 00:00 every day Monday to Friday" do
-      interval.weekdays.to_s.should == '0 0 * * 1-5'
+      expect(interval.weekdays.to_s).to eq('0 0 * * 1-5')
+    end
+  end
+
+  describe "yearly method" do
+    it "should output interval to run on the 1st day of January at 00:00 by default" do
+      expect(interval.yearly.to_s).to eq('0 0 1 1 *')
+    end
+
+    it "should override day of week if set" do
+      interval.dow = 1
+      expect(interval.yearly.to_s).to eq('0 0 1 1 *')
+    end
+
+    it "should preserve hour, minute, day and month if set" do
+      interval.min = 10
+      interval.hour = 11
+      interval.day = 12
+      interval.month = 3
+      expect(interval.yearly.to_s).to eq('10 11 12 3 *')
     end
   end
 
   describe "every(x).minutes" do
     it "should output interval for list of minutes differing by arg value" do
-      interval.every(15).minutes.to_s.should == '0,15,30,45 * * * *'
+      expect(interval.every(15).minutes.to_s).to eq('0,15,30,45 * * * *')
     end
 
     it "should raise error if x not a divisor of 60" do
-      lambda { interval.every(13).minutes }.should raise_error
+      expect { interval.every(13).minutes }.to raise_error(ArgumentError)
     end
   end
 
   describe "every(x).hours" do
     it "should output interval for 0 minute and list of hours differing by arg value" do
-      interval.every(6).hours.to_s.should == '0 0,6,12,18 * * *'
+      expect(interval.every(6).hours.to_s).to eq('0 0,6,12,18 * * *')
     end
 
     it "should raise error if x not a divisor of 24" do
-      lambda { interval.every(13).minutes }.should raise_error
+      expect { interval.every(13).minutes }.to raise_error(ArgumentError)
     end
   end
 
   describe "every(x).months" do
     it "should output interval for 00:00 on 1st day of month and list of months differing by arg value" do
-      interval.every(6).hours.to_s.should == '0 0,6,12,18 * * *'
+      expect(interval.every(6).hours.to_s).to eq('0 0,6,12,18 * * *')
     end
 
     it "should raise error if x not a divisor of 12" do
-      lambda { interval.every(7).minutes }.should raise_error
+      expect { interval.every(7).minutes }.to raise_error(ArgumentError)
     end
   end
   
   describe "every(day_name)" do
     it "should output interval for day symbol as day of week" do
-      interval.every(:sunday).to_s.should == '* * * * 0'
+      expect(interval.every(:sunday).to_s).to eq('* * * * 0')
     end
 
     it "should output interval for list of days as days of week" do
-      interval.every(:thursay, 'Friday').to_s.should == '* * * * 4,5'
+      expect(interval.every(:thursay, 'Friday').to_s).to eq('* * * * 4,5')
     end
   end
 
   describe "every(month_name)" do
     it "should output interval for month symbol as month" do
-      interval.every(:january).to_s.should == '* * * 1 *'
+      expect(interval.every(:january).to_s).to eq('* * * 1 *')
     end
 
     it "should output interval for list of months as months" do
-      interval.every(:february, 'March').to_s.should == '* * * 2,3 *'
+      expect(interval.every(:february, 'March').to_s).to eq('* * * 2,3 *')
     end
   end
 
   describe "combinations" do
     it "weekly.at(3.30) should output '30 3 * * 0'" do
-      interval.weekly.at(3.30).to_s.should == '30 3 * * 0'
+      expect(interval.weekly.at(3.30).to_s).to eq('30 3 * * 0')
     end
 
     it "monthly.at(3.30) should output '30 3 * * *'" do
-      interval.monthly.at(3.30).to_s.should == '30 3 1 * *'
+      expect(interval.monthly.at(3.30).to_s).to eq('30 3 1 * *')
     end
 
     it "monthly.on_the('15th').at(3.30) should output '30 3 15 * *'" do
-      interval.monthly.on_the('15th').at(3.30).to_s.should == '30 3 15 * *'
+      expect(interval.monthly.on_the('15th').at(3.30).to_s).to eq('30 3 15 * *')
     end
 
     it "at('11pm').on_days(:monday, :tuesday) should output '0 11 * * 1,2'" do
-      interval.at('11pm').on_days(:monday, :tuesday).to_s.should == '0 23 * * 1,2'
+      expect(interval.at('11pm').on_days(:monday, :tuesday).to_s).to eq('0 23 * * 1,2')
     end
 
     it "on(15).of(:january) should output '* * 15 1 *'" do
-      interval.on(15).of(:january).to_s.should == '* * 15 1 *'
+      expect(interval.on(15).of(:january).to_s).to eq('* * 15 1 *')
     end
 
     it "on(15, 16, 17).of(:january) should output '* * 15,16,17 1 *'" do
-      interval.on(15, 16, 17).of(:january).to_s.should == '* * 15,16,17 1 *'
+      expect(interval.on(15, 16, 17).of(:january).to_s).to eq('* * 15,16,17 1 *')
     end
     
     it "on(15..17).of(:january) should output '* * 15-17 1 *'" do
-      interval.on(15..17).of(:january).to_s.should == '* * 15-17 1 *'
+      expect(interval.on(15..17).of(:january).to_s).to eq('* * 15-17 1 *')
     end
 
     it "on(15, 16, 17).of(:january) should output '* * 15 1,6,12 *'" do
-      interval.on(15).of(:jan, :jun, :dec).to_s.should == '* * 15 1,6,12 *'
+      expect(interval.on(15).of(:jan, :jun, :dec).to_s).to eq('* * 15 1,6,12 *')
     end
     
     it "at('2.13pm').on_the_('15th').of(:january) should output '13 14 15 1'" do
-      interval.at('2.13pm').on_the(15).of(:january).to_s.should == '13 14 15 1 *'
+      expect(interval.at('2.13pm').on_the(15).of(:january).to_s).to eq('13 14 15 1 *')
     end
     
     it "every(15).minutes.on_the('15th').of(:january) should output '0,15,30,45 * 15 1 *'" do
-      interval.every(15).minutes.on_the('15th').of(:january).to_s.should == '0,15,30,45 * 15 1 *'
+      expect(interval.every(15).minutes.on_the('15th').of(:january).to_s).to eq('0,15,30,45 * 15 1 *')
+    end
+  end
+
+  describe "cron string parser" do
+
+    it "should parse '* * * * *'" do
+      value = '* * * * *' 
+      expect(parse(value)).to eq(value)
+    end
+
+    it "should parse '1 2 3 4 5'" do
+      value = '1 2 3 4 5'
+      expect(parse(value)).to eq(value)
+    end
+
+    # it "should parse ''" do
+    #   value = ''
+    #   parse(value).should == value
+    # end
+
+    def parse(cron)
+      Cronos::Interval.new(cron).to_s
     end
   end
 
@@ -351,7 +400,7 @@ end
 describe Cronos::TaskInterval do
 
   it "should output task at end of interval string" do
-    Cronos::TaskInterval.new('ls').at('12pm').to_s.should == '0 12 * * * ls'
+    expect(Cronos::TaskInterval.new('ls').at('12pm').to_s).to eq('0 12 * * * ls')
   end
 
 end

data/spec/spec_helper.rb

@@ -1,6 +1,5 @@
-$TESTING=true
 $:.push File.join(File.dirname(__FILE__), '..', 'lib')
 
 require 'rubygems'
-require 'spec'
+require 'rspec'
 require 'cronos'

metadata

@@ -1,63 +1,67 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: cronos
-version: !ruby/object:Gem::Version 
-  version: 0.4.0
+version: !ruby/object:Gem::Version
+  version: 0.4.1
 platform: ruby
-authors: 
+authors:
 - Adam Meehan
 autorequire: cronos
 bindir: bin
 cert_chain: []
-
-date: 2009-03-12 00:00:00 +11:00
-default_executable: 
-dependencies: []
-
+date: 2009-03-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 description: Tool for generating cron intervals using a natural syntax
 email: adam.meehan@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
 - LICENSE
 - TODO
 - CHANGELOG
-files: 
+files:
+- CHANGELOG
 - LICENSE
 - README.rdoc
 - Rakefile
 - TODO
-- CHANGELOG
 - lib/cronos.rb
-- spec/spec_helper.rb
 - spec/cronos_spec.rb
-has_rdoc: true
+- spec/spec_helper.rb
 homepage: http://github.com/adzap/cronos
-post_install_message: 
+licenses: []
+metadata: {}
+post_install_message:
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      version: "0"
-  version: 
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.3.1
-signing_key: 
-specification_version: 2
+rubygems_version: 3.0.3.1
+signing_key:
+specification_version: 4
 summary: Tool for generating cron intervals using a natural syntax
 test_files: []
-