tod 1.5.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cb8660843c84b0445056017a9e55c4e24a26759d
-  data.tar.gz: af34e5365fdcc5fed74129ffcf1c46dd5476414a
+  metadata.gz: 7ea9182b8d4d70181c761c96a87a97bc3ac8c316
+  data.tar.gz: 846e0db24fb222b1e445e50eb5a6623b020ee82f
 SHA512:
-  metadata.gz: 091d891b412086559a229fa04407f200315b01fc39f0a79c7305a0847b865f8d4e20252d53fe77bd0f1290d1b0cceea31f90d681f00a1bb8a39c2f2bd3942ea8
-  data.tar.gz: f29c38d109354008fad673e1ad7c3afcb78510992c70f96b4bfe8aab512a3b132e8d6a6674e185aa8aed4ae46dec39ae44cfb840169d82459543a3b38ed8de1c
+  metadata.gz: 50d7a807b6cbee926593c019abba1ee47f2c9f13ca00f1cf85a7a1213a70951db5b490b02ceb10e93b40784d9243ba71ee68fa0f3ed6d51c327cc687abae066e
+  data.tar.gz: abdea735146667ace0f136b4040b2f9fd762ec1e2179febd7e51e608ef68827c62bdd720a2222aba77a1e3d8a0249979fce3bc5c83e491d05d44448935938c10

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# 2.0.0 (April 18, 2015)
+
+* Shift now supports exclusive ends like a Ruby range
+* Add Shift#overlaps? (Michael Amor Righi)
+* Add Shift#contains? (Michael Amor Righi)
+* Do not pollute global namespace
+
 # 1.5.0 (January 15, 2015)
 
 * Fix: return nil unless other is comparable (Peter Yates)

data/Gemfile.lock

@@ -1,52 +1,42 @@
 PATH
   remote: .
   specs:
-    tod (1.4.0)
+    tod (1.5.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (3.2.13)
-      activesupport (= 3.2.13)
-      builder (~> 3.0.0)
-    activerecord (3.2.13)
-      activemodel (= 3.2.13)
-      activesupport (= 3.2.13)
-      arel (~> 3.0.2)
-      tzinfo (~> 0.3.29)
-    activesupport (3.2.13)
-      i18n (= 0.6.1)
-      multi_json (~> 1.0)
-    arel (3.0.2)
-    bourne (1.4.0)
-      mocha (~> 0.13.2)
-    builder (3.0.4)
-    i18n (0.6.1)
-    metaclass (0.0.1)
-    mocha (0.13.3)
-      metaclass (~> 0.0.1)
-    multi_json (1.7.2)
-    rake (10.0.4)
-    shoulda (3.4.0)
-      shoulda-context (~> 1.0, >= 1.0.1)
-      shoulda-matchers (~> 1.0, >= 1.4.1)
-    shoulda-context (1.1.1)
-    shoulda-matchers (1.5.6)
-      activesupport (>= 3.0.0)
-      bourne (~> 1.3)
-    sqlite3 (1.3.7)
-    test-unit (2.5.4)
-    tzinfo (0.3.37)
+    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)
+    i18n (0.7.0)
+    json (1.8.2)
+    minitest (5.5.1)
+    rake (10.4.2)
+    sqlite3 (1.3.10)
+    thread_safe (0.3.4)
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
   activerecord (>= 3.0.0)
-  mocha
+  minitest
   rake
-  shoulda
   sqlite3
-  test-unit
   tod!
   tzinfo

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010 Jack Christensen
+Copyright (c) 2010-2015 Jack Christensen
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.markdown

@@ -24,8 +24,8 @@ Loading Tod
 Creating from hour, minute, and second
 --------------------------------------
 
-    TimeOfDay.new 8                                # => 08:00:00
-    TimeOfDay.new 8, 15, 30                        # => 08:15:30
+    Tod::TimeOfDay.new 8                                # => 08:00:00
+    Tod::TimeOfDay.new 8, 15, 30                        # => 08:15:30
 
 Parsing text
 ------------
@@ -33,70 +33,74 @@ Parsing text
 Strings only need to contain an hour. Minutes, seconds, AM or PM, and colons
 are all optional.
 
