Merge pull request ice-cube-ruby#374 from seejohnrun/upgrade_rspec

Upgrade rspec via transpec

Author: seejohnrun

ice_cube.gemspec

@@ -18,5 +18,5 @@ Gem::Specification.new do |s|
   s.rubyforge_project = "ice-cube"
 
   s.add_development_dependency('rake')
-  s.add_development_dependency('rspec', '~> 2.12.0')
+  s.add_development_dependency('rspec')
 end

spec/examples/_no_active_support_spec.rb

@@ -4,11 +4,10 @@
 # ActiveSupport gets loaded by other specs.
 
 module IceCube
-  describe TimeUtil, :if_active_support_time => false do
+  describe TimeUtil do
 
     before do
-      Time.any_instance.should_receive(:respond_to?).with(:time_zone).
-        at_least(1).times.and_return(false)
+      raise 'ActiveSupport should not be loaded' if defined?(ActiveSuppport)
     end
 
     WORLD_TIME_ZONES.each do |zone|
@@ -17,14 +16,14 @@ module IceCube
         it 'should be able to calculate end of dates without active_support' do
           date        = Date.new(2011, 1, 1)
           end_of_date = Time.local(2011, 1, 1, 23, 59, 59)
-          TimeUtil.end_of_date(date).to_s.should == end_of_date.to_s
+          expect(TimeUtil.end_of_date(date).to_s).to eq(end_of_date.to_s)
         end
 
         it 'should be able to calculate beginning of dates without active_support' do
           date = Date.new(2011, 1, 1)
           res = [ TimeUtil.beginning_of_date(date), Time.local(2011, 1, 1, 0, 0, 0) ]
           res.all? { |r| r.class.name == 'Time' }
-          res.map(&:to_s).uniq.size.should == 1
+          expect(res.map(&:to_s).uniq.size).to eq(1)
         end
 
         it 'should serialize to hash without error' do

spec/examples/active_support_spec.rb

@@ -19,64 +19,64 @@ module IceCube
     it 'works with a single recurrence time starting from a TimeWithZone' do
       schedule = Schedule.new(t0 = Time.zone.parse("2010-02-05 05:00:00"))
       schedule.add_recurrence_time t0
-      schedule.all_occurrences.should == [t0]
+      expect(schedule.all_occurrences).to eq([t0])
     end
 
     it 'works with a monthly recurrence rule starting from a TimeWithZone' do
       schedule = Schedule.new(t0 = Time.zone.parse("2010-02-05 05:00:00"))
       schedule.add_recurrence_rule Rule.monthly
-      schedule.first(10).should == [
+      expect(schedule.first(10)).to eq([
         Time.zone.parse("2010-02-05 05:00"), Time.zone.parse("2010-03-05 05:00"),
         Time.zone.parse("2010-04-05 05:00"), Time.zone.parse("2010-05-05 05:00"),
         Time.zone.parse("2010-06-05 05:00"), Time.zone.parse("2010-07-05 05:00"),
         Time.zone.parse("2010-08-05 05:00"), Time.zone.parse("2010-09-05 05:00"),
         Time.zone.parse("2010-10-05 05:00"), Time.zone.parse("2010-11-05 05:00")
-      ]
+      ])
     end
 
     it 'works with a monthly schedule converting to UTC across DST' do
       Time.zone = 'Eastern Time (US & Canada)'
       schedule = Schedule.new(t0 = Time.zone.parse("2009-10-28 19:30:00"))
       schedule.add_recurrence_rule Rule.monthly
-      schedule.first(7).map { |d| d.getutc }.should == [
+      expect(schedule.first(7).map { |d| d.getutc }).to eq([
         Time.utc(2009, 10, 28, 23, 30, 0), Time.utc(2009, 11, 29,  0, 30, 0),
         Time.utc(2009, 12, 29,  0, 30, 0), Time.utc(2010,  1, 29,  0, 30, 0),
         Time.utc(2010,  3,  1,  0, 30, 0), Time.utc(2010,  3, 28, 23, 30, 0),
         Time.utc(2010,  4, 28, 23, 30, 0)
-      ]
+      ])
     end
 
     it 'can round trip TimeWithZone to YAML' do
       schedule = Schedule.new(t0 = Time.zone.parse("2010-02-05 05:00:00"))
       schedule.add_recurrence_time t0
       schedule2 = Schedule.from_yaml(schedule.to_yaml)
