time_crisis 0.1.4

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,7 @@
+*.sw?
+.DS_Store
+.idea
+coverage
+nbproject
+pkg
+rdoc

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Travis Tilley
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,60 @@
+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.
+
+	TimeCrisis::Date.today.for(2, 'years')
+     => #<TimeCrisis::Date 2009-09-22>..#<TimeCrisis::Date 2011-09-21> 
+
+	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:
+
+	TimeCrisis::Date.today.range(2, 'months', 'future')
+	 => #<TimeCrisis::Date 2009-09-22>..#<TimeCrisis::Date 2009-11-21>
+
+	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).
+
+	TimeCrisis::Date.range(:begin => Date.today, :scale => 'months', :unit => 3)
+	 => #<TimeCrisis::Date 2009-09-22>..#<TimeCrisis::Date 2009-12-21>
+
+	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.
+
+	TimeCrisis::Date.february # 28 days in feb 2009
+	 => #<TimeCrisis::Date 2009-02-01>..#<TimeCrisis::Date 2009-02-28>
+
+	TimeCrisis::Date.february(2008) # 29 days in feb 2008
+	 => #<TimeCrisis::Date 2008-02-01>..#<TimeCrisis::Date 2008-02-29>
+
+
+Meteorological Season Calculations
+==================================
+
+	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 
+
+	TimeCrisis::Date.civil(2009, 4, 1).meteorological_winter?
+	 => false 
+
+	TimeCrisis::Date.civil(2009, 10, 1).meteorological_season
+	 => "fall" 
+
+
+
+Copyright (c) 2009 Travis Tilley. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,82 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "time_crisis"
+    gem.summary = %Q{date and time related extensions}
+    gem.description = %Q{date and time related extensions}
+    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
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+begin
+  require 'reek/rake_task'
+  Reek::RakeTask.new do |t|
+    t.fail_on_error = true
+    t.verbose = false
+    t.source_files = 'lib/**/*.rb'
+  end
+rescue LoadError
+  task :reek do
+    abort "Reek is not available. In order to run reek, you must: sudo gem install reek"
+  end
+end
+
+begin
+  require 'roodi'
+  require 'roodi_task'
+  RoodiTask.new do |t|
+    t.verbose = false
+  end
+rescue LoadError
+  task :roodi do
+    abort "Roodi is not available. In order to run roodi, you must: sudo gem install roodi"
+  end
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "time_crisis #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION.yml

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

data/lib/time_crisis/date_range.rb

@@ -0,0 +1,110 @@
+class TimeCrisis::DateRange < Range
+  def initialize(*args)
+    options = args.last.is_a?(Hash) ? args.pop : {}
+
+    # make compatibile with Range's normal arguments
+    options[:begin] = args.shift unless args.empty?
+    options[:end] = args.shift unless args.empty?
+    options[:exclude_end] = args.shift unless args.empty?
+
+    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'
+    scale = scale.pluralize if scale.respond_to?(:pluralize)
+
+    if start && !stop
+      stop = start.advance({scale.to_sym => unit, :days => -1})
+    elsif !start && stop
+      start = stop.advance({scale.to_sym => -unit, :days => 1})
+    end
+
+    super(start, stop, options[:exclude_end] || false)
+  end
+
+  def include?(datelike)
+    super(datelike.to_tc_date)
+  end
+
+  def each_slice_by_date(*args, &block)
+    dates = args.map! do |datelike|
+      date = datelike.to_tc_date
+      raise ArgumentError, "Date not within range: #{date}" unless self.include?(date)
+      date
+    end
+    dates.sort!
+
+    start = self.begin
+
+    dates.each do |date|
+      yield self.class.new(start, date, true, self.subopt)
+      start = date
+    end
+
+    yield self.class.new(start, self.end, self.exclude_end?, self.subopt)
+  end
+
+  def each_slice_by_period(period, unit=1, &block)
+    start = self.begin
+    nstart = start.advance(period.to_sym => unit)
+
+    raise ArgumentError, "Period exceeds range" if nstart >= self.real_end
+
+    while nstart < self.real_end
+      yield self.class.new(start, nstart, true, self.subopt)
+      start = nstart
+      nstart = start.advance(period.to_sym => unit)
+    end
+
+    yield self.class.new(start, self.end, self.exclude_end?, self.subopt)
+  end
+
+  def each_month(&block)
+    each_slice_by_period(:months, 1, &block)
+  end
+
+  def each_year(&block)
+    each_slice_by_period(:years, 1, &block)
+  end
+
+  protected
+
+  def real_end
+    @real_end ||= self.exclude_end? ? self.end.advance({:days => -1}) : self.end
+  end
+
+  # make life easier when subclassing
+  def subopt
+    @subopt ||= {}
+  end
+end
+
+module TimeCrisis::DateRange::Date
+  module InstanceMethods
+    def from(unit, scale)
+      self.range(unit, scale, 'past')
+    end
+
+    def for(unit, scale)
+      self.range(unit, scale, 'future')
+    end
+
+    def range(unit=1, scale='years', direction='past')
+      selfkey = direction == 'past' ? :end : :begin
+      self.class.range({selfkey => self, :unit => unit, :scale => scale})
+    end
+  end
+
+  module ClassMethods
+    def range(*args)
+      TimeCrisis::DateRange.new(*args)
+    end
+  end
+end
+
+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

