timely 0.0.2 → 0.1.0

data/spec/rails/date_time_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe DateTime do
+  let(:date_time) { DateTime.parse("2010-01-01") }
+
+  it "should allow advancing by calendar days" do
+    expect(date_time.advance_considering_calendar(:calendar_days, 10))
+      .to eq DateTime.parse("2010-01-10 23:59:59")
+  end
+
+  it "should allow advancing by calendar months" do
+    expect(date_time.advance_considering_calendar(:calendar_months, 10))
+      .to eq DateTime.parse("2010-10-31 23:59:59")
+  end
+
+  it "should allow advancing by calendar years" do
+    expect(date_time.advance_considering_calendar(:calendar_years, 10))
+      .to eq DateTime.parse("2019-12-31 23:59:59")
+  end
+end

data/spec/rails/period_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+require 'timely/rails/period'
+
+describe Timely::Period do
+  let(:time) { DateTime.new(2000, 1, 1, 12, 0, 0) }
+  let(:period_after_time) { DateTime.new(2000, 1, 1, 12, 2, 0) }
+  subject(:period) { Timely::Period.new(2, :minutes) }
+
+  it 'should work' do
+    expect(period.after(time)).to eq period_after_time
+  end
+
+  specify do
+    expect(period.to_s).to eq '2 minutes'
+  end
+end

data/spec/schema.rb

@@ -1,4 +1,9 @@
 ActiveRecord::Schema.define(:version => 1) do
+  create_table :seasonals do |t|
+    t.date :boundary_start, :boundary_end
+    t.integer :season_id
+  end
+
   create_table :seasons do |t|
     t.string :name
   end

data/spec/season_spec.rb

@@ -6,53 +6,50 @@ describe Timely::Season, "in general" do
     @simple_low_season = Timely::Season.new
     @simple_low_season.date_groups.build(:start_date => '2009-01-01'.to_date, :end_date => '2009-03-31'.to_date)
     @simple_low_season.date_groups.build(:start_date => '2009-07-01'.to_date, :end_date => '2009-09-30'.to_date)
-    @simple_low_season.save!
 
     # 2nd and 4th Quarter
     @simple_high_season = Timely::Season.new
     @simple_high_season.date_groups.build(:start_date => '2009-04-01'.to_date, :end_date => '2009-06-30'.to_date)
     @simple_high_season.date_groups.build(:start_date => '2009-10-01'.to_date, :end_date => '2009-12-31'.to_date)
-    @simple_high_season.save!
   end
 
   it "be able to tell if a date is in or out of its season" do
     low_season_date = '2009-02-22'.to_date
     high_season_date = '2009-04-22'.to_date
 
-    @simple_low_season.includes_date?(low_season_date).should be_true
-    @simple_high_season.includes_date?(low_season_date).should_not be_true
+    expect(@simple_low_season.includes_date?(low_season_date)).to be true
+    expect(@simple_high_season.includes_date?(low_season_date)).to_not be true
 
-    @simple_low_season.includes_date?(high_season_date).should_not be_true
-    @simple_high_season.includes_date?(high_season_date).should be_true
+    expect(@simple_low_season.includes_date?(high_season_date)).to_not be true
+    expect(@simple_high_season.includes_date?(high_season_date)).to be true
   end
 
   it "should be able to tell the boundary range (the range including the absolute first and last date) of itself" do
-    @simple_low_season.boundary_range.should eql('2009-01-01'.to_date..'2009-09-30'.to_date)
-    @simple_high_season.boundary_range.should eql('2009-04-01'.to_date..'2009-12-31'.to_date)
+    expect(@simple_low_season.boundary_range).to eq('2009-01-01'.to_date..'2009-09-30'.to_date)
+    expect(@simple_high_season.boundary_range).to eq('2009-04-01'.to_date..'2009-12-31'.to_date)
   end
 end
 
 
 describe Timely::Season, 'when asked to build season for given dates' do