-      schedule.all_occurrences.should == schedule2.all_occurrences
+      expect(schedule.all_occurrences).to eq(schedule2.all_occurrences)
     end
 
     it 'uses local zone from start time to determine occurs_on? from the beginning of day' do
       schedule = Schedule.new(t0 = Time.local(2009, 2, 7, 23, 59, 59))
       schedule.add_recurrence_rule Rule.daily
-      schedule.occurs_on?(Date.new(2009, 2, 7)).should be_true
+      expect(schedule.occurs_on?(Date.new(2009, 2, 7))).to be_truthy
     end
 
     it 'uses local zone from start time to determine occurs_on? to the end of day' do
       schedule = Schedule.new(t0 = Time.local(2009, 2, 7, 0, 0, 0))
       schedule.add_recurrence_rule Rule.daily
-      schedule.occurs_on?(Date.new(2009, 2, 7)).should be_true
+      expect(schedule.occurs_on?(Date.new(2009, 2, 7))).to be_truthy
     end
 
     it 'should use the correct zone for next_occurrences before start_time' do
       future_time = Time.zone.now.beginning_of_day + IceCube::ONE_DAY
       schedule = Schedule.new(future_time)
       schedule.add_recurrence_rule Rule.daily
-      schedule.next_occurrence.time_zone.should == schedule.start_time.time_zone
+      expect(schedule.next_occurrence.time_zone).to eq(schedule.start_time.time_zone)
     end
 
     it 'should use the correct zone for next_occurrences after start_time' do
       past_time = Time.zone.now.beginning_of_day
       schedule = Schedule.new(past_time)
       schedule.add_recurrence_rule Rule.daily
-      schedule.next_occurrence.time_zone.should == schedule.start_time.time_zone
+      expect(schedule.next_occurrence.time_zone).to eq(schedule.start_time.time_zone)
     end
 
     describe 'querying with time arguments for a different zone' do
@@ -92,69 +92,69 @@ module IceCube
 
       it 'uses schedule zone for next_occurrence' do
         next_occurrence = schedule.next_occurrence(reference_time)
-        next_occurrence.should == Time.utc(2013, 1, 2)
-        next_occurrence.time_zone.should == schedule.start_time.time_zone
+        expect(next_occurrence).to eq(Time.utc(2013, 1, 2))
+        expect(next_occurrence.time_zone).to eq(schedule.start_time.time_zone)
       end
 
       it 'uses schedule zone for next_occurrences' do
         next_occurrences = schedule.next_occurrences(2, reference_time)
-        next_occurrences.should == [Time.utc(2013, 1, 2), Time.utc(2013, 1, 3)]
+        expect(next_occurrences).to eq([Time.utc(2013, 1, 2), Time.utc(2013, 1, 3)])
         next_occurrences.each do |t|
-          t.time_zone.should == schedule.start_time.time_zone
+          expect(t.time_zone).to eq(schedule.start_time.time_zone)
         end
       end
 
       it 'uses schedule zone for remaining_occurrences' do
         remaining_occurrences = schedule.remaining_occurrences(reference_time + IceCube::ONE_DAY)
-        remaining_occurrences.should == [Time.utc(2013, 1, 2), Time.utc(2013, 1, 3)]
+        expect(remaining_occurrences).to eq([Time.utc(2013, 1, 2), Time.utc(2013, 1, 3)])
         remaining_occurrences.each do |t|
-          t.time_zone.should == schedule.start_time.time_zone
+          expect(t.time_zone).to eq(schedule.start_time.time_zone)
         end
       end
 
       it 'uses schedule zone for occurrences' do
         occurrences = schedule.occurrences(reference_time + IceCube::ONE_DAY)
-        occurrences.should == [Time.utc(2013, 1, 1), Time.utc(2013, 1, 2)]
+        expect(occurrences).to eq([Time.utc(2013, 1, 1), Time.utc(2013, 1, 2)])
         occurrences.each do |t|
-          t.time_zone.should == schedule.start_time.time_zone
+          expect(t.time_zone).to eq(schedule.start_time.time_zone)
         end
       end
 
       it 'uses schedule zone for occurrences_between' do
         occurrences_between = schedule.occurrences_between(reference_time, reference_time + IceCube::ONE_DAY)
