chronological 1.0.0beta6 → 1.0.0beta7

data/README.md

@@ -252,6 +252,11 @@ default behavior which is `Time.now.utc`.  Using this option you can more easily
 see if an instance (or instances) would be started, ended, etc as of a given
 date.
 
+All range status methods can also take a `:base_of` option _this is only
+meaningful for strategies which utilize an offset for either the start
+time or the end time_ which will calculate the absolute time based on
+that time rather than any time stored within the instance.
+
 Affected methods:
 
 * `started?`

data/lib/chronological/strategies/base.rb

@@ -56,6 +56,18 @@ module Chronological
       (object.send(field_names[:starting_time]) <= Time.now.utc) && object.send(field_names[:ending_time]).future?
     end
 
+    def started?(object, options = {})
+      Time.now >= object.send(field_names[:starting_time], options)
+    end
+
+    def ended?(object, options = {})
+      Time.now >= object.send(field_names[:ending_time], options)
+    end
+
+    def not_yet_ended?(object, options = {})
+      !ended?(object, options)
+    end
+
     ###
     # Scopes
     #

data/lib/chronological/strategies/relative.rb

@@ -1,15 +1,19 @@
 module Chronological
   class RelativeStrategy < BaseStrategy
-    def starting_time(object)
-      return nil unless object.send(field_names[:base_of_offset]).present? && object.send(field_names[:starting_offset]).present?
+    def starting_time(object, options = {})
+      base_of_offset = options[:base_of] || object.send(field_names[:base_of_offset])
 
-      object.send(field_names[:base_of_offset]) - object.send(field_names[:starting_offset])
+      return nil unless base_of_offset.present? && object.send(field_names[:starting_offset]).present?
+
+      base_of_offset - object.send(field_names[:starting_offset])
     end
 
-    def ending_time(object)
-      return nil unless object.send(field_names[:base_of_offset]).present? && object.send(field_names[:ending_offset]).present?
+    def ending_time(object, options = {})
+      base_of_offset = options[:base_of] || object.send(field_names[:base_of_offset])
+
+      return nil unless base_of_offset.present? && object.send(field_names[:ending_offset]).present?
 
-      object.send(field_names[:base_of_offset]) - object.send(field_names[:ending_offset])
+      base_of_offset - object.send(field_names[:ending_offset])
     end
 
     def scheduled?(object)

data/lib/chronological/version.rb

@@ -1,3 +1,3 @@
 module Chronological
-  VERSION = '1.0.0beta6'
+  VERSION = '1.0.0beta7'
 end

data/lib/chronological.rb

@@ -15,18 +15,48 @@ module Chronological
       columns_hash[strategy.field_names[:ending_date].to_s]   ||= ActiveRecord::ConnectionAdapters::Column.new(strategy.field_names[:ending_date],   nil, 'date')
     end
 
-    unless strategy.has_absolute_start?
-      define_method(strategy.field_names[:starting_time]) do
-        strategy.starting_time(self)
+    if strategy.has_absolute_start?
+      define_method(strategy.field_names[:starting_time]) do |*args|
+        super()
+      end
+    else
+      define_method(strategy.field_names[:starting_time]) do |*args|
+        options = args.last.is_a?(Hash) ? args.last : {}
+
+        strategy.starting_time(self, options)
       end
     end
 
-    unless strategy.has_absolute_end?
-      define_method(strategy.field_names[:ending_time]) do
-        strategy.ending_time(self)
+    if strategy.has_absolute_end?
+      define_method(strategy.field_names[:ending_time]) do |*args|
+        super()
+      end
+    else
+      define_method(strategy.field_names[:ending_time]) do |*args|
+        options = args.last.is_a?(Hash) ? args.last : {}
+
+        strategy.ending_time(self, options)
       end
     end
 
