chronological 0.0.9 → 1.0.0beta1

data/spec/strategies/base_spec.rb

@@ -0,0 +1,296 @@
+require 'spec_helper'
+require 'ostruct'
+
+describe Chronological::BaseStrategy do
+  let(:strategy)    { Chronological::BaseStrategy.new(field_names)  }
+  let(:chrono)      { OpenStruct.new(fields)                        }
+  let(:fields)      { nil                                           }
+  let(:field_names) do
+    { starting_time:  :start_time,
+      ending_time:    :end_time }
+  end
+
+  describe '#starting_date' do
+    context 'when working with a date/time' do
+      let(:fields)  { { start_time:     Time.utc(2012, 7, 26, 7, 12, 0) } }
+
+      it 'converts it to a date only' do
+        strategy.starting_date(chrono).should eql Time.utc(2012, 7, 26, 7, 12, 0).to_date
+      end
+    end
+
+    context 'when working with a string' do
+      let(:fields) { { start_time:      '2012-07-26 03:15:12' } }
+
+      it 'properly converts the date' do
+        strategy.starting_date(chrono).should eql Time.utc(2012, 7, 26, 3, 15, 12).to_date
+      end
+    end
+
+    context 'when working with nothing' do
+      let(:fields) { { start_time:      nil } }
+
+      it 'is nil' do
+        strategy.starting_date(chrono).should be_nil
+      end
+    end
+  end
+
+  describe '#ending_date' do
+    context 'when working with a date/time' do
+      let(:fields)  { { end_time:     Time.utc(2012, 7, 26, 7, 12, 0) } }
+
+      it 'converts it to a date only' do
+        strategy.ending_date(chrono).should eql Time.utc(2012, 7, 26, 7, 12, 0).to_date
+      end
+    end
+
+    context 'when working with a string' do
+      let(:fields) { { end_time:      '2012-07-26 03:15:12' } }
+
+      it 'properly converts the date' do
+        strategy.ending_date(chrono).should eql Time.utc(2012, 7, 26, 3, 15, 12).to_date
+      end
+    end
+
+    context 'when working with nothing' do
+      let(:fields) { { end_time:      nil } }
+
+      it 'is nil' do
+        strategy.ending_date(chrono).should be_nil
+      end
+    end
+  end
+
+  describe '#inactive?' do
+    it 'is the opposite of in_progress?' do
+      chrono.should_receive(:in_progress?).and_return false
+
+      strategy.inactive?(chrono).should be_true
+    end
+  end
+
+  describe '#duration' do
+    context 'when the strategy represents something with a duration' do
+      before { strategy.should_receive(:duration_in_seconds).and_return(6263) }
+
+      it 'is a hash with the correct hours' do
+        strategy.duration(chrono)[:hours].should eql 1
+      end
+
+      it 'is a hash with the correct minutes' do
+        strategy.duration(chrono)[:minutes].should eql 44
+      end
+
+      it 'is a hash with the correct seconds' do
+        strategy.duration(chrono)[:seconds].should eql 23
+      end
+    end
+
+    context 'when the strategy represents something with an even second time duration' do
+      before { strategy.should_receive(:duration_in_seconds).and_return(6240) }
+
+      it 'is a hash with the correct hours' do
+        strategy.duration(chrono)[:hours].should eql 1
+      end
+
+      it 'is a hash with the correct minutes' do
+        strategy.duration(chrono)[:minutes].should eql 44
+      end
+
+      it 'is a hash with the correct seconds' do
+        strategy.duration(chrono)[:seconds].should eql 0
+      end
+    end
+
+    context 'when the strategy represents something with an even minute time duration' do
+      before { strategy.should_receive(:duration_in_seconds).and_return(3600) }
+
+      it 'is a hash with the correct hours' do
+        strategy.duration(chrono)[:hours].should eql 1
+      end
+
+      it 'is a hash with the correct minutes' do
+        strategy.duration(chrono)[:minutes].should eql 0
+      end
+
+      it 'is a hash with the correct seconds' do
+        strategy.duration(chrono)[:seconds].should eql 0
+      end
+    end
+
+    context 'when the strategy represents something with a zero duration' do
+      before { strategy.should_receive(:duration_in_seconds).and_return(0) }
+
+      it 'is a hash with the correct hours' do
+        strategy.duration(chrono)[:hours].should eql 0
+      end
+
+      it 'is a hash with the correct minutes' do
+        strategy.duration(chrono)[:minutes].should eql 0
+      end
+
+      it 'is a hash with the correct seconds' do
+        strategy.duration(chrono)[:seconds].should eql 0
+      end
+    end
+
+    context 'when duration in seconds returns an empty value' do
+      before { strategy.should_receive(:duration_in_seconds).and_return(nil) }
+
+      it 'is an empty hash' do
+        strategy.duration(chrono).should eql Hash.new
+      end
+    end
+  end
+
+  describe '#in_progress?', :timecop => true do
+    let(:later) { Time.local(2012, 7, 26, 6, 0, 26) }
+    let(:now)   { Time.local(2012, 7, 26, 6, 0, 25) }
+    let(:past)  { Time.local(2012, 7, 26, 6, 0, 24) }
+
+    before      { Timecop.freeze(now)             }
+
+    context 'when it does not have an absolute timeframe' do
+      before { strategy.should_receive(:has_absolute_timeframe?).and_return(false) }
+
+      it 'is false' do
+        strategy.in_progress?(chrono).should_not be_true
+      end
+    end
+
+    context 'when it does have an absolute timeframe' do
+      before { strategy.should_receive(:has_absolute_timeframe?).and_return(true) }
+
+      context 'and it has already started' do
+        context 'and already ended' do
+          let(:fields) do
+            { start_time: past,
+              end_time:   past }
+          end
+
+          it 'is false' do
+            strategy.in_progress?(chrono).should_not be_true
+          end
+        end
+
+        context 'and ends now' do
+          let(:fields) do
+            { start_time: past,
+              end_time:   now }
+          end
+
+          it 'is false' do
+            strategy.in_progress?(chrono).should_not be_true
+          end
+        end
+
+        context 'and ends later' do
+          let(:fields) do
+            { start_time: past,
+              end_time:   later }
+          end
+
+          it 'is true' do
+            strategy.in_progress?(chrono).should be_true
+          end
+        end
+      end
+
+      context 'and there is a strategy that starts now' do
+        context 'and ends now' do
+          let(:fields) do
+            { start_time: now,
+              end_time:   now }
+          end
+
+          it 'is false' do
+            strategy.in_progress?(chrono).should_not be_true
+          end
+        end
+
+        context 'and ends later' do
+          let(:fields) do
+            { start_time: now,
+              end_time:   later }
+          end
+
+          it 'is true' do
+            strategy.in_progress?(chrono).should be_true
+          end
+        end
+      end
+
+      context 'and there is a strategy that has not yet started' do
+        let(:fields) do
+          { start_time: later,
+            end_time:   later }
+        end
+
+        it 'is false' do
+          strategy.in_progress?(chrono).should_not be_true
+        end
+      end
+    end
+  end
+
+  describe '#scheduled?' do
+    context 'when the time zone option is passed in' do
+      let(:field_names) { { time_zone: :time_zone } }
+
+      context 'and a time zone exists' do
+        let(:fields) { { time_zone: 'Alaska' } }
+
+        it 'is the time zone' do
+          strategy.scheduled?(chrono).should eql 'Alaska'
+        end
+      end
+
+      context 'and a time zone does not exist' do
+        let(:fields) { { time_zone: nil } }
+
+        it 'is the time zone' do
+          strategy.scheduled?(chrono).should be_nil
+        end
+      end
+    end
+
+    context 'when the time zone option is not passed in' do
+      let(:field_names) { Hash.new }
+
+      it 'is always true' do
+        strategy.scheduled?(chrono).should be_true
+      end
+    end
+  end
+
+  describe '#partially_scheduled?' do
+    context 'when the time zone option is passed in' do
+      let(:field_names) { { time_zone: :time_zone } }
+
+      context 'and a time zone exists' do
+        let(:fields) { { time_zone: 'Alaska' } }
+
+        it 'is the time zone' do
+          strategy.partially_scheduled?(chrono).should eql 'Alaska'
+        end
+      end
+
+      context 'and a time zone does not exist' do
+        let(:fields) { { time_zone: nil } }
+
+        it 'is the time zone' do
+          strategy.partially_scheduled?(chrono).should be_nil
+        end
+      end
+    end
+
+    context 'when the time zone option is not passed in' do
+      let(:field_names) { Hash.new }
+
+      it 'is always false' do
+        strategy.partially_scheduled?(chrono).should be_false
+      end
+    end
+  end
+end