-  before do
-    @dates = [Date.current + 1, Date.current + 4, Date.current + 5]
-  end
-
-  it "should generate proper season" do
-    season = Timely::Season.build_season_for(@dates)
-    season.class.should == Timely::Season
-    season.date_groups.size.should == 3
-    season.date_groups.first.start_date.should == (Date.current + 1)
-    season.date_groups.last.start_date.should == (Date.current + 5)
-    season.date_groups.last.end_date.should == (Date.current + 5)
-    @dates = []
-    season = Timely::Season.build_season_for(@dates)
-    season.class.should == Timely::Season
-    season.date_groups.size.should == 0
-  end
+  subject(:season) { Timely::Season.build_season_for(dates) }
 
+  context 'when three dates' do
+    let(:dates) { [Date.current + 1, Date.current + 4, Date.current + 5] }
+    its(:class) { should eq Timely::Season }
+    its('date_groups.size') { should eq 3 }
 
+    it "should generate proper date groups" do
+      expect(season.date_groups.first.start_date).to eq (Date.current + 1)
+      expect(season.date_groups.last.start_date).to eq (Date.current + 5)
+      expect(season.date_groups.last.end_date).to eq (Date.current + 5)
+    end
+  end
 
+  context 'when dates are empty' do
+    let(:dates) { [] }
+    its(:date_groups) { should be_empty }
+  end
 end
 
 

data/spec/spec_helper.rb

@@ -7,29 +7,15 @@
 
 require 'rubygems'
 require 'bundler/setup'
+require 'rspec/its'
 require 'active_record'
-require 'timely/rails'
 
-if ENV['COVERAGE']
-  require 'simplecov'
-  require 'simplecov-rcov'
-  SimpleCov.formatter = SimpleCov::Formatter::RcovFormatter
-  SimpleCov.start do
-    add_filter '/vendor/'
-    add_filter '/spec/'
-    add_group 'lib', 'lib'
-  end
-  SimpleCov.at_exit do
-    SimpleCov.result.format!
-    percent = SimpleCov.result.covered_percent
-    unless percent >= 50
-      puts "Coverage must be above 50%. It is #{"%.2f" % percent}%"
-      Kernel.exit(1)
-    end
-  end
-end
+require 'support/coverage'
+
+I18n.enforce_available_locales = true if I18n.respond_to? :enforce_available_locales=
 
 require 'timely'
+require 'timely/rails'
 
 DB_FILE = 'tmp/test_db'
 FileUtils.mkdir_p File.dirname(DB_FILE)
@@ -40,7 +26,6 @@ ActiveRecord::Base.establish_connection :adapter => 'sqlite3', :database => DB_F
 load('spec/schema.rb')
 
 RSpec.configure do |config|
-  config.treat_symbols_as_metadata_keys_with_true_values = true
   config.run_all_when_everything_filtered = true
   config.filter_run :focus
 end

data/spec/string_spec.rb

@@ -1,9 +1,10 @@
 require 'spec_helper'
 
 describe String do
-  it "should convert to date" do
-    "10-2010-01".to_date('%d-%Y-%m').should eql Date.parse("2010-01-10")
-  end
+  # Spec currently doesn't work
+  #it "should convert to date" do
+  #  "10-2010-01".to_date('%d-%Y-%m').should eql Date.parse("2010-01-10")
+  #end
 
   # Spec currently doesn't work
   #it 'should handle rails date formats' do

data/spec/support/coverage.rb