+    define_method(:started?) do |*args|
+      options = args.last.is_a?(Hash) ? args.last : {}
+
+      strategy.started?(self, options)
+    end
+
+    define_method(:ended?) do |*args|
+      options = args.last.is_a?(Hash) ? args.last : {}
+
+      strategy.ended?(self, options)
+    end
+
+    define_method(:not_yet_ended?) do |*args|
+      options = args.last.is_a?(Hash) ? args.last : {}
+
+      strategy.not_yet_ended?(self, options)
+    end
+
     define_method(:scheduled?) do
       strategy.scheduled?(self)
     end

data/spec/strategies/absolute_spec.rb

@@ -407,6 +407,36 @@ describe Chronological::AbsoluteStrategy, :timecop => true do
       context 'and has already ended' do
         let(:end_time) { past }
 
+        describe '#started?' do
+          it 'is started when called directly' do
+            chronologicable.should be_started
+          end
+
+          it 'ignores any passed in base time' do
+            chronologicable.should be_started(:base_of => 100.years.from_now)
+          end
+        end
+
+        describe '#ended?' do
+          it 'is ended when called directly' do
+            chronologicable.should be_ended
+          end
+
+          it 'ignores any passed in base time' do
+            chronologicable.should be_ended(:base_of => 100.years.from_now)
+          end
+        end
+
+        describe '#not_yet_ended?' do
+          it 'is not_yet_ended when called directly' do
+            chronologicable.should_not be_not_yet_ended
+          end
+
+          it 'ignores any passed in base time' do
+            chronologicable.should_not be_not_yet_ended(:base_of => 100.years.from_now)
+          end
+        end
+
         describe '.in_progress?' do
           it 'is false' do
             AbsoluteChronologicable.should_not be_in_progress
@@ -441,6 +471,36 @@ describe Chronological::AbsoluteStrategy, :timecop => true do
       context 'and ends now' do
         let(:end_time) { now }
 
+        describe '#started?' do
+          it 'is started when called directly' do
+            chronologicable.should be_started
+          end
+
+          it 'ignores any passed in base time' do
+            chronologicable.should be_started(:base_of => 100.years.from_now)
+          end
+        end
+
+        describe '#ended?' do
+          it 'is ended when called directly' do
+            chronologicable.should be_ended
+          end
+
+          it 'ignores any passed in base time' do
+            chronologicable.should be_ended(:base_of => 100.years.from_now)
+          end
+        end
+
+        describe '#not_yet_ended?' do
+          it 'is not_yet_ended when called directly' do
+            chronologicable.should_not be_not_yet_ended
+          end
+
+          it 'ignores any passed in base time' do
+            chronologicable.should_not be_not_yet_ended(:base_of => 100.years.from_now)
+          end
+        end
+
         describe '.in_progress?' do
           it 'is false' do
             AbsoluteChronologicable.should_not be_in_progress
@@ -475,6 +535,36 @@ describe Chronological::AbsoluteStrategy, :timecop => true do
       context 'and ends later' do
         let(:end_time) { later }
 
+        describe '#started?' do
+          it 'is started when called directly' do
+            chronologicable.should be_started
+          end
+
+          it 'ignores any passed in base time' do
+            chronologicable.should be_started(:base_of => 100.years.from_now)
+          end
+        end
+
+        describe '#ended?' do
+          it 'is ended when called directly' do
+            chronologicable.should_not be_ended
+          end
+
+          it 'ignores any passed in base time' do
+            chronologicable.should_not be_ended(:base_of => 100.years.ago)
+          end
+        end
+
+        describe '#not_yet_ended?' do
+          it 'is not_yet_ended when called directly' do
+            chronologicable.should be_not_yet_ended
+          end
+
+          it 'ignores any passed in base time' do
+            chronologicable.should be_not_yet_ended(:base_of => 100.years.ago)
+          end
+        end
+
         describe '.in_progress?' do
           it 'is true' do
             AbsoluteChronologicable.should be_in_progress
