tod 1.5.0 → 2.0.0

data/lib/tod/shift.rb

@@ -1,41 +1,55 @@
 module Tod
+
+  # Shift is a range-like class that handles wrapping around midnight.
+  # For example, the Shift of 2300 to 0200 would include 0100.
   class Shift
-    attr_reader :beginning, :ending
+    attr_reader :beginning, :ending, :range
 
-    def initialize(beginning, ending)
+    def initialize(beginning, ending, exclude_end=false)
       raise ArgumentError, "beginning can not be nil" unless beginning
       raise ArgumentError, "ending can not be nil" unless ending
+      unless [true, false].include? exclude_end
+        raise ArgumentError, "exclude_end must be true or false"
+      end
 
       @beginning = beginning
       @ending = ending
+      @exclude_end = exclude_end
+
+      normalized_ending = ending.to_i
+      normalized_ending += TimeOfDay::NUM_SECONDS_IN_DAY if normalized_ending < beginning.to_i
+
+      @range = Range.new(beginning.to_i, normalized_ending, @exclude_end)
+
       freeze # Shift instances are value objects
     end
 
-    # Returns true if the time of day is inside the shift (inclusive range), false otherwise
+    # Returns true if the time of day is inside the shift, false otherwise.
     def include?(tod)
-      if ending >= beginning
-        tod >= beginning && tod <= ending
-      else
-        start_of_day   = TimeOfDay.new(0,0,0)
-        end_of_day     = TimeOfDay.new(23,59,59)
-        (tod >= beginning && tod <= end_of_day) || (tod >= start_of_day && tod <= ending)
-      end
+      second = tod.to_i
+      second += TimeOfDay::NUM_SECONDS_IN_DAY if second < @range.first
+      @range.cover?(second)
+    end
+
+    # Returns true if ranges overlap, false otherwise.
+    def overlaps?(other)
+      a, b = [self, other].map(&:range).sort_by(&:first)
+      op = a.exclude_end? ? :> : :>=
+      a.last.send(op, b.first)
+    end
+
+    def contains?(shift)
+      self.include?(shift.beginning) && self.include?(shift.ending)
     end
 
     # Return shift duration in seconds.
     # if ending is lower than beginning this method will calculate the duration as the ending time is from the following day
     def duration
-      if ending >= beginning
-        (ending.to_i - beginning.to_i)
-      else
-        start_of_day   = TimeOfDay.new(0,0,0)
-        end_of_day     = TimeOfDay.new(23,59,59)
-        duration_day_1 = (end_of_day.to_i - beginning.to_i) + 1
-        duration_day_2 = (ending.to_i - start_of_day.to_i)
-        duration_day_1 + duration_day_2
-      end
+      @range.last - @range.first
+    end
+
+    def exclude_end?
+      @exclude_end
     end
   end
 end
-
-Shift = Tod::Shift

data/lib/tod/time_extensions.rb

@@ -0,0 +1,9 @@
+module Tod
+  module TimeExtensions
+    def to_time_of_day
+      Tod::TimeOfDay.new hour, min, sec
+    end
+  end
+end
+
+Time.send :include, Tod::TimeExtensions

data/lib/tod/version.rb

@@ -1,3 +1,3 @@
 module Tod
-  VERSION = "1.5.0"
+  VERSION = "2.0.0"
 end

data/test/support/active_record.rb

@@ -3,5 +3,5 @@ ActiveRecord::Base.establish_connection adapter: 'sqlite3', database: ':memory:'
 
 ActiveRecord::Migration.create_table :orders do |t|
   t.time :time
-  t.timestamps
-end
+  t.timestamps null: false
+end

data/test/test_helper.rb

@@ -1,7 +1,9 @@
 $LOAD_PATH.unshift File.join(File.dirname(__FILE__),'..','lib')
 
 require 'bundler/setup'
+require 'active_support/time'
 require 'tod'
-require 'test/unit'
-require 'shoulda'
-require 'mocha/setup'
+require 'tod/core_extensions'
+require 'minitest/autorun'
+
+Time.zone = "Central Time (US & Canada)"

data/test/tod/conversion_test.rb

@@ -1,48 +1,52 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
-require 'active_support/time'
 
-class TimeOfDayConversionTest < Test::Unit::TestCase
-  should "handle TimeOfDay" do
-    t   = TimeOfDay.new(13, 56, 12)
-    tod = TimeOfDay(t)
+describe "TimeOfDay()" do
+  it "handles Tod::TimeOfDay" do
+    t   = Tod::TimeOfDay.new(13, 56, 12)
+    tod = Tod::TimeOfDay(t)
 
     assert_equal(t, tod)
   end
-  should "handle Time" do
+
+  it "handles Time" do
     t   = Time.new(2014, 2, 27, 12, 01, 02)