-        occurrences_between.should == [Time.utc(2013, 1, 1), Time.utc(2013, 1, 2)]
+        expect(occurrences_between).to eq([Time.utc(2013, 1, 1), Time.utc(2013, 1, 2)])
         occurrences_between.each do |t|
-          t.time_zone.should == schedule.start_time.time_zone
+          expect(t.time_zone).to eq(schedule.start_time.time_zone)
         end
       end
 
       it "uses schedule zone for occurrences_between with a rule terminated by #count" do
         utc = Time.utc(2013, 1, 1).in_time_zone('UTC')
         s = Schedule.new(utc) { |s| s.add_recurrence_rule Rule.daily.count(3) }
         occurrences_between = s.occurrences_between(reference_time, reference_time + IceCube::ONE_DAY)
-        occurrences_between.should == [Time.utc(2013, 1, 1), Time.utc(2013, 1, 2)]
+        expect(occurrences_between).to eq([Time.utc(2013, 1, 1), Time.utc(2013, 1, 2)])
         occurrences_between.each do |t|
-          t.time_zone.should == schedule.start_time.time_zone
+          expect(t.time_zone).to eq(schedule.start_time.time_zone)
         end
       end
 
       it "uses schedule zone for occurrences_between with a rule terminated by #until" do
         utc = Time.utc(2013, 1, 1).in_time_zone('UTC')
         s = Schedule.new(utc) { |s| s.add_recurrence_rule Rule.daily.until(utc.advance(:days => 3)) }
         occurrences_between = s.occurrences_between(reference_time, reference_time + IceCube::ONE_DAY)
-        occurrences_between.should == [Time.utc(2013, 1, 1), Time.utc(2013, 1, 2)]
+        expect(occurrences_between).to eq([Time.utc(2013, 1, 1), Time.utc(2013, 1, 2)])
         occurrences_between.each do |t|
-          t.time_zone.should == schedule.start_time.time_zone
+          expect(t.time_zone).to eq(schedule.start_time.time_zone)
         end
       end
 
       it "uses schedule zone for occurrences_between with an unterminated rule" do
         utc = Time.utc(2013, 1, 1).in_time_zone('UTC')
         s = Schedule.new(utc) { |s| s.add_recurrence_rule Rule.daily }
         occurrences_between = s.occurrences_between(reference_time, reference_time + IceCube::ONE_DAY)
-        occurrences_between.should == [Time.utc(2013, 1, 1), Time.utc(2013, 1, 2)]
+        expect(occurrences_between).to eq([Time.utc(2013, 1, 1), Time.utc(2013, 1, 2)])
         occurrences_between.each do |t|
-          t.time_zone.should == schedule.start_time.time_zone
+          expect(t.time_zone).to eq(schedule.start_time.time_zone)
         end
       end
 
@@ -169,7 +169,7 @@ module IceCube
     occurrence = Occurrence.new(start_time)
 
     difference = (start_time + 60) - occurrence
-    difference.should == 60
+    expect(difference).to eq(60)
   end
 
 end

spec/examples/daily_rule_spec.rb

@@ -4,12 +4,12 @@ module IceCube
   describe DailyRule, 'interval validation' do
     it 'converts a string integer to an actual int when using the interval method' do
       rule = Rule.daily.interval("2")
-      rule.validations_for(:interval).first.interval.should == 2
+      expect(rule.validations_for(:interval).first.interval).to eq(2)
     end
 
     it 'converts a string integer to an actual int when using the initializer' do
       rule = Rule.daily("3")
-      rule.validations_for(:interval).first.interval.should == 3
+      expect(rule.validations_for(:interval).first.interval).to eq(3)
     end
 
     it 'raises an argument error when a bad value is passed using the interval method' do
@@ -27,36 +27,36 @@ module IceCube
 
   describe DailyRule do
 
-    context :system_time_zone => 'America/Vancouver' do
+    describe 'in Vancouver time', :system_time_zone => 'America/Vancouver' do
 
       it 'should include nearest time in DST start hour' do
         schedule = Schedule.new(t0 = Time.local(2013, 3, 9, 2, 30, 0))
         schedule.add_recurrence_rule Rule.daily