@@ -0,0 +1,72 @@
+module TimeCrisis
+  # Meteorological seasons are reckoned by temperature, with summer being
+  # the hottest quarter of the year and winter the coldest quarter of the
+  # year. Using this reckoning, the Roman calendar began the year and the
+  # spring season on the first of March, with each season occupying three
+  # months. In 1780 the Societas Meteorologica Palatina, an early
+  # international organization for meteorology, defined seasons as groupings
+  # of three whole months. Ever since, professional meteorologists
+  # everywhere have used this definition. So, in meteorology for the
+  # Northern hemisphere: spring begins on 1 March, summer on 1 June, autumn
+  # on 1 September, and winter on 1 December.
+  # - http://en.wikipedia.org/wiki/Season
+  module MeteorologicalSeasons
+    module ClassMethods
+      def beginning_of_meteorological_spring(year=current.year)
+        TimeCrisis::Date.civil(year, 3, 1)
+      end
+
+      def beginning_of_meteorological_summer(year=current.year)
+        TimeCrisis::Date.civil(year, 6, 1)
+      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 beginning_of_meteorological_winter(year=current.year)
+        TimeCrisis::Date.civil(year, 12, 1)
+      end
+    end
+
+    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
+
+TimeCrisis::Date.extend(TimeCrisis::MeteorologicalSeasons::ClassMethods)
+TimeCrisis::Date.send(:include, TimeCrisis::MeteorologicalSeasons::InstanceMethods)

data/lib/time_crisis/named_months.rb

@@ -0,0 +1,28 @@
+module TimeCrisis
+  module NamedMonths
+    def january(year=nil);    month_range(1, year); end
+    def february(year=nil);   month_range(2, year); end
+    def march(year=nil);      month_range(3, year); end
+    def april(year=nil);      month_range(4, year); end
+    def may(year=nil);        month_range(5, year); end
+    def june(year=nil);       month_range(6, year); end
+    def july(year=nil);       month_range(7, year); end
+    def august(year=nil);     month_range(8, year); end
+    def september(year=nil);  month_range(9, year); end
+    def october(year=nil);    month_range(10, year); end
+    def november(year=nil);   month_range(11, year); end
+    def december(year=nil);   month_range(12, year); end
+
+    def month_range(month=nil, year=nil)
+      month ||= current.month
+      year ||= current.year
+      
+      base = TimeCrisis::Date.civil(year, month, 1)
+      base.for(1, 'months')
+    end
+  end
+end
+
+TimeCrisis::Date.extend(TimeCrisis::NamedMonths)
+
+::Date.extend(TimeCrisis::NamedMonths)

data/lib/time_crisis/support/acts_like.rb

@@ -0,0 +1,20 @@
+module TimeCrisis::Support::ActsLike
+  module Date
+    def acts_like_date?
+      true
+    end
+  end
+
+  module DateTime
+    def acts_like_date?
+      true
+    end
+
+    def acts_like_time?
+      true
+    end
+  end
+end
+
+TimeCrisis::Date.send(:include, TimeCrisis::Support::ActsLike::Date)
+TimeCrisis::DateTime.send(:include, TimeCrisis::Support::ActsLike::DateTime)

