time_crisis 0.2.0 → 0.3.0

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

@@ -0,0 +1,88 @@
+require 'rational'
+
+module TimeCrisis
+  class DateTime
+    class << self
+      def local_offset
+        ::TimeCrisis::Time.local(2007).utc_offset
+      end
+
+      def current
+        ::TimeCrisis::Time.zone_default ? ::TimeCrisis::Time.zone.now.to_tc_datetime : ::TimeCrisis::Time.now.to_tc_datetime
+      end
+    end
+
+    def past?
+      self < ::TimeCrisis::DateTime.current
+    end
+
+    def future?
+      self > ::TimeCrisis::DateTime.current
+    end
+
+    def seconds_since_midnight
+      sec + (min * 60) + (hour * 3600)
+    end
+
+    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
+
+    def advance(options)
+      d = to_tc_date.advance(options)
+      datetime_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)
+    end
+
+    def ago(seconds)
+      since(-seconds)
+    end
+
+    def since(seconds)
+      self + Rational(seconds.round, 86400).to_f
+    end
+    alias :in :since
+
+    def beginning_of_day
+      change(:hour => 0)
+    end
+    alias :midnight :beginning_of_day
+    alias :at_midnight :beginning_of_day
+    alias :at_beginning_of_day :beginning_of_day
+
+    def end_of_day
+      change(:hour => 23, :min => 59, :sec => 59)
+    end
+
+    def utc
+      new_offset(0)
+    end
+    alias_method :getutc, :utc
+
+    def utc?
+      offset == 0
+    end
+
+    def utc_offset
+      offset
+    end
+
+    def compare_with_coercion(other)
+      other = other.comparable_time if other.respond_to?(:comparable_time)
+      other = other.to_tc_datetime unless other.acts_like?(:date)
+      compare_without_coercion(other)
+    end
+    alias_method :compare_without_coercion, :<=>
+    alias_method :<=>, :compare_with_coercion
+  end
+end

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

@@ -0,0 +1,66 @@
+module TimeCrisis
+  class DateTime
+    def to_formatted_s(format = :default)
+      if formatter = ::TimeCrisis::Time::DATE_FORMATS[format]
+        formatter.respond_to?(:call) ? formatter.call(self).to_s : strftime(formatter)
+      else
+        to_default_s
+      end
+    end
+    alias_method :to_default_s, :to_s unless (instance_methods(false) & [:to_s, 'to_s']).empty?
+    alias_method :to_s, :to_formatted_s
+
+    def formatted_offset(colon = true, alternate_utc_string = nil)
+      utc? && alternate_utc_string || TimeCrisis::TimeZone.seconds_to_utc_offset(utc_offset, colon)
+    end
+
+    def readable_inspect
+      "#<TimeCrisis::DateTime #{self.to_s(:rfc822)}>"
+    end
+    alias_method :default_inspect, :inspect
+    alias_method :inspect, :readable_inspect
+
+    def to_date
+      ::Date.civil(year, month, day)
+    end
+
+    def to_tc_date
+      ::TimeCrisis::Date.civil(year, month, day)
+    end
+
+    def to_tc_datetime
+      self
+    end
+
+    def to_datetime
+      ::DateTime.civil(year, month, day, hour, minute, second, Rational(offset, 86400))
+    end
+
+    def to_time
+      ::Time.at(self.to_i)
+    end
+    
+    def to_tc_time
+      ::TimeCrisis::Time.at(self.to_i)
+    end
+
+    def xmlschema
+      strftime("%Y-%m-%dT%H:%M:%S%Z")
+    end
+
+    def to_f
+      seconds_since_unix_epoch.to_f
+    end
+
+    def to_i
+      seconds_since_unix_epoch.to_i
+    end
+
+    private
+
+    def seconds_since_unix_epoch
+      seconds_per_day = 86_400
+      (self - ::TimeCrisis::DateTime.civil(1970)) * seconds_per_day
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+class DateTime
+  def in_time_zone(zone = ::TimeCrisis::Time.zone)
+    TimeCrisis::TimeWithZone.new(utc? ? self : getutc, ::TimeCrisis::Time.__send__(:get_zone, zone))
+  end
+end

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

@@ -0,0 +1,5 @@
+class Object
+  def acts_like?(duck)
+    respond_to? :"acts_like_#{duck}?"
+  end
+end

data/lib/time_crisis/support/ext/object/blank.rb

@@ -0,0 +1,47 @@
+class Object
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+
+  def present?
+    !blank?
+  end
+end
+
+class NilClass
+  def blank?
+    true
+  end
+end
+
+class FalseClass
+  def blank?
+    true
+  end
+end
+
+class TrueClass
+  def blank?
+    false
+  end
+end
+
+class Array
+  alias_method :blank?, :empty?
+end
+
+class Hash
+  alias_method :blank?, :empty?
+end
+
+class String
+  def blank?
+    self !~ /\S/
+  end
+end
+
+class Numeric
+  def blank?
+    false
+  end
+end

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

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

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

