tod 2.0.1 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 0e1df7c0f812d7e18d6d9b10c256f2e26e63268c
-  data.tar.gz: f01a512e048fa9087ab1b89376a2f6a49574357f
+SHA256:
+  metadata.gz: 8986b140f4dcc736d253b188cd5f9a46a72110f38887cd6e8ff93ecee823c438
+  data.tar.gz: 95d31c83abc1264946bf2ce6aa6ba6fac45dcaeca1362b76a22d54eab27f402f
 SHA512:
-  metadata.gz: cf81e8e52153b7e894d0a970a88c6da2fe94dbabf984cd289be160b7ab1eb43ce78e6c991c0f833ac25ebc818a7950deae44d19610a1f66081ba1998dae3bbd3
-  data.tar.gz: d6665499e05b78076fab42c5dfe4b67c94750ad71fc722384f51b7c97aad9b6fc78fc3b2e9906d3af273f66c769bdd73bce956cb206f7a4b63209cd8237d43d0
+  metadata.gz: 2d1c3b50deb1df502928666b38e113fb7d58b4a25c140119bac8155ad3ff3add0689cffba810b7bdd6ab1461493838873a839ac259895630210e47679ae9ef89
+  data.tar.gz: 98a76ddcb2b8c866f602efe1def27c236b88ffcc6bbb12812580794113dc964d5b6df1bd95b0f055a48e9e95ca4b69ccf3dea93b20f866ca72be7932596e1aaf

data/.gitignore