data/spec/{relative_timeframe_spec.rb → strategies/relative_spec.rb}

@@ -1,14 +1,15 @@
 require 'spec_helper'
 
 class RelativeChronologicable < ActiveRecord::Base
-  include Chronological::RelativeTimeframe
+  extend Chronological
 
-  relative_timeframe start:    :starting_offset,
-                     end:      :ending_offset,
-                     base_utc: :base_datetime_utc
+  timeframe type:             :relative,
+            starting_offset:  :starting_offset,
+            ending_offset:    :ending_offset,
+            base_of_offset:   :base_datetime_utc
 end
 
-describe Chronological::RelativeTimeframe do
+describe Chronological::RelativeStrategy, :timecop => true do
   let(:now)             { nil }
   let(:starting_offset) { nil }
   let(:ending_offset)   { nil }
@@ -23,10 +24,133 @@ describe Chronological::RelativeTimeframe do
 
   before { Timecop.freeze(now) }
 
-  it { RelativeChronologicable.new.respond_to?(:active?).should  be_true }
+  describe '.by_date' do
+    before { RelativeChronologicable.delete_all }
 
-  it { RelativeChronologicable.respond_to?(:active?).should      be_true }
-  it { RelativeChronologicable.respond_to?(:active).should       be_true }
+    context 'when there are two chronologicables that start at the same time' do
+      context 'but end at different times' do
+        let!(:chronologicable_1) { RelativeChronologicable.create(:base_datetime_utc => Time.now, :starting_offset => 3, :ending_offset => 2) }
+        let!(:chronologicable_2) { RelativeChronologicable.create(:base_datetime_utc => Time.now, :starting_offset => 3, :ending_offset => 1) }
+
+        context 'when no option is passed' do
+          it 'properly sorts them in ascending order' do
+            RelativeChronologicable.by_date.first.should  eql chronologicable_1
+            RelativeChronologicable.by_date.last.should   eql chronologicable_2
+          end
+        end
+
+        context 'when the :desc option is passed' do
+          it 'sorts them backwards by the start date' do
+            RelativeChronologicable.by_date(:desc).first.should  eql chronologicable_2
+            RelativeChronologicable.by_date(:desc).last.should   eql chronologicable_1
+          end
+        end
+      end
+
+      context 'and end at the same time' do
+        let!(:chronologicable_1) { RelativeChronologicable.create(:base_datetime_utc => Time.now, :starting_offset => 3, :ending_offset => 2) }
+        let!(:chronologicable_2) { RelativeChronologicable.create(:base_datetime_utc => Time.now, :starting_offset => 3, :ending_offset => 2) }
+
+        describe '.by_date' do
+          context 'when in ascending order' do
+            it 'does not matter what order they are in as long as they are all there' do
+              RelativeChronologicable.by_date.should  include chronologicable_1
+              RelativeChronologicable.by_date.should  include chronologicable_2
+            end
+          end
+
+          context 'when in descending order' do
+            it 'does not matter what order they are in as long as they are all there' do
+              RelativeChronologicable.by_date(:desc).should  include chronologicable_1
+              RelativeChronologicable.by_date(:desc).should  include chronologicable_2
+            end
+          end
+        end
+      end
+    end
+
+    context 'when there are two chronologicables that start at different times' do
+      context 'and end at different times' do
+        let!(:chronologicable_1) { RelativeChronologicable.create(:base_datetime_utc => Time.now, :starting_offset => 3, :ending_offset => 2) }
+        let!(:chronologicable_2) { RelativeChronologicable.create(:base_datetime_utc => Time.now, :starting_offset => 2,  :ending_offset => 1) }
+
+        context 'when in ascending order' do
+          it 'sorts them by the start date' do
+            RelativeChronologicable.by_date.first.should  eql chronologicable_1
+            RelativeChronologicable.by_date.last.should   eql chronologicable_2
+          end
+        end
+
+        context 'when in descending order' do
+          it 'sorts them backwards by the start date' do
+            RelativeChronologicable.by_date(:desc).first.should  eql chronologicable_2
+            RelativeChronologicable.by_date(:desc).last.should   eql chronologicable_1
+          end
+        end
+      end
+
+      context 'but end at the same time' do
+        let!(:chronologicable_1) { RelativeChronologicable.create(:base_datetime_utc => Time.now, :starting_offset => 3, :ending_offset => 1) }
+        let!(:chronologicable_2) { RelativeChronologicable.create(:base_datetime_utc => Time.now, :starting_offset => 2,  :ending_offset => 1) }
+
+        context 'when in ascending order' do
+          it 'sorts them by the start date' do
+            RelativeChronologicable.by_date.first.should  eql chronologicable_1
+            RelativeChronologicable.by_date.last.should   eql chronologicable_2
+          end
+        end
+
+        context 'when in descending order' do
+          it 'sorts them backwards by the start date' do
+            RelativeChronologicable.by_date(:desc).first.should  eql chronologicable_2
+            RelativeChronologicable.by_date(:desc).last.should   eql chronologicable_1
+          end
+        end
+      end
+    end
+  end
+
+  describe '.by_duration' do
+    before { RelativeChronologicable.delete_all }
+
+    context 'when there are two chronologicables that are different durations' do
+      let!(:chronologicable_1) { RelativeChronologicable.create(:base_datetime_utc => Time.now, :starting_offset => 3, :ending_offset => 2) }
+      let!(:chronologicable_2) { RelativeChronologicable.create(:base_datetime_utc => Time.now, :starting_offset => 3, :ending_offset => 1) }
+
+      context 'when no option is passed' do
+        it 'properly sorts them in ascending order' do
+          RelativeChronologicable.by_date.first.should  eql chronologicable_1
+          RelativeChronologicable.by_date.last.should   eql chronologicable_2
+        end
+      end
+
+      context 'when the :desc option is passed' do
+        it 'sorts them backwards by the start date' do
+          RelativeChronologicable.by_date(:desc).first.should  eql chronologicable_2
+          RelativeChronologicable.by_date(:desc).last.should   eql chronologicable_1
+        end
+      end
+    end
+
+    context 'when there are two chronologicables that are the same duration' do
+      let!(:chronologicable_1) { RelativeChronologicable.create(:base_datetime_utc => Time.now, :starting_offset => 3, :ending_offset => 1) }
+      let!(:chronologicable_2) { RelativeChronologicable.create(:base_datetime_utc => Time.now, :starting_offset => 3, :ending_offset => 1) }
+
+      context 'when no option is passed' do
+        it 'does not matter what order they are in' do
+          RelativeChronologicable.by_date.should  include chronologicable_1
+          RelativeChronologicable.by_date.should  include chronologicable_2
+        end
+      end
+
+      context 'when the :desc option is passed' do
+        it 'does not matter what order they are in' do
+          RelativeChronologicable.by_date(:desc).should  include chronologicable_1
+          RelativeChronologicable.by_date(:desc).should  include chronologicable_2
+        end
+      end
+    end
+  end
 
   context 'when the base time is not set' do
     let(:base_time)       { nil }