@@ -0,0 +1,228 @@
+require 'time_crisis/support/duration'
+require 'time_crisis/support/ext/date/acts_like'
+require 'time_crisis/support/ext/date/calculations'
+
+module TimeCrisis
+  class Time
+    DAYS_INTO_WEEK = { :monday => 0, :tuesday => 1, :wednesday => 2, :thursday => 3, :friday => 4, :saturday => 5, :sunday => 6 }
+
+    class << self
+      def ===(other)
+        other.is_a?(::Time)
+      end
+
+      def days_in_month(month, year = now.year)
+        ::TimeCrisis::Date.civil(year, month, 1).days_in_month
+      end
+
+      def time_with_datetime_fallback(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0, usec=0)
+        ::TimeCrisis::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)
+      rescue
+        offset = utc_or_local.to_sym == :local ? ::TimeCrisis::DateTime.local_offset : 0
+        ::DateTime.civil(year, month, day, hour, min, sec, 0, offset)
+      end
+
+      def utc_time(*args)
+        time_with_datetime_fallback(:utc, *args)
+      end
+
+      def local_time(*args)
+        time_with_datetime_fallback(:local, *args)
+      end
+    end
+
+    def past?
+      self < ::TimeCrisis::Time.current
+    end
+
+    def today?
+      to_tc_date == ::TimeCrisis::Date.current
+    end
+
+    def future?
+      self > ::TimeCrisis::Time.current
+    end
+
+    def seconds_since_midnight
+      to_i - change(:hour => 0).to_i + (usec / 1.0e+6)
+    end
+
+    def change(options)
+      ::TimeCrisis::Time.send(
+        utc? ? :utc_time : :local_time,
+        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 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_tc_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
+
+    def ago(seconds)
+      since(-seconds)
+    end
+
+    def since(seconds)
+      self + seconds
+    rescue
+      to_tc_datetime.since(seconds)
+    end
+    alias :in :since
+
+    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
+
+    def last_month
+      months_ago(1)
+    end
+
+    def next_month
+      months_since(1)
+    end
+
+    def beginning_of_week
+      days_to_monday = wday!=0 ? wday-1 : 6
+      (self - days_to_monday.days).midnight
+    end
+    alias :monday :beginning_of_week
+    alias :at_beginning_of_week :beginning_of_week
+
+    def end_of_week
+      days_to_sunday = wday!=0 ? 7-wday : 0
+      (self + days_to_sunday.days).end_of_day
+    end
+    alias :at_end_of_week :end_of_week
+
+    def next_week(day = :monday)
+      since(1.week).beginning_of_week.since(DAYS_INTO_WEEK[day].day).change(:hour => 0)
+    end
+
+    def beginning_of_day
+      change(:hour => 0, :min => 0, :sec => 0, :usec => 0)
+    end
+    alias :midnight :beginning_of_day
+    alias :at_midnight :beginning_of_day
+    alias :at_beginning_of_day :beginning_of_day
+
+    def end_of_day
+      change(:hour => 23, :min => 59, :sec => 59, :usec => 999999.999)
+    end
+
+    def beginning_of_month
+      change(:day => 1,:hour => 0, :min => 0, :sec => 0, :usec => 0)
+    end
+    alias :at_beginning_of_month :beginning_of_month
+
+    def end_of_month
+      last_day = ::TimeCrisis::Time.days_in_month(month, year)
+      change(:day => last_day, :hour => 23, :min => 59, :sec => 59, :usec => 999999.999)
+    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 <= 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 >= month }).end_of_month
+    end
+    alias :at_end_of_quarter :end_of_quarter
+
+    def beginning_of_year
+      change(:month => 1, :day => 1, :hour => 0, :min => 0, :sec => 0, :usec => 0)
+    end
+    alias :at_beginning_of_year :beginning_of_year
+
+    def end_of_year
+      change(:month => 12, :day => 31, :hour => 23, :min => 59, :sec => 59, :usec => 999999.999)
+    end
+    alias :at_end_of_year :end_of_year
+
+    def yesterday
+      advance(:days => -1)
+    end
+
+    def tomorrow
+      advance(:days => 1)
+    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
+        other.until(self)
+      else
+        minus_without_duration(other)
+      end
+    end
+    alias_method :minus_without_duration, :-
+    alias_method :-, :minus_with_duration
+
+    def minus_with_coercion(other)
+      other = other.comparable_time if other.respond_to?(:comparable_time)
+      minus_without_coercion(other)
+    end
+    alias_method :minus_without_coercion, :-
+    alias_method :-, :minus_with_coercion
+
+    def compare_with_coercion(other)
+      other = other.comparable_time if other.respond_to?(:comparable_time)
+      if other.acts_like?(:date)
+        to_tc_datetime.compare_without_coercion(other)
+      else
+        compare_without_coercion(other)
+      end
+    end
+    alias_method :compare_without_coercion, :<=>
+    alias_method :<=>, :compare_with_coercion
+  end
+end