tod 1.5.0 → 2.0.0

data/test/tod/time_of_day_serializable_attribute_test.rb

@@ -2,24 +2,28 @@ require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
 require File.expand_path(File.join(File.dirname(__FILE__),'..','support/active_record'))
 
 class Order < ActiveRecord::Base
-  serialize :time, TimeOfDay
+  serialize :time, Tod::TimeOfDay
 end
-class TimeOfDayWithActiveRecordSerializableAttribute < Test::Unit::TestCase
-  context "self.dump" do
-    should "be able to set time of day" do
-      Order.create(time: TimeOfDay.new(9, 30))
+
+describe "TimeOfDay with ActiveRecord Serializable Attribute" do
+  describe ".dump" do
+    it "sets time of day" do
+      Order.create(time: Tod::TimeOfDay.new(9, 30))
     end
-    should "be able to set nil as value" do
+
+    it "sets nil as value" do
       Order.create(time: nil)
     end
   end
-  context "self.load" do
-    should "load set time" do
-      time_of_day = TimeOfDay.new(9, 30)
+
+  describe ".load" do
+    it "loads set time" do
+      time_of_day = Tod::TimeOfDay.new(9, 30)
       order = Order.create(time: time_of_day)
       assert_equal order.time, time_of_day
     end
-    should "return nil if time is not set" do
+
+    it "returns nil if time is not set" do
       order = Order.create(time: nil)
       assert_equal order.time, nil
     end

data/test/tod/time_of_day_test.rb

@@ -1,58 +1,57 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
-require 'active_support/time'
 
-class TimeOfDayTest < Test::Unit::TestCase
-  context "initialize" do
-    should "block invalid hours" do
-      assert_raise(ArgumentError) { TimeOfDay.new -1 }
-      assert_raise(ArgumentError) { TimeOfDay.new 24 }
+describe "TimeOfDay" do
+  describe "#initialize" do
+    it "blocks invalid hours" do
+      assert_raises(ArgumentError) { Tod::TimeOfDay.new -1 }
+      assert_raises(ArgumentError) { Tod::TimeOfDay.new 24 }
     end
 
-    should "block invalid minutes" do
-      assert_raise(ArgumentError) { TimeOfDay.new 0, -1 }
-      assert_raise(ArgumentError) { TimeOfDay.new 0, 60 }
+    it "blocks invalid minutes" do
+      assert_raises(ArgumentError) { Tod::TimeOfDay.new 0, -1 }
+      assert_raises(ArgumentError) { Tod::TimeOfDay.new 0, 60 }
     end
 
-    should "block invalid seconds" do
-      assert_raise(ArgumentError) { TimeOfDay.new 0, 0, -1 }
-      assert_raise(ArgumentError) { TimeOfDay.new 0, 0, 60 }
+    it "blocks invalid seconds" do
+      assert_raises(ArgumentError) { Tod::TimeOfDay.new 0, 0, -1 }
+      assert_raises(ArgumentError) { Tod::TimeOfDay.new 0, 0, 60 }
     end
   end
 
-  context "second_of_day" do
-    should "be 0 at midnight" do
-      assert_equal 0, TimeOfDay.new(0,0,0).second_of_day
+  describe "second_of_day" do
+    it "is 0 at midnight" do
+      assert_equal 0, Tod::TimeOfDay.new(0,0,0).second_of_day
     end
 
-    should "be 3661 at 1:01:01" do
-      assert_equal 3661, TimeOfDay.new(1,1,1).second_of_day
+    it "is 3661 at 1:01:01" do
+      assert_equal 3661, Tod::TimeOfDay.new(1,1,1).second_of_day
     end
 
-    should "be 86399 at last second of day" do
-      assert_equal 86399, TimeOfDay.new(23,59,59).second_of_day
+    it "is 86399 at last second of day" do
+      assert_equal 86399, Tod::TimeOfDay.new(23,59,59).second_of_day
     end
 
-    should "have alias to_i" do
-      tod = TimeOfDay.new(0,0,0)
+    it "have alias to_i" do
+      tod = Tod::TimeOfDay.new(0,0,0)
       assert_equal tod.method(:second_of_day), tod.method(:to_i)
     end
   end
 
   def self.should_parse(parse_string, expected_hour, expected_minute, expected_second)
-    expected_tod = TimeOfDay.new expected_hour, expected_minute, expected_second
+    expected_tod = Tod::TimeOfDay.new expected_hour, expected_minute, expected_second
 