@@ -75,7 +199,7 @@ describe Chronological::RelativeTimeframe do
       end
 
       it 'does not have a start time' do
-        chronologicable.started_at_utc.should be_nil
+        chronologicable.started_at.should be_nil
       end
     end
 
@@ -103,7 +227,7 @@ describe Chronological::RelativeTimeframe do
       end
 
       it 'does not have a start time' do
-        chronologicable.started_at_utc.should be_nil
+        chronologicable.started_at.should be_nil
       end
     end
 
@@ -111,7 +235,7 @@ describe Chronological::RelativeTimeframe do
       let(:ending_offset) { 0 }
 
       it 'does not have a end time' do
-        chronologicable.ended_at_utc.should be_nil
+        chronologicable.ended_at.should be_nil
       end
     end
 
@@ -119,7 +243,7 @@ describe Chronological::RelativeTimeframe do
       let(:ending_offset) { nil }
 
       it 'does not have a end time' do
-        chronologicable.ended_at_utc.should be_nil
+        chronologicable.ended_at.should be_nil
       end
     end
 
@@ -193,7 +317,7 @@ describe Chronological::RelativeTimeframe do
       end
 
       it 'does not have a start time' do
-        chronologicable.started_at_utc.should be_nil
+        chronologicable.started_at.should be_nil
       end
     end
 