@@ -513,6 +603,36 @@ describe Chronological::AbsoluteStrategy, :timecop => true do
       context 'and ends now' do
         let(:end_time) { now }
 
+        describe '#started?' do
+          it 'is started when called directly' do
+            chronologicable.should be_started
+          end
+
+          it 'ignores any passed in base time' do
+            chronologicable.should be_started(:base_of => 100.years.from_now)
+          end
+        end
+
+        describe '#ended?' do
+          it 'is ended when called directly' do
+            chronologicable.should be_ended
+          end
+
+          it 'ignores any passed in base time' do
+            chronologicable.should be_ended(:base_of => 100.years.from_now)
+          end
+        end
+
+        describe '#not_yet_ended?' do
+          it 'is not_yet_ended when called directly' do
+            chronologicable.should_not be_not_yet_ended
+          end
+
+          it 'ignores any passed in base time' do
+            chronologicable.should_not be_not_yet_ended(:base_of => 100.years.from_now)
+          end
+        end
+
         describe '.in_progress?' do
           it 'is false' do
             AbsoluteChronologicable.should_not be_in_progress
@@ -547,6 +667,36 @@ describe Chronological::AbsoluteStrategy, :timecop => true do
       context 'and ends later' do
         let(:end_time) { later }
 
+        describe '#started?' do
+          it 'is started when called directly' do
+            chronologicable.should be_started
+          end
+
+          it 'ignores any passed in base time' do
+            chronologicable.should be_started(:base_of => 100.years.from_now)
+          end
+        end
+
+        describe '#ended?' do
+          it 'is ended when called directly' do
+            chronologicable.should_not be_ended
+          end
+
+          it 'ignores any passed in base time' do
+            chronologicable.should_not be_ended(:base_of => 100.years.ago)
+          end
+        end
+
+        describe '#not_yet_ended?' do
+          it 'is not_yet_ended when called directly' do
+            chronologicable.should be_not_yet_ended
+          end
+
+          it 'ignores any passed in base time' do
+            chronologicable.should be_not_yet_ended(:base_of => 100.years.ago)
+          end
+        end
+
         describe '.in_progress?' do
           it 'is true' do
             AbsoluteChronologicable.should be_in_progress
@@ -583,6 +733,36 @@ describe Chronological::AbsoluteStrategy, :timecop => true do
       let(:start_time) { later }
       let(:end_time)   { later }
 
+      describe '#started?' do
+        it 'is started when called directly' do
+          chronologicable.should_not be_started
+        end
+
+        it 'ignores any passed in base time' do
+          chronologicable.should_not be_started(:base_of => 100.years.ago)
+        end
+      end
+
+      describe '#ended?' do
+        it 'is ended when called directly' do
+          chronologicable.should_not be_ended
+        end
+
+        it 'ignores any passed in base time' do
+          chronologicable.should_not be_ended(:base_of => 100.years.ago)
+        end
+      end
+
+      describe '#not_yet_ended?' do
+        it 'is not_yet_ended when called directly' do
+          chronologicable.should be_not_yet_ended
+        end
+
+        it 'ignores any passed in base time' do
+          chronologicable.should be_not_yet_ended(:base_of => 100.years.ago)
+        end
+      end
+
       describe '.in_progress?' do
         it 'is false' do
           AbsoluteChronologicable.should_not be_in_progress

data/spec/strategies/relative_spec.rb

@@ -376,9 +376,13 @@ describe Chronological::RelativeStrategy, :timecop => true do
         end
       end
 
-      it 'does not have a start time' do
+      it 'does not have a start time when called directly' do
         chronologicable.started_at.should be_nil
       end
+
+      it 'has the proper start time when a base is passed in' do
+        chronologicable.started_at(:base_of => Time.local(2012, 7, 26, 12, 0, 0)).should eql Time.local(2012, 7, 26, 11, 59, 30)
+      end
     end
 
     context 'and the starting offset is not set' do
