tod 2.1.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 07c87817736be833dd3bc8ce83a55f075cdf79d9
-  data.tar.gz: 6eec299d0c6fe1b0c4c9385d555d9bf60e794ae1
+SHA256:
+  metadata.gz: fd0d2d6c4e128195e0162e4516a89be2ceb08d42787e114e9a03a094e2d24f35
+  data.tar.gz: 1a879241486d84fb99744a23688e48b3d9cd1da0d42019d221ab332c145aaea6
 SHA512:
-  metadata.gz: ac687afb2c4bf51aeb96143f955d68abcf5c1e4e9d82cd1fbd782131f4fbfa30c1992927f19715ef348fa05c8bb0732dc58a4cae24ea84dd41bc17f5bafbc06c
-  data.tar.gz: f1c51e6615f4b1961f5ce874a878a66cd258d30ff3069bd8b3fe3b265412e36273b333286c4ea7ed0ce3046255cbba64e307f4e113e72f06dde63419cdd9934b
+  metadata.gz: df47cc6c284da3c00d8faa6b6fa064cd2d0e69fd696e2ef3be7e4a8a88823d82713de5e70407aea76d71f12dded69e8fb3f1fad45dfd2ccda2f223c48f76d7b1
+  data.tar.gz: a9e9cd0823b2870e8ec4d2dd687b3ec963132a5c795a50d4bb16fbcc0f7117212bc188885f951acdf61806c2e6bb1fc6caf3937d91747857e9e184682b4157ed

data/.gitignore

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

data/.travis.yml

@@ -1,10 +1,3 @@
 language: ruby
 rvm:
-  - 2.3.1
-  - 2.2.5
-  - 2.1.10
-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,25 @@
+# 3.1.0 (December 20, 2021)
+
+* Allow / ignore parsing milliseconds (Eli Fatsi)
+* Improve TimeOfDate#inspect and Shift#inspect (zverok)
+* Fix Shift#contains? with exclusive ending (nazamoresco)
+
+# 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)

data/Gemfile.lock

@@ -1,54 +1,52 @@
 PATH
   remote: .
   specs:
-    tod (2.1.0)
+    tod (3.1.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (4.2.3)
-      activesupport (= 4.2.3)
-      builder (~> 3.1)
-    activerecord (4.2.3)
-      activemodel (= 4.2.3)
-      activesupport (= 4.2.3)
-      arel (~> 6.0)
-    activesupport (4.2.3)
-      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.2)
-    builder (3.2.2)
-    coderay (1.1.0)
-    i18n (0.7.0)
-    json (1.8.3)
-    method_source (0.8.2)
-    minitest (5.7.0)
-    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.5)
-    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)
-  arel
+  activerecord (>= 6.0.0)
   minitest
-  pry
+  pry-byebug
   rake
   sqlite3
   tod!
   tzinfo
 
 BUNDLED WITH
-   1.11.2
+   2.2.15

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
@@ -153,7 +182,7 @@ Include?
     Tod::Shift.new(Tod::TimeOfDay.new(5), Tod::TimeOfDay.new(9), true).include?(Tod::TimeOfDay.new(9)) # => false
 
 
-Overlap?
+Overlaps?
 --------------------
 
     breakfast = Tod::Shift.new(Tod::TimeOfDay.new(8), Tod::TimeOfDay.new(11))
@@ -184,16 +213,32 @@ 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.
+
+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.
 
-Active Record Serializable Attribute Support
+    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
+ActiveModel::Type.register(:time_only, Tod::TimeOfDayType)
+ActiveRecord::Type.register(:time_only, Tod::TimeOfDayType)
+
 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 +286,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/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/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

@@ -24,6 +24,10 @@ module Tod
       freeze # Shift instances are value objects
     end
 
+    def inspect
+      "#<#{self.class} #{beginning}#{exclude_end? ? '...' : '..'}#{ending}>"
+    end
+
     # Returns true if the time of day is inside the shift, false otherwise.
     def include?(tod)
       second = tod.to_i
@@ -33,24 +37,44 @@ module Tod
 
     # Returns true if ranges overlap, false otherwise.
     def overlaps?(other)
-      max_seconds = TimeOfDay::NUM_SECONDS_IN_DAY
-
-      # Standard case, when Shifts are on the same day
-      a, b = [self, other].map(&:range).sort_by(&:first)
-      op = a.exclude_end? ? :> : :>=
-      return true if a.last.send(op, b.first)
-
-      # Special cases, when Shifts span to the next day
-      return false if (a.last < max_seconds) && (b.last < max_seconds)
-
-      a = Range.new(a.first, a.last - max_seconds, a.exclude_end?) if a.last > max_seconds
-      b = Range.new(b.first, b.last - max_seconds, b.exclude_end?) if b.last > max_seconds
-      a, b = [a, b].sort_by(&:last)
-      b.last.send(op, a.last) && 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)
-      self.include?(shift.beginning) && self.include?(shift.ending)
+      self.include?(shift.beginning) && self.include?(shift.inclusive_ending)
     end
 
     # Return shift duration in seconds.
@@ -79,5 +103,12 @@ module Tod
     def slide(seconds)
       self.class.new(beginning + seconds, ending + seconds, exclude_end?)
     end