@@ -241,7 +365,7 @@ describe Chronological::RelativeTimeframe do
       end
 
       it 'calculates the correct start time' do
-        chronologicable.started_at_utc.should eql Time.local(2012, 7, 26, 6, 0, 0)
+        chronologicable.started_at.should eql Time.local(2012, 7, 26, 6, 0, 0)
       end
     end
 
@@ -249,7 +373,7 @@ describe Chronological::RelativeTimeframe do
       let(:ending_offset) { 30 }
 
       it 'calculates the correct end time' do
-        chronologicable.ended_at_utc.should eql Time.local(2012, 7, 26, 6, 0, 0)
+        chronologicable.ended_at.should eql Time.local(2012, 7, 26, 6, 0, 0)
       end
     end
 
@@ -257,7 +381,7 @@ describe Chronological::RelativeTimeframe do
       let(:ending_offset) { nil }
 
       it 'does not have a end time' do
-        chronologicable.ended_at_utc.should be_nil
+        chronologicable.ended_at.should be_nil
       end
     end
   end
@@ -270,6 +394,18 @@ describe Chronological::RelativeTimeframe do
     context 'and before the ending offset' do
       let(:ending_offset) { 30 }
 
+      it 'is not included in the started list' do
+        RelativeChronologicable.started.should_not include chronologicable
+      end
+
+      it 'is not included in the ended list' do
+        RelativeChronologicable.ended.should_not include chronologicable
+      end
+
+      it 'is included in the not yet ended list' do
+        RelativeChronologicable.not_yet_ended.should include chronologicable
+      end
+
       it 'is not included in the in progress list' do
         RelativeChronologicable.in_progress.should_not include chronologicable
       end