data/lib/time_crisis/support/advance.rb

@@ -0,0 +1,25 @@
+module TimeCrisis::Support::Advance
+  module Date
+    def advance(options)
+      options = options.dup
+      d = self
+      d = d >> options.delete(:years) * 12 if options[:years]
+      d = d >> options.delete(:months) if options[:months]
+      d = d + options.delete(:weeks) * 7 if options[:weeks]
+      d = d + options.delete(:days) if options[:days]
+      d
+    end
+  end
+
+  module DateTime
+    def advance(options)
+      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 ? advanced_by_date : (advanced_by_date + Rational(seconds_to_advance.round, 86400).to_f)
+    end
+  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

@@ -0,0 +1,47 @@
+module TimeCrisis::Support::Change
+  module Date
+    def change(options={})
+      TimeCrisis::Date.civil(
+              options[:year] || self.year,
+              options[:month] || self.month,
+              options[:day] || self.day
+      )
+    end
+
+    def beginning_of_year
+      change(:month => 1, :day => 1)
+    end
+
+    def end_of_year
+      change(:month => 12, :day => 31)
+    end
+
+    def beginning_of_month
+      change(:day => 1)
+    end
+
+    def end_of_month
+      last_day = days_in_month
+      change(:day => last_day)
+    end
+  end
+
+  module DateTime
+    def change(options={})
+      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
+
+TimeCrisis::Date.send(:public, :days_in_month)
+TimeCrisis::Date.send(:include,  TimeCrisis::Support::Change::Date)
+TimeCrisis::DateTime.send(:include, TimeCrisis::Support::Change::DateTime)

data/lib/time_crisis/support/conversions.rb

@@ -0,0 +1,89 @@
+module TimeCrisis::Support::Conversions
+  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
+
+    module Time
+      def to_tc_date
+        TimeCrisis::Date.civil(year, month, day)
+      end
+
+      def to_tc_datetime
+        TimeCrisis::DateTime.civil(year, month, day, hour, min, sec, 0, utc_offset)
+      end
+    end
+
+    module DateTime
+      def to_tc_date
+        TimeCrisis::Date.civil(year, month, day)
+      end
+
+      def to_tc_datetime
+        TimeCrisis::DateTime.civil(year, month, day, hour, min, sec, 0, (offset * 86400).to_i)
+      end
+    end
+
+    module String
+      def to_tc_date(opts={})
+        TimeCrisis::Date.parse(self, opts)
+      end
+
+      def to_tc_datetime(opts={})
+        TimeCrisis::DateTime.parse(self, opts)
+      end
+    end
+  end
+
+  module Internal
+    module Date
+      def to_tc_date
+        self
+      end
+
+      def to_tc_datetime
+        TimeCrisis::DateTime.civil(year, month, day, 0, 0, 0, 0)
+      end
+
+      def to_date
+        ::Date.civil(year, month, day)
+      end
+
+      def to_datetime
+        ::DateTime.civil(year, month, day, 0, 0, 0, 0)
+      end
+
+      def to_time(form = :local)
+        ::Time.send(form, year, month, day)
+      end
+    end
+
+    module DateTime
+      def to_tc_date
+        TimeCrisis::Date.civil(year, month, day)
+      end
+
+      def to_tc_datetime
+        self
+      end
+
+      def to_date
+        ::Date.civil(year, month, day)
+      end
+    end
+  end
+end
+
+TimeCrisis::Date.send(:include, TimeCrisis::Support::Conversions::Internal::Date)
+TimeCrisis::DateTime.send(:include, TimeCrisis::Support::Conversions::Internal::DateTime)
+
+::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

@@ -0,0 +1,16 @@
+module TimeCrisis::Support::Current
+  module Date
+    def current
+      today
+    end
+  end
+
+  module DateTime
+    def current
+      now
+    end
+  end
+end
+
+TimeCrisis::Date.extend(TimeCrisis::Support::Current::Date)
+TimeCrisis::DateTime.extend(TimeCrisis::Support::Current::DateTime)