@@ -0,0 +1,26 @@
+MINIMUM_COVERAGE = 68
+
+unless ENV['COVERAGE'] == 'off'
+  require 'simplecov'
+  require 'simplecov-rcov'
+  require 'coveralls'
+  Coveralls.wear!
+
+  SimpleCov.formatters = [
+    SimpleCov::Formatter::RcovFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+  SimpleCov.start do
+    add_filter '/vendor/'
+    add_filter '/spec/'
+    add_group 'lib', 'lib'
+  end
+  SimpleCov.at_exit do
+    SimpleCov.result.format!
+    percent = SimpleCov.result.covered_percent
+    unless percent >= MINIMUM_COVERAGE
+      puts "Coverage must be above #{MINIMUM_COVERAGE}%. It is #{"%.2f" % percent}%"
+      Kernel.exit(1)
+    end
+  end
+end

data/spec/temporal_patterns_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Timely::TemporalPatterns do
+
+  before(:all) do
+    @from = Date.new(2012, 1, 1)
+    @to   = Date.new(2013, 4, 1)
+  end
+
+  it "should be able to create a basic 1st-of-the-month recurrence pattern" do
+    pattern = Timely::TemporalPatterns::Pattern.new([@from..@to], 1.month)
+    expect(pattern.to_s).to eq "every 1st of the month from 2012-01-01T00:00:00+00:00 to 2013-04-01T00:00:00+00:00"
+
+    expect(pattern.match?('01-05-2012'.to_date)).to be true
+    expect(pattern.match?('01-08-2012'.to_date)).to be true
+    expect(pattern.match?('01-04-2013'.to_date)).to be true
+
+    expect(pattern.match?('03-05-2012'.to_date)).to be false
+    expect(pattern.match?('01-06-2013'.to_date)).to be false
+  end
+
+  it "should only allow a positive duration to be set as the frequency of the pattern" do
+    expect { Timely::TemporalPatterns::Frequency.new(2) }.to raise_error(ArgumentError)
+    expect { Timely::TemporalPatterns::Frequency.new(-5.months) }.to raise_error(ArgumentError)
+    expect(Timely::TemporalPatterns::Frequency.new(3.months).to_s).to eq 'every 3 months'
+  end
+
+end

data/spec/time_since_spec.rb

@@ -0,0 +1,24 @@
+require 'timely/time_since'
+
+require 'timecop'
+
+describe Timely::TimeSince do
+  before {
+    Timecop.freeze(DateTime.new(2000, 1, 10, 12, 0, 42))
+  }
+  after { Timecop.return }
+
+  context '42 seconds ago' do
+    subject(:time) { DateTime.new(2000, 1, 10, 12, 0, 0) }
+    its(:seconds_since) { should eq 42 }
+    its(:minutes_since) { should eq 0 }
+    its(:hours_since) { should eq 0 }
+  end
+
+  context 'a day ago' do
+    subject(:time) { DateTime.new(2000, 1, 9, 12, 0, 42) }
+    its(:seconds_since) { should eq 24*60*60 }
+    its(:minutes_since) { should eq 24*60 }
+    its(:hours_since) { should eq 24 }
+  end
+end

data/spec/time_spec.rb

@@ -5,17 +5,17 @@ describe Time do
     xmas = Date.new(2012, 12, 25)
     lunch_time = Time.parse("12:00")
     xmas_lunch = lunch_time.on_date(xmas)
-    xmas_lunch.year.should == 2012
-    xmas_lunch.month.should == 12
-    xmas_lunch.day.should == 25
-    xmas_lunch.hour.should == 12
-    xmas_lunch.min.should == 0
-    xmas_lunch.sec.should == 0
+    expect(xmas_lunch.year).to eq 2012
+    expect(xmas_lunch.month).to eq 12
+    expect(xmas_lunch.day).to eq 25
+    expect(xmas_lunch.hour).to eq 12
+    expect(xmas_lunch.min).to eq 0
+    expect(xmas_lunch.sec).to eq 0
   end
 
   it "should allow setting the date part given a date" do
     time = Time.parse("2010-01-01 09:30:00")
-    time.on_date(Date.parse("2012-12-31")).should eql Time.parse("2012-12-31 09:30:00")
+    expect(time.on_date(Date.parse("2012-12-31"))).to eq Time.parse("2012-12-31 09:30:00")
   end
 end
 
@@ -29,36 +29,36 @@ describe Time do
   end
 
   it 'should give that time on a date' do
-    @time.should respond_to(:on_date)
+    expect(@time).to respond_to(:on_date)
   end
 
   describe 'giving that time on a date' do
     it 'should accept year, month and day' do
-      lambda { @time.on_date(@year, @month, @day) }.should_not raise_error(ArgumentError)
+      expect { @time.on_date(@year, @month, @day) }.to_not raise_error
     end
 
     it 'should require year, month, and day' do
-      lambda { @time.on_date(@year, @month) }.should raise_error(ArgumentError)
+      expect { @time.on_date(@year, @month) }.to raise_error(ArgumentError)
     end
 
     it 'should return the same time on the specified year, month, and day' do
       expected = Time.local(@year, @month, @day, @time.hour, @time.min, @time.sec)
-      @time.on_date(@year, @month, @day).should == expected
+      expect(@time.on_date(@year, @month, @day)).to eq expected
     end
 
     it 'should accept a date' do
-      lambda { @time.on_date(Date.today) }.should_not raise_error(ArgumentError)
+      expect { @time.on_date(Date.today) }.to_not raise_error
     end
 
     it 'should return the same time on the specified date' do
       @date = Date.today - 2345
       expected = Time.local(@date.year, @date.month, @date.day, @time.hour, @time.min, @time.sec)
-      @time.on_date(@date).should == expected
+      expect(@time.on_date(@date)).to eq expected
     end
   end
 
   it "should provide 'on' as an alias" do
     expected = Time.local(@year, @month, @day, @time.hour, @time.min, @time.sec)
-    @time.on(@year, @month, @day).should == expected
+    expect(@time.on(@year, @month, @day)).to eq expected
   end
 end

data/spec/trackable_date_set_spec.rb

@@ -7,27 +7,27 @@ describe Timely::TrackableDateSet, ' tracking 7 days' do
   end
 
   it "should start on the first date" do
-    @trackable_date_set.start_date.should == Date.today
+    expect(@trackable_date_set.start_date).to eq Date.today
   end
 
   it "should end on the last date" do
-    @trackable_date_set.end_date.should == Date.today + 6
+    expect(@trackable_date_set.end_date).to eq Date.today + 6
   end
 
   it "should have the 7 days set" do
-    get_dates.should == @range.to_a
-    @trackable_date_set.duration.should == 7
-    @trackable_date_set.number_of_nights.should == 7
+    expect(get_dates).to eq @range.to_a
+    expect(@trackable_date_set.duration).to eq 7
+    expect(@trackable_date_set.number_of_nights).to eq 7
   end
 
   it "should have all the 7 days to do" do
-    get_dates_to_do.should == @range.to_a
+    expect(get_dates_to_do).to eq @range.to_a
     should_not_have_done(@range.to_a)
   end
 
   it "should have only the last 6 days to do when we set_done! the first one" do
     @trackable_date_set.set_date_done!(Date.today)
-    get_dates_to_do.should == ((Date.today + 1)..(Date.today + 6)).to_a
+    expect(get_dates_to_do).to eq ((Date.today + 1)..(Date.today + 6)).to_a
 
     should_not_have_done(@range.to_a - [Date.today])
     should_have_done([Date.today])
@@ -37,33 +37,33 @@ describe Timely::TrackableDateSet, ' tracking 7 days' do
     dates_to_be_done = [Date.today + 1, Date.today + 2, Date.today + 3]
     @trackable_date_set.set_dates_done!(dates_to_be_done)
 
-    get_dates_to_do.should == [Date.today, Date.today + 4, Date.today + 5, Date.today + 6]
+    expect(get_dates_to_do).to eq [Date.today, Date.today + 4, Date.today + 5, Date.today + 6]
     should_not_have_done(@range.to_a - dates_to_be_done)
     should_have_done(dates_to_be_done)
   end
 
   it "should have none left to do when set_all_done!" do
     @trackable_date_set.set_all_done!
-    get_dates_to_do.should == []
+    expect(get_dates_to_do).to eq []
     should_have_done(@range.to_a)
   end
 
   it 'should have no actions applied' do
-    @trackable_date_set.action_applied?(:some_action).should == false
+    expect(@trackable_date_set.action_applied?(:some_action)).to be false
   end
 
   it 'should remember if we apply an action' do
     @trackable_date_set.apply_action(:some_action)
-    @trackable_date_set.action_applied?(:some_action).should == true
-    @trackable_date_set.action_applied?(:some_other_action).should == false
+    expect(@trackable_date_set.action_applied?(:some_action)).to be true
+    expect(@trackable_date_set.action_applied?(:some_other_action)).to be false
   end
 
   def should_have_done(dates)
-    dates.each{|date| @trackable_date_set.has_done?(date).should == true }
+    dates.each{|date| expect(@trackable_date_set.has_done?(date)).to be true }
   end
 
   def should_not_have_done(dates)
-    dates.each{|date| @trackable_date_set.has_done?(date).should == false }
+    dates.each{|date| expect(@trackable_date_set.has_done?(date)).to be false }
   end
 
   def get_dates

data/spec/week_days_spec.rb

@@ -8,44 +8,44 @@ describe Timely::WeekDays do
   it 'should create via hash, integer and array' do
     # 0   0   1   0   1   0   0
     # Sat Fri Thu Wed Tue Mon Sun
-    Timely::WeekDays.new(0b0010100).weekdays.should == [:tue, :thu]
-    Timely::WeekDays.new(%w(0 0 1 0 1 0 0)).weekdays.should == [:tue, :thu]
-    Timely::WeekDays.new(:tue => true, :thu => true).weekdays.should == [:tue, :thu]
+    expect(Timely::WeekDays.new(0b0010100).weekdays).to eq [:tue, :thu]
+    expect(Timely::WeekDays.new(%w(0 0 1 0 1 0 0)).weekdays).to eq [:tue, :thu]
+    expect(Timely::WeekDays.new(:tue => true, :thu => true).weekdays).to eq [:tue, :thu]
   end
 
   it 'should be able to set/unset days' do
     @weekdays[:mon] = true
-    @weekdays.weekdays.should == [:mon, :tue, :thu]
+    expect(@weekdays.weekdays).to eq [:mon, :tue, :thu]
     @weekdays[:tue] = false
-    @weekdays.weekdays.should == [:mon, :thu]
+    expect(@weekdays.weekdays).to eq [:mon, :thu]
   end
 
   it 'should output days nicely' do 
-    Timely::WeekDays.new(%w(1 0 0 0 0 0 0)).to_s.should == "Sun"
-    Timely::WeekDays.new(%w(1 0 1 0 0 0 0)).to_s.should == "Sun, and Tue"
-    Timely::WeekDays.new(%w(1 0 1 1 0 0 0)).to_s.should == "Sun, Tue, and Wed"
-    Timely::WeekDays.new(%w(1 0 1 1 0 1 0)).to_s.should == "Sun, Tue, Wed, and Fri"    
+    expect(Timely::WeekDays.new(%w(1 0 0 0 0 0 0)).to_s).to eq "Sun"
+    expect(Timely::WeekDays.new(%w(1 0 1 0 0 0 0)).to_s).to eq "Sun, and Tue"
+    expect(Timely::WeekDays.new(%w(1 0 1 1 0 0 0)).to_s).to eq "Sun, Tue, and Wed"
+    expect(Timely::WeekDays.new(%w(1 0 1 1 0 1 0)).to_s).to eq "Sun, Tue, Wed, and Fri"    
   end
 
   it 'should be able to determine if days of the week are selected' do
     # Test mon and tue in both symbol/integer forms
-    @weekdays.has_day?(1).should be_false
-    @weekdays.has_day?(:mon).should be_false
-    @weekdays.has_day?(2).should be_true
-    @weekdays.has_day?(:tue).should be_true
+    expect(@weekdays.has_day?(1)).to be false
+    expect(@weekdays.has_day?(:mon)).to be false
+    expect(@weekdays.has_day?(2)).to be true
+    expect(@weekdays.has_day?(:tue)).to be true
   end
 
   it 'should be able to determine if it would be applicable on a date' do
-    @weekdays.applies_for_date?(Date.new(2012, 04, 22)).should be_false # Sunday
-    @weekdays.applies_for_date?(Date.new(2012, 04, 24)).should be_true  # Tuesday
+    expect(@weekdays.applies_for_date?(Date.new(2012, 04, 22))).to be false # Sunday
+    expect(@weekdays.applies_for_date?(Date.new(2012, 04, 24))).to be true  # Tuesday
   end
 
   it 'should be able to convert to integer for use in databases, etc.' do
-    @weekdays.weekdays_int.should == 4 + 16 # 4 = Tue, 16 = Thu
+    expect(@weekdays.weekdays_int).to eq 4 + 16 # 4 = Tue, 16 = Thu
   end
 
   it 'should be able to determine if all days are selected' do
-    Timely::WeekDays.new(%w(1 1 1 1 1 1 1)).all_days?.should be_true
-    Timely::WeekDays.new(%w(1 1 1 1 1 0 1)).all_days?.should be_false
+    expect(Timely::WeekDays.new(%w(1 1 1 1 1 1 1)).all_days?).to be true
+    expect(Timely::WeekDays.new(%w(1 1 1 1 1 0 1)).all_days?).to be false
   end
 end