-    should "parse '#{parse_string}' into #{expected_tod.inspect}" do
-      assert_equal true, TimeOfDay.parsable?(parse_string)
-      assert_equal expected_tod, TimeOfDay.try_parse(parse_string)
-      assert_equal expected_tod, TimeOfDay.parse(parse_string)
+    it "parses '#{parse_string}' into #{expected_tod.inspect}" do
+      assert_equal true, Tod::TimeOfDay.parsable?(parse_string)
+      assert_equal expected_tod, Tod::TimeOfDay.try_parse(parse_string)
+      assert_equal expected_tod, Tod::TimeOfDay.parse(parse_string)
     end
   end
 
   def self.should_not_parse(parse_string)
-    should "not parse '#{parse_string}'" do
-      assert_equal false, TimeOfDay.parsable?(parse_string)
-      assert_equal nil, TimeOfDay.try_parse(parse_string)
-      assert_raise(ArgumentError) { TimeOfDay.parse(parse_string) }
+    it "does not parse '#{parse_string}'" do
+      assert_equal false, Tod::TimeOfDay.parsable?(parse_string)
+      assert_equal nil, Tod::TimeOfDay.try_parse(parse_string)
+      assert_raises(ArgumentError) { Tod::TimeOfDay.parse(parse_string) }
     end
   end
 
@@ -97,123 +96,121 @@ class TimeOfDayTest < Test::Unit::TestCase
   should_not_parse ""
   should_not_parse []
 
-  should "not parse 'nil'" do
-    assert_equal false, TimeOfDay.parsable?(nil)
-    assert_equal nil, TimeOfDay.try_parse(nil)
-    assert_raise(ArgumentError) { TimeOfDay.parse(nil) }
+  it "does not parse 'nil'" do
+    assert_equal false, Tod::TimeOfDay.parsable?(nil)
+    assert_equal nil, Tod::TimeOfDay.try_parse(nil)
+    assert_raises(ArgumentError) { Tod::TimeOfDay.parse(nil) }
   end
 
-  should "provide spaceship operator" do
-    assert_equal -1, TimeOfDay.new(8,0,0) <=> TimeOfDay.new(9,0,0)
-    assert_equal 0, TimeOfDay.new(9,0,0) <=> TimeOfDay.new(9,0,0)
-    assert_equal 1, TimeOfDay.new(10,0,0) <=> TimeOfDay.new(9,0,0)
+  it "provides spaceship operator" do
+    assert_equal -1, Tod::TimeOfDay.new(8,0,0) <=> Tod::TimeOfDay.new(9,0,0)
+    assert_equal 0, Tod::TimeOfDay.new(9,0,0) <=> Tod::TimeOfDay.new(9,0,0)
+    assert_equal 1, Tod::TimeOfDay.new(10,0,0) <=> Tod::TimeOfDay.new(9,0,0)
   end
 
-  should "compare equality by value" do
-    assert_equal TimeOfDay.new(8,0,0), TimeOfDay.new(8,0,0)
+  it "compares equality by value" do
+    assert_equal Tod::TimeOfDay.new(8,0,0), Tod::TimeOfDay.new(8,0,0)
   end
 
 
-  context "strftime" do
-    should "delegate to Time.parse" do
-      format_string = "%H:%M"
-      Time.any_instance.expects(:strftime).with(format_string)
-      TimeOfDay.new(8,15,30).strftime format_string
+  describe "strftime" do
+    it "accepts standard strftime format codes" do
+      assert_equal "08:15", Tod::TimeOfDay.new(8,15,30).strftime("%H:%M")
     end
   end
 
-  context "to_s" do
-    should "format to HH:MM:SS" do
-      assert_equal "08:15:30", TimeOfDay.new(8,15,30).to_s
-      assert_equal "22:10:45", TimeOfDay.new(22,10,45).to_s
+  describe "to_s" do
+    it "formats to HH:MM:SS" do
+      assert_equal "08:15:30", Tod::TimeOfDay.new(8,15,30).to_s
+      assert_equal "22:10:45", Tod::TimeOfDay.new(22,10,45).to_s
     end
   end
 
-  context "to_i" do
-    should "format to integer" do
-      assert_equal 29730, TimeOfDay.new(8,15,30).to_i
-      assert TimeOfDay.new(22,10,45).to_i.is_a? Integer
+  describe "to_i" do
+    it "formats to integer" do
+      assert_equal 29730, Tod::TimeOfDay.new(8,15,30).to_i
+      assert Tod::TimeOfDay.new(22,10,45).to_i.is_a? Integer
     end
   end
 
-  context "addition" do
-    should "add seconds" do
-      original = TimeOfDay.new(8,0,0)
+  describe "addition" do
+    it "adds seconds" do
+      original = Tod::TimeOfDay.new(8,0,0)
       result = original + 15