-    TimeOfDay.parse "8"                            # => 08:00:00
-    TimeOfDay.parse "8am"                          # => 08:00:00
-    TimeOfDay.parse "8pm"                          # => 20:00:00
-    TimeOfDay.parse "8p"                           # => 20:00:00
-    TimeOfDay.parse "9:30"                         # => 09:30:00
-    TimeOfDay.parse "15:30"                        # => 15:30:00
-    TimeOfDay.parse "3:30pm"                       # => 15:30:00
-    TimeOfDay.parse "1230"                         # => 12:30:00
-    TimeOfDay.parse "3:25:58"                      # => 03:25:58
-    TimeOfDay.parse "515p"                         # => 17:15:00
-    TimeOfDay.parse "151253"                       # => 15:12:53
-    TimeOfDay.parse "noon"                         # => 12:00:00
-    TimeOfDay.parse "midnight"                     # => 00:00:00
-
-TimeOfDay.parse raises an ArgumentError is the argument to parse is not
-parsable. TimeOfDay.try_parse will instead return nil if the argument is not
+    Tod::TimeOfDay.parse "8"                            # => 08:00:00
+    Tod::TimeOfDay.parse "8am"                          # => 08:00:00
+    Tod::TimeOfDay.parse "8pm"                          # => 20:00:00
+    Tod::TimeOfDay.parse "8p"                           # => 20:00:00
+    Tod::TimeOfDay.parse "9:30"                         # => 09:30:00
+    Tod::TimeOfDay.parse "15:30"                        # => 15:30:00
+    Tod::TimeOfDay.parse "3:30pm"                       # => 15:30:00
+    Tod::TimeOfDay.parse "1230"                         # => 12:30:00
+    Tod::TimeOfDay.parse "3:25:58"                      # => 03:25:58
+    Tod::TimeOfDay.parse "515p"                         # => 17:15:00
+    Tod::TimeOfDay.parse "151253"                       # => 15:12:53
+    Tod::TimeOfDay.parse "noon"                         # => 12:00:00
+    Tod::TimeOfDay.parse "midnight"                     # => 00:00:00
+
+Tod::TimeOfDay.parse raises an ArgumentError if the argument to parse is not
+parsable. Tod::TimeOfDay.try_parse will instead return nil if the argument is not
 parsable.
 
-    TimeOfDay.try_parse "3:30pm"                   # => 15:30:00
-    TimeOfDay.try_parse "foo"                      # => nil
+    Tod::TimeOfDay.try_parse "3:30pm"                   # => 15:30:00
+    Tod::TimeOfDay.try_parse "foo"                      # => nil
 
-Values can be tested with TimeOfDay.parsable? to see if they can be parsed.
+Values can be tested with Tod::TimeOfDay.parsable? to see if they can be parsed.
 
-    TimeOfDay.parsable? "3:30pm"                   # => true
-    TimeOfDay.parsable? "foo"                      # => false
+    Tod::TimeOfDay.parsable? "3:30pm"                   # => true
+    Tod::TimeOfDay.parsable? "foo"                      # => false
 
 Adding or subtracting time
 -----------------------------
 
-Seconds can be added to or subtracted TimeOfDay objects. Time correctly wraps
+Seconds can be added to or subtracted Tod::TimeOfDay objects. Time correctly wraps
 around midnight.
 
-    TimeOfDay.new(8) + 3600                        # => 09:00:00
-    TimeOfDay.new(8) - 3600                        # => 07:00:00
-    TimeOfDay.new(0) - 30                          # => 23:59:30
-    TimeOfDay.new(23,59,45) + 30                   # => 00:00:15
+    Tod::TimeOfDay.new(8) + 3600                        # => 09:00:00
+    Tod::TimeOfDay.new(8) - 3600                        # => 07:00:00
+    Tod::TimeOfDay.new(0) - 30                          # => 23:59:30
+    Tod::TimeOfDay.new(23,59,45) + 30                   # => 00:00:15
 
 Comparing
 --------------------
 
-TimeOfDay includes Comparable.
+Tod::TimeOfDay includes Comparable.
 
