timely 0.0.2 → 0.1.0

data/lib/timely/time_since.rb

@@ -0,0 +1,17 @@
+module Timely
+  module TimeSince
+    def seconds_since
+      ::DateTime.now.to_i - self.to_i
+    end
+
+    def minutes_since
+      seconds_since/60
+    end
+
+    def hours_since
+      minutes_since/60
+    end
+  end
+end
+
+DateTime.send :include, Timely::TimeSince

data/lib/timely/version.rb

@@ -0,0 +1,3 @@
+module Timely
+  VERSION = "0.1.0"
+end

data/spec/calendar_tag_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+class ActionViewTest
+  include Timely::ActionViewHelpers::FormTagHelper
+end
+
+describe Timely::ActionViewHelpers do
+  subject { ActionViewTest.new }
+  let(:string) { double(:string) }
+  let(:date) { Date.new(2000, 12, 25) }
+  before {
+    expect(date).to receive(:to_s).with(:calendar).and_return('25-12-2000')
+    expect(Timely).to receive(:current_date).and_return(date)
+  }
+
+  it 'should generate calendar tags' do
+    expect(string).to receive(:html_safe)
+    expect(subject).to receive(:tag).with(:input,
+      :id    => 'test',
+      :class => 'datepicker input-small',
+      :size  => 10,
+      :maxlength => 10,
+      :name  => 'test',
+      :type  => 'text',
+      :value => '25-12-2000'
+    ).and_return(string)
+    subject.calendar_tag :test
+  end
+end

data/spec/date_chooser_spec.rb

@@ -8,61 +8,70 @@ describe Timely::DateChooser do
 
   #Validation
   it "rejects blank FROM dates" do
-    lambda { Timely::DateChooser.new({:from=>""}) }.should raise_error(Timely::DateChooserException)
+    expect { Timely::DateChooser.new({:from=>""}) }.to raise_error(
+      Timely::DateChooserException, 'A Start Date is required')
   end
 
   it "rejects TO dates later than FROM dates" do
-    lambda {Timely::DateChooser.new(
+    expect {Timely::DateChooser.new(
       :multiple_dates => true, :from => @from + 10, :to => @from
-    )}.should raise_error(Timely::DateChooserException)
+    )}.to raise_error(Timely::DateChooserException, 'Start Date is after End Date')
   end
 
   #Operation
   it "returns today if client only wants single date" do
-    Timely::DateChooser.new(
+    expect(Timely::DateChooser.new(
       :multiple_dates => false, :from => @from
-    ).choose_dates.should == [@from]
+    ).choose_dates).to eq [@from]
   end
 
   #Test specific date of month
   it "returns from and to as same (one) day in the case that only from date is given" do
-    Timely::DateChooser.new(
+    expect(Timely::DateChooser.new(
       :multiple_dates => true, :from => @from, :to => ''
-    ).choose_dates.should == [@from]
+    ).choose_dates).to eq [@from]
   end
 
   it "returns all days between from and to days in the basic case" do
-    Timely::DateChooser.new(
+    expect(Timely::DateChooser.new(
       :multiple_dates => true, :from => @from, :to => @to
-    ).choose_dates.should == (@from..@to).to_a
+    ).choose_dates).to eq (@from..@to).to_a
   end
 