-      assert_equal TimeOfDay.new(8,0,15), result
+      assert_equal Tod::TimeOfDay.new(8,0,15), result
     end
 
-    should "wrap around midnight" do
-      original = TimeOfDay.new(23,0,0)
+    it "wraps around midnight" do
+      original = Tod::TimeOfDay.new(23,0,0)
       result = original + 7200
-      assert_equal TimeOfDay.new(1,0,0), result
+      assert_equal Tod::TimeOfDay.new(1,0,0), result
     end
 
-    should "return new TimeOfDay" do
-      original = TimeOfDay.new(8,0,0)
+    it "returns new Tod::TimeOfDay" do
+      original = Tod::TimeOfDay.new(8,0,0)
       result = original + 15
-      assert_not_equal original.object_id, result.object_id
+      refute_equal original.object_id, result.object_id
     end
   end
 
-  context "subtraction" do
-    should "subtract seconds" do
-      original = TimeOfDay.new(8,0,0)
+  describe "subtraction" do
+    it "subtracts seconds" do
+      original = Tod::TimeOfDay.new(8,0,0)
       result = original - 15
-      assert_equal TimeOfDay.new(7,59,45), result
+      assert_equal Tod::TimeOfDay.new(7,59,45), result
     end
 
-    should "wrap around midnight" do
-      original = TimeOfDay.new(1,0,0)
+    it "wraps around midnight" do
+      original = Tod::TimeOfDay.new(1,0,0)
       result = original - 7200
-      assert_equal TimeOfDay.new(23,0,0), result
+      assert_equal Tod::TimeOfDay.new(23,0,0), result
     end
 
-    should "return new TimeOfDay" do
-      original = TimeOfDay.new(8,0,0)
+    it "returns new Tod::TimeOfDay" do
+      original = Tod::TimeOfDay.new(8,0,0)
       result = original - 15
-      assert_not_equal original.object_id, result.object_id
+      refute_equal original.object_id, result.object_id
     end
   end
 
-  context "from_second_of_day" do
-    should "handle positive numbers" do
-      assert_equal TimeOfDay.new(0,0,30), TimeOfDay.from_second_of_day(30)
-      assert_equal TimeOfDay.new(0,1,30), TimeOfDay.from_second_of_day(90)
-      assert_equal TimeOfDay.new(1,1,5), TimeOfDay.from_second_of_day(3665)
-      assert_equal TimeOfDay.new(23,59,59), TimeOfDay.from_second_of_day(86399)
+  describe "from_second_of_day" do
+    it "handles positive numbers" do
+      assert_equal Tod::TimeOfDay.new(0,0,30), Tod::TimeOfDay.from_second_of_day(30)
+      assert_equal Tod::TimeOfDay.new(0,1,30), Tod::TimeOfDay.from_second_of_day(90)
+      assert_equal Tod::TimeOfDay.new(1,1,5), Tod::TimeOfDay.from_second_of_day(3665)
+      assert_equal Tod::TimeOfDay.new(23,59,59), Tod::TimeOfDay.from_second_of_day(86399)
     end
 
-    should "handle positive numbers a day or more away" do
-      assert_equal TimeOfDay.new(0,0,0), TimeOfDay.from_second_of_day(86400)
-      assert_equal TimeOfDay.new(0,0,30), TimeOfDay.from_second_of_day(86430)
-      assert_equal TimeOfDay.new(0,1,30), TimeOfDay.from_second_of_day(86490)
-      assert_equal TimeOfDay.new(1,1,5), TimeOfDay.from_second_of_day(90065)
-      assert_equal TimeOfDay.new(23,59,59), TimeOfDay.from_second_of_day(172799)
+    it "handles positive numbers a day or more away" do
+      assert_equal Tod::TimeOfDay.new(0,0,0), Tod::TimeOfDay.from_second_of_day(86400)
+      assert_equal Tod::TimeOfDay.new(0,0,30), Tod::TimeOfDay.from_second_of_day(86430)
+      assert_equal Tod::TimeOfDay.new(0,1,30), Tod::TimeOfDay.from_second_of_day(86490)
+      assert_equal Tod::TimeOfDay.new(1,1,5), Tod::TimeOfDay.from_second_of_day(90065)
+      assert_equal Tod::TimeOfDay.new(23,59,59), Tod::TimeOfDay.from_second_of_day(172799)
     end
 
-    should "handle negative numbers" do
-      assert_equal TimeOfDay.new(23,59,30), TimeOfDay.from_second_of_day(-30)
+    it "handles negative numbers" do
+      assert_equal Tod::TimeOfDay.new(23,59,30), Tod::TimeOfDay.from_second_of_day(-30)
     end
 