+
+    protected
+
+    # If exclusive ending returns equivalent ending but inclusive
+    def inclusive_ending
+      self.exclude_end? ? ending - 1 : ending
+    end
   end
 end

data/lib/tod/time_of_day.rb

@@ -9,11 +9,12 @@ module Tod
 
     PARSE_24H_REGEX = /
       \A
-      ([01]?\d|2[0-3])
+      ([01]?\d|2[0-4])
       :?
       ([0-5]\d)?
       :?
       ([0-5]\d)?
+      (?:\.\d{3})?
       \z
     /x
 
@@ -24,6 +25,7 @@ module Tod
       ([0-5]\d)?
       :?
       ([0-5]\d)?
+      (?:\.\d{3})?
       \s*
       ([ap])
       \.?
@@ -34,20 +36,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 +72,48 @@ 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
+
+    def inspect
+      "#<#{self.class} #{self}>"
     end
 
     # Return a new TimeOfDay num_seconds greater than self. It will wrap around
@@ -96,6 +142,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
@@ -122,8 +170,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)
@@ -160,17 +210,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)
-      ::Tod::TimeOfDay(time) if time && !time.to_s.empty?
-    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.1.0"
+  VERSION = "3.1.0"
 end

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/test/test_helper.rb

@@ -4,7 +4,6 @@ require 'bundler/setup'
 require 'active_support/time'
 require 'tod'
 require 'tod/core_extensions'
-require 'tod/arel_extensions'
 require 'minitest/autorun'
 require 'pry'
 

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,25 @@ 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
+
+  it "parses 24:00:00.000" do
+    t   = "24:00:00.000"
+    tod = Tod::TimeOfDay(t)
+
+    assert_equal(tod, Tod::TimeOfDay.new(24, 00, 00))
+  end
+
+  it "parses 04:00:00.000 pm" do
+    t   = "04:00:00.000 pm"
+    tod = Tod::TimeOfDay(t)
+
+    assert_equal(tod, Tod::TimeOfDay.new(16, 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
@@ -11,6 +11,16 @@ describe "Shift" do
     end
   end
 
+  describe "inspect" do
+    it "provides friendly description" do
+      shift = Tod::Shift.new Tod::TimeOfDay.new(8), Tod::TimeOfDay.new(10), false
+      assert_equal "#<Tod::Shift 08:00:00..10:00:00>", shift.inspect
+
+      shift = Tod::Shift.new Tod::TimeOfDay.new(8), Tod::TimeOfDay.new(10), true
+      assert_equal "#<Tod::Shift 08:00:00...10:00:00>", shift.inspect
+    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
@@ -99,6 +109,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
@@ -119,6 +172,12 @@ describe "Shift" do
       shift2 = Tod::Shift.new(Tod::TimeOfDay.new(18), Tod::TimeOfDay.new(19))
       refute shift1.contains?(shift2)
     end
+
+    it "is true when beginning is included and exclusive endings match" do
+      inside = Tod::Shift.new(Tod::TimeOfDay.new(13), Tod::TimeOfDay.new(17), true)
+      outside = Tod::Shift.new(Tod::TimeOfDay.new(10), Tod::TimeOfDay.new(17), true)
+      assert outside.contains?(inside)
+    end
   end
 
   describe "#include?" do

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,55 @@ 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
+
+  describe "inspect" do
+    it "is friendly representation" do
+      t = Tod::TimeOfDay.new(12,15,05)
+      assert_equal "#<Tod::TimeOfDay 12:15:05>", t.inspect
     end
   end
 
@@ -201,7 +272,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)
@@ -219,6 +290,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,10 +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 "arel"
+  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.1.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Jack Christensen
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-05-09 00:00:00.000000000 Z
+date: 2021-12-20 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,21 +81,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry
-  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: arel
+  name: pry-byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -124,26 +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/arel_extensions.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
@@ -152,7 +135,7 @@ homepage: https://github.com/JackC/tod
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -167,9 +150,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: Supplies TimeOfDay and Shift class
 test_files:
@@ -178,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/lib/tod/arel_extensions.rb

@@ -1,25 +0,0 @@
-require 'arel'
-
-module Tod
-  module ArelDepthFirstExtensions
-    def self.included(base)
-      base.send :alias_method, :visit_Tod_TimeOfDay, :terminal
-    end
-  end
-
-  module ArelDotExtensions
-    def self.included(base)
-      base.send :alias_method, :visit_Tod_TimeOfDay, :visit_String
-    end
-  end
-
-  module ArelToSqlExtensions
-    def visit_Tod_TimeOfDay(o, collector=nil)
-      quote Tod::TimeOfDay.dump(o)
-    end
-  end
-end
-
-Arel::Visitors::DepthFirst.send :include, Tod::ArelDepthFirstExtensions
-Arel::Visitors::Dot.send :include, Tod::ArelDotExtensions
-Arel::Visitors::ToSql.send :include, Tod::ArelToSqlExtensions

data/test/tod/time_of_day_serializable_attribute_test.rb

@@ -1,42 +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)
-      order.reload
-      assert_equal order.time, time_of_day
-    end
-
-    it "returns nil if time is not set" do
-      order = Order.create!(time: nil)
-      order.reload
-      assert_equal order.time, nil
-    end
-  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