ttilley-time_crisis 0.0.3 → 0.1.0

data/README.markdown

@@ -3,55 +3,58 @@ Arbitrary Date Ranges
 
 You can create a Range with a beginning and end Date using the convenience methods 'for' and 'from'. 'for' will create a range into the future while 'from' creates a range into the past.
 
-	Date.today.for(2, 'years')
-	 => Fri, 18 Sep 2009..Sat, 17 Sep 2011 
+	TimeCrisis::Date.today.for(2, 'years')
+     => #<TimeCrisis::Date 2009-09-22>..#<TimeCrisis::Date 2011-09-21> 
 
-	Date.today.from(2, 'years')
-	 => Wed, 19 Sep 2007..Fri, 18 Sep 2009 
+	TimeCrisis::Date.today.from(2, 'years')
+	 => #<TimeCrisis::Date 2007-09-23>..#<TimeCrisis::Date 2009-09-22>
 
 If you want to be more literal in your syntax, you can use the range method directly:
 
-	Date.today.range(2, 'months', 'future')
-	 => Fri, 18 Sep 2009..Tue, 17 Nov 2009 
+	TimeCrisis::Date.today.range(2, 'months', 'future')
+	 => #<TimeCrisis::Date 2009-09-22>..#<TimeCrisis::Date 2009-11-21>
 
-	Date.today.range(2, 'months', 'past')
-	 => Sun, 19 Jul 2009..Fri, 18 Sep 2009 
+	TimeCrisis::Date.today.range(2, 'months', 'past')
+	 => #<TimeCrisis::Date 2009-07-23>..#<TimeCrisis::Date 2009-09-22>
 
 There is also a class method for defining ranges that allows you to specify a beginning and end for the range, or just one of beginning or end and then the scale (months, years) and unit (number of scale).
 
-	Date.range(:begin => Date.today, :scale => 'months', :unit => 3)
-	 => Fri, 18 Sep 2009..Thu, 17 Dec 2009 
+	TimeCrisis::Date.range(:begin => Date.today, :scale => 'months', :unit => 3)
+	 => #<TimeCrisis::Date 2009-09-22>..#<TimeCrisis::Date 2009-12-21>
 
-	Date.range(:begin => Date.civil(2008, 3, 1), :end => Date.civil(2008, 12, 31))
-	 => Sat, 01 Mar 2008..Wed, 31 Dec 2008 
+	TimeCrisis::Date.range(:begin => Date.civil(2008, 3, 1), :end => Date.civil(2008, 12, 31))
+	 => #<TimeCrisis::Date 2008-03-01>..#<TimeCrisis::Date 2008-12-31>
 
 Named Months
 ============
 
 A range of dates for a month can be created using that month's name, optionally passing in a year.
 
-	Date.february # 28 days in feb 2009
-	 => Sun, 01 Feb 2009..Sat, 28 Feb 2009 
+	TimeCrisis::Date.february # 28 days in feb 2009
+	 => #<TimeCrisis::Date 2009-02-01>..#<TimeCrisis::Date 2009-02-28>
 
-	Date.february(2008) # 29 days in feb 2008
-	 => Fri, 01 Feb 2008..Fri, 29 Feb 2008 
+	TimeCrisis::Date.february(2008) # 29 days in feb 2008
+	 => #<TimeCrisis::Date 2008-02-01>..#<TimeCrisis::Date 2008-02-29>
 
 
 Meteorological Season Calculations
 ==================================
 
-	Date.civil(2009, 4, 1).meteorological_spring?
+	TimeCrisis::Date.beginning_of_meteorological_spring
+	 => #<TimeCrisis::Date 2009-03-01>
+
+	TimeCrisis::Date.beginning_of_meteorological_spring(2008)
+	 => #<TimeCrisis::Date 2008-03-01> 
+
+	TimeCrisis::Date.civil(2009, 4, 1).meteorological_spring?
 	 => true 
 
-	Date.civil(2009, 4, 1).meteorological_winter?
+	TimeCrisis::Date.civil(2009, 4, 1).meteorological_winter?
 	 => false 
 
-	Date.civil(2009, 10, 1).meteorological_season
+	TimeCrisis::Date.civil(2009, 10, 1).meteorological_season
 	 => "fall" 
 
-	Date.today.beginning_of_meteorological_summer
-	 => Mon, 01 Jun 2009 
-
 
 
 Copyright (c) 2009 Travis Tilley. See LICENSE for details.

