tod 2.1.1 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 5546b071b1fedc06fb6af4b11dff091e05ffc98d
-  data.tar.gz: bda08b0019d1af90e0a4cb31f5d86833b096737d
+SHA256:
+  metadata.gz: 5b81b1887eee62d6f7a98bf6281f16da3cffd47206925beca789a94b91c3e7c2
+  data.tar.gz: 662b50760caef5be2bf7e41b1b59ced86ece56b8d46b10aa6fe7cd24e33cb869
 SHA512:
-  metadata.gz: 1c6993e9088d273ca572061ee93d80c5549e418dc7d720833dbba5d2ea68d199707e65d459657c3d6af961e4a1bb1c0cdce3b10ee31699c9b769e30e93bed335
-  data.tar.gz: 73c8d5a8b90b06de86d327abf54eac4ce6ee877609595977cbedb3da7322d06eeb1159fcc478eaa34ae7a7541e7fd7052d4407d687cb94a35b99e735f271133d
+  metadata.gz: 8b97d86a5945a3f274b3674b11bd4f09add9ca409e4512ddba81c107acc8e5bc339896fa7b94a5da7d9e61bf8d579e7c866b0473dfc86ef3e6cd2b63c0174964
+  data.tar.gz: f539df0792da43d8a45244e9ba978732d59c02ffc36406047725c7209a44e1958926647b05bdb9c7d51a5d1417d6f2f396246e9aeba63bb17b017b87756a9195

data/.travis.yml

@@ -7,3 +7,7 @@ gemfile:
   - gemfiles/4.1.gemfile
   - gemfiles/4.2.gemfile
   - gemfiles/5.0.gemfile
+matrix:
+  include:
+    - rvm: 2.5.1
+      gemfile: gemfiles/5.2.gemfile

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 2.2.0 (October 10, 2018)
+
+* Add string formatting compatible with Rails (Tate Johnson)
+* Add ability to use ActiveRecord's attribute API (Brent Wheeldon)
+
 # 2.1.1 (April 14, 2017)
 
 * Fix serialize Ruby Time to Tod::TimeOfDay (Ryan Dick)

data/Gemfile.lock

@@ -1,37 +1,40 @@
 PATH
   remote: .
   specs:
-    tod (2.1.1)
+    tod (2.2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (5.0.2)
-      activesupport (= 5.0.2)
-    activerecord (5.0.2)
-      activemodel (= 5.0.2)
-      activesupport (= 5.0.2)
-      arel (~> 7.0)
-    activesupport (5.0.2)
+    activemodel (5.2.0)
+      activesupport (= 5.2.0)
+    activerecord (5.2.0)
+      activemodel (= 5.2.0)
+      activesupport (= 5.2.0)
+      arel (>= 9.0)
+    activesupport (5.2.0)
       concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (~> 0.7)
+      i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-    arel (7.1.4)
-    coderay (1.1.1)
+    arel (9.0.0)
+    byebug (10.0.2)
+    coderay (1.1.2)
     concurrent-ruby (1.0.5)
-    i18n (0.8.1)
-    method_source (0.8.2)
-    minitest (5.10.1)
-    pry (0.10.4)
+    i18n (1.0.1)
+      concurrent-ruby (~> 1.0)
+    method_source (0.9.0)
+    minitest (5.11.3)
+    pry (0.11.3)
       coderay (~> 1.1.0)
-      method_source (~> 0.8.1)
-      slop (~> 3.4)
-    rake (12.0.0)
-    slop (3.6.0)
+      method_source (~> 0.9.0)
+    pry-byebug (3.6.0)
+      byebug (~> 10.0)
+      pry (~> 0.10)
+    rake (12.3.1)
     sqlite3 (1.3.13)
     thread_safe (0.3.6)
-    tzinfo (1.2.2)
+    tzinfo (1.2.5)
       thread_safe (~> 0.1)
 
 PLATFORMS
@@ -41,11 +44,11 @@ DEPENDENCIES
   activerecord (>= 3.0.0)
   arel
   minitest
-  pry
+  pry-byebug
   rake
   sqlite3
   tod!
   tzinfo
 
 BUNDLED WITH
-   1.14.6
+   1.16.3

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,6 +95,19 @@ 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
 ----------
 
@@ -101,7 +120,8 @@ Round to the given nearest number of seconds.
 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
@@ -193,13 +213,26 @@ 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 Serializable Attribute Support
 =======================
 Tod::TimeOfDay implements a custom serialization contract for ActiveRecord serialize which allows to store Tod::TimeOfDay directly
 in a column of the time type.
+
 Example:
+
 ```ruby
 class Order < ActiveRecord::Base
   serialize :time, Tod::TimeOfDay
@@ -208,6 +241,17 @@ order = Order.create(time: Tod::TimeOfDay.new(9,30))
 order.time                                      # => 09:30:00
 ```
 
+By default Rails 5.1 treats database `time` values as if time zones are
+meaningful. Tod::TimeOfDay cannot correctly save and restore values when Rails
+automatically shifts values based on time zone and the normal `serialize`
+interface is not able to override this behavior. To correctly serialize
+Tod::TimeOfDay values with Rails 5.1 time zone handling must be disabled for
+database `time` types. This can be done with the following config:
+
+```
+config.active_record.time_zone_aware_types = [:datetime]
+```
+
 MongoDB Support
 ===============
 

data/gemfiles/5.2.gemfile

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

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/railtie.rb

@@ -0,0 +1,9 @@
+require "tod/time_of_day_type"
+
+module Tod
+  class Railtie < Rails::Railtie
+    initializer "tod.register_active_record_type" do
+      ActiveRecord::Type.register(:time_only, Tod::TimeOfDayType)
+    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)?
       :?
