Support development for different Rails/Ruby versions

Author: avit

.travis.yml

@@ -4,12 +4,28 @@ before_install:
 notifications:
   email:
     - [email protected]
+    - [email protected]
 branches:
   only:
     - master
-    - v0.7
 rvm:
   - 1.9.3
-  - 2.0.0
+  - 2.0
   - 2.1
   - 2.2
+  - 2.3
+  - ruby-head
+env:
+  - RAILS_VERSION='~> 3.2'
+  - RAILS_VERSION='~> 4.2'
+  - RAILS_VERSION='~> 5.0'
+matrix:
+  exclude:
+    - rvm: 1.9.3
+      env: RAILS_VERSION='~> 5.0'
+    - rvm: 2.0
+      env: RAILS_VERSION='~> 5.0'
+    - rvm: 2.1
+      env: RAILS_VERSION='~> 5.0'
+    - rvm: 2.2
+      env: RAILS_VERSION='~> 5.0'

Gemfile

@@ -1,3 +1,11 @@
 source 'https://rubygems.org'
+gemspec
 
-gemspec
+compatible_rails_versions = [
+  '>= 3.0.0',
+  ('<5' if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.2.2'))
+].compact
+
+gem 'activesupport', (ENV['RAILS_VERSION'] || compatible_rails_versions), require: false
+gem 'i18n', require: false
+gem 'tzinfo', require: false # only needed explicitly for RAILS_VERSION=3

ice_cube.gemspec

@@ -19,7 +19,4 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency('rake')
   s.add_development_dependency('rspec', '~> 2.12.0')
-  s.add_development_dependency('activesupport', ['>= 3.0.0', ('<5' if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('2.2.2'))].compact)
-  s.add_development_dependency('tzinfo')
-  s.add_development_dependency('i18n')
 end

spec/examples/active_support_spec.rb

@@ -1,5 +1,7 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 require 'active_support/time'
+require 'active_support/version'
+require 'tzinfo' if ActiveSupport::VERSION::MAJOR == 3
 
 
 module IceCube
@@ -64,7 +66,7 @@ module IceCube
     end
 
     it 'should use the correct zone for next_occurrences before start_time' do
-      future_time = Time.zone.now.beginning_of_day + 1.day
+      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
@@ -103,23 +105,23 @@ module IceCube
       end
 
       it 'uses schedule zone for remaining_occurrences' do
-        remaining_occurrences = schedule.remaining_occurrences(reference_time + 1.day)
+        remaining_occurrences = schedule.remaining_occurrences(reference_time + IceCube::ONE_DAY)
         remaining_occurrences.should == [Time.utc(2013, 1, 2), Time.utc(2013, 1, 3)]
         remaining_occurrences.each do |t|
           t.time_zone.should == schedule.start_time.time_zone
         end
       end
 
       it 'uses schedule zone for occurrences' do
-        occurrences = schedule.occurrences(reference_time + 1.day)
+        occurrences = schedule.occurrences(reference_time + IceCube::ONE_DAY)
         occurrences.should == [Time.utc(2013, 1, 1), Time.utc(2013, 1, 2)]
         occurrences.each do |t|
           t.time_zone.should == schedule.start_time.time_zone
         end
       end
 
       it 'uses schedule zone for occurrences_between' do
-        occurrences_between = schedule.occurrences_between(reference_time, reference_time + 1.day)
+        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)]
         occurrences_between.each do |t|
           t.time_zone.should == schedule.start_time.time_zone
@@ -129,7 +131,7 @@ module IceCube
       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 + 1.day)
+        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)]
         occurrences_between.each do |t|
           t.time_zone.should == schedule.start_time.time_zone
@@ -139,7 +141,7 @@ module IceCube
       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 + 1.day)
+        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)]
         occurrences_between.each do |t|
           t.time_zone.should == schedule.start_time.time_zone
@@ -149,7 +151,7 @@ module IceCube
       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 + 1.day)
+        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)]
         occurrences_between.each do |t|
           t.time_zone.should == schedule.start_time.time_zone

spec/examples/from_ical_spec.rb