-    tod = TimeOfDay(t)
+    tod = Tod::TimeOfDay(t)
 
-    assert_equal(tod, TimeOfDay.new(12, 01, 02))
+    assert_equal(tod, Tod::TimeOfDay.new(12, 01, 02))
   end
-  should "handle Date" do
+
+  it "handles Date" do
     t   = Date.new(2014, 2, 27)
-    tod = TimeOfDay(t)
+    tod = Tod::TimeOfDay(t)
 
-    assert_equal(tod, TimeOfDay.new(0, 0, 0))
+    assert_equal(tod, Tod::TimeOfDay.new(0, 0, 0))
   end
-  should "handle DateTime" do
+
+  it "handles DateTime" do
     t   = DateTime.new(2014, 2, 27, 12, 01, 02)
-    tod = TimeOfDay(t)
+    tod = Tod::TimeOfDay(t)
 
-    assert_equal(tod, TimeOfDay.new(12, 01, 02))
+    assert_equal(tod, Tod::TimeOfDay.new(12, 01, 02))
   end
-  should "string" do
+
+  it "parses string" do
     t   = "12:01:02"
-    tod = TimeOfDay(t)
+    tod = Tod::TimeOfDay(t)
 
-    assert_equal(tod, TimeOfDay.new(12, 01, 02))
+    assert_equal(tod, Tod::TimeOfDay.new(12, 01, 02))
   end
-  should "parse 'noon'" do
+
+  it "parses 'noon'" do
     t   = "noon"
-    tod = TimeOfDay(t)
+    tod = Tod::TimeOfDay(t)
 
-    assert_equal(tod, TimeOfDay.new(12, 00, 00))
+    assert_equal(tod, Tod::TimeOfDay.new(12, 00, 00))
   end
-  should "parse 'midnight'" do
+
+  it "parses 'midnight'" do
     t   = "midnight"
-    tod = TimeOfDay(t)
+    tod = Tod::TimeOfDay(t)
 
-    assert_equal(tod, TimeOfDay.new(0, 00, 00))
+    assert_equal(tod, Tod::TimeOfDay.new(0, 00, 00))
   end
-
-end
+end

data/test/tod/date_test.rb

@@ -1,28 +1,27 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
-require 'active_support/time'
 
-class DateTest < Test::Unit::TestCase
-  context "at" do
-    should "accept TimeOfDay and return Time on same date" do
+describe "Date extensions" do
+  describe "#at" do
+    it "accepts TimeOfDay and return Time on same date" do
       date = Date.civil 2000,1,1
-      tod = TimeOfDay.new 8,30
-      assert_equal Time.local(2000,1,1, 8,30), date.at(tod)
+      tod = Tod::TimeOfDay.new 8,30
+      assert_equal Time.zone.local(2000,1,1, 8,30), date.at(tod)
     end
 
-    context "with a time zone" do
-      should "accept TimeOfDay and TimeWithZone on same date" do
+    describe "with a time zone" do
+      it "accepts TimeOfDay and TimeWithZone on same date" do
         date = Date.civil 2000,1,1
-        tod = TimeOfDay.new 8,30
+        tod = Tod::TimeOfDay.new 8,30
         time_zone = ActiveSupport::TimeZone['Eastern Time (US & Canada)']
         assert_equal time_zone.local(2000,1,1, 8,30), date.at(tod, time_zone)
       end
     end
   end
 
-  context "to_time_day" do
-    should "be TimeOfDay" do
+  describe "#to_time_day" do
+    it "is TimeOfDay" do
       date_time = DateTime.new 2013, 9, 19, 15, 17, 34
-      assert_equal TimeOfDay.new(15, 17, 34), date_time.to_time_of_day
+      assert_equal Tod::TimeOfDay.new(15, 17, 34), date_time.to_time_of_day
     end
   end
 end

data/test/tod/shift_test.rb

@@ -1,94 +1,169 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
-require 'active_support/time'
 
-class ShiftTest < Test::Unit::TestCase
-  context "duration" do
-    should "return correct duration when first time is lower than the second one" do
+describe "Shift" do
+  describe "#initialize" do
+    it "parses bounds" do
+      shift = Tod::Shift.new Tod::TimeOfDay.new(8), Tod::TimeOfDay.new(10), false
+      refute shift.exclude_end?
+
+      shift = Tod::Shift.new Tod::TimeOfDay.new(8), Tod::TimeOfDay.new(10), true
+      assert shift.exclude_end?
+    end
+  end
+
+  describe "#duration" do
+    it "returns correct duration when first time is lower than the second one" do
       duration_expected = 4 * 60 * 60 + 30 * 60 + 30 # 4 hours, 30 min and 30 sec later