-    TimeOfDay.new(8) < TimeOfDay.new(9)            # => true
-    TimeOfDay.new(8) == TimeOfDay.new(9)           # => false
-    TimeOfDay.new(9) == TimeOfDay.new(9)           # => true
-    TimeOfDay.new(10) > TimeOfDay.new(9)           # => true
+    Tod::TimeOfDay.new(8) < Tod::TimeOfDay.new(9)            # => true
+    Tod::TimeOfDay.new(8) == Tod::TimeOfDay.new(9)           # => false
+    Tod::TimeOfDay.new(9) == Tod::TimeOfDay.new(9)           # => true
+    Tod::TimeOfDay.new(10) > Tod::TimeOfDay.new(9)           # => true
 
 Formatting
 ----------
 
 Format strings are passed to Time#strftime.
 
-    TimeOfDay.new(8,30).strftime("%H:%M")          # => "08:30"
-    TimeOfDay.new(17,15).strftime("%I:%M %p")      # => "05:15 PM"
-    TimeOfDay.new(22,5,15).strftime("%I:%M:%S %p") # => "10:05:15 PM"
+    Tod::TimeOfDay.new(8,30).strftime("%H:%M")          # => "08:30"
+    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"
 
 Convenience methods for dates and times
 ---------------------------------------
 
-Tod adds Date#on and Time#to_time_of_day. If you do not want the core extensions
-then require 'tod/time_of_day' instead of 'tod'.
+Pass a date to Tod::TimeOfDay#on and it will return a time with that date and time.
 
-    tod = TimeOfDay.new 8, 30                       # => 08:30:00
+    tod = Tod::TimeOfDay.new 8, 30                  # => 08:30:00
     tod.on Date.today                               # => 2010-12-29 08:30:00 -0600
+
+Tod offers Date#at and Time#to_time_of_day. Require 'tod/core_extensions' to enable.
+
+    require 'tod/core_extensions'
+    tod = Tod::TimeOfDay.new 8, 30                  # => 08:30:00
     Date.today.at tod                               # => 2010-12-29 08:30:00 -0600
     Time.now.to_time_of_day                         # => 16:30:43
     DateTime.now.to_time_of_day                     # => 16:30:43
@@ -106,57 +110,132 @@ Conversion method
 
 Tod provides a conversion method which will handle a variety of input types:
 
-    TimeOfDay(TimeOfDay.new(8, 30))           # => 08:30:00
-    TimeOfDay("09:45")                        # => 09:45:00
-    TimeOfDay(Time.new(2014, 1, 1, 12, 30))   # => 12:30:00
-    TimeOfDay(Date.new(2014, 1, 1))           # => 00:00:00
+    Tod::TimeOfDay(Tod::TimeOfDay.new(8, 30))           # => 08:30:00
+    Tod::TimeOfDay("09:45")                        # => 09:45:00
+    Tod::TimeOfDay(Time.new(2014, 1, 1, 12, 30))   # => 12:30:00
+    Tod::TimeOfDay(Date.new(2014, 1, 1))           # => 00:00:00
 
 
 Shifts
 =======================
 
-Represents a period of time, using a beginning and ending TimeOfDay. Allows to calculate its duration and
-to determine if a TimeOfDay is included inside the shift. For nightly shifts (when beginning time is greater than ending time),
-it supposes the shift ends the following day.
+Tod::Shift is a range-like object that represents a period of time, using a
+beginning and ending Tod::TimeOfDay. Allows to calculate its duration and to
+determine if a Tod::TimeOfDay is included inside the shift. For nightly shifts
+(when beginning time is greater than ending time), it supposes the shift ends
+the following day. Tod::Shift behaves like a Ruby range in that it defaults to
+inclusive endings. For exclusive endings, pass true as the third argument
+(like a Ruby range).
 
-Creating from TimeOfDay
+Creating from Tod::TimeOfDay
 --------------------------------------
 
-    Shift.new(TimeOfDay.new(9), TimeOfDay.new(17))
-    Shift.new(TimeOfDay.new(22), TimeOfDay.new(4))
+    Tod::Shift.new(Tod::TimeOfDay.new(9), Tod::TimeOfDay.new(17))
+    Tod::Shift.new(Tod::TimeOfDay.new(22), Tod::TimeOfDay.new(4))
 
 Duration
 --------------------
 