data/Rakefile

@@ -10,6 +10,7 @@ begin
     gem.email = "ttilley@gmail.com"
     gem.homepage = "http://github.com/ttilley/time_crisis"
     gem.authors = ["Travis Tilley"]
+    gem.add_dependency 'third_base'
     gem.add_development_dependency "thoughtbot-shoulda"
     # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
   end

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:minor: 0
-:patch: 3
+:patch: 0
 :major: 0
+:minor: 1

data/lib/time_crisis.rb

@@ -1,9 +1,12 @@
-module TimeCrisis; end
+require 'third_base'
 
-# the support directory is a simplified version of the same methods in
-# ActiveSupport, and are completely unnecessary if we're actually
-# using that library. I just didn't want to depend on it.
-require 'time_crisis/support' unless defined?(ActiveSupport)
+module TimeCrisis
+  include ThirdBase
+end
+
+# add needed bits of active support to time crisis
+# necessary now that it uses ThirdBase
+require 'time_crisis/support'
 
 require 'time_crisis/meteorological_seasons'
 require 'time_crisis/date_range'

data/lib/time_crisis/date_range.rb

@@ -7,8 +7,8 @@ class TimeCrisis::DateRange < Range
     options[:end] = args.shift unless args.empty?
     options[:exclude_end] = args.shift unless args.empty?
 
-    start = options[:begin].nil? ? false : options[:begin].to_date
-    stop = options[:end].nil? ? false : options[:end].to_date
+    start = options[:begin].nil? ? false : options[:begin].to_tc_date
+    stop = options[:end].nil? ? false : options[:end].to_tc_date
 
     unit = options[:unit] || 1
     scale = options[:scale] || 'years'
@@ -24,12 +24,12 @@ class TimeCrisis::DateRange < Range
   end
 
   def include?(datelike)
-    super(datelike.to_date)
+    super(datelike.to_tc_date)
   end
 
   def each_slice_by_date(*args, &block)
     dates = args.map! do |datelike|
-      date = datelike.to_date
+      date = datelike.to_tc_date
       raise ArgumentError, "Date not within range: #{date}" unless self.include?(date)
       date
     end
@@ -98,5 +98,8 @@ module TimeCrisis::DateRange::Date
   end
 end
 
-Date.send(:include, TimeCrisis::DateRange::Date::InstanceMethods)
-Date.extend(TimeCrisis::DateRange::Date::ClassMethods)
+TimeCrisis::Date.send(:include, TimeCrisis::DateRange::Date::InstanceMethods)
+TimeCrisis::Date.extend(TimeCrisis::DateRange::Date::ClassMethods)
+
+::Date.send(:include, TimeCrisis::DateRange::Date::InstanceMethods)
+::Date.extend(TimeCrisis::DateRange::Date::ClassMethods)

data/lib/time_crisis/meteorological_seasons.rb

@@ -11,47 +11,55 @@ module TimeCrisis
   # on 1 September, and winter on 1 December.
   # - http://en.wikipedia.org/wiki/Season
   module MeteorologicalSeasons
-    def beginning_of_meteorological_spring
-      ::Date.civil(self.year, 3, 1)
-    end
-
-    def beginning_of_meteorological_summer
-      ::Date.civil(self.year, 6, 1)
-    end
-
-    def beginning_of_meteorological_autumn
-      ::Date.civil(self.year, 9, 1)
-    end
-    alias beginning_of_meteorological_fall beginning_of_meteorological_autumn
-
-    def beginning_of_meteorological_winter
-      ::Date.civil(self.year, 12, 1)
-    end
-
-    def meteorological_spring?
-      (beginning_of_meteorological_spring...beginning_of_meteorological_summer).include?(self)
-    end
+    module ClassMethods
+      def beginning_of_meteorological_spring(year=current.year)
+        TimeCrisis::Date.civil(year, 3, 1)
+      end
 
-    def meteorological_summer?
-      (beginning_of_meteorological_summer...beginning_of_meteorological_autumn).include?(self)
-    end
+      def beginning_of_meteorological_summer(year=current.year)
+        TimeCrisis::Date.civil(year, 6, 1)
+      end
 
-    def meteorological_autumn?
-      (beginning_of_meteorological_autumn...beginning_of_meteorological_winter).include?(self)
-    end
+      def beginning_of_meteorological_autumn(year=current.year)
+        TimeCrisis::Date.civil(year, 9, 1)
+      end
+      alias beginning_of_meteorological_fall beginning_of_meteorological_autumn
 