-      tod1 = TimeOfDay.new 8,30
-      tod2 = TimeOfDay.new 13,00,30
-      shift = Shift.new tod1, tod2
+      tod1 = Tod::TimeOfDay.new 8,30
+      tod2 = Tod::TimeOfDay.new 13,00,30
+      shift = Tod::Shift.new tod1, tod2
       duration = shift.duration
       assert_equal duration, duration_expected
     end
-    should "return correct duration when first time is greater than the second one" do
+
+    it "returns correct duration when first time is greater than the second one" do
       duration_expected = 4 * 60 * 60 + 30 * 60 + 30 # 4 hours, 30 min and 30 sec later
-      tod1 = TimeOfDay.new 22,30
-      tod2 = TimeOfDay.new 3,00,30
-      shift = Shift.new tod1, tod2
+      tod1 = Tod::TimeOfDay.new 22,30
+      tod2 = Tod::TimeOfDay.new 3,00,30
+      shift = Tod::Shift.new tod1, tod2
       duration = shift.duration
       assert_equal duration, duration_expected
     end
-    should "be zero when both times are equal" do
-      tod1 = TimeOfDay.new 3,00,30
-      shift = Shift.new tod1, tod1
+
+    it "is zero when both times are equal" do
+      tod1 = Tod::TimeOfDay.new 3,00,30
+      shift = Tod::Shift.new tod1, tod1
       duration = shift.duration
       assert_equal duration, 0
     end
   end
 
-  context "include?" do
+  describe "overlaps?" do
+    it "is true when shifts overlap" do
+      shift1 = Tod::Shift.new(Tod::TimeOfDay.new(12), Tod::TimeOfDay.new(18))
+      shift2 = Tod::Shift.new(Tod::TimeOfDay.new(13), Tod::TimeOfDay.new(15))
+      assert shift1.overlaps?(shift2)
+    end
+
+    it "is false when shifts don't overlap" do
+      shift1 = Tod::Shift.new(Tod::TimeOfDay.new(1), Tod::TimeOfDay.new(5))
+      shift2 = Tod::Shift.new(Tod::TimeOfDay.new(9), Tod::TimeOfDay.new(12))
+      refute shift1.overlaps?(shift2)
+    end
+
+    it "is true when shifts touch with inclusive end" do
+      shift1 = Tod::Shift.new(Tod::TimeOfDay.new(1), Tod::TimeOfDay.new(5))
+      shift2 = Tod::Shift.new(Tod::TimeOfDay.new(5), Tod::TimeOfDay.new(12))
+      assert shift1.overlaps?(shift2)
+    end
+
+    it "is false when shifts touch with exclusive end" do
+      shift1 = Tod::Shift.new(Tod::TimeOfDay.new(1), Tod::TimeOfDay.new(5), true)
+      shift2 = Tod::Shift.new(Tod::TimeOfDay.new(5), Tod::TimeOfDay.new(12), true)
+      refute shift1.overlaps?(shift2)
+    end
+  end
+
+  describe "contains?" do
+    it "is true when one shift contains another" do
+      outside = Tod::Shift.new(Tod::TimeOfDay.new(12), Tod::TimeOfDay.new(18))
+      inside = Tod::Shift.new(Tod::TimeOfDay.new(13), Tod::TimeOfDay.new(15))
+      assert outside.contains?(inside)
+    end
+
+    it "is false when a shift is contained by another" do
+      outside = Tod::Shift.new(Tod::TimeOfDay.new(12), Tod::TimeOfDay.new(18))
+      inside = Tod::Shift.new(Tod::TimeOfDay.new(13), Tod::TimeOfDay.new(15))
+      refute inside.contains?(outside)
+    end
+
+    it "is false when shifts don't even overlap" do
+      shift1 = Tod::Shift.new(Tod::TimeOfDay.new(12), Tod::TimeOfDay.new(15))
+      shift2 = Tod::Shift.new(Tod::TimeOfDay.new(18), Tod::TimeOfDay.new(19))
+      refute shift1.contains?(shift2)
+    end
+  end
+
+  describe "#include?" do
     # |------------------------|--------T1----V----T2----|------------------------|
-    should "be true when value is between ToDs and boths tods are in the same day" do
-      tod1  = TimeOfDay.new 8
-      tod2  = TimeOfDay.new 16
-      value = TimeOfDay.new 12
-      shift = Shift.new tod1, tod2
-      assert_equal shift.include?(value), true
+    it "is true when value is between ToDs and boths tods are in the same day" do
+      tod1  = Tod::TimeOfDay.new 8
+      tod2  = Tod::TimeOfDay.new 16
+      value = Tod::TimeOfDay.new 12
+      shift = Tod::Shift.new tod1, tod2
+      assert shift.include?(value)
     end
 
     # |------------------T1----|-------V----------T2-----|------------------------|