data/lib/time_crisis/support/readable_inspect.rb

@@ -0,0 +1,30 @@
+module TimeCrisis::Support::ReadableInspect
+  module Date
+    def readable_inspect
+      "#<TimeCrisis::Date #{strftime('%Y-%m-%d')}>"
+    end
+
+    def self.included(base)
+      base.class_eval do
+        alias_method :default_inspect, :inspect
+        alias_method :inspect, :readable_inspect
+      end
+    end
+  end
+
+  module DateTime
+    def readable_inspect
+      "#<TimeCrisis::DateTime #{strftime('%Y-%m-%dT%H:%M:%S%Z')}>"
+    end
+
+    def self.included(base)
+      base.class_eval do
+        alias_method :default_inspect, :inspect
+        alias_method :inspect, :readable_inspect
+      end
+    end
+  end
+end
+
+TimeCrisis::Date.send(:include, TimeCrisis::Support::ReadableInspect::Date)
+TimeCrisis::DateTime.send(:include, TimeCrisis::Support::ReadableInspect::DateTime)

data/lib/time_crisis/support.rb

@@ -0,0 +1,10 @@
+module TimeCrisis::Support
+end
+
+require 'time_crisis/support/conversions'
+require 'time_crisis/support/current'
+require 'time_crisis/support/change'
+require 'time_crisis/support/advance'
+require 'time_crisis/support/readable_inspect'
+require 'time_crisis/support/acts_like'
+

data/lib/time_crisis.rb

@@ -0,0 +1,13 @@
+require 'third_base'
+
+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'
+require 'time_crisis/named_months'

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'time_crisis'
+
+class Test::Unit::TestCase
+end

data/test/time_crisis_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class TimeCrisisTest < Test::Unit::TestCase
+  should "probably rename this file and start testing for real" do
+    flunk "hey buddy, you should probably rename this file and start testing for real"
+  end
+end

data/time_crisis.gemspec

@@ -0,0 +1,66 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{time_crisis}
+  s.version = "0.1.4"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Travis Tilley"]
+  s.date = %q{2009-09-30}
+  s.description = %q{date and time related extensions}
+  s.email = %q{ttilley@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION.yml",
+     "lib/time_crisis.rb",
+     "lib/time_crisis/date_range.rb",
+     "lib/time_crisis/meteorological_seasons.rb",
+     "lib/time_crisis/named_months.rb",
+     "lib/time_crisis/support.rb",
+     "lib/time_crisis/support/acts_like.rb",
+     "lib/time_crisis/support/advance.rb",
+     "lib/time_crisis/support/change.rb",
+     "lib/time_crisis/support/conversions.rb",
+     "lib/time_crisis/support/current.rb",
+     "lib/time_crisis/support/readable_inspect.rb",
+     "test/test_helper.rb",
+     "test/time_crisis_test.rb",
+     "time_crisis.gemspec"
+  ]
+  s.homepage = %q{http://github.com/ttilley/time_crisis}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{date and time related extensions}
+  s.test_files = [
+    "test/test_helper.rb",
+     "test/time_crisis_test.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    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

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: time_crisis
+version: !ruby/object:Gem::Version 
+  version: 0.1.4
+platform: ruby
+authors: 
+- Travis Tilley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-30 00:00:00 -04: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
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: date and time related extensions
+email: ttilley@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION.yml
+- lib/time_crisis.rb
+- lib/time_crisis/date_range.rb
+- lib/time_crisis/meteorological_seasons.rb
+- lib/time_crisis/named_months.rb
+- lib/time_crisis/support.rb
+- lib/time_crisis/support/acts_like.rb
+- lib/time_crisis/support/advance.rb
+- lib/time_crisis/support/change.rb
+- lib/time_crisis/support/conversions.rb
+- lib/time_crisis/support/current.rb
+- lib/time_crisis/support/readable_inspect.rb
+- test/test_helper.rb
+- test/time_crisis_test.rb
+- time_crisis.gemspec
+has_rdoc: true
+homepage: http://github.com/ttilley/time_crisis
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: date and time related extensions
+test_files: 
+- test/test_helper.rb
+- test/time_crisis_test.rb