@@ -468,25 +472,37 @@ describe Chronological::RelativeStrategy, :timecop => true do
         end
       end
 
-      it 'does not have a start time' do
+      it 'does not have a start time when called directly' do
         chronologicable.started_at.should be_nil
       end
+
+      it 'does not have a start time when a base is passed in' do
+        chronologicable.started_at(:base_of => Time.local(2012, 7, 26, 12, 0, 0)).should be_nil
+      end
     end
 
     context 'and the ending offset is set' do
       let(:ending_offset) { 0 }
 
-      it 'does not have an end time' do
+      it 'does not have an end time when called directly' do
         chronologicable.ended_at.should be_nil
       end
+
+      it 'calculates the correct end time when a base is passed in' do
+        chronologicable.ended_at(:base_of => Time.local(2012, 7, 26, 12, 0, 0)).should eql Time.local(2012, 7, 26, 12, 0, 0)
+      end
     end
 
     context 'and the ending offset is not set' do
       let(:ending_offset) { nil }
 
-      it 'does not have an end time' do
+      it 'does not have an end time when called directly' do
         chronologicable.ended_at.should be_nil
       end
+
+      it 'does not have an end time when a base is passed in' do
+        chronologicable.ended_at(:base_of => Time.local(2012, 7, 26, 12, 0, 0)).should be_nil
+      end
     end
 
     context 'and neither of the offsets is set' do
@@ -750,9 +766,13 @@ describe Chronological::RelativeStrategy, :timecop => true do
         end
       end
 
-      it 'does not have a start time' do
+      it 'does not have a start time when called directly' do
         chronologicable.started_at.should be_nil
       end
+
+      it 'does not have a start time when a base is passed in' do
+        chronologicable.started_at(:base_of => Time.local(2012, 7, 26, 12, 0, 0)).should be_nil
+      end
     end
 
     context 'when the starting offset is set' do
@@ -926,25 +946,37 @@ describe Chronological::RelativeStrategy, :timecop => true do
         end
       end
 
-      it 'calculates the correct start time' do
+      it 'calculates the correct start time when called directly' do
         chronologicable.started_at.should eql Time.local(2012, 7, 26, 6, 0, 0)
       end
+
+      it 'calculates the correct start time when a base is passed in' do
+        chronologicable.started_at(:base_of => Time.local(2012, 7, 26, 12, 0, 0)).should eql Time.local(2012, 7, 26, 11, 59, 30)
+      end
     end
 
     context 'and the ending offset is set' do
       let(:ending_offset) { 30 }
 
-      it 'calculates the correct end time' do
+      it 'calculates the correct end time when called directly' do
         chronologicable.ended_at.should eql Time.local(2012, 7, 26, 6, 0, 0)
       end
+
+      it 'calculates the correct end time when a base is passed in' do
+        chronologicable.ended_at(:base_of => Time.local(2012, 7, 26, 12, 0, 0)).should eql Time.local(2012, 7, 26, 11, 59, 30)
+      end
     end
 
     context 'and the ending offset is not set' do
       let(:ending_offset) { nil }
 
-      it 'does not have a end time' do
+      it 'does not have a end time when called directly' do
         chronologicable.ended_at.should be_nil
       end
+
+      it 'does not have an end time when a base is passed in' do
+        chronologicable.ended_at(:base_of => Time.local(2012, 7, 26, 12, 0, 0)).should be_nil
+      end
     end
   end
 
@@ -956,6 +988,30 @@ describe Chronological::RelativeStrategy, :timecop => true do
     context 'and before the ending offset' do
       let(:ending_offset) { 30 }
 