@@ -288,6 +424,18 @@ describe Chronological::RelativeTimeframe do
     context 'and before the ending offset' do
       let(:ending_offset) { 29 }
 
+      it 'is included in the started list' do
+        RelativeChronologicable.started.should include chronologicable
+      end
+
+      it 'is not included in the ended list' do
+        RelativeChronologicable.ended.should_not include chronologicable
+      end
+
+      it 'is included in the not yet ended list' do
+        RelativeChronologicable.not_yet_ended.should include chronologicable
+      end
+
       it 'is included in the in progress list' do
         RelativeChronologicable.in_progress.should include chronologicable
       end
@@ -300,6 +448,18 @@ describe Chronological::RelativeTimeframe do
     context 'and the same as the ending offset' do
       let(:ending_offset) { 30 }
 
+      it 'is included in the started list' do
+        RelativeChronologicable.started.should include chronologicable
+      end
+
+      it 'is included in the ended list' do
+        RelativeChronologicable.ended.should include chronologicable
+      end
+
+      it 'is not included in the not yet ended list' do
+        RelativeChronologicable.not_yet_ended.should_not include chronologicable
+      end
+
       it 'is not included in the in progress list' do
         RelativeChronologicable.in_progress.should_not include chronologicable
       end
@@ -318,6 +478,18 @@ describe Chronological::RelativeTimeframe do
     context 'and before the ending offset' do
       let(:ending_offset) { 27 }
 