-    should "handle negative numbers more than a day away" do
-      assert_equal TimeOfDay.new(23,59,30), TimeOfDay.from_second_of_day(-86430)
+    it "handles negative numbers more than a day away" do
+      assert_equal Tod::TimeOfDay.new(23,59,30), Tod::TimeOfDay.from_second_of_day(-86430)
     end
 
-    should "have alias from_i" do
-      assert_equal TimeOfDay.method(:from_second_of_day), TimeOfDay.method(:from_i)
+    it "has alias from_i" do
+      assert_equal Tod::TimeOfDay.method(:from_second_of_day), Tod::TimeOfDay.method(:from_i)
     end
   end
 
-  context "on" do
-    should "be local Time on given date" do
-      assert_equal Time.local(2010,12,29, 8,30), TimeOfDay.new(8,30).on(Date.civil(2010,12,29))
+  describe "on" do
+    it "is local Time on given date" do
+      assert_equal Time.zone.local(2010,12,29, 8,30), Tod::TimeOfDay.new(8,30).on(Date.civil(2010,12,29))
     end
 
-    context "with a time zone" do
-      should "be TimeWithZone on given date" do
+    describe "with a time zone" do
+      it "is TimeWithZone on given 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), tod.on(date, time_zone)
       end

data/test/tod/time_of_day_time_zone_with_active_support_test.rb

@@ -1,18 +1,32 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
-require 'active_support/time'
 
-class TimeOfDayWithActiveSupportTest < Test::Unit::TestCase
-  context "self.time_zone" do
-    context "when Time.zone is nil" do
-      should "be Time" do
-        assert_equal Time, TimeOfDay.time_zone
+describe "TimeOfDay with ActiveSupport" do
+  describe ".time_zone" do
+    before do
+      @orig_zone = Time.zone
+    end
+
+    after do
+      Time.zone = @orig_zone
+    end
+
+    describe "when Time.zone is nil" do
+      before do
+        Time.zone = nil
+      end
+
+      it "is Time" do
+        assert_equal Time, Tod::TimeOfDay.time_zone
       end
     end
 
-    context "when Time.zone is set" do
-      should "be Time.zone" do
+    describe "when Time.zone is set" do
+      before do
         Time.zone = "Central Time (US & Canada)"
-        assert_equal Time.zone, TimeOfDay.time_zone
+      end
+
+      it "is Time.zone" do
+        assert_equal Time.zone, Tod::TimeOfDay.time_zone
       end
     end
   end

data/test/tod/time_test.rb

@@ -1,10 +1,10 @@
 require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
 
-class TimeTest < Test::Unit::TestCase
-  context "to_time_of_day" do
-    should "be TimeOfDay" do
+describe "Time extensions" do
+  describe "#to_time_of_day" do
+    it "is Tod::TimeOfDay" do
       time = Time.local 2000,1,1, 12,30,15
-      assert_equal TimeOfDay.new(12,30,15), time.to_time_of_day
+      assert_equal Tod::TimeOfDay.new(12,30,15), time.to_time_of_day
     end
   end
 end

data/tod.gemspec

@@ -13,9 +13,7 @@ Gem::Specification.new do |s|
   s.description = %q{Supplies TimeOfDay and Shift class that includes parsing, strftime, comparison, and arithmetic.}
   s.license     = 'MIT'
 
-  s.add_development_dependency "test-unit"
-  s.add_development_dependency "shoulda"
-  s.add_development_dependency "mocha"
+  s.add_development_dependency "minitest"
   s.add_development_dependency "tzinfo"
   s.add_development_dependency "rake"
   s.add_development_dependency "activerecord", ">= 3.0.0"

metadata

@@ -1,45 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: tod
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Jack Christensen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-16 00:00:00.000000000 Z
+date: 2015-04-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: test-unit
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: shoulda
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: mocha
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -130,15 +102,15 @@ files:
 - gemfiles/4.2.gemfile
 - lib/tod.rb
 - lib/tod/conversions.rb
-- lib/tod/date.rb
+- lib/tod/core_extensions.rb
+- lib/tod/date_extensions.rb
 - lib/tod/mongoization.rb
 - lib/tod/shift.rb
-- lib/tod/time.rb
+- lib/tod/time_extensions.rb
 - lib/tod/time_of_day.rb
 - lib/tod/version.rb
 - test/support/active_record.rb
 - test/test_helper.rb
-- test/tod/a_a_a_time_of_day_time_zone_without_active_support_test.rb
 - test/tod/conversion_test.rb
 - test/tod/date_test.rb
 - test/tod/shift_test.rb