+      it 'is not started when called directly' do
+        chronologicable.should_not be_started
+      end
+
+      it 'is started if the base time is overridden to a time before the offset plus "now"' do
+        chronologicable.should be_started(:base_of => Time.local(2012, 7, 26, 6,  0, 29))
+      end
+
+      it 'is not ended when called directly' do
+        chronologicable.should_not be_ended
+      end
+
+      it 'is ended if the base time is overridden to a time on or after the offset plus "now"' do
+        chronologicable.should be_ended(:base_of => Time.local(2012, 7, 26, 6,  0, 29))
+      end
+
+      it 'is not yet ended when called directly' do
+        chronologicable.should be_not_yet_ended
+      end
+
+      it 'is not not yet ended if the base time is overridden to a time on or after the offset plus "now"' do
+        chronologicable.should_not be_not_yet_ended(:base_of => Time.local(2012, 7, 26, 6,  0, 29))
+      end
+
       it 'is not included in the started list' do
         RelativeChronologicable.started.should_not include chronologicable
       end
@@ -979,13 +1035,37 @@ describe Chronological::RelativeStrategy, :timecop => true do
   end
 
   context 'when it is currently a time the same as the starting offset' do
-    let(:now)             { Time.local(2012, 7, 26, 6, 0, 0) }
+    let(:now)             { Time.local(2012, 7, 26, 6,  0,  0) }
     let(:base_time)       { Time.local(2012, 7, 26, 6,  0, 30) }
     let(:starting_offset) { 30 }
 
     context 'and before the ending offset' do
       let(:ending_offset) { 29 }
 
+      it 'is not started when called directly' do
+        chronologicable.should be_started
+      end
+
+      it 'is not started if the base time is overridden to a time after the offset plus "now"' do
+        chronologicable.should_not be_started(:base_of => Time.local(2012, 7, 26, 6,  0, 31))
+      end
+
+      it 'is not ended when called directly' do
+        chronologicable.should_not be_ended
+      end
+
+      it 'is ended if the base time is overridden to a time on or after the offset plus "now"' do
+        chronologicable.should be_ended(:base_of => Time.local(2012, 7, 26, 6,  0, 29))
+      end
+
+      it 'is not yet ended when called directly' do
+        chronologicable.should be_not_yet_ended
+      end
+
+      it 'is not not yet ended if the base time is overridden to a time on or after the offset plus "now"' do
+        chronologicable.should_not be_not_yet_ended(:base_of => Time.local(2012, 7, 26, 6,  0, 29))
+      end
+
       it 'is included in the started list' do
         RelativeChronologicable.started.should include chronologicable
       end
@@ -1010,6 +1090,30 @@ describe Chronological::RelativeStrategy, :timecop => true do
     context 'and the same as the ending offset' do
       let(:ending_offset) { 30 }
 
+      it 'is not started when called directly' do
+        chronologicable.should be_started
+      end
+
+      it 'is not started if the base time is overridden to a time after the offset plus "now"' do
+        chronologicable.should_not be_started(:base_of => Time.local(2012, 7, 26, 6,  0, 31))
+      end
+
+      it 'is not ended when called directly' do
+        chronologicable.should be_ended
+      end
+
+      it 'is ended if the base time is overridden to a time on or after the offset plus "now"' do
+        chronologicable.should_not be_ended(:base_of => Time.local(2012, 7, 26, 6,  0, 31))
+      end
+
+      it 'is not yet ended when called directly' do
+        chronologicable.should_not be_not_yet_ended
+      end
+
+      it 'is not not yet ended if the base time is overridden to a time on or after the offset plus "now"' do
+        chronologicable.should be_not_yet_ended(:base_of => Time.local(2012, 7, 26, 6,  0, 31))
+      end
+
       it 'is included in the started list' do
         RelativeChronologicable.started.should include chronologicable
       end
@@ -1033,13 +1137,37 @@ describe Chronological::RelativeStrategy, :timecop => true do
   end
 
   context 'when it is currently a time after the starting offset' do