-    should "be true when value is on second day between ToDs and start ToD is in a different day" do
-      tod1  = TimeOfDay.new 20
-      tod2  = TimeOfDay.new 15
-      value = TimeOfDay.new 12
-      shift = Shift.new tod1, tod2
-      assert_equal shift.include?(value), true
+    it "is true when value is on second day between ToDs and start ToD is in a different day" do
+      tod1  = Tod::TimeOfDay.new 20
+      tod2  = Tod::TimeOfDay.new 15
+      value = Tod::TimeOfDay.new 12
+      shift = Tod::Shift.new tod1, tod2
+      assert shift.include?(value)
     end
 
     # |------------------T1--V-|------------------T2-----|------------------------|
-    should "be true when value is on first day between ToDs and start ToD is in a different day" do
-      tod1  = TimeOfDay.new 20
-      tod2  = TimeOfDay.new 15
-      value = TimeOfDay.new 22
-      shift = Shift.new tod1, tod2
-      assert_equal shift.include?(value), true
+    it "is true when value is on first day between ToDs and start ToD is in a different day" do
+      tod1  = Tod::TimeOfDay.new 20
+      tod2  = Tod::TimeOfDay.new 15
+      value = Tod::TimeOfDay.new 22
+      shift = Tod::Shift.new tod1, tod2
+      assert shift.include?(value)
     end
 
     # |------------------------|--------T1----------V----|----T2------------------|
-    should "be true when value is on first day between ToDs and end ToD is in a different day" do
-      tod1  = TimeOfDay.new 16
-      tod2  = TimeOfDay.new 4
-      value = TimeOfDay.new 20
-      shift = Shift.new tod1, tod2
-      assert_equal shift.include?(value), true
+    it "is true when value is on first day between ToDs and end ToD is in a different day" do
+      tod1  = Tod::TimeOfDay.new 16
+      tod2  = Tod::TimeOfDay.new 4
+      value = Tod::TimeOfDay.new 20
+      shift = Tod::Shift.new tod1, tod2
+      assert shift.include?(value)
     end
 
     # |------------------------|--------T1---------------|--V---T2----------------|
-    should "be true when value is on second day between ToDs and end ToD is in a different day" do
-      tod1  = TimeOfDay.new 16
-      tod2  = TimeOfDay.new 4
-      value = TimeOfDay.new 2
-      shift = Shift.new tod1, tod2
-      assert_equal shift.include?(value), true
+    it "is true when value is on second day between ToDs and end ToD is in a different day" do
+      tod1  = Tod::TimeOfDay.new 16
+      tod2  = Tod::TimeOfDay.new 4
+      value = Tod::TimeOfDay.new 2
+      shift = Tod::Shift.new tod1, tod2
+      assert shift.include?(value)
     end
 
     # |------------------------|--------T1-----T2----V---|------------------------|
-    should "be false when value is after second ToD" do
-      tod1  = TimeOfDay.new 10
-      tod2  = TimeOfDay.new 16
-      value = TimeOfDay.new 20
-      shift = Shift.new tod1, tod2
-      assert_equal shift.include?(value), false
+    it "is false when value is after second ToD" do
+      tod1  = Tod::TimeOfDay.new 10
+      tod2  = Tod::TimeOfDay.new 16
+      value = Tod::TimeOfDay.new 20
+      shift = Tod::Shift.new tod1, tod2
+      refute shift.include?(value)
     end
 
     # |------------------------|--V-----T1-----T2--------|------------------------|
-    should "be false when value is before first ToD" do
-      tod1  = TimeOfDay.new 10
-      tod2  = TimeOfDay.new 16
-      value = TimeOfDay.new 8
-      shift = Shift.new tod1, tod2
-      assert_equal shift.include?(value), false
+    it "is false when value is before first ToD" do
+      tod1  = Tod::TimeOfDay.new 10
+      tod2  = Tod::TimeOfDay.new 16
+      value = Tod::TimeOfDay.new 8
+      shift = Tod::Shift.new tod1, tod2
+      refute shift.include?(value)
+    end
+
+    # |------------------------|--------T1-----T2V-------|------------------------|
+    it "is false when value is equal to second ToD and Shift is ending exclusive" do
+      tod1  = Tod::TimeOfDay.new 10
+      tod2  = Tod::TimeOfDay.new 16
+      value = Tod::TimeOfDay.new 16
+      shift = Tod::Shift.new tod1, tod2, true
+      refute shift.include?(value)
+    end
+
+    # |------------------------|--------T1-----T2V-------|------------------------|
+    it "is true when value is equal to second ToD and Shift is ending inclusive" do
+      tod1  = Tod::TimeOfDay.new 10
+      tod2  = Tod::TimeOfDay.new 16
+      value = Tod::TimeOfDay.new 16
+      shift = Tod::Shift.new tod1, tod2, false
+      assert shift.include?(value)
     end
   end
 end