-    def meteorological_winter?
-      (beginning_of_year...beginning_of_meteorological_spring).include?(self) ||
-        (beginning_of_meteorological_winter..end_of_year).include?(self)
+      def beginning_of_meteorological_winter(year=current.year)
+        TimeCrisis::Date.civil(year, 12, 1)
+      end
     end
-
-    def meteorological_season
-      return 'spring' if meteorological_spring?
-      return 'summer' if meteorological_summer?
-      return 'fall' if meteorological_autumn?
-      return 'winter' if meteorological_winter?
+    
+    module InstanceMethods
+      def meteorological_spring?
+        [3,4,5].include?(self.month)
+      end
+      
+      def meteorological_summer?
+        [6,7,8].include?(self.month)
+      end
+      
+      def meteorological_autumn?
+        [9,10,11].include?(self.month)
+      end
+      alias meteorological_fall? meteorological_autumn?
+      
+      def meteorological_winter?
+        [1,2,12].include?(self.month)
+      end
+      
+      def meteorological_season
+        case self.month
+        when (1..2) then 'winter'
+        when (3..5) then 'spring'
+        when (6..8) then 'summer'
+        when (9..11) then 'fall'
+        when 12 then 'winter'
+        end
+      end
     end
   end
 end
 
-Date.send(:include, TimeCrisis::MeteorologicalSeasons)
+TimeCrisis::Date.extend(TimeCrisis::MeteorologicalSeasons::ClassMethods)
+TimeCrisis::Date.send(:include, TimeCrisis::MeteorologicalSeasons::InstanceMethods)

data/lib/time_crisis/named_months.rb

@@ -13,12 +13,16 @@ module TimeCrisis
     def november(year=nil);   month_range(11, year); end
     def december(year=nil);   month_range(12, year); end
 
-    def month_range(month, year = nil)
+    def month_range(month=nil, year=nil)
+      month ||= current.month
       year ||= current.year
-      base = ::Date.civil(year, month, 1)
+      
+      base = TimeCrisis::Date.civil(year, month, 1)
       base.for(1, 'months')
     end
   end
 end
 
-Date.extend(TimeCrisis::NamedMonths)
+TimeCrisis::Date.extend(TimeCrisis::NamedMonths)
+
+::Date.extend(TimeCrisis::NamedMonths)

data/lib/time_crisis/support.rb

@@ -1,8 +1,7 @@
 module TimeCrisis::Support; end
 
+require 'time_crisis/support/conversions'
 require 'time_crisis/support/current'
-require 'time_crisis/support/days_in_month'
 require 'time_crisis/support/change'
 require 'time_crisis/support/advance'
-require 'time_crisis/support/conversions'
-require 'time_crisis/support/readable_inspect'
+require 'time_crisis/support/readable_inspect'

data/lib/time_crisis/support/advance.rb

@@ -11,37 +11,15 @@ module TimeCrisis::Support::Advance
     end
   end
 
-  module Time
-    def advance(options)
-      unless options[:weeks].nil?
-        options[:weeks], partial_weeks = options[:weeks].divmod(1)
-        options[:days] = (options[:days] || 0) + 7 * partial_weeks
-      end
-
-      unless options[:days].nil?
-        options[:days], partial_days = options[:days].divmod(1)
-        options[:hours] = (options[:hours] || 0) + 24 * partial_days
-      end
-
-      d = to_date.advance(options)
-      time_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
-      seconds_to_advance = (options[:seconds] || 0) + (options[:minutes] || 0) * 60 + (options[:hours] || 0) * 3600
-      seconds_to_advance == 0 ? time_advanced_by_date : time_advanced_by_date.since(seconds_to_advance)
-    end
-  end
-
   module DateTime
     def advance(options)
-      d = to_date.advance(options)
-      datetime_advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
+      d = to_tc_date.advance(options)
+      advanced_by_date = change(:year => d.year, :month => d.month, :day => d.day)
       seconds_to_advance = (options[:seconds] || 0) + (options[:minutes] || 0) * 60 + (options[:hours] || 0) * 3600
-      seconds_to_advance == 0 ? datetime_advanced_by_date : datetime_advanced_by_date.since(seconds_to_advance)
+      seconds_to_advance == 0 ? advanced_by_date : (advanced_by_date + Rational(seconds_to_advance.round, 86400).to_f)
     end
   end
 end
 