-    let(:now)             { Time.local(2012, 7, 26, 6, 0, 2) }
+    let(:now)             { Time.local(2012, 7, 26, 6,  0,  2) }
     let(:base_time)       { Time.local(2012, 7, 26, 6,  0, 30) }
     let(:starting_offset) { 30 }
 
     context 'and before the ending offset' do
       let(:ending_offset) { 27 }
 
+      it 'is not started when called directly' do
+        chronologicable.should be_started
+      end
+
+      it 'is not started if the base time is overridden to a time after the offset plus "now"' do
+        chronologicable.should_not be_started(:base_of => Time.local(2012, 7, 26, 6,  0, 33))
+      end
+
+      it 'is not ended when called directly' do
+        chronologicable.should_not be_ended
+      end
+
+      it 'is ended if the base time is overridden to a time on or after the offset plus "now"' do
+        chronologicable.should be_ended(:base_of => Time.local(2012, 7, 26, 6,  0, 29))
+      end
+
+      it 'is not yet ended when called directly' do
+        chronologicable.should be_not_yet_ended
+      end
+
+      it 'is not not yet ended if the base time is overridden to a time on or after the offset plus "now"' do
+        chronologicable.should_not be_not_yet_ended(:base_of => Time.local(2012, 7, 26, 6,  0, 29))
+      end
+
       it 'is included in the started list' do
         RelativeChronologicable.started.should include chronologicable
       end
@@ -1064,6 +1192,30 @@ describe Chronological::RelativeStrategy, :timecop => true do
     context 'and the same as the ending offset' do
       let(:ending_offset) { 28 }
 
+      it 'is not started when called directly' do
+        chronologicable.should be_started
+      end
+
+      it 'is not started if the base time is overridden to a time after the offset plus "now"' do
+        chronologicable.should_not be_started(:base_of => Time.local(2012, 7, 26, 6,  0, 33))
+      end
+
+      it 'is not ended when called directly' do
+        chronologicable.should be_ended
+      end
+
+      it 'is ended if the base time is overridden to a time on or after the offset plus "now"' do
+        chronologicable.should_not be_ended(:base_of => Time.local(2012, 7, 26, 6,  0, 31))
+      end
+
+      it 'is not yet ended when called directly' do
+        chronologicable.should_not be_not_yet_ended
+      end
+
+      it 'is not not yet ended if the base time is overridden to a time on or after the offset plus "now"' do
+        chronologicable.should be_not_yet_ended(:base_of => Time.local(2012, 7, 26, 6,  0, 31))
+      end
+
       it 'is included in the started list' do
         RelativeChronologicable.started.should include chronologicable
       end
@@ -1088,6 +1240,30 @@ describe Chronological::RelativeStrategy, :timecop => true do
     context 'and after the ending offset' do
       let(:ending_offset) { 29 }
 
+      it 'is not started when called directly' do
+        chronologicable.should be_started
+      end
+
+      it 'is not started if the base time is overridden to a time after the offset plus "now"' do
+        chronologicable.should_not be_started(:base_of => Time.local(2012, 7, 26, 6,  0, 33))
+      end
+
+      it 'is not ended when called directly' do
+        chronologicable.should be_ended
+      end
+
+      it 'is ended if the base time is overridden to a time on or after the offset plus "now"' do
+        chronologicable.should_not be_ended(:base_of => Time.local(2012, 7, 26, 6,  0, 32))
+      end
+
+      it 'is not yet ended when called directly' do
+        chronologicable.should_not be_not_yet_ended
+      end
+
+      it 'is not not yet ended if the base time is overridden to a time on or after the offset plus "now"' do
+        chronologicable.should be_not_yet_ended(:base_of => Time.local(2012, 7, 26, 6,  0, 32))
+      end
+
       it 'is included in the started list' do
         RelativeChronologicable.started.should include chronologicable
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chronological
 version: !ruby/object:Gem::Version
-  version: 1.0.0beta6
+  version: 1.0.0beta7
   prerelease: 5
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-05 00:00:00.000000000 Z
+date: 2012-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec