time_crisis 0.2.0 → 0.3.0

data/lib/time_crisis/meteorological_seasons.rb

@@ -70,3 +70,6 @@ end
 
 ::TimeCrisis::Date.extend(TimeCrisis::MeteorologicalSeasons::ClassMethods)
 ::TimeCrisis::Date.send(:include, TimeCrisis::MeteorologicalSeasons::InstanceMethods)
+::TimeCrisis::DateTime.send(:include, TimeCrisis::MeteorologicalSeasons::InstanceMethods)
+::TimeCrisis::Time.send(:include, TimeCrisis::MeteorologicalSeasons::InstanceMethods)
+

data/lib/time_crisis/nth_weekday.rb

@@ -14,13 +14,16 @@ module TimeCrisis
       def nth_weekday(h={})
         raise ArgumentError unless h[:nth]
         nth = h[:nth].to_s == 'last' ? 5 : h[:nth]
+        
+        unless h[:year] && h[:month] && h[:weekday]
+          today = self.current
+          
+          h[:year] ||= today.year
+          h[:month] ||= today.month
+          h[:weekday] ||= today.wday
+        end
 
-        today = TimeCrisis::Date.today
-        h[:year] ||= today.year
-        h[:month] ||= today.month
-        h[:weekday] ||= today.wday
-
-        target_month = TimeCrisis::Date.new(h[:year], h[:month], 1)
+        target_month = self.civil(h[:year], h[:month], 1)
         days_in_month = target_month.days_in_month
         target_weekday = h[:weekday].is_a?(Numeric) ? h[:weekday] : @@days_of_the_week[h[:weekday]]
         first_weekday = target_month.wday
@@ -33,15 +36,7 @@ module TimeCrisis
           day = calculate_day_with_offset(nth, offset)
         end
 
-        if $DEBUG
-          STDERR.puts "Arguments: #{h.inspect}"
-          STDERR.puts "Target weekday: #{target_weekday}"
-          STDERR.puts "First weekday: #{first_weekday}"
-          STDERR.puts "Offset: #{offset}"
-          STDERR.puts "Day: #{day}"
-        end
-
-        TimeCrisis::Date.civil(h[:year], h[:month], day)
+        self.civil(h[:year], h[:month], day)
       end
 
       private

data/lib/time_crisis/support.rb

@@ -1,10 +1,15 @@
-module TimeCrisis::Support
-end
+require 'time_crisis/support/ext/time/publicize_conversion_methods'
+require 'time_crisis/support/ext/time/marshal_with_utc_flag'
+require 'time_crisis/support/ext/time/acts_like'
+require 'time_crisis/support/ext/time/calculations'
+require 'time_crisis/support/ext/time/conversions'
+require 'time_crisis/support/ext/time/zones'
 
-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'
+require 'time_crisis/support/ext/date/acts_like'
+require 'time_crisis/support/ext/date/calculations'
+require 'time_crisis/support/ext/date/conversions'
 
+require 'time_crisis/support/ext/date_time/acts_like'
+require 'time_crisis/support/ext/date_time/calculations'
+require 'time_crisis/support/ext/date_time/conversions'
+require 'time_crisis/support/ext/date_time/zones'

data/lib/time_crisis/support/basic_object.rb

@@ -0,0 +1,18 @@
+module TimeCrisis
+  if defined? ::BasicObject
+    class BasicObject < ::BasicObject
+      undef_method :==
+      undef_method :equal?
+
+      def raise(*args)
+        ::Object.send(:raise, *args)
+      end
+    end
+  else
+    class BasicObject
+      instance_methods.each do |m|
+        undef_method(m) if m.to_s !~ /(?:^__|^nil\?$|^send$|^object_id$)/
+      end
+    end
+  end
+end

data/lib/time_crisis/support/duration.rb

@@ -0,0 +1,87 @@
+require 'time_crisis/support/basic_object'
+
+module TimeCrisis
+  class Duration < BasicObject
+    attr_accessor :value, :parts
+
+    def initialize(value, parts) #:nodoc:
+      @value, @parts = value, parts
+    end
+
+    def +(other)
+      if Duration === other
+        Duration.new(value + other.value, @parts + other.parts)
+      else
+        Duration.new(value + other, @parts + [[:seconds, other]])
+      end
+    end
+
+    def -(other)
+      self + (-other)
+    end
+
+    def -@ #:nodoc:
+      Duration.new(-value, parts.map { |type,number| [type, -number] })
+    end
+
+    def is_a?(klass) #:nodoc:
+      klass == Duration || super
+    end
+
+    def ==(other)
+      if Duration === other
+        other.value == value
+      else
+        other == value
+      end
+    end
+
+    def self.===(other) #:nodoc:
+      other.is_a?(Duration) rescue super
+    end
+
+    def since(time = ::Time.current)
+      sum(1, time)
+    end
+    alias :from_now :since
+
+    def ago(time = ::Time.current)
+      sum(-1, time)
+    end
+    alias :until :ago
+
+    def inspect #:nodoc:
+      consolidated = parts.inject(::Hash.new(0)) { |h,part| h[part.first] += part.last; h }
+      parts = [:years, :months, :days, :minutes, :seconds].map do |length|
+        n = consolidated[length]
+        # "#{n} #{n == 1 ? length.to_s.singularize : length.to_s}" if n.nonzero?
+        "#{n} #{length}" if n > 0
+      end.compact
+      parts = ["0 seconds"] if parts.empty?
+      # parts.to_sentence(:locale => :en)
+      parts.join(', ')
+    end
+
+    protected
+
+    def sum(sign, time = ::Time.current) #:nodoc:
+      parts.inject(time) do |t,(type,number)|
+        if t.acts_like?(:time) || t.acts_like?(:date)
+          if type == :seconds
+            t.since(sign * number)
+          else
+            t.advance(type => sign * number)
+          end
+        else
+          raise ::ArgumentError, "expected a time or date, got #{time.inspect}"
+        end
+      end
+    end
+
+    private
+
+    def method_missing(method, *args, &block) #:nodoc:
+      value.send(method, *args)
+    end
+  end
+end

data/lib/time_crisis/support/ext/date/acts_like.rb

@@ -0,0 +1,9 @@
+require 'time_crisis/support/ext/object/acts_like'
+
+module TimeCrisis
+  class Date
+    def acts_like_date?
+      true
+    end
+  end
+end

data/lib/time_crisis/support/ext/date/calculations.rb