@@ -4,3 +4,5 @@ pkg/*
 nbproject
 *.swp
 .rvmrc
+vendor/
+.idea

data/.travis.yml

@@ -1,11 +1,3 @@
 language: ruby
 rvm:
-  - 2.2.0
-  - 2.1.5
-  - 2.0.0
-  - 1.9.3
-gemfile:
-  - gemfiles/3.2.gemfile
-  - gemfiles/4.0.gemfile
-  - gemfiles/4.1.gemfile
-  - gemfiles/4.2.gemfile
+  - 2.6.5

data/CHANGELOG.md

@@ -1,3 +1,31 @@
+# 3.0.0 (March 6, 2021)
+
+* Support and require Rails 6
+
+# 2.2.0 (October 10, 2018)
+
+* Add string formatting compatible with Rails (Tate Johnson)
+* Add ability to use ActiveRecord's attribute API (Brent Wheeldon)
+* Add method for use in Rails database quoting (Ben Jackson)
+
+# 2.1.1 (April 14, 2017)
+
+* Fix serialize Ruby Time to Tod::TimeOfDay (Ryan Dick)
+* Fix TimeOfDay.from_second_of_day when passed float (Jack Christensen)
+* Fix Rails 5 multi-param assignment (Miklos Fazekas)
+
+# 2.1.0 (May 9, 2016)
+
+* Fix date extensions requiring date (ambirdsall)
+* Add subtraction to TimeOfDay (Hiroki Shirai)
+* Add equality comparison for shifts (Greg Beech)
+* Add arel_extensions for TimeOfDay (Paul Tyng)
+* Support for shifts that span to other days (kennyeni)
+
+# 2.0.2 (May 21, 2015)
+
+* Fix ActiveRecord serialization when core extensions not loaded
+
 # 2.0.1 (May 8, 2015)
 
 * Fix Tod::TimeOfDay() without core extensions

data/Gemfile.lock

@@ -1,50 +1,52 @@
 PATH
   remote: .
   specs:
-    tod (2.0.0)
+    tod (3.0.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (4.2.0)
-      activesupport (= 4.2.0)
-      builder (~> 3.1)
-    activerecord (4.2.0)
-      activemodel (= 4.2.0)
-      activesupport (= 4.2.0)
-      arel (~> 6.0)
-    activesupport (4.2.0)
-      i18n (~> 0.7)
-      json (~> 1.7, >= 1.7.7)
-      minitest (~> 5.1)
-      thread_safe (~> 0.3, >= 0.3.4)
-      tzinfo (~> 1.1)
-    arel (6.0.0)
-    builder (3.2.2)
-    coderay (1.1.0)
-    i18n (0.7.0)
-    json (1.8.2)
-    method_source (0.8.2)
-    minitest (5.5.1)
-    pry (0.10.1)
-      coderay (~> 1.1.0)
-      method_source (~> 0.8.1)
-      slop (~> 3.4)
-    rake (10.4.2)
-    slop (3.6.0)
-    sqlite3 (1.3.10)
-    thread_safe (0.3.4)
-    tzinfo (1.2.2)
-      thread_safe (~> 0.1)
+    activemodel (6.1.3)
+      activesupport (= 6.1.3)
+    activerecord (6.1.3)
+      activemodel (= 6.1.3)
+      activesupport (= 6.1.3)
+    activesupport (6.1.3)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 1.6, < 2)
+      minitest (>= 5.1)
+      tzinfo (~> 2.0)
+      zeitwerk (~> 2.3)
+    byebug (11.1.3)
+    coderay (1.1.3)
+    concurrent-ruby (1.1.8)
+    i18n (1.8.9)
+      concurrent-ruby (~> 1.0)
+    method_source (1.0.0)
+    minitest (5.14.4)
+    pry (0.13.1)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-byebug (3.9.0)
+      byebug (~> 11.0)
+      pry (~> 0.13.0)
+    rake (13.0.3)
+    sqlite3 (1.4.2)
+    tzinfo (2.0.4)
+      concurrent-ruby (~> 1.0)
+    zeitwerk (2.4.2)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  activerecord (>= 3.0.0)
+  activerecord (>= 6.0.0)
   minitest
-  pry
+  pry-byebug
   rake
   sqlite3
   tod!
   tzinfo
+
+BUNDLED WITH
+   2.0.2

data/README.markdown

@@ -54,6 +54,12 @@ parsable.
     Tod::TimeOfDay.try_parse "3:30pm"                   # => 15:30:00
     Tod::TimeOfDay.try_parse "foo"                      # => nil
 
+You can also give a block to parse to handle special input with your own logic.
+
+    Tod::TimeOfDay.parse "25" do |time_string|
+      Tod::TimeOfDay.new(time_string.to_i % 24)
+    end                                                 # => 01:00:00
+
 Values can be tested with Tod::TimeOfDay.parsable? to see if they can be parsed.
 
     Tod::TimeOfDay.parsable? "3:30pm"                   # => true
@@ -62,7 +68,7 @@ Values can be tested with Tod::TimeOfDay.parsable? to see if they can be parsed.
 Adding or subtracting time
 -----------------------------
 
-Seconds can be added to or subtracted Tod::TimeOfDay objects. Time correctly wraps
+Seconds can be added to or subtracted from Tod::TimeOfDay objects. Time correctly wraps
 around midnight.
 
     Tod::TimeOfDay.new(8) + 3600                        # => 09:00:00
@@ -89,10 +95,33 @@ Format strings are passed to Time#strftime.
     Tod::TimeOfDay.new(17,15).strftime("%I:%M %p")      # => "05:15 PM"
     Tod::TimeOfDay.new(22,5,15).strftime("%I:%M:%S %p") # => "10:05:15 PM"
 
+Or a Rails style `to_formatted_s` is aliased to `to_s`.
+
+    Tod::TimeOfDay.new(8,30).to_s(:short)    # => "8:30 am"
+
+Or [i18n](https://github.com/svenfuchs/i18n) in a Rails ERB view.
+
+    <%= l Tod::TimeOfDay.new(8, 30), format: :short %>
+
+Add new formatters to `Tod::TimeOfDay::FORMATS`.
+
+    Tod::TimeOfDay::FORMATS[:seconds_only] = "%S"
+    Tod::TimeOfDay.new(8,30,57).to_s(:seconds_only)  # => "57"
+
+Rounding
+----------
+
+Round to the given nearest number of seconds.
+
+    Tod::TimeOfDay.new(8,15,31).round(5)     # => "08:15:30"
+    Tod::TimeOfDay.new(8,15,34).round(60)    # => "08:16:00"
+    Tod::TimeOfDay.new(8,02,29).round(300)   # => "08:00:00"
+
 Convenience methods for dates and times
 ---------------------------------------
 
-Pass a date to Tod::TimeOfDay#on and it will return a time with that date and time.
+Pass a date to Tod::TimeOfDay#on and it will return a time with that date and time,
+in the time zone of the ruby runtime (`Time.now.zone`).
 
     tod = Tod::TimeOfDay.new 8, 30                  # => 08:30:00
     tod.on Date.today                               # => 2010-12-29 08:30:00 -0600
@@ -184,16 +213,29 @@ Contains?
 Rails Time Zone Support
 =======================
 
-If Rails time zone support is loaded, Date#on and Tod::TimeOfDay#at will automatically use Time.zone.
+If Rails time zone support is loaded, Date#on and Tod::TimeOfDay#at (when given a Date) will automatically use Time.zone.
 
-Active Record Serializable Attribute Support
+When Tod::TimeOfDay#on is given a `Time` or `Time`-like object like `ActiveSupport::TimeWithZone`,
+Tod will ignore the specified timezone and return the time on that date in UTC. In order to
+produce an object with the correct time and time zone, pass in an
+`ActiveSupport::TimeZone` object. Date#at has analogous behavior.
+
+    time = Time.now.in_time_zone("US/Eastern")           # => Mon, 24 Sep 2018 05:07:23 EDT -04:00
+    tod.on time                                          # => Mon, 24 Sep 2018 08:30:00 UTC +00:00
+    tod.on time, time.time_zone                          # => Mon, 24 Sep 2018 08:30:00 EDT -04:00
+    tod.on time, Time.find_zone!("US/Mountain")          # => Mon, 24 Sep 2018 08:30:00 MDT -06:00
+    Date.tomorrow.at tod, Time.find_zone!("US/Mountain") # => Tue, 25 Sep 2018 08:30:00 MDT -06:00
+
+ActiveRecord Attribute Support
 =======================
-Tod::TimeOfDay implements a custom serialization contract for ActiveRecord serialize which allows to store Tod::TimeOfDay directly
+Tod::TimeOfDay can be used as an ActiveRecord attribute to store Tod::TimeOfDay directly
 in a column of the time type.
+
 Example:
+
 ```ruby
 class Order < ActiveRecord::Base
-  serialize :time, Tod::TimeOfDay
+  attribute :time, :time_only
 end
 order = Order.create(time: Tod::TimeOfDay.new(9,30))
 order.time                                      # => 09:30:00
@@ -241,10 +283,10 @@ Compatibility
 
 [![Build Status](https://travis-ci.org/jackc/tod.png)](https://travis-ci.org/jackc/tod)
 
-Tod is compatible with Ruby 1.9.3, 2.0.0, 2.1.8, and 2.2.0. It is tested against Rails 3.2, 4.0, 4.1, 4.2.
+Tod is tested against Ruby 2.6.x and  Rails 6.x.
 
 
 License
 =======
 
-Copyright (c) 2010-2015 Jack Christensen, released under the MIT license
+Copyright (c) 2010-2021 Jack Christensen, released under the MIT license

data/lib/tod.rb

@@ -1,3 +1,5 @@
 require 'tod/time_of_day'
 require 'tod/shift'
 require 'tod/conversions'
+
+require 'tod/railtie' if defined?(Rails)

data/lib/tod/conversions.rb

@@ -1,5 +1,5 @@
 module Tod
-  def TimeOfDay(obj_or_string)
+  def TimeOfDay(obj_or_string, &block)
     if obj_or_string.is_a?(TimeOfDay)
       obj_or_string
     elsif obj_or_string.respond_to?(:to_time_of_day)
@@ -9,7 +9,7 @@ module Tod
     elsif obj_or_string.is_a?(Date)
       TimeOfDay.new 0
     else
-      TimeOfDay.parse(obj_or_string)
+      TimeOfDay.parse(obj_or_string, &block)
     end
   end
 

data/lib/tod/date_extensions.rb

@@ -1,3 +1,5 @@
+require 'date'
+
 module Tod
   module DateExtensions
     # Returns a local Time instance with this date and time_of_day

data/lib/tod/railtie.rb

@@ -0,0 +1,12 @@
+require "active_model/type"
+require "active_record/type"
+require "tod/time_of_day_type"
+
+module Tod
+  class Railtie < Rails::Railtie
+    initializer "tod.register_active_model_type" do
+      ActiveModel::Type.register(:time_only, Tod::TimeOfDayType)
+      ActiveRecord::Type.register(:time_only, Tod::TimeOfDayType)
+    end
+  end
+end

data/lib/tod/shift.rb

@@ -33,9 +33,40 @@ module Tod
 
     # 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)
+      a, b = [self, other].map(&:range)
+      #
+      #  Although a Shift which passes through midnight is stored
+      #  internally as lasting more than TimeOfDay::NUM_SECONDS_IN_DAY
+      #  seconds from midnight, that's not how it is meant to be
+      #  handled.  Rather, it consists of two chunks:
+      #
+      #    range.first => Midnight
+      #    Midnight => range.last
+      #
+      #  The second one is *before* the first.  None of it is more than
+      #  TimeOfDay::NUM_SECONDS_IN_DAY after midnight.  We thus need to shift
+      #  each of our ranges to cover all overlapping possibilities.
+      #
+      one_day = TimeOfDay::NUM_SECONDS_IN_DAY
+      ashifted =
+        Range.new(a.first + one_day, a.last + one_day, a.exclude_end?)
+      bshifted =
+        Range.new(b.first + one_day, b.last + one_day, b.exclude_end?)
+      #
+      #  For exclusive ranges we need:
+      #
+      #  a.ending > b.beginning && b.ending > a.beginning
+      #
+      #  and for inclusive we need:
+      #
+      #  a.ending >= b.beginning && b.ending >= a.beginning
+      #
+      aop = a.exclude_end? ? :> : :>=
+      bop = b.exclude_end? ? :> : :>=
+      #
+      (a.last.send(aop, b.first) && b.last.send(bop, a.first)) ||
+      (ashifted.last.send(aop, b.first) && b.last.send(bop, ashifted.first)) ||
+      (a.last.send(aop, bshifted.first) && bshifted.last.send(bop, a.first))
     end
 
     def contains?(shift)
@@ -51,5 +82,22 @@ module Tod
     def exclude_end?
       @exclude_end
     end
+
+    def ==(other)
+      @range == other.range
+    end
+
+    def eql?(other)
+      @range.eql?(other.range)
+    end
+
+    def hash
+      @range.hash
+    end
+
+    # Move start and end by a number of seconds and return new shift.
+    def slide(seconds)
+      self.class.new(beginning + seconds, ending + seconds, exclude_end?)
+    end
   end
 end

data/lib/tod/time_of_day.rb

@@ -9,7 +9,7 @@ module Tod
 
     PARSE_24H_REGEX = /
       \A
-      ([01]?\d|2[0-3])
+      ([01]?\d|2[0-4])
       :?
       ([0-5]\d)?
       :?
@@ -34,20 +34,29 @@ module Tod
     /x
 
     WORDS = {
-      "noon" => "12pm",
-      "midnight" => "12am"
+      "noon" => "12pm".freeze,
+      "midnight" => "12am".freeze
     }
 
     NUM_SECONDS_IN_DAY = 86400
     NUM_SECONDS_IN_HOUR = 3600
     NUM_SECONDS_IN_MINUTE = 60
 
+    FORMATS = {
+      short: "%-l:%M %P".freeze,
+      medium: "%-l:%M:%S %P".freeze,
+      time: "%H:%M".freeze
+    }
+
     def initialize(h, m=0, s=0)
       @hour = Integer(h)
       @minute = Integer(m)
       @second = Integer(s)
 
-      raise ArgumentError, "hour must be between 0 and 23" unless (0..23).include?(@hour)
+      raise ArgumentError, "hour must be between 0 and 24" unless (0..24).include?(@hour)
+      if @hour == 24 && (@minute != 0 || @second != 0)
+        raise ArgumentError, "hour can only be 24 when minute and second are 0"
+      end
       raise ArgumentError, "minute must be between 0 and 59" unless (0..59).include?(@minute)
       raise ArgumentError, "second must be between 0 and 59" unless (0..59).include?(@second)
 
@@ -61,13 +70,44 @@ module Tod
       @second_of_day <=> other.second_of_day
     end
 
+    # Rounding to the given nearest number of seconds
+    def round(round_sec = 1)
+      down = self - (self.to_i % round_sec)
+      up = down + round_sec
+
+      difference_down = self - down
+      difference_up = up - self
+
+      if (difference_down < difference_up)
+        return down
+      else
+        return up
+      end
+    end
+
     # Formats identically to Time#strftime
     def strftime(format_string)
+      # Special case 2400 because strftime will load TimeOfDay into Time which
+      # will convert 24 to 0
+      format_string = format_string.gsub(/%H|%k/, '24') if @hour == 24
       Time.local(2000,1,1, @hour, @minute, @second).strftime(format_string)
     end
 
-    def to_s
-      strftime "%H:%M:%S"
+    def to_formatted_s(format = :default)
+      if formatter = FORMATS[format]
+        if formatter.respond_to?(:call)
+          formatter.call(self).to_s
+        else
+          strftime(formatter)
+        end
+      else
+        strftime "%H:%M:%S"
+      end
+    end
+    alias_method :to_s, :to_formatted_s
+
+    def value_for_database
+      to_s
     end
 
     # Return a new TimeOfDay num_seconds greater than self. It will wrap around
@@ -78,8 +118,12 @@ module Tod
 
     # Return a new TimeOfDay num_seconds less than self. It will wrap around
     # at midnight.
-    def -(num_seconds)
-      TimeOfDay.from_second_of_day @second_of_day - num_seconds
+    def -(other)
+      if other.instance_of?(TimeOfDay)
+        TimeOfDay.from_second_of_day @second_of_day - other.second_of_day
+      else
+        TimeOfDay.from_second_of_day @second_of_day - other
+      end
     end
 
     # Returns a Time instance on date using self as the time of day
@@ -92,6 +136,8 @@ module Tod
     #
     #   TimeOfDay.from_second_of_day(3600) == TimeOfDay.new(1)   # => true
     def self.from_second_of_day(second_of_day)
+      second_of_day = Integer(second_of_day)
+      return new 24 if second_of_day == NUM_SECONDS_IN_DAY
       remaining_seconds = second_of_day % NUM_SECONDS_IN_DAY
       hour = remaining_seconds / NUM_SECONDS_IN_HOUR
       remaining_seconds -= hour * NUM_SECONDS_IN_HOUR
@@ -118,8 +164,10 @@ module Tod
     #   TimeOfDay.parse "3:25:58"                      # => 03:25:58
     #   TimeOfDay.parse "515p"                         # => 17:15:00
     #   TimeOfDay.parse "151253"                       # => 15:12:53
+    # You can give a block, that is called with the input if the string is not parsable.
+    # If no block is given an ArgumentError is raised if try_parse returns nil.
     def self.parse(tod_string)
-      try_parse(tod_string) || (raise ArgumentError, "Invalid time of day string")
+      try_parse(tod_string) || (block_given? ? yield(tod_string) : raise(ArgumentError, "Invalid time of day string"))
     end
 
     # Same as parse(), but return nil if not parsable (instead of raising an error)
@@ -156,21 +204,5 @@ module Tod
     def self.time_zone
       (Time.respond_to?(:zone) && Time.zone) || Time
     end
-
-    def self.dump(time_of_day)
-      if time_of_day.to_s == ''
-        nil
-      else
-        time_of_day.to_s
-      end
-    end
-
-    def self.load(time)
-      if time.respond_to?(:to_time_of_day)
-        time.to_time_of_day
-      else
-        TimeOfDay.parse(time) if time && !time.empty?
-      end
-    end
   end
 end

data/lib/tod/time_of_day_type.rb

@@ -0,0 +1,18 @@
+module Tod
+  class TimeOfDayType < ActiveModel::Type::Value
+    def cast(value)
+      if value.is_a? Hash
+          # rails multiparam attribute
+          # get hour, minute and second and construct new TimeOfDay object
+        ::Tod::TimeOfDay.new(value[4], value[5], value[6])
+      else
+        # return nil, if input is not parsable
+        Tod::TimeOfDay(value){}
+      end
+    end
+
+    def serialize(value)
+      value.to_s if value.present?
+    end
+  end
+end

data/lib/tod/version.rb

@@ -1,3 +1,3 @@
 module Tod
-  VERSION = "2.0.1"
+  VERSION = "3.0.0"
 end

data/test/tod/conversion_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+require_relative '../test_helper'
 
 describe "TimeOfDay()" do
   it "handles Tod::TimeOfDay" do
@@ -81,4 +81,11 @@ describe "TimeOfDay()" do
 
     assert_equal(tod, Tod::TimeOfDay.new(0, 00, 00))
   end
+
+  it "parses 24:00:00" do
+    t   = "24:00:00"
+    tod = Tod::TimeOfDay(t)
+
+    assert_equal(tod, Tod::TimeOfDay.new(24, 00, 00))
+  end
 end

data/test/tod/date_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+require_relative '../test_helper'
 
 describe "Date extensions" do
   describe "#at" do

data/test/tod/shift_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+require_relative '../test_helper'
 
 describe "Shift" do
   describe "#initialize" do
@@ -43,12 +43,49 @@ describe "Shift" 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)
+
+      # Additional Testing for Shifts that span from one day to another
+      cases = [
+        [5, 8, 7, 2],
+        [7, 2, 1, 8],
+        [7, 2, 5, 8],
+        [4, 8, 1, 5],
+        [1, 5, 4, 8],
+        [7, 2, 1, 4],
+        [1, 4, 7, 2],
+        [1, 4, 3, 2],
+        [5, 8, 7, 2],
+        [7, 2, 8, 3],
+        [7, 2, 6, 3],
+        [7, 2, 1, 8]
+      ]
+
+      cases.each do |c|
+        shift1 = Tod::Shift.new(Tod::TimeOfDay.new(c[0]), Tod::TimeOfDay.new(c[1]))
+        shift2 = Tod::Shift.new(Tod::TimeOfDay.new(c[2]), Tod::TimeOfDay.new(c[3]))
+        assert shift1.overlaps?(shift2), "Failed with args: #{c}"
+      end
     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)
+
+      # Additional Testing for Shifts that span from one day to another
+      cases = [
+        [7, 8, 1, 5],
+        [1, 5, 7, 8],
+        [7, 2, 3, 4],
+        [3, 4, 5, 2],
+        [1, 5, 9, 12]
+      ]
+
+      cases.each do |c|
+        shift1 = Tod::Shift.new(Tod::TimeOfDay.new(c[0]), Tod::TimeOfDay.new(c[1]))
+        shift2 = Tod::Shift.new(Tod::TimeOfDay.new(c[2]), Tod::TimeOfDay.new(c[3]))
+        refute shift1.overlaps?(shift2), "Failed with args: #{c}"
+      end
     end
 
     it "is true when shifts touch with inclusive end" do
@@ -62,6 +99,49 @@ describe "Shift" do
       shift2 = Tod::Shift.new(Tod::TimeOfDay.new(5), Tod::TimeOfDay.new(12), true)
       refute shift1.overlaps?(shift2)
     end
+
+    it "copes correctly with mixed shifts" 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), true)
+      assert shift1.overlaps?(shift2)
+      assert shift2.overlaps?(shift1)
+      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))
+      refute shift1.overlaps?(shift2)
+      refute shift2.overlaps?(shift1)
+    end
+
+    it "copes correctly with zero length inclusive end shifts" do
+      shift1 = Tod::Shift.new(Tod::TimeOfDay.new(9), Tod::TimeOfDay.new(17))
+      shift2 = Tod::Shift.new(Tod::TimeOfDay.new(10), Tod::TimeOfDay.new(10))
+      shift3 = Tod::Shift.new(Tod::TimeOfDay.new(9), Tod::TimeOfDay.new(9))
+      shift4 = Tod::Shift.new(Tod::TimeOfDay.new(17), Tod::TimeOfDay.new(17))
+      assert shift1.overlaps?(shift2)
+      assert shift2.overlaps?(shift1)
+
+      assert shift1.overlaps?(shift3)
+      assert shift3.overlaps?(shift1)
+
+      assert shift1.overlaps?(shift4)
+      assert shift4.overlaps?(shift1)
+
+    end
+
+    it "copes correctly with zero length exclusive end shifts" do
+      shift1 = Tod::Shift.new(Tod::TimeOfDay.new(9), Tod::TimeOfDay.new(17), true)
+      shift2 = Tod::Shift.new(Tod::TimeOfDay.new(10), Tod::TimeOfDay.new(10), true)
+      shift3 = Tod::Shift.new(Tod::TimeOfDay.new(9), Tod::TimeOfDay.new(9), true)
+      shift4 = Tod::Shift.new(Tod::TimeOfDay.new(17), Tod::TimeOfDay.new(17), true)
+      assert shift1.overlaps?(shift2)
+      assert shift2.overlaps?(shift1)
+
+      refute shift1.overlaps?(shift3)
+      refute shift3.overlaps?(shift1)
+
+      refute shift1.overlaps?(shift4)
+      refute shift4.overlaps?(shift1)
+
+    end
   end
 
   describe "contains?" do
@@ -166,4 +246,153 @@ describe "Shift" do
       assert shift.include?(value)
     end
   end
+
+  describe "#==" do
+    it "is true when the beginning time, end time, and exclude end are the same" do
+      tod1 = Tod::TimeOfDay.new 8,30
+      tod2 = Tod::TimeOfDay.new 13,00,30
+      shift1 = Tod::Shift.new tod1, tod2
+      shift2 = Tod::Shift.new tod1, tod2
+      assert shift1 == shift2
+    end
+
+    it "is false when the beginning time is different" do
+      tod1 = Tod::TimeOfDay.new 8,30
+      tod2 = Tod::TimeOfDay.new 13,00,30
+      shift1 = Tod::Shift.new tod1, tod2
+      shift2 = Tod::Shift.new tod1, Tod::TimeOfDay.new(14,00)
+      assert !(shift1 == shift2)
+    end
+
+    it "is false when the ending time is different" do
+      tod1 = Tod::TimeOfDay.new 8,30
+      tod2 = Tod::TimeOfDay.new 13,00,30
+      shift1 = Tod::Shift.new tod1, tod2
+      shift2 = Tod::Shift.new Tod::TimeOfDay.new(9,30), tod2
+      assert !(shift1 == shift2)
+    end
+
+    it "is false when exclude end is different" do
+      tod1 = Tod::TimeOfDay.new 8,30
+      tod2 = Tod::TimeOfDay.new 13,00,30
+      shift1 = Tod::Shift.new tod1, tod2
+      shift2 = Tod::Shift.new tod1, tod2, true
+      assert !(shift1 == shift2)
+    end
+  end
+
+  describe "#eql?" do
+    it "is true when the beginning time, end time, and exclude end are the same" do
+      tod1 = Tod::TimeOfDay.new 8,30
+      tod2 = Tod::TimeOfDay.new 13,00,30
+      shift1 = Tod::Shift.new tod1, tod2
+      shift2 = Tod::Shift.new tod1, tod2
+      assert shift1.eql?(shift2)
+    end
+
+    it "is false when the beginning time is different" do
+      tod1 = Tod::TimeOfDay.new 8,30
+      tod2 = Tod::TimeOfDay.new 13,00,30
+      shift1 = Tod::Shift.new tod1, tod2
+      shift2 = Tod::Shift.new tod1, Tod::TimeOfDay.new(14,00)
+      assert !shift1.eql?(shift2)
+    end
+
+    it "is false when the ending time is different" do
+      tod1 = Tod::TimeOfDay.new 8,30
+      tod2 = Tod::TimeOfDay.new 13,00,30
+      shift1 = Tod::Shift.new tod1, tod2
+      shift2 = Tod::Shift.new Tod::TimeOfDay.new(9,30), tod2
+      assert !shift1.eql?(shift2)
+    end
+
+    it "is false when exclude end is different" do
+      tod1 = Tod::TimeOfDay.new 8,30
+      tod2 = Tod::TimeOfDay.new 13,00,30
+      shift1 = Tod::Shift.new tod1, tod2
+      shift2 = Tod::Shift.new tod1, tod2, true
+      assert !shift1.eql?(shift2)
+    end
+  end
+
+  describe "#hash" do
+    it "is the same when the beginning time, end time, and exclude end are the same" do
+      tod1 = Tod::TimeOfDay.new 8,30
+      tod2 = Tod::TimeOfDay.new 13,00,30
+      shift1 = Tod::Shift.new tod1, tod2
+      shift2 = Tod::Shift.new tod1, tod2
+      assert_equal shift1.hash, shift2.hash
+    end
+
+    it "is usually different when the beginning time is different" do
+      tod1 = Tod::TimeOfDay.new 8,30
+      tod2 = Tod::TimeOfDay.new 13,00,30
+      shift1 = Tod::Shift.new tod1, tod2
+      shift2 = Tod::Shift.new tod1, Tod::TimeOfDay.new(14,00)
+      assert shift1.hash != shift2.hash
+    end
+
+    it "is usually different when the ending time is different" do
+      tod1 = Tod::TimeOfDay.new 8,30
+      tod2 = Tod::TimeOfDay.new 13,00,30
+      shift1 = Tod::Shift.new tod1, tod2
+      shift2 = Tod::Shift.new Tod::TimeOfDay.new(9,30), tod2
+      assert shift1.hash != shift2.hash
+    end
+
+    it "is usually different when exclude end is different" do
+      tod1 = Tod::TimeOfDay.new 8,30
+      tod2 = Tod::TimeOfDay.new 13,00,30
+      shift1 = Tod::Shift.new tod1, tod2
+      shift2 = Tod::Shift.new tod1, tod2, true
+      assert shift1.hash != shift2.hash
+    end
+  end
+
+  describe "slide" do
+    it "handles positive numbers" do
+      slide = 30 * 60 # 30 minutes in seconds
+
+      beginning_expected = Tod::TimeOfDay.new 10, 30
+      ending_expected = Tod::TimeOfDay.new 16, 30
+
+      beginning  = Tod::TimeOfDay.new 10
+      ending  = Tod::TimeOfDay.new 16
+      shift = Tod::Shift.new(beginning, ending, false).slide(slide)
+
+      assert_equal beginning_expected, shift.beginning
+      assert_equal ending_expected, shift.ending
+      refute shift.exclude_end?
+    end
+
+    it "handles negative numbers" do
+      slide = -30 * 60 # -30 minutes in seconds
+
+      beginning_expected = Tod::TimeOfDay.new 9, 30
+      ending_expected = Tod::TimeOfDay.new 15, 30
+
+      beginning  = Tod::TimeOfDay.new 10
+      ending  = Tod::TimeOfDay.new 16
+      shift = Tod::Shift.new(beginning, ending, false).slide(slide)
+
+      assert_equal beginning_expected, shift.beginning
+      assert_equal ending_expected, shift.ending
+      refute shift.exclude_end?
+    end
+
+    it "handles ActiveSupport::Duration" do
+      slide = 30.minutes
+
+      beginning_expected = Tod::TimeOfDay.new 10, 30
+      ending_expected = Tod::TimeOfDay.new 16, 30
+
+      beginning  = Tod::TimeOfDay.new 10
+      ending  = Tod::TimeOfDay.new 16
+      shift = Tod::Shift.new(beginning, ending, false).slide(slide)
+
+      assert_equal beginning_expected, shift.beginning
+      assert_equal ending_expected, shift.ending
+      refute shift.exclude_end?
+    end
+  end
 end

data/test/tod/time_of_day_attribute_test.rb

@@ -0,0 +1,74 @@
+require_relative '../test_helper'
+require File.expand_path(File.join(File.dirname(__FILE__),'..','support/active_record'))
+
+require 'tod/time_of_day_type'
+
+ActiveModel::Type.register(:time_only, Tod::TimeOfDayType)
+ActiveRecord::Type.register(:time_only, Tod::TimeOfDayType)
+
+class Order < ActiveRecord::Base
+  attribute :time, :time_only
+end
+
+describe "TimeOfDay with ActiveRecord Attribute" do
+  it "sets time of day" do
+    Order.create!(time: Tod::TimeOfDay.new(9, 30))
+  end
+
+  it "sets nil as value" do
+    Order.create!(time: nil)
+  end
+
+  it "works with multiparam time arguments" do
+    order = Order.create!({"time(4i)" => "8", "time(5i)" => "6", "time(6i)" => "5"})
+    assert_equal Tod::TimeOfDay.new(8,6,5), order.time
+  end
+
+  it "should not raise Exception on access of unparsable values" do
+    order = Order.new(time: 'unparsable')
+    order.time
+    assert order.valid?
+  end
+
+  it "should dump unparsable values to nil" do
+    assert_nil Order.new(time: '').time
+    assert_nil Order.new(time: 'unparsable').time
+    assert_nil Order.new(time: nil).time
+  end
+
+  it "loads set Tod::TimeOfDay" do
+    time_of_day = Tod::TimeOfDay.new(9, 30)
+    order = Order.create!(time: time_of_day)
+    order.reload
+    assert_equal order.time, time_of_day
+  end
+
+  it "loads set Time" do
+    time_of_day = Time.new(2015, 10, 21, 16, 29, 0, "-07:00")
+    order = Order.create!(time: time_of_day)
+    order.reload
+    assert_equal order.time, Tod::TimeOfDay.new(16, 29)
+  end
+
+  it "returns nil if time is not set" do
+    order = Order.create!(time: nil)
+    order.reload
+    assert_nil order.time
+  end
+
+  it "dump 24:00:00 and get it back" do
+    time_of_day = Tod::TimeOfDay.new(24, 0, 0)
+    order = Order.create!(time: time_of_day)
+    order.reload
+    assert_equal Tod::TimeOfDay.new(24), order.time
+  end
+
+  describe "Order.where" do
+    it "handles TimeOfDay as a parameter" do
+      tod = Tod::TimeOfDay.new(11, 11)
+      expected = Order.create!(time: tod)
+      actual = Order.where(time: tod).first
+      assert_equal expected, actual
+    end
+  end
+end

data/test/tod/time_of_day_test.rb

@@ -1,10 +1,10 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+require_relative '../test_helper'
 
 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 }
+      assert_raises(ArgumentError) { Tod::TimeOfDay.new(-1) }
+      assert_raises(ArgumentError) { Tod::TimeOfDay.new 25 }
     end
 
     it "blocks invalid minutes" do
@@ -31,6 +31,10 @@ describe "TimeOfDay" do
       assert_equal 86399, Tod::TimeOfDay.new(23,59,59).second_of_day
     end
 
+    it "is 86400 at beginning of next day" do
+      assert_equal 86400, Tod::TimeOfDay.new(24,0,0).second_of_day
+    end
+
     it "have alias to_i" do
       tod = Tod::TimeOfDay.new(0,0,0)
       assert_equal tod.method(:second_of_day), tod.method(:to_i)
@@ -50,7 +54,7 @@ describe "TimeOfDay" do
   def self.should_not_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_nil Tod::TimeOfDay.try_parse(parse_string)
       assert_raises(ArgumentError) { Tod::TimeOfDay.parse(parse_string) }
     end
   end
@@ -84,9 +88,12 @@ describe "TimeOfDay" do
   should_parse "12a",          0, 0, 0
   should_parse "12p",         12, 0, 0
 
+  should_parse "24:00:00",    24, 0, 0
+  should_parse "24:00",       24, 0, 0
+  should_parse "24",          24, 0, 0
+  should_parse "2400",        24, 0, 0
+
   should_not_parse "-1:30"
-  should_not_parse "24:00:00"
-  should_not_parse "24"
   should_not_parse "00:60"
   should_not_parse "00:00:60"
   should_not_parse "13a"
@@ -98,12 +105,17 @@ describe "TimeOfDay" do
 
   it "does not parse 'nil'" do
     assert_equal false, Tod::TimeOfDay.parsable?(nil)
-    assert_equal nil, Tod::TimeOfDay.try_parse(nil)
+    assert_nil Tod::TimeOfDay.try_parse(nil)
     assert_raises(ArgumentError) { Tod::TimeOfDay.parse(nil) }
   end
 
+  it "executes block on parsing failure and return result instead" do
+    assert_equal Tod::TimeOfDay.new(1), Tod::TimeOfDay.parse('25:00:00') { Tod::TimeOfDay.new(1) }
+    assert_equal Tod::TimeOfDay.new(1), Tod::TimeOfDay.parse('25:00:00') { |time_string| Tod::TimeOfDay.parse(time_string.sub('25', '01')) }
+  end
+
   it "provides spaceship operator" do
-    assert_equal -1, Tod::TimeOfDay.new(8,0,0) <=> Tod::TimeOfDay.new(9,0,0)
+    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
@@ -112,6 +124,20 @@ describe "TimeOfDay" do
     assert_equal Tod::TimeOfDay.new(8,0,0), Tod::TimeOfDay.new(8,0,0)
   end
 
+  describe "round_nearest" do
+    it "rounds to the given nearest number of seconds" do
+      assert_equal Tod::TimeOfDay.new(8,15,30), Tod::TimeOfDay.new(8,15,31).round(5)
+      assert_equal Tod::TimeOfDay.new(8,15,35), Tod::TimeOfDay.new(8,15,33).round(5)
+      assert_equal Tod::TimeOfDay.new(8,16,0), Tod::TimeOfDay.new(8,15,34).round(60)
+      assert_equal Tod::TimeOfDay.new(8,15,0), Tod::TimeOfDay.new(8,15,15).round(60)
+      assert_equal Tod::TimeOfDay.new(8,15,0), Tod::TimeOfDay.new(8,17,15).round(300)
+      assert_equal Tod::TimeOfDay.new(8,20,0), Tod::TimeOfDay.new(8,18,15).round(300)
+      assert_equal Tod::TimeOfDay.new(8,20,0), Tod::TimeOfDay.new(8,20,00).round(300)
+      assert_equal Tod::TimeOfDay.new(9,0,0), Tod::TimeOfDay.new(8,58,00).round(300)
+      assert_equal Tod::TimeOfDay.new(8,0,0), Tod::TimeOfDay.new(8,02,29).round(300)
+      assert_equal Tod::TimeOfDay.new(24,0,0), Tod::TimeOfDay.new(23,58,29).round(300)
+    end
+  end
 
   describe "strftime" do
     it "accepts standard strftime format codes" do
@@ -119,10 +145,48 @@ describe "TimeOfDay" do
     end
   end
 
+  describe "to_formatted_s" do
+    it "has a default format" do
+      assert_equal "08:15:30", Tod::TimeOfDay.new(8,15,30).to_formatted_s
+      assert_equal "22:10:45", Tod::TimeOfDay.new(22,10,45).to_formatted_s
+    end
+
+    it "has a short format" do
+      assert_equal "8:15 am", Tod::TimeOfDay.new(8,15,30).to_formatted_s(:short)
+      assert_equal "10:10 pm", Tod::TimeOfDay.new(22,10,45).to_formatted_s(:short)
+    end
+
+    it "has a medium format" do
+      assert_equal "8:15:30 am", Tod::TimeOfDay.new(8,15,30).to_formatted_s(:medium)
+      assert_equal "10:10:45 pm", Tod::TimeOfDay.new(22,10,45).to_formatted_s(:medium)
+    end
+
+    it "has an ActiveSupport compatible time format" do
+      assert_equal "08:15", Tod::TimeOfDay.new(8,15,30).to_formatted_s(:time)
+      assert_equal "22:10", Tod::TimeOfDay.new(22,10,45).to_formatted_s(:time)
+    end
+
+    it "evaluates custom lambda lambda formats" do
+      begin
+        Tod::TimeOfDay::FORMATS[:lambda] = -> (t) { t.strftime("%H%M 😎") }
+        assert_equal "1337 😎", Tod::TimeOfDay.new(13,37).to_formatted_s(:lambda)
+      ensure
+        Tod::TimeOfDay::FORMATS.delete(:lambda)
+      end
+    end
+  end
+
+  describe "value_for_database" do
+    it "returns a formatted value for database query serialization" do
+      t = Tod::TimeOfDay.new(12,15,05)
+      assert_equal "12:15:05", t.value_for_database
+    end
+  end
+
   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
+    it "is aliased to to_formatted_s" do
+      t = Tod::TimeOfDay.new(8,15,30)
+      assert_equal t.to_formatted_s, t.to_s
     end
   end
 
@@ -151,6 +215,12 @@ describe "TimeOfDay" do
       result = original + 15
       refute_equal original.object_id, result.object_id
     end
+
+    it "handles ActiveSupport::Duration" do
+      original = Tod::TimeOfDay.new(8,0,0)
+      result = original + 10.minutes
+      assert_equal Tod::TimeOfDay.new(8,10,0), result
+    end
   end
 
   describe "subtraction" do
@@ -171,6 +241,19 @@ describe "TimeOfDay" do
       result = original - 15
       refute_equal original.object_id, result.object_id
     end
+
+    it "handles ActiveSupport::Duration" do
+      original = Tod::TimeOfDay.new(8,0,0)
+      result = original - 10.minutes
+      assert_equal Tod::TimeOfDay.new(7,50,0), result
+    end
+
+    it "subtracts Tod::TimeOfDay object" do
+      right_side = Tod::TimeOfDay.new(10,0,0)
+      left_side = Tod::TimeOfDay.new(12,0,30)
+      result = right_side - left_side
+      assert_equal Tod::TimeOfDay.new(21,59,30), result
+    end
   end
 
   describe "from_second_of_day" do
@@ -182,7 +265,7 @@ describe "TimeOfDay" do
     end
 
     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(24,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)
@@ -200,6 +283,10 @@ describe "TimeOfDay" do
     it "has alias from_i" do
       assert_equal Tod::TimeOfDay.method(:from_second_of_day), Tod::TimeOfDay.method(:from_i)
     end
+
+    it "handles floats" do
+      assert_equal Tod::TimeOfDay.new(15,30,0), Tod::TimeOfDay.from_second_of_day(55800.0)
+    end
   end
 
   describe "on" do

data/test/tod/time_of_day_time_zone_with_active_support_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+require_relative '../test_helper'
 
 describe "TimeOfDay with ActiveSupport" do
   describe ".time_zone" do

data/test/tod/time_test.rb

@@ -1,4 +1,4 @@
-require File.expand_path(File.join(File.dirname(__FILE__),'..','test_helper'))
+require_relative '../test_helper'
 
 describe "Time extensions" do
   describe "#to_time_of_day" do

data/tod.gemspec

@@ -16,9 +16,9 @@ Gem::Specification.new do |s|
   s.add_development_dependency "minitest"
   s.add_development_dependency "tzinfo"
   s.add_development_dependency "rake"
-  s.add_development_dependency "activerecord", ">= 3.0.0"
+  s.add_development_dependency "activerecord", ">= 6.0.0"
   s.add_development_dependency "sqlite3"
-  s.add_development_dependency "pry"
+  s.add_development_dependency "pry-byebug"
 
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tod
 version: !ruby/object:Gem::Version
-  version: 2.0.1
+  version: 3.0.0
 platform: ruby
 authors:
 - Jack Christensen
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-05-08 00:00:00.000000000 Z
+date: 2021-03-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 6.0.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.0
+        version: 6.0.0
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
@@ -81,7 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -110,25 +110,23 @@ files:
 - MIT-LICENSE
 - README.markdown
 - Rakefile
-- gemfiles/3.2.gemfile
-- gemfiles/4.0.gemfile
-- gemfiles/4.1.gemfile
-- gemfiles/4.2.gemfile
 - lib/tod.rb
 - lib/tod/conversions.rb
 - lib/tod/core_extensions.rb
 - lib/tod/date_extensions.rb
 - lib/tod/mongoization.rb
+- lib/tod/railtie.rb
 - lib/tod/shift.rb
 - lib/tod/time_extensions.rb
 - lib/tod/time_of_day.rb
+- lib/tod/time_of_day_type.rb
 - lib/tod/version.rb
 - test/support/active_record.rb
 - test/test_helper.rb
 - test/tod/conversion_test.rb
 - test/tod/date_test.rb
 - test/tod/shift_test.rb
-- test/tod/time_of_day_serializable_attribute_test.rb
+- test/tod/time_of_day_attribute_test.rb
 - test/tod/time_of_day_test.rb
 - test/tod/time_of_day_time_zone_with_active_support_test.rb
 - test/tod/time_test.rb
@@ -137,7 +135,7 @@ homepage: https://github.com/JackC/tod
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -152,9 +150,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.5
-signing_key: 
+rubygems_version: 3.0.6
+signing_key:
 specification_version: 4
 summary: Supplies TimeOfDay and Shift class
 test_files:
@@ -163,7 +160,7 @@ test_files:
 - test/tod/conversion_test.rb
 - test/tod/date_test.rb
 - test/tod/shift_test.rb
-- test/tod/time_of_day_serializable_attribute_test.rb
+- test/tod/time_of_day_attribute_test.rb
 - test/tod/time_of_day_test.rb
 - test/tod/time_of_day_time_zone_with_active_support_test.rb
 - test/tod/time_test.rb

data/gemfiles/3.2.gemfile

@@ -1,5 +0,0 @@
-source "https://rubygems.org"
-
-gem "activerecord", "~> 3.2.13"
-
-gemspec :path=>"../"

data/gemfiles/4.0.gemfile

@@ -1,5 +0,0 @@
-source "https://rubygems.org"
-
-gem "activerecord", "4.0.0"
-
-gemspec :path=>"../"

data/gemfiles/4.1.gemfile

@@ -1,5 +0,0 @@
-source "https://rubygems.org"
-
-gem "activerecord", "~> 4.1.8"
-
-gemspec :path=>"../"

data/gemfiles/4.2.gemfile

@@ -1,5 +0,0 @@
-source "https://rubygems.org"
-
-gem "activerecord", "~> 4.2.0"
-
-gemspec :path=>"../"

data/test/tod/time_of_day_serializable_attribute_test.rb

@@ -1,31 +0,0 @@
-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, Tod::TimeOfDay
-end
-
-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
-
-    it "sets nil as value" do
-      Order.create(time: nil)
-    end
-  end
-
-  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
-
-    it "returns nil if time is not set" do
-      order = Order.create(time: nil)
-      assert_equal order.time, nil
-    end
-  end
-end