-        schedule.first(3).should == [
+        expect(schedule.first(3)).to eq([
           Time.local(2013, 3,  9, 2, 30, 0), # -0800
           Time.local(2013, 3, 10, 3, 30, 0), # -0700
           Time.local(2013, 3, 11, 2, 30, 0)  # -0700
-        ]
+        ])
       end
 
       it 'should not skip times in DST end hour' do
         schedule = Schedule.new(t0 = Time.local(2013, 11, 2, 2, 30, 0))
         schedule.add_recurrence_rule Rule.daily
-        schedule.first(3).should == [
+        expect(schedule.first(3)).to eq([
           Time.local(2013, 11, 2, 2, 30, 0), # -0700
           Time.local(2013, 11, 3, 2, 30, 0), # -0800
           Time.local(2013, 11, 4, 2, 30, 0)  # -0800
-        ]
+        ])
       end
 
       it 'should include nearest time to DST start when locking hour_of_day' do
         schedule = Schedule.new(t0 = Time.local(2013, 3, 9, 2, 0, 0))
         schedule.add_recurrence_rule Rule.daily.hour_of_day(2)
-        schedule.first(3).should == [
+        expect(schedule.first(3)).to eq([
           Time.local(2013, 3,  9, 2, 0, 0), # -0800
           Time.local(2013, 3, 10, 3, 0, 0), # -0700
           Time.local(2013, 3, 11, 2, 0, 0)  # -0700
-        ]
+        ])
       end
 
     end
@@ -65,45 +65,45 @@ module IceCube
       schedule = double(start_time: t0 = Time.now)
       rule = Rule.daily(7)
       rule.interval(5)
-      rule.next_time(t0 + 1, schedule, nil).should == t0 + 5 * ONE_DAY
+      expect(rule.next_time(t0 + 1, schedule, nil)).to eq(t0 + 5 * ONE_DAY)
     end
 
     it 'should produce the correct days for @interval = 1' do
       schedule = Schedule.new(t0 = Time.now)
       schedule.add_recurrence_rule Rule.daily
       #check assumption
       times = schedule.occurrences(t0 + 2 * ONE_DAY)
-      times.size.should == 3
-      times.should == [t0, t0 + ONE_DAY, t0 + 2 * ONE_DAY]
+      expect(times.size).to eq(3)
+      expect(times).to eq([t0, t0 + ONE_DAY, t0 + 2 * ONE_DAY])
     end
 
     it 'should produce the correct days for @interval = 2' do
       schedule = Schedule.new(t0 = Time.now)
       schedule.add_recurrence_rule Rule.daily(2)
       #check assumption (3) -- (1) 2 (3) 4 (5) 6
       times = schedule.occurrences(t0 + 5 * ONE_DAY)
-      times.size.should == 3
-      times.should == [t0, t0 + 2 * ONE_DAY, t0 + 4 * ONE_DAY]
+      expect(times.size).to eq(3)
+      expect(times).to eq([t0, t0 + 2 * ONE_DAY, t0 + 4 * ONE_DAY])
     end
 
     it 'should produce the correct days for @interval = 2 when crossing into a new year' do
       schedule = Schedule.new(t0 = Time.utc(2011, 12, 29))
       schedule.add_recurrence_rule Rule.daily(2)
       #check assumption (3) -- (1) 2 (3) 4 (5) 6
       times = schedule.occurrences(t0 + 5 * ONE_DAY)
-      times.size.should == 3
-      times.should == [t0, t0 + 2 * ONE_DAY, t0 + 4 * ONE_DAY]
+      expect(times.size).to eq(3)
+      expect(times).to eq([t0, t0 + 2 * ONE_DAY, t0 + 4 * ONE_DAY])
     end
 
     it 'should produce the correct days for interval of 4 day with hour and minute of day set' do
       schedule = Schedule.new(t0 = Time.local(2010, 3, 1))
       schedule.add_recurrence_rule Rule.daily(4).hour_of_day(5).minute_of_hour(45)
       #check assumption 2 -- 1 (2) (3) (4) 5 (6)
       times = schedule.occurrences(t0 + 5 * ONE_DAY)
-      times.should == [
+      expect(times).to eq([
         t0 + 5 * ONE_HOUR + 45 * ONE_MINUTE,
         t0 + 4 * ONE_DAY + 5 * ONE_HOUR + 45 * ONE_MINUTE
-      ]
+      ])
     end
 
   end