@@ -42,12 +42,21 @@ module Tod
     NUM_SECONDS_IN_HOUR = 3600
     NUM_SECONDS_IN_MINUTE = 60
 
+    FORMATS = {
+      short: "%-l:%M %P",
+      medium: "%-l:%M:%S %P",
+      time: "%H:%M"
+    }
+
     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)
 
@@ -78,12 +87,24 @@ module Tod
 
     # 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.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
 
     # Return a new TimeOfDay num_seconds greater than self. It will wrap around
     # at midnight.
@@ -112,6 +133,7 @@ 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
@@ -138,8 +160,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)
@@ -178,19 +202,23 @@ module Tod
     end
 
     def self.dump(time_of_day)
-      if time_of_day.is_a? Hash
-        # rails multiparam attribute
-        hour,minute,second = time_of_day[4], time_of_day[5], time_of_day[6]
-        ::Tod::TimeOfDay.new(hour, minute, second).to_s
-      elsif time_of_day.to_s == ''
-        nil
-      else
-        Tod::TimeOfDay(time_of_day).to_s
-      end
+      time_of_day =
+        if time_of_day.is_a? Hash
+           # rails multiparam attribute
+           # get hour, minute and second and construct new TimeOfDay object
+          ::Tod::TimeOfDay.new(time_of_day[4], time_of_day[5], time_of_day[6])
+        else
+          # return nil, if input is not parsable
+          Tod::TimeOfDay(time_of_day){}
+        end
+      time_of_day.to_s if time_of_day
     end
 
     def self.load(time)
-      ::Tod::TimeOfDay(time) if time && !time.to_s.empty?
+      if time && !time.to_s.empty?
+        return ::Tod::TimeOfDay.new(24) if time.respond_to?(:day) && time.day == 2 && time.hour == 0 && time.min == 0 && time.sec == 0
+        ::Tod::TimeOfDay(time)
+      end
     end
   end
 end

data/lib/tod/time_of_day_type.rb

@@ -0,0 +1,11 @@
+module Tod
+  class TimeOfDayType < ActiveRecord::Type::Value
+    def cast(value)
+      TimeOfDay.load(value)
+    end
+
+    def serialize(value)
+      TimeOfDay.dump(value)
+    end
+  end
+end

data/lib/tod/version.rb

@@ -1,3 +1,3 @@
 module Tod
-  VERSION = "2.1.1"
+  VERSION = "2.2.0"
 end

data/test/tod/conversion_test.rb

@@ -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/time_of_day_serializable_attribute_test.rb

@@ -19,6 +19,18 @@ describe "TimeOfDay with ActiveRecord Serializable Attribute" 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 Tod::TimeOfDay.dump('')
+      assert_nil Tod::TimeOfDay.dump('unparsable')
+      assert_nil Tod::TimeOfDay.dump(nil)
+    end
   end
 
   describe ".load" do
@@ -41,6 +53,13 @@ describe "TimeOfDay with ActiveRecord Serializable Attribute" do
       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
   end
 
   describe "Order.where" do

data/test/tod/time_of_day_test.rb

@@ -4,7 +4,7 @@ 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 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)
@@ -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"
@@ -102,6 +109,11 @@ describe "TimeOfDay" do
     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 0, Tod::TimeOfDay.new(9,0,0) <=> Tod::TimeOfDay.new(9,0,0)
@@ -123,7 +135,7 @@ describe "TimeOfDay" do
       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(0,0,0), Tod::TimeOfDay.new(23,58,29).round(300)
+      assert_equal Tod::TimeOfDay.new(24,0,0), Tod::TimeOfDay.new(23,58,29).round(300)
     end
   end
 
@@ -133,10 +145,41 @@ 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 "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
 
@@ -215,7 +258,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)

data/tod.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.add_development_dependency "rake"
   s.add_development_dependency "activerecord", ">= 3.0.0"
   s.add_development_dependency "sqlite3"
-  s.add_development_dependency "pry"
+  s.add_development_dependency "pry-byebug"
   s.add_development_dependency "arel"
 
   s.files         = `git ls-files`.split("\n")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tod
 version: !ruby/object:Gem::Version
-  version: 2.1.1
+  version: 2.2.0
 platform: ruby
 authors:
 - Jack Christensen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-14 00:00:00.000000000 Z
+date: 2018-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -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:
     - - ">="
@@ -128,15 +128,18 @@ files:
 - gemfiles/4.1.gemfile
 - gemfiles/4.2.gemfile
 - gemfiles/5.0.gemfile
+- gemfiles/5.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
@@ -168,7 +171,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Supplies TimeOfDay and Shift class