@@ -0,0 +1,183 @@
+require 'time_crisis/support/duration'
+require 'time_crisis/support/ext/time/zones'
+
+module TimeCrisis
+  class Date
+    class << self
+      def yesterday
+        ::TimeCrisis::Date.today.yesterday
+      end
+
+      def tomorrow
+        ::TimeCrisis::Date.today.tomorrow
+      end
+
+      def current
+        ::TimeCrisis::Time.zone_default ? ::TimeCrisis::Time.zone.today : ::TimeCrisis::Date.today
+      end
+    end
+
+    def past?
+      self < ::TimeCrisis::Date.current
+    end
+
+    def today?
+      self.to_tc_date == ::TimeCrisis::Date.current
+    end
+
+    def future?
+      self > ::TimeCrisis::Date.current
+    end
+
+    def ago(seconds)
+      to_tc_time.since(-seconds)
+    end
+
+    def since(seconds)
+      to_tc_time.since(seconds)
+    end
+    alias :in :since
+
+    def beginning_of_day
+      to_tc_time
+    end
+    alias :midnight :beginning_of_day
+    alias :at_midnight :beginning_of_day
+    alias :at_beginning_of_day :beginning_of_day
+
+    def end_of_day
+      to_tc_time.end_of_day
+    end
+
+    def plus_with_duration(other) #:nodoc:
+      if TimeCrisis::Duration === other
+        other.since(self)
+      else
+        plus_without_duration(other)
+      end
+    end
+    alias_method :plus_without_duration, :+
+    alias_method :+, :plus_with_duration
+
+    def minus_with_duration(other) #:nodoc:
+      if TimeCrisis::Duration === other
+        plus_with_duration(-other)
+      else
+        minus_without_duration(other)
+      end
+    end
+    alias_method :minus_without_duration, :-
+    alias_method :-, :minus_with_duration
+
+    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
+
+    def change(options)
+      ::TimeCrisis::Date.civil(
+        options[:year]  || self.year,
+        options[:month] || self.month,
+        options[:day]   || self.day
+      )
+    end
+
+    def months_ago(months)
+      advance(:months => -months)
+    end
+
+    def months_since(months)
+      advance(:months => months)
+    end
+
+    def years_ago(years)
+      advance(:years => -years)
+    end
+
+    def years_since(years)
+      advance(:years => years)
+    end
+
+    def last_year
+      years_ago(1)
+    end
+
+    def next_year
+      years_since(1)
+    end unless method_defined?(:next_year)
+
+    def last_month
+      months_ago(1)
+    end
+
+    def next_month
+      months_since(1)
+    end unless method_defined?(:next_month)
+
+    def beginning_of_week
+      days_to_monday = self.wday!=0 ? self.wday-1 : 6
+      result = self - days_to_monday
+      self.acts_like?(:time) ? result.midnight : result
+    end
+    alias :monday :beginning_of_week
+    alias :at_beginning_of_week :beginning_of_week
+
+    def end_of_week
+      days_to_sunday = self.wday!=0 ? 7-self.wday : 0
+      result = self + days_to_sunday.days
+      self.acts_like?(:time) ? result.end_of_day : result
+    end
+    alias :at_end_of_week :end_of_week
+
+    def next_week(day = :monday)
+      days_into_week = { :monday => 0, :tuesday => 1, :wednesday => 2, :thursday => 3, :friday => 4, :saturday => 5, :sunday => 6}
+      result = (self + 7).beginning_of_week + days_into_week[day]
+      self.acts_like?(:time) ? result.change(:hour => 0) : result
+    end
+
+    def beginning_of_month
+      self.acts_like?(:time) ? change(:day => 1,:hour => 0, :min => 0, :sec => 0) : change(:day => 1)
+    end
+    alias :at_beginning_of_month :beginning_of_month
+
+    def end_of_month
+      last_day = ::TimeCrisis::Time.days_in_month( self.month, self.year )
+      self.acts_like?(:time) ? change(:day => last_day, :hour => 23, :min => 59, :sec => 59) : change(:day => last_day)
+    end
+    alias :at_end_of_month :end_of_month
+
+    def beginning_of_quarter
+      beginning_of_month.change(:month => [10, 7, 4, 1].detect { |m| m <= self.month })
+    end
+    alias :at_beginning_of_quarter :beginning_of_quarter
+
+    def end_of_quarter
+      beginning_of_month.change(:month => [3, 6, 9, 12].detect { |m| m >= self.month }).end_of_month
+    end
+    alias :at_end_of_quarter :end_of_quarter
+
+    def beginning_of_year
+      self.acts_like?(:time) ? change(:month => 1, :day => 1, :hour => 0, :min => 0, :sec => 0) : change(:month => 1, :day => 1)
+    end
+    alias :at_beginning_of_year :beginning_of_year
+
+    def end_of_year
+      self.acts_like?(:time) ? change(:month => 12,:day => 31,:hour => 23, :min => 59, :sec => 59) : change(:month => 12, :day => 31)
+    end
+    alias :at_end_of_year :end_of_year
+
+    def yesterday
+      self - 1
+    end
+
+    def tomorrow
+      self + 1
+    end
+  end
+
+end

data/lib/time_crisis/support/ext/date/conversions.rb

@@ -0,0 +1,60 @@
+module TimeCrisis
+  class Date
+    DATE_FORMATS = {
+      :short        => "%e %b",
+      :long         => "%B %e, %Y",
+      :db           => "%Y-%m-%d",
+      :number       => "%Y%m%d",
+      :rfc822       => "%e %b %Y"
+    }
+
+    def to_formatted_s(format = :default)
+      if formatter = DATE_FORMATS[format]
+        if formatter.respond_to?(:call)
+          formatter.call(self).to_s
+        else
+          strftime(formatter)
+        end
+      else
+        to_default_s
+      end
+    end
+    alias_method :to_default_s, :to_s
+    alias_method :to_s, :to_formatted_s
+
+    def readable_inspect
+      "#<TimeCrisis::Date #{strftime('%a, %d %b %Y')}>"
+    end
+    alias_method :default_inspect, :inspect
+    alias_method :inspect, :readable_inspect
+
+    def to_tc_date
+      self
+    end
+
+    def to_tc_datetime
+      ::TimeCrisis::DateTime.civil(year, month, day, 0, 0, 0, 0)
+    end
+    
+    def to_tc_time(form = :local)
+      ::TimeCrisis::Time.send(form, year, month, day)
+    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
+
+    def xmlschema
+      to_tc_datetime.xmlschema
+    end
+
+  end
+end

data/lib/time_crisis/support/ext/date_time/acts_like.rb

@@ -0,0 +1,13 @@
+require 'time_crisis/support/ext/object/acts_like'
+
+module TimeCrisis
+  class DateTime
+    def acts_like_date?
+      true
+    end
+
+    def acts_like_time?
+      true
+    end
+  end
+end