-    Shift.new(TimeOfDay.new(9), TimeOfDay.new(17)).duration # => 28800
-    Shift.new(TimeOfDay.new(20), TimeOfDay.new(2)).duration # => 21600
+    Tod::Shift.new(Tod::TimeOfDay.new(9), Tod::TimeOfDay.new(17)).duration # => 28800
+    Tod::Shift.new(Tod::TimeOfDay.new(20), Tod::TimeOfDay.new(2)).duration # => 21600
 
 Include?
 --------------------
 
-    Shift.new(TimeOfDay.new(9), TimeOfDay.new(17)).include?(TimeOfDay.new(12)) # => true
-    Shift.new(TimeOfDay.new(9), TimeOfDay.new(17)).include?(TimeOfDay.new(7))  # => false
-    Shift.new(TimeOfDay.new(20), TimeOfDay.new(4)).include?(TimeOfDay.new(2))  # => true
-    Shift.new(TimeOfDay.new(20), TimeOfDay.new(4)).include?(TimeOfDay.new(18)) # => false
+    Tod::Shift.new(Tod::TimeOfDay.new(9), Tod::TimeOfDay.new(17)).include?(Tod::TimeOfDay.new(12)) # => true
+    Tod::Shift.new(Tod::TimeOfDay.new(9), Tod::TimeOfDay.new(17)).include?(Tod::TimeOfDay.new(7))  # => false
+    Tod::Shift.new(Tod::TimeOfDay.new(20), Tod::TimeOfDay.new(4)).include?(Tod::TimeOfDay.new(2))  # => true
+    Tod::Shift.new(Tod::TimeOfDay.new(20), Tod::TimeOfDay.new(4)).include?(Tod::TimeOfDay.new(18)) # => false
+
+#include? respects exclusive endings.
+
+    Tod::Shift.new(Tod::TimeOfDay.new(5), Tod::TimeOfDay.new(9)).include?(Tod::TimeOfDay.new(9)) # => true
+    Tod::Shift.new(Tod::TimeOfDay.new(5), Tod::TimeOfDay.new(9), true).include?(Tod::TimeOfDay.new(9)) # => false
+
+
+Overlap?
+--------------------
+
+    breakfast = Tod::Shift.new(Tod::TimeOfDay.new(8), Tod::TimeOfDay.new(11))
+    lunch = Tod::Shift.new(Tod::TimeOfDay.new(10), Tod::TimeOfDay.new(14))
+    breakfast.overlaps?(lunch) # => true
+    lunch.overlaps?(breakfast) # => true
+
+    dinner = Tod::Shift.new(Tod::TimeOfDay.new(18), Tod::TimeOfDay.new(20))
+    dinner.overlaps?(lunch) # => false
+
+    # Exclude ending
+    morning_shift = Tod::Shift.new(Tod::TimeOfDay.new(9), Tod::TimeOfDay.new(17), true)
+    evening_shift = Tod::Shift.new(Tod::TimeOfDay.new(17), Tod::TimeOfDay.new(1), true)
+    morning_shift.overlaps?(evening_shift) # => false
+
+
+Contains?
+--------------------
+    workday = Shift.new(TimeOfDay.new(9), TimeOfDay.new(17))
+    lunch = Shift.new(TimeOfDay.new(10), TimeOfDay.new(14))
+    workday.contains?(lunch) # => true
+    lunch.contains?(workday) # => false
+
+    dinner = Shift.new(TimeOfDay.new(18), TimeOfDay.new(20))
+    dinner.overlaps?(lunch) # => false
+
 
 Rails Time Zone Support
 =======================
 
-If Rails time zone support is loaded, Date#on and TimeOfDay#at will automatically use Time.zone.
+If Rails time zone support is loaded, Date#on and Tod::TimeOfDay#at will automatically use Time.zone.
 
 Active Record Serializable Attribute Support
 =======================
-TimeOfDay implements a custom serialization contract for activerecord serialize which allows to store TimeOfDay directly
+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
 end