-  it "returns the specific dates if this option is picked" do
-    Timely::DateChooser.new(
+  it "returns the recurring dates within the range if this option is picked" do
+    expect(Timely::DateChooser.new(
       :multiple_dates => true, :select => 'days', :dates => '1,11,3', :from => @from, :to => @to
-    ).choose_dates.should == [
+    ).choose_dates).to eq [
       "1-01-2011", "3-01-2011", "11-01-2011", "1-02-2011",
       "3-02-2011", "11-02-2011", "1-03-2011"
     ].map(&:to_date)
   end
 
+  it "returns the specific dates, within or outside of the range, if this option is picked" do
+    expect(Timely::DateChooser.new(
+      :multiple_dates => true, :select => 'specific_days', :specific_dates => '11-01-2011, 18-02-2011, 22-06-2011', :from => @from, :to => @to
+    ).choose_dates).to eq [
+      "11-01-2011", "18-02-2011", "22-06-2011"
+    ].map(&:to_date)
+  end
+
   #Test days of week, every X weeks
   it "returns every sunday correctly" do
-    Timely::DateChooser.new(
+    expect(Timely::DateChooser.new(
       :multiple_dates => true, :select => 'weekdays', :from => @from, :to => @to,
-      :interval => {:level => "1", :unit => "w"}, :weekdays => {:sun => true}
-    ).choose_dates.should == [
+      :interval => {:level => "1", :unit => "week"}, :weekdays => {:sun => true}
+    ).choose_dates).to eq [
       "2-01-2011", "9-01-2011", "16-01-2011", "23-01-2011", "30-01-2011",
       "06-02-2011", "13-02-2011", "20-02-2011", "27-02-2011"
     ].map(&:to_date)
   end
 
   it "returns every thursday and sunday correctly" do
-    Timely::DateChooser.new(
+    expect(Timely::DateChooser.new(
       :multiple_dates => true, :select => 'weekdays',
-      :interval => {:level => "1", :unit => "w"},
+      :interval => {:level => "1", :unit => "week"},
       :weekdays => {:sun => true, :thu => true}, :from => @from, :to => @to
-    ).choose_dates.should == [
+    ).choose_dates).to eq [
       "2-01-2011", "6-01-2011", "9-01-2011", "13-01-2011", "16-01-2011",
       "20-01-2011", "23-01-2011", "27-01-2011", "30-01-2011", "3-02-2011",
       "06-02-2011", "10-02-2011", "13-02-2011", "17-02-2011", "20-02-2011",
@@ -71,11 +80,11 @@ describe Timely::DateChooser do
   end
 
   it "returns every 2nd thursday and sunday correctly" do
-    Timely::DateChooser.new(
+    expect(Timely::DateChooser.new(
       :multiple_dates => true, :select => 'weekdays',
-      :interval => {:level => "2", :unit => "w"},
+      :interval => {:level => "2", :unit => "week"},
       :weekdays => {:sun => "1", :thu => "1"}, :from => @from, :to => @to
-    ).choose_dates.should == [
+    ).choose_dates).to eq [
       "2-01-2011", "6-01-2011", "16-01-2011", "20-01-2011", "30-01-2011",
       "3-02-2011", "13-02-2011", "17-02-2011", "27-02-2011"
     ].map(&:to_date)
@@ -83,18 +92,18 @@ describe Timely::DateChooser do
 
   #Test correct results for every Nth week of month
   it "returns every 1st Tuesday" do
-    Timely::DateChooser.new(
+    expect(Timely::DateChooser.new(
       :multiple_dates => true, :select => 'weekdays', :from => @from, :to => @to,
-      :interval => {:level => "1", :unit => "wom"}, :weekdays => {:tue => true}
-    ).choose_dates.should == ["4-01-2011", "1-02-2011", "1-03-2011"].map(&:to_date)
+      :interval => {:level => "1", :unit => "week_of_month"}, :weekdays => {:tue => true}
+    ).choose_dates).to eq ["4-01-2011", "1-02-2011", "1-03-2011"].map(&:to_date)
   end
 
   it "returns every 3st Monday and Friday" do
-    Timely::DateChooser.new(
+    expect(Timely::DateChooser.new(
       :multiple_dates => true, :select => 'weekdays',
-      :interval => {:level => "3", :unit => "wom"},
+      :interval => {:level => "3", :unit => "week_of_month"},
       :weekdays => {:mon => true, :fri => true}, :from => @from, :to => @to
-    ).choose_dates.should == [
+    ).choose_dates).to eq [
       "17-01-2011", "21-01-2011", "18-02-2011", "21-02-2011"
     ].map(&:to_date)
   end

data/spec/date_group_spec.rb

@@ -1,16 +1,16 @@
 require "spec_helper"
 describe Timely::DateGroup do
   before do
-    @date_group = Timely::DateGroup.create!(
+    @date_group = Timely::DateGroup.new(
       :start_date => '2000-01-01', :end_date => '2000-01-03', :weekdays => %w(1 1 1 1 1 1 1)
     )
   end
 
   it 'should detect overlaps' do
-    @date_group.applicable_for_duration?(Timely::DateRange.new('2000-01-01'.to_date, '2000-01-01'.to_date)).should be_true
-    @date_group.applicable_for_duration?(Timely::DateRange.new('2000-01-01'.to_date, '2000-01-06'.to_date)).should be_true
-    @date_group.applicable_for_duration?(Timely::DateRange.new('2001-01-01'.to_date, '2001-01-01'.to_date)).should be_false
-    @date_group.applicable_for_duration?(Timely::DateRange.new('1999-12-29'.to_date, '2000-01-05'.to_date)).should be_true 
+    expect(@date_group.applicable_for_duration?(Timely::DateRange.new('2000-01-01'.to_date, '2000-01-01'.to_date))).to be true
+    expect(@date_group.applicable_for_duration?(Timely::DateRange.new('2000-01-01'.to_date, '2000-01-06'.to_date))).to be true
+    expect(@date_group.applicable_for_duration?(Timely::DateRange.new('2001-01-01'.to_date, '2001-01-01'.to_date))).to be false
+    expect(@date_group.applicable_for_duration?(Timely::DateRange.new('1999-12-29'.to_date, '2000-01-05'.to_date))).to be true 
   end
 
   it "should detect overlaps when certain weekdays aren't selected" do
@@ -18,9 +18,9 @@ describe Timely::DateGroup do
       :start_date => '2012-01-01', :end_date => '2012-01-07', :weekdays => %w(1 0 1 0 1 0 1)
     )
     # Note: 2012-01-1 is a Sunday
-    @date_group.applicable_for_duration?(Timely::DateRange.new('2012-01-01'.to_date, '2012-01-01'.to_date)).should be_true
-    @date_group.applicable_for_duration?(Timely::DateRange.new('2012-01-02'.to_date, '2012-01-02'.to_date)).should be_false
-    @date_group.applicable_for_duration?(Timely::DateRange.new('2012-01-03'.to_date, '2012-01-03'.to_date)).should be_true
-    @date_group.applicable_for_duration?(Timely::DateRange.new('2012-01-01'.to_date, '2012-01-03'.to_date)).should be_true
+    expect(@date_group.applicable_for_duration?(Timely::DateRange.new('2012-01-01'.to_date, '2012-01-01'.to_date))).to be true
+    expect(@date_group.applicable_for_duration?(Timely::DateRange.new('2012-01-02'.to_date, '2012-01-02'.to_date))).to be false
+    expect(@date_group.applicable_for_duration?(Timely::DateRange.new('2012-01-03'.to_date, '2012-01-03'.to_date))).to be true
+    expect(@date_group.applicable_for_duration?(Timely::DateRange.new('2012-01-01'.to_date, '2012-01-03'.to_date))).to be true
   end
 end

data/spec/date_range_spec.rb

@@ -3,38 +3,76 @@ require 'spec_helper'
 describe Timely::DateRange do
   
   it "should allow initialization with two dates" do
-    lambda { @date_range = Timely::DateRange.new(Date.today, Date.today + 3) }.should_not raise_error
-    @date_range.start_date.should eql Date.today
-    @date_range.end_date.should eql Date.today + 3
+    expect { @date_range = Timely::DateRange.new(Date.today, Date.today + 3) }.to_not raise_error
+    expect(@date_range.start_date).to eq Date.today
+    expect(@date_range.end_date).to eq Date.today + 3
+    expect(@date_range.number_of_nights).to eq 4
   end
   
   it "should allow initialization with one date" do
-    lambda { @date_range = Timely::DateRange.new(Date.today) }.should_not raise_error
-    @date_range.start_date.should eql Date.today
-    @date_range.end_date.should eql Date.today
+    expect { @date_range = Timely::DateRange.new(Date.today) }.to_not raise_error
+    expect(@date_range.start_date).to eq Date.today
+    expect(@date_range.end_date).to eq Date.today
+    expect(@date_range.number_of_nights).to eq 1
   end
   
   it "should allow initialization with a range" do
-    lambda { @date_range = Timely::DateRange.new(Date.today..Date.today + 3) }.should_not raise_error
-    @date_range.start_date.should eql Date.today
-    @date_range.end_date.should eql Date.today + 3
+    expect { @date_range = Timely::DateRange.new(Date.today..Date.today + 3) }.to_not raise_error
+    expect(@date_range.start_date).to eq Date.today
+    expect(@date_range.end_date).to eq Date.today + 3
+  end
+
+  it 'should print a readable version of time between two dates' do
+    expect(Timely::DateRange.new('2000-01-04'.to_date, '2000-01-04'.to_date).to_s).to eq '2000-01-04'
+    expect(Timely::DateRange.new('2000-01-04'.to_date, '2000-01-06'.to_date).to_s).to eq '2000-01-04 to 2000-01-06 (inclusive)'
+    expect(Timely::DateRange.new('2000-01-01'.to_date, '2000-05-31'.to_date).to_s).to eq 'Jan 2000 to May 2000'
+    expect(Timely::DateRange.new('2000-01-01'.to_date, '2000-01-31'.to_date).to_s).to eq 'Jan 2000'
+    Date::DATE_FORMATS[:short] = '%Y-%m-%d'
+    expect(Timely::DateRange.to_s('2000-01-01'.to_date, nil)).to eq 'on or after 2000-01-01'
+    expect(Timely::DateRange.to_s(nil, '2000-01-31'.to_date)).to eq 'on or before 2000-01-31'
+    expect(Timely::DateRange.to_s(nil, nil)).to eq 'no date range'
+  end
+
+  let(:fourth) { '2000-01-04'.to_date }
+  let(:fifth)  { '2000-01-05'.to_date }
+  let(:sixth)  { '2000-01-06'.to_date }
+
+  it 'should print a readable version of time between two times' do
+    expect(Timely::DateRange.to_s(fourth.at(9, 30), sixth.at(4, 20)))
+      .to eq '2000-01-04 09:30 to 2000-01-06 04:20'
+    expect(Timely::DateRange.to_s(fourth.at(9, 30)))
+      .to eq 'on or after 2000-01-04 09:30'
+  end
+
+  it 'should handle params' do
+    today = Timely::DateRange.from_params('2000-01-04')
+    expect(today.first).to eq '2000-01-04'.to_date
+    expect(today.last).to eq '2000-01-04'.to_date
+
+    today = Timely::DateRange.from_params('2000-01-04', '2')
+    expect(today.first).to eq '2000-01-04'.to_date
+    expect(today.last).to eq '2000-01-05'.to_date
+
+    today = Timely::DateRange.from_params('2000-01-04', 2)
+    expect(today.first).to eq '2000-01-04'.to_date
+    expect(today.last).to eq '2000-01-05'.to_date
   end
 
   it "should correctly find the interesection between two date ranges" do
     @date_range = Timely::DateRange.new("2000-01-03".to_date, "2000-01-06".to_date)
-    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-04".to_date, "2000-01-07".to_date)).should == ("2000-01-04".to_date.."2000-01-06".to_date)
-    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-01".to_date, "2000-01-02".to_date)).should == []
-    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-01".to_date, "2000-01-03".to_date)).should == ("2000-01-03".to_date.."2000-01-03".to_date)
-    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-06".to_date, "2000-01-07".to_date)).should == ("2000-01-06".to_date.."2000-01-06".to_date)
-    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-06".to_date, "2000-01-07".to_date)).should == ("2000-01-06".to_date.."2000-01-06".to_date)
-    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-04".to_date, "2000-01-05".to_date)).should == ("2000-01-04".to_date.."2000-01-05".to_date)
-    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-05".to_date, "2000-01-05".to_date)).should == ("2000-01-05".to_date.."2000-01-05".to_date)
+    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-04".to_date, "2000-01-07".to_date))).to eq ("2000-01-04".to_date.."2000-01-06".to_date)
+    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-01".to_date, "2000-01-02".to_date))).to eq []
+    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-01".to_date, "2000-01-03".to_date))).to eq ("2000-01-03".to_date.."2000-01-03".to_date)
+    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-06".to_date, "2000-01-07".to_date))).to eq ("2000-01-06".to_date.."2000-01-06".to_date)
+    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-06".to_date, "2000-01-07".to_date))).to eq ("2000-01-06".to_date.."2000-01-06".to_date)
+    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-04".to_date, "2000-01-05".to_date))).to eq ("2000-01-04".to_date.."2000-01-05".to_date)
+    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-05".to_date, "2000-01-05".to_date))).to eq ("2000-01-05".to_date.."2000-01-05".to_date)
 
     @date_range = Timely::DateRange.new("2000-01-03".to_date, "2000-01-03".to_date)
-    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-04".to_date, "2000-01-07".to_date)).should == []
-    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-01".to_date, "2000-01-03".to_date)).should == ("2000-01-03".to_date.."2000-01-03".to_date)
-    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-03".to_date, "2000-01-05".to_date)).should == ("2000-01-03".to_date.."2000-01-03".to_date)
-    @date_range.intersecting_dates(Timely::DateRange.new("2000-01-02".to_date, "2000-01-04".to_date)).should == ("2000-01-03".to_date.."2000-01-03".to_date)
+    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-04".to_date, "2000-01-07".to_date))).to eq []
+    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-01".to_date, "2000-01-03".to_date))).to eq ("2000-01-03".to_date.."2000-01-03".to_date)
+    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-03".to_date, "2000-01-05".to_date))).to eq ("2000-01-03".to_date.."2000-01-03".to_date)
+    expect(@date_range.intersecting_dates(Timely::DateRange.new("2000-01-02".to_date, "2000-01-04".to_date))).to eq ("2000-01-03".to_date.."2000-01-03".to_date)
   end
   
 end

data/spec/date_spec.rb

@@ -1,5 +1,13 @@
 require 'spec_helper'
 
+describe Date do
+  it 'should determine if date between' do
+    expect(Date.today.between?(nil, nil)).to be true
+    expect(Date.today.between?(Date.today - 1, Date.today - 1)).to be false
+    expect(Date.today.between?(Date.today - 1, nil)).to be true
+  end
+end
+
 describe Date do
   before :each do
     @date = Date.today - 5
@@ -10,59 +18,59 @@ describe Date do
   end
 
   it 'should give a time on that date' do
-    @date.should respond_to(:at_time)
+    expect(@date).to respond_to(:at_time)
   end
 
   describe 'giving a time on that date' do
     it 'should accept hour, minute, and second' do
-      lambda { @date.at_time(@hour, @minute, @second) }.should_not raise_error(ArgumentError)
+      expect { @date.at_time(@hour, @minute, @second) }.to_not raise_error
     end
 
     it 'should accept hour and minute' do
-      lambda { @date.at_time(@hour, @minute) }.should_not raise_error(ArgumentError)
+      expect { @date.at_time(@hour, @minute) }.to_not raise_error
     end
 
     it 'should accept hour' do
-      lambda { @date.at_time(@hour) }.should_not raise_error(ArgumentError)
+      expect { @date.at_time(@hour) }.to_not raise_error
     end
 
     it 'should accept no arguments' do
-      lambda { @date.at_time }.should_not raise_error(ArgumentError)
+      expect { @date.at_time }.to_not raise_error
     end
 
     it 'should return a time for the given hour, minute, and second if all three are specified' do
       expected = Time.local(@date.year, @date.month, @date.day, @hour, @minute, @second)
-      @date.at_time(@hour, @minute, @second).should == expected
+      expect(@date.at_time(@hour, @minute, @second)).to eq expected
     end
 
     it 'should default second to 0 if unspecified' do
       expected = Time.local(@date.year, @date.month, @date.day, @hour, @minute, 0)
-      @date.at_time(@hour, @minute).should == expected
+      expect(@date.at_time(@hour, @minute)).to eq expected
     end
 
     it 'should default minute to 0 if unspecified' do
       expected = Time.local(@date.year, @date.month, @date.day, @hour, 0, 0)
-      @date.at_time(@hour).should == expected
+      expect(@date.at_time(@hour)).to eq expected
     end
 
     it 'should default hour to 0 if unspecified' do
       expected = Time.local(@date.year, @date.month, @date.day, 0, 0, 0)
-      @date.at_time.should == expected
+      expect(@date.at_time).to eq expected
     end
 
     it 'should accept a time' do
-      lambda { @date.at_time(Time.now) }.should_not raise_error(ArgumentError)
+      expect { @date.at_time(Time.now) }.to_not raise_error
     end
 
     it 'should return the passed-in time on the date' do
       @time = Time.now - 12345
       expected = Time.local(@date.year, @date.month, @date.day, @time.hour, @time.min, @time.sec)
-      @date.at_time(@time).should == expected
+      expect(@date.at_time(@time)).to eq expected
     end
   end
 
   it "should provide 'at' as an alias" do
     expected = Time.local(@date.year, @date.month, @date.day, @hour, @minute, @second)
-    @date.at(@hour, @minute, @second).should == expected
+    expect(@date.at(@hour, @minute, @second)).to eq expected
   end
 end

data/spec/extensions_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'timely/rails/extensions'
+
+describe Timely::Extensions do
+  before do
+    class TimelyExtensionsTestSeasonal < ActiveRecord::Base
+      self.table_name = 'seasonals'
+      acts_as_seasonal
+    end
+  end
+
+  after { Object.send(:remove_const, 'TimelyExtensionsTestSeasonal') }
+
+  it 'should cache boundary start' do
+    season = Timely::Season.new
+    season.date_groups.build(:start_date => Date.current, :end_date => Date.current + 2)
+    season.date_groups.build(:start_date => Date.current - 1, :end_date => Date.current + 1)
+    season.save!
+
+    o = TimelyExtensionsTestSeasonal.new
+    o.season = season
+    o.save!
+    expect(o.boundary_start).to eq Date.current - 1
+    expect(o.boundary_end  ).to eq Date.current + 2
+
+    expect(TimelyExtensionsTestSeasonal.season_on(Date.current + 3)).to be_empty
+    expect(TimelyExtensionsTestSeasonal.season_on(Date.current + 2)).to eq [o]
+    expect(TimelyExtensionsTestSeasonal.season_on(Date.current - 1)).to eq [o]
+    expect(TimelyExtensionsTestSeasonal.season_on(Date.current - 2)).to be_empty
+
+  end
+end

data/spec/rails/date_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Date do
+  let(:date) { Date.parse("2010-01-01") }
+
+  before { Time.zone = ActiveSupport::TimeZone["Adelaide"] }
+
+  subject(:converted) { date.to_time_in_time_zone }
+
+  it "should convert to time in time zone" do
+    expect(converted.year).to eq date.year
+    expect(converted.month).to eq date.month
+    expect(converted.day).to eq date.day
+    expect(converted.time_zone).to eq Time.zone
+  end
+end