+      it 'is included in the started list' do
+        RelativeChronologicable.started.should include chronologicable
+      end
+
+      it 'is not included in the ended list' do
+        RelativeChronologicable.ended.should_not include chronologicable
+      end
+
+      it 'is included in the not yet ended list' do
+        RelativeChronologicable.not_yet_ended.should include chronologicable
+      end
+
       it 'is included in the in progress list' do
         RelativeChronologicable.in_progress.should include chronologicable
       end
@@ -330,6 +502,18 @@ describe Chronological::RelativeTimeframe do
     context 'and the same as the ending offset' do
       let(:ending_offset) { 28 }
 
+      it 'is included in the started list' do
+        RelativeChronologicable.started.should include chronologicable
+      end
+
+      it 'is included in the ended list' do
+        RelativeChronologicable.ended.should include chronologicable
+      end
+
+      it 'is not included in the not yet ended list' do
+        RelativeChronologicable.not_yet_ended.should_not include chronologicable
+      end
+
       it 'is not included in the in progress list' do
         RelativeChronologicable.in_progress.should_not include chronologicable
       end
@@ -342,6 +526,18 @@ describe Chronological::RelativeTimeframe do
     context 'and after the ending offset' do
       let(:ending_offset) { 29 }
 
+      it 'is included in the started list' do
+        RelativeChronologicable.started.should include chronologicable
+      end
+
+      it 'is included in the ended list' do
+        RelativeChronologicable.ended.should include chronologicable
+      end
+
+      it 'is not included in the not yet ended list' do
+        RelativeChronologicable.not_yet_ended.should_not include chronologicable
+      end
+
       it 'is not included in the in progress list' do
         RelativeChronologicable.in_progress.should_not include chronologicable
       end

data/spec/strategy_resolver_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Chronological::StrategyResolver do
+  describe '.resolve' do
+    let(:resolved_strategy) { Chronological::StrategyResolver.resolve(options_to_resolve) }
+
+    context 'when passed a strategy name' do
+      let(:options_to_resolve) { { :type => :absolute } }
+
+      it 'resolves to the proper class' do
+        resolved_strategy.should be_a Chronological::AbsoluteStrategy
+      end
+
+      it 'tells the strategy to create itself with the default fields' do
+        Chronological::AbsoluteStrategy.should_receive(:new).with starting_time:  :started_at,
+                                                                  ending_time:    :ended_at,
+                                                                  starting_date:  :started_on,
+                                                                  ending_date:    :ended_on
+
+        resolved_strategy
+      end
+
+      context 'with some overridden field name options' do
+        let(:options_to_resolve) { {  type:           :absolute,
+                                      starting_time:  :my_starting_field } }
+
+        it 'overrides the proper default fields and tells the strategy to create itself with those' do
+          Chronological::AbsoluteStrategy.should_receive(:new).with starting_time:  :my_starting_field,
+                                                                    ending_time:    :ended_at,
+                                                                    starting_date:  :started_on,
+                                                                    ending_date:    :ended_on
+
+          resolved_strategy
+        end
+      end
+    end
+
+    context 'when passed exact field names that relate to a strategy' do
+      let(:options_to_resolve) { { starting_time: :my_starting_field,
+                                   ending_time:   :my_ending_field } }
+
+      it 'resolves the proper strategy to instantiate' do
+        resolved_strategy.should be_a Chronological::AbsoluteStrategy
+      end
+    end
+
+    context 'when passed something it does not know how to resolve' do
+      let(:options_to_resolve) { { start_me_up:                             :my_starting_field,
+                                   its_the_end_of_the_world_as_we_know_it:  :my_ending_field } }
+
+      it 'resolves the proper strategy to instantiate' do
+        lambda { Chronological::StrategyResolver.resolve(options_to_resolve) }.should raise_error Chronological::UndefinedStrategy
+      end
+    end
+  end
+end