-order = Order.create(time: TimeOfDay.new(9,30))
+order = Order.create(time: Tod::TimeOfDay.new(9,30))
 order.time                                      # => 09:30:00
 ```
 
+MongoDB Support
+===============
+
+Tod includes optional serialization support for Tod::TimeOfDay to be serialized to MongoDB.
+
+```
+require 'tod/mongoization'
+```
+
+Upgrading from Versions Prior to 2.0.0
+======================================
+
+Tod has a new focus on not polluting the global namespace.
+
+Tod no longer puts Tod::TimeOfDay and Tod::Shift in the global namespace by default. You can either fully qualify access to these classes or include Tod in the global namespace.
+
+```
+require 'tod'
+include Tod # TimeOfDay and Shift are now in the global namespace like in versions prior to 2.0.0
+```
+
+Tod no longer automatically extends the Time and Date classes. Require them explicitly.
+
+```
+require 'tod/core_extensions'
+tod = Tod::TimeOfDay.new 8, 30                  # => 08:30:00
+Date.today.at tod                               # => 2010-12-29 08:30:00 -0600
+Time.now.to_time_of_day                         # => 16:30:43
+DateTime.now.to_time_of_day                     # => 16:30:43
+```
+
+Tod no longer automatically includes MongoDB serialization methods in Tod::TimeOfDay. Require them explicitly.
+
+```
+require 'tod/mongoization'
+```
+
 Compatibility
 =============
 
@@ -168,4 +247,4 @@ Tod is compatible with Ruby 1.9.3, 2.0.0, 2.1.8, and 2.2.0. It is tested against
 License
 =======
 
-Copyright (c) 2010-2013 Jack Christensen, released under the MIT license
+Copyright (c) 2010-2015 Jack Christensen, released under the MIT license

data/lib/tod.rb

@@ -1,13 +1,3 @@
 require 'tod/time_of_day'
-require 'tod/date'
-require 'tod/time'
 require 'tod/shift'
 require 'tod/conversions'
-require 'tod/mongoization'
-
-include Tod
-include Tod::Conversions
-class TimeOfDay
-  include(Tod::Mongoization)
-  extend(Tod::Mongoization::ClassMethods)
-end

data/lib/tod/conversions.rb

@@ -1,15 +1,13 @@
 module Tod
-  module Conversions
-    module_function
-
-    def TimeOfDay(obj_or_string)
-      if obj_or_string.is_a?(TimeOfDay)
-        obj_or_string
-      elsif obj_or_string.respond_to?(:to_time_of_day)
-        obj_or_string.to_time_of_day
-      else
-        TimeOfDay.parse(obj_or_string)
-      end
+  def TimeOfDay(obj_or_string)
+    if obj_or_string.is_a?(TimeOfDay)
+      obj_or_string
+    elsif obj_or_string.respond_to?(:to_time_of_day)
+      obj_or_string.to_time_of_day
+    else
+      TimeOfDay.parse(obj_or_string)
     end
   end
+
+  module_function :TimeOfDay
 end

data/lib/tod/core_extensions.rb

@@ -0,0 +1,2 @@
+require 'tod/date_extensions'
+require 'tod/time_extensions'

data/lib/tod/date_extensions.rb

@@ -0,0 +1,15 @@
+module Tod
+  module DateExtensions
+    # Returns a local Time instance with this date and time_of_day
+    # Pass in time_zone to use ActiveSupport::TimeZone
+    def at(time_of_day, time_zone=Tod::TimeOfDay.time_zone)
+      time_zone.local year, month, day, time_of_day.hour, time_of_day.minute, time_of_day.second
+    end
+
+    def to_time_of_day
+      Tod::TimeOfDay.new hour, minute, second
+    end
+  end
+end
+
+Date.send :include, Tod::DateExtensions

data/lib/tod/mongoization.rb

@@ -1,3 +1,5 @@
+require 'tod/time_of_day'
+
 module Tod
   module Mongoization
 
@@ -33,4 +35,11 @@ module Tod
       end
     end
   end
-end
+end
+
+module Tod
+  class TimeOfDay
+    include(Tod::Mongoization)
+    extend(Tod::Mongoization::ClassMethods)
+  end
+end