@@ -89,7 +89,7 @@ module IceCube
     it 'should return no occurrences after daily interval with count is over' do
       schedule = IceCube::Schedule.new(Time.now)
       schedule.add_recurrence_rule(IceCube::Rule.from_ical("FREQ=DAILY;COUNT=5"))
-      schedule.occurrences_between(Time.now + 7.days, Time.now + 14.days).count.should == 0
+      schedule.occurrences_between(Time.now + (IceCube::ONE_DAY * 7), Time.now + (IceCube::ONE_DAY * 14)).count.should == 0
     end
 
   end
@@ -177,7 +177,7 @@ def sorted_ical(ical)
         start_time = Time.now
 
         schedule = IceCube::Schedule.new(start_time)
-        schedule.add_recurrence_rule(IceCube::Rule.daily.until(start_time + 15.days))
+        schedule.add_recurrence_rule(IceCube::Rule.daily.until(start_time + (IceCube::ONE_DAY * 15)))
 
         ical = schedule.to_ical
         sorted_ical(IceCube::Schedule.from_ical(ical).to_ical).should eq(sorted_ical(ical))
@@ -357,7 +357,7 @@ def sorted_ical(ical)
 
         schedule = IceCube::Schedule.new(start_time)
         schedule.add_recurrence_rule(IceCube::Rule.daily)
-        schedule.add_exception_time(Time.now + 2.days)
+        schedule.add_exception_time(Time.now + (IceCube::ONE_DAY * 2))
 
         ical = schedule.to_ical
         sorted_ical(IceCube::Schedule.from_ical(ical).to_ical).should eq(sorted_ical(ical))

spec/examples/ice_cube_spec.rb

@@ -334,14 +334,14 @@
   describe "using occurs_between with a biweekly schedule" do
     [[0, 1, 2], [0, 6, 1], [5, 1, 6], [6, 5, 7]].each do |wday, offset, lead|
       start_week    = Time.utc(2014, 1, 5)
-      expected_week =  start_week + 2.weeks
+      expected_week =  start_week + (IceCube::ONE_DAY * 14)
       offset_wday   = (wday + offset) % 7
 
       context "starting on weekday #{wday} selecting weekday #{offset} with a #{lead} day advance window" do
         let(:biweekly)      { Rule.weekly(2).day(0, 1, 2, 3, 4, 5, 6) }
-        let(:schedule)      { Schedule.new(start_week + wday.days) { |s| s.rrule biweekly } }
-        let(:expected_date) { expected_week + offset_wday.days }
-        let(:range)         { [expected_date - lead.days, expected_date] }
+        let(:schedule)      { Schedule.new(start_week + (IceCube::ONE_DAY * wday)) { |s| s.rrule biweekly } }
+        let(:expected_date) { expected_week + (IceCube::ONE_DAY * offset_wday) }
+        let(:range)         { [expected_date - (IceCube::ONE_DAY * lead), expected_date] }
 
         it "should include weekday #{offset_wday} of the expected week" do
           expect(schedule.occurrences_between(range.first, range.last)).to include expected_date

spec/examples/monthly_rule_spec.rb

@@ -36,7 +36,7 @@ module IceCube
       schedule = double(start_time: t0 = Time.utc(2013, 5, 17))
       rule = Rule.monthly(3)
       rule.interval(1)
-      rule.next_time(t0 + 1, schedule, nil).should == t0 + 31.days
+      rule.next_time(t0 + 1, schedule, nil).should == t0 + (IceCube::ONE_DAY * 31)
     end
 
     it 'should produce the correct number of days for @interval = 1' do

spec/examples/yearly_rule_spec.rb

@@ -31,7 +31,7 @@
     schedule = double(start_time: t0 = Time.utc(2013, 5, 1))
     rule = Rule.yearly(3)
     rule.interval(1)
-    rule.next_time(t0 + 1, schedule, nil).should == t0 + 365.days
+    rule.next_time(t0 + 1, schedule, nil).should == t0 + (IceCube::ONE_DAY * 365)
   end
 
   it 'should be able to specify complex yearly rules' do