-[Date, Time, DateTime].each do |klass|
-  unless klass.instance_methods.include?('advance')
-    klass.send(:include, TimeCrisis::Support::Advance.const_get(klass.to_s))
-  end
-end
+TimeCrisis::Date.send(:include, TimeCrisis::Support::Advance::Date)
+TimeCrisis::DateTime.send(:include, TimeCrisis::Support::Advance::DateTime)

data/lib/time_crisis/support/change.rb

@@ -1,7 +1,7 @@
 module TimeCrisis::Support::Change
   module Date
     def change(options={})
-      ::Date.civil(
+      TimeCrisis::Date.civil(
         options[:year]  || self.year,
         options[:month] || self.month,
         options[:day]   || self.day
@@ -21,77 +21,26 @@ module TimeCrisis::Support::Change
     end
 
     def end_of_month
-      last_day = self.class.days_in_month(self.month, self.year)
+      last_day = TimeCrisis::Date.days_in_month(self.month, self.year)
       change(:day => last_day)
     end
-
-    def beginning_of_day
-      to_time
-    end
-
-    def end_of_day
-      to_time.end_of_day
-    end
-  end
-
-  module Time
-    def change(options={})
-      ::Time.send(
-        utc? ? :utc_time : :local,
-        options[:year]  || year,
-        options[:month] || month,
-        options[:day]   || day,
-        options[:hour]  || hour,
-        options[:min]   || (options[:hour] ? 0 : min),
-        options[:sec]   || ((options[:hour] || options[:min]) ? 0 : sec),
-        options[:usec]  || ((options[:hour] || options[:min] || options[:sec]) ? 0 : usec)
-      )
-    end
-
-    def beginning_of_year
-      change(:month => 1, :day => 1, :hour => 0, :min => 0, :sec => 0)
-    end
-
-    def end_of_year
-      change(:month => 12,:day => 31,:hour => 23, :min => 59, :sec => 59)
-    end
-
-    def beginning_of_month
-      change(:day => 1,:hour => 0, :min => 0, :sec => 0, :usec => 0)
-    end
-
-    def end_of_month
-      last_day = self.class.days_in_month(self.month, self.year)
-      change(:day => last_day, :hour => 23, :min => 59, :sec => 59, :usec => 999999.999)
-    end
-
-    def beginning_of_day
-      change(:hour => 0, :min => 0, :sec => 0, :usec => 0)
-    end
-
-    def end_of_day
-      change(:hour => 23, :min => 59, :sec => 59, :usec => 999999.999)
-    end
   end
 
   module DateTime
     def change(options={})
-      ::DateTime.civil(
-        options[:year]  || year,
-        options[:month] || month,
-        options[:day]   || day,
-        options[:hour]  || hour,
-        options[:min]   || (options[:hour] ? 0 : min),
-        options[:sec]   || ((options[:hour] || options[:min]) ? 0 : sec),
-        options[:offset]  || offset,
-        options[:start]  || start
+      TimeCrisis::DateTime.civil(
+        options[:year]    || year,
+        options[:month]   || month,
+        options[:day]     || day,
+        options[:hour]    || hour,
+        options[:min]     || (options[:hour] ? 0 : min),
+        options[:sec]     || ((options[:hour] || options[:min]) ? 0 : sec),
+        options[:usec]    || ((options[:hour] || options[:min] || options[:sec]) ? 0 : usec),
+        options[:offset]  || offset
       )
     end
   end
 end
 
-[Date, Time, DateTime].each do |klass|
-  unless klass.instance_methods.include?('change')
-    klass.send(:include, TimeCrisis::Support::Change.const_get(klass.to_s))
-  end
-end
+TimeCrisis::Date.send(:include,  TimeCrisis::Support::Change::Date)
+TimeCrisis::DateTime.send(:include, TimeCrisis::Support::Change::DateTime)

data/lib/time_crisis/support/conversions.rb

@@ -1,82 +1,77 @@
-require 'rational'
-
 module TimeCrisis::Support::Conversions
-  module Date
-    def to_date
-      self
-    end if RUBY_VERSION < '1.9'
-
-    def to_time(form = :local)
-      ::Time.send(form, year, month, day)
+  module Ruby
+    module Date
+      def to_tc_date
+        TimeCrisis::Date.civil(year, month, day)
+      end
+
+      def to_tc_datetime
+        TimeCrisis::DateTime.civil(year, month, day, 0, 0, 0, 0)
+      end
     end
 
-    def to_datetime
-      ::DateTime.civil(year, month, day, 0, 0, 0, 0)
-    end if RUBY_VERSION < '1.9'
-  end
-
-  module Time
-    def to_date
-      ::Date.new(year, month, day)
-    end
+    module Time
+      def to_tc_date
+        TimeCrisis::Date.civil(year, month, day)
+      end
 
-    def to_time
-      self
+      def to_tc_datetime
+        TimeCrisis::DateTime.civil(year, month, day, hour, min, sec, 0, utc_offset)
+      end
     end
 
-    def to_datetime
-      ::DateTime.civil(year, month, day, hour, min, sec, Rational(utc_offset, 86400))
-    end
-  end
+    module DateTime
+      def to_tc_date
+        TimeCrisis::Date.civil(year, month, day)
+      end
 
-  module DateTime
-    def to_date
-      ::Date.civil(year, month, day)
+      def to_tc_datetime
+        TimeCrisis::DateTime.civil(year, month, day, hour, min, sec, 0, (offset * 86400).to_i)
+      end
     end
 
-    def to_time
-      self.offset == 0 ? ::Time.utc(year, month, day, hour, min, sec) : self
-    end
+    module String
+      def to_tc_date(opts={})
+        TimeCrisis::Date.parse(self, opts)
+      end
 
-    def to_datetime
-      self
+      def to_tc_datetime(opts={})
+        TimeCrisis::DateTime.parse(self, opts)
+      end
     end
   end
-
-  module String
-    def to_time(form = :utc)
-      d = ::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec, :sec_fraction).map { |arg| arg || 0 }
-      d[6] *= 1000000
-      ::Time.send(form, *d)
-    end
-
-    def to_date
-      ::Date.civil(*::Date._parse(self, false).values_at(:year, :mon, :mday))
+  
+  module Internal
+    module Date
+      def to_tc_date
+        self
+      end
+      alias to_date to_tc_date
+      
+      def to_tc_datetime
+        TimeCrisis::DateTime.civil(year, month, day, 0, 0, 0, 0)
+      end
+      alias to_datetime to_tc_datetime
     end
 
-    def to_datetime
-      d = ::Date._parse(self, false).values_at(:year, :mon, :mday, :hour, :min, :sec, :zone, :sec_fraction).map { |arg| arg || 0 }
-      d[5] += d.pop
-      ::DateTime.civil(*d)
+    module DateTime
+      def to_tc_date
+        TimeCrisis::Date.civil(year, month, day)
+      end
+      alias to_date to_tc_date
+      
+      def to_tc_datetime
+        self
+      end
+      alias to_datetime to_tc_datetime
     end
   end
 end
 
-# active support has support for time zones, so don't overwrite its' version
-unless Time.instance_methods.include?('local_time')
-  Date.class_eval do
-    # Ruby 1.9 has Date#to_time which converts to localtime only.
-    remove_method :to_time if instance_methods.include?(:to_time)
-    include TimeCrisis::Support::Conversions::Date
-  end
-
-  DateTime.class_eval do
-    # Ruby 1.9 has DateTime#to_time which internally relies on Time.
-    remove_method :to_time if instance_methods.include?(:to_time)
-    include TimeCrisis::Support::Conversions::DateTime
-  end
-end
-
-Time.send(:include, TimeCrisis::Support::Conversions::Time)
+TimeCrisis::Date.send(:include, TimeCrisis::Support::Conversions::Internal::Date)
+TimeCrisis::DateTime.send(:include, TimeCrisis::Support::Conversions::Internal::DateTime)
 
-String.send(:include, TimeCrisis::Support::Conversions::String)
+::Date.send(:include, TimeCrisis::Support::Conversions::Ruby::Date)
+::Time.send(:include, TimeCrisis::Support::Conversions::Ruby::Time)
+::DateTime.send(:include, TimeCrisis::Support::Conversions::Ruby::DateTime)
+::String.send(:include, TimeCrisis::Support::Conversions::Ruby::String)

data/lib/time_crisis/support/current.rb

@@ -1,10 +1,4 @@
 module TimeCrisis::Support::Current
-  module Time
-    def current
-      now
-    end
-  end
-
   module Date
     def current
       today
@@ -13,11 +7,10 @@ module TimeCrisis::Support::Current
 
   module DateTime
     def current
-      ::Time.now.to_datetime
+      now
     end
   end
 end
 
-Time.extend(TimeCrisis::Support::Current::Time) unless Time.respond_to?(:current)
-Date.extend(TimeCrisis::Support::Current::Date) unless Date.respond_to?(:current)
-DateTime.extend(TimeCrisis::Support::Current::DateTime) unless DateTime.respond_to?(:current)
+TimeCrisis::Date.extend(TimeCrisis::Support::Current::Date)
+TimeCrisis::DateTime.extend(TimeCrisis::Support::Current::DateTime)

data/lib/time_crisis/support/readable_inspect.rb

@@ -1,9 +1,9 @@
 module TimeCrisis::Support::ReadableInspect
   module Date
     def readable_inspect
-      strftime("%a, %d %b %Y")
+      "#<TimeCrisis::Date #{strftime('%Y-%m-%d')}>"
     end
-
+    
     def self.included(base)
       base.class_eval do
         alias_method :default_inspect, :inspect
@@ -11,12 +11,12 @@ module TimeCrisis::Support::ReadableInspect
       end
     end
   end
-
+  
   module DateTime
     def readable_inspect
-      to_s(:rfc822)
+      "#<TimeCrisis::DateTime #{strftime('%Y-%m-%dT%H:%M:%S%Z')}>"
     end
-
+    
     def self.included(base)
       base.class_eval do
         alias_method :default_inspect, :inspect
@@ -26,8 +26,5 @@ module TimeCrisis::Support::ReadableInspect
   end
 end
 
-Date.send(:include, TimeCrisis::Support::ReadableInspect::Date) unless
-Date.instance_methods.include?('readable_inspect')
-
-DateTime.send(:include, TimeCrisis::Support::ReadableInspect::DateTime) unless
-DateTime.instance_methods.include?('readable_inspect')
+TimeCrisis::Date.send(:include, TimeCrisis::Support::ReadableInspect::Date)
+TimeCrisis::DateTime.send(:include, TimeCrisis::Support::ReadableInspect::DateTime)

data/time_crisis.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{time_crisis}
-  s.version = "0.0.3"
+  s.version = "0.1.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Travis Tilley"]
-  s.date = %q{2009-09-21}
+  s.date = %q{2009-09-22}
   s.description = %q{date and time related extensions}
   s.email = %q{ttilley@gmail.com}
   s.extra_rdoc_files = [
@@ -32,7 +32,6 @@ Gem::Specification.new do |s|
      "lib/time_crisis/support/change.rb",
      "lib/time_crisis/support/conversions.rb",
      "lib/time_crisis/support/current.rb",
-     "lib/time_crisis/support/days_in_month.rb",
      "lib/time_crisis/support/readable_inspect.rb",
      "test/test_helper.rb",
      "test/time_crisis_test.rb",
@@ -53,11 +52,14 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<third_base>, [">= 0"])
       s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
     else
+      s.add_dependency(%q<third_base>, [">= 0"])
       s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
     end
   else
+    s.add_dependency(%q<third_base>, [">= 0"])
     s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ttilley-time_crisis
 version: !ruby/object:Gem::Version 
-  version: 0.0.3
+  version: 0.1.0
 platform: ruby
 authors: 
 - Travis Tilley
@@ -9,9 +9,19 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-09-21 00:00:00 -07:00
+date: 2009-09-22 00:00:00 -07:00
 default_executable: 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: third_base
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 - !ruby/object:Gem::Dependency 
   name: thoughtbot-shoulda
   type: :development
@@ -47,7 +57,6 @@ files:
 - lib/time_crisis/support/change.rb
 - lib/time_crisis/support/conversions.rb
 - lib/time_crisis/support/current.rb
-- lib/time_crisis/support/days_in_month.rb
 - lib/time_crisis/support/readable_inspect.rb
 - test/test_helper.rb
 - test/time_crisis_test.rb

data/lib/time_crisis/support/days_in_month.rb

@@ -1,11 +0,0 @@
-module TimeCrisis::Support::DaysInMonth
-  GregorianDaysInMonth = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-
-  def days_in_month(month, year = current.year)
-    (month == 2 && ::Date.gregorian_leap?(year)) ? 29 : GregorianDaysInMonth[month]
-  end
-end
-
-Date.extend(TimeCrisis::Support::DaysInMonth) unless Date.respond_to?(:days_in_month)
-Time.extend(TimeCrisis::Support::DaysInMonth) unless Time.respond_to?(:days_in_month)
-DateTime.extend(TimeCrisis::Support::DaysInMonth) unless DateTime.respond_to?(:days_in_month)