activesupport 3.2.22.5 → 4.0.0.beta1

data/lib/active_support/core_ext/date/conversions.rb

@@ -5,25 +5,27 @@ require 'active_support/core_ext/module/remove_method'
 
 class Date
   DATE_FORMATS = {
-    :short        => "%e %b",
-    :long         => "%B %e, %Y",
-    :db           => "%Y-%m-%d",
-    :number       => "%Y%m%d",
-    :long_ordinal => lambda { |date| date.strftime("%B #{ActiveSupport::Inflector.ordinalize(date.day)}, %Y") }, # => "April 25th, 2007"
-    :rfc822       => "%e %b %Y"
+    :short        => '%e %b',
+    :long         => '%B %e, %Y',
+    :db           => '%Y-%m-%d',
+    :number       => '%Y%m%d',
+    :long_ordinal => lambda { |date|
+      day_format = ActiveSupport::Inflector.ordinalize(date.day)
+      date.strftime("%B #{day_format}, %Y") # => "April 25th, 2007"
+    },
+    :rfc822       => '%e %b %Y'
   }
 
   # Ruby 1.9 has Date#to_time which converts to localtime only.
-  remove_possible_method :to_time
+  remove_method :to_time
 
   # Ruby 1.9 has Date#xmlschema which converts to a string without the time component.
-  remove_possible_method :xmlschema
+  remove_method :xmlschema
 
   # Convert to a formatted string. See DATE_FORMATS for predefined formats.
   #
   # This method is aliased to <tt>to_s</tt>.
   #
-  # ==== Examples
   #   date = Date.new(2007, 11, 10)       # => Sat, 10 Nov 2007
   #
   #   date.to_formatted_s(:db)            # => "2007-11-10"
@@ -40,8 +42,8 @@ class Date
   # or Proc instance that takes a date argument as the value.
   #
   #   # config/initializers/time_formats.rb
-  #   Date::DATE_FORMATS[:month_and_year] = "%B %Y"
-  #   Date::DATE_FORMATS[:short_ordinal] = lambda { |date| date.strftime("%B #{date.day.ordinalize}") }
+  #   Date::DATE_FORMATS[:month_and_year] = '%B %Y'
+  #   Date::DATE_FORMATS[:short_ordinal] = ->(date) { date.strftime("%B #{date.day.ordinalize}") }
   def to_formatted_s(format = :default)
     if formatter = DATE_FORMATS[format]
       if formatter.respond_to?(:call)
@@ -58,21 +60,14 @@ class Date
 
   # Overrides the default inspect method with a human readable one, e.g., "Mon, 21 Feb 2005"
   def readable_inspect
-    strftime("%a, %d %b %Y")
+    strftime('%a, %d %b %Y')
   end
   alias_method :default_inspect, :inspect
   alias_method :inspect, :readable_inspect
 
-  # A method to keep Time, Date and DateTime instances interchangeable on conversions.
-  # In this case, it simply returns +self+.
-  def to_date
-    self
-  end if RUBY_VERSION < '1.9'
-
   # Converts a Date instance to a Time, where the time is set to the beginning of the day.
   # The timezone can be either :local or :utc (default :local).
   #
-  # ==== Examples
   #   date = Date.new(2007, 11, 10)  # => Sat, 10 Nov 2007
   #
   #   date.to_time                   # => Sat Nov 10 00:00:00 0800 2007
@@ -80,27 +75,10 @@ class Date
   #
   #   date.to_time(:utc)             # => Sat Nov 10 00:00:00 UTC 2007
   def to_time(form = :local)
-    ::Time.send("#{form}_time", year, month, day)
+    ::Time.send(form, year, month, day)
   end
 
-  # Converts a Date instance to a DateTime, where the time is set to the beginning of the day
-  # and UTC offset is set to 0.
-  #
-  # ==== Examples
-  #   date = Date.new(2007, 11, 10)  # => Sat, 10 Nov 2007
-  #
-  #   date.to_datetime               # => Sat, 10 Nov 2007 00:00:00 0000
-  def to_datetime
-    ::DateTime.civil(year, month, day, 0, 0, 0, 0)
-  end if RUBY_VERSION < '1.9'
-
-  def iso8601
-    strftime('%F')
-  end if RUBY_VERSION < '1.9'
-
-  alias_method :rfc3339, :iso8601 if RUBY_VERSION < '1.9'
-
   def xmlschema
-    to_time_in_current_zone.xmlschema
+    in_time_zone.xmlschema
   end
 end

data/lib/active_support/core_ext/date/infinite_comparable.rb

@@ -0,0 +1,5 @@
+require 'active_support/core_ext/infinite_comparable'
+
+class Date
+  include InfiniteComparable
+end

data/lib/active_support/core_ext/date/zones.rb

@@ -2,13 +2,36 @@ require 'date'
 require 'active_support/core_ext/time/zones'
 
 class Date
-  # Converts Date to a TimeWithZone in the current zone if Time.zone or Time.zone_default
-  # is set, otherwise converts Date to a Time via Date#to_time
+  # *DEPRECATED*: Use +Date#in_time_zone+ instead.
+  #
+  # Converts Date to a TimeWithZone in the current zone if <tt>Time.zone</tt> or
+  # <tt>Time.zone_default</tt> is set, otherwise converts Date to a Time via
+  # Date#to_time.
   def to_time_in_current_zone
+    ActiveSupport::Deprecation.warn 'Date#to_time_in_current_zone is deprecated. Use Date#in_time_zone instead', caller
+
     if ::Time.zone
       ::Time.zone.local(year, month, day)
     else
       to_time
     end
   end
+
+  # Converts Date to a TimeWithZone in the current zone if Time.zone or Time.zone_default
+  # is set, otherwise converts Date to a Time via Date#to_time
+  #
+  #   Time.zone = 'Hawaii'         # => 'Hawaii'
+  #   Date.new(2000).in_time_zone  # => Sat, 01 Jan 2000 00:00:00 HST -10:00
+  #
+  # You can also pass in a TimeZone instance or string that identifies a TimeZone as an argument,
+  # and the conversion will be based on that zone instead of <tt>Time.zone</tt>.
+  #
+  #   Date.new(2000).in_time_zone('Alaska')  # => Sat, 01 Jan 2000 00:00:00 AKST -09:00
+  def in_time_zone(zone = ::Time.zone)
+    if zone
+      ::Time.find_zone!(zone).local(year, month, day)
+    else
+      to_time
+    end
+  end
 end

data/lib/active_support/core_ext/date_and_time/calculations.rb

@@ -0,0 +1,232 @@
+module DateAndTime
+  module Calculations
+    DAYS_INTO_WEEK = {
+      :monday    => 0,
+      :tuesday   => 1,
+      :wednesday => 2,
+      :thursday  => 3,
+      :friday    => 4,
+      :saturday  => 5,
+      :sunday    => 6
+    }
+
+    # Returns a new date/time representing yesterday.
+    def yesterday
+      advance(:days => -1)
+    end
+
+    # Returns a new date/time representing tomorrow.
+    def tomorrow
+      advance(:days => 1)
+    end
+
+    # Returns true if the date/time is today.
+    def today?
+      to_date == ::Date.current
+    end
+
+    # Returns true if the date/time is in the past.
+    def past?
+      self < self.class.current
+    end
+
+    # Returns true if the date/time is in the future.
+    def future?
+      self > self.class.current
+    end
+
+    # Returns a new date/time the specified number of days ago.
+    def days_ago(days)
+      advance(:days => -days)
+    end
+
+    # Returns a new date/time the specified number of days in the future.
+    def days_since(days)
+      advance(:days => days)
+    end
+
+    # Returns a new date/time the specified number of weeks ago.
+    def weeks_ago(weeks)
+      advance(:weeks => -weeks)
+    end
+
+    # Returns a new date/time the specified number of weeks in the future.
+    def weeks_since(weeks)
+      advance(:weeks => weeks)
+    end
+
+    # Returns a new date/time the specified number of months ago.
+    def months_ago(months)
+      advance(:months => -months)
+    end
+
+    # Returns a new date/time the specified number of months in the future.
+    def months_since(months)
+      advance(:months => months)
+    end
+
+    # Returns a new date/time the specified number of years ago.
+    def years_ago(years)
+      advance(:years => -years)
+    end
+
+    # Returns a new date/time the specified number of years in the future.
+    def years_since(years)
+      advance(:years => years)
+    end
+
+    # Returns a new date/time at the start of the month.
+    # DateTime objects will have a time set to 0:00.
+    def beginning_of_month
+      first_hour{ change(:day => 1) }
+    end
+    alias :at_beginning_of_month :beginning_of_month
+
+    # Returns a new date/time at the start of the quarter.
+    # Example: 1st January, 1st July, 1st October.
+    # DateTime objects will have a time set to 0:00.
+    def beginning_of_quarter
+      first_quarter_month = [10, 7, 4, 1].detect { |m| m <= month }
+      beginning_of_month.change(:month => first_quarter_month)
+    end
+    alias :at_beginning_of_quarter :beginning_of_quarter
+
+    # Returns a new date/time at the end of the quarter.
+    # Example: 31st March, 30th June, 30th September.
+    # DateTIme objects will have a time set to 23:59:59.
+    def end_of_quarter
+      last_quarter_month = [3, 6, 9, 12].detect { |m| m >= month }
+      beginning_of_month.change(:month => last_quarter_month).end_of_month
+    end
+    alias :at_end_of_quarter :end_of_quarter
+
+    # Return a new date/time at the beginning of the year.
+    # Example: 1st January.
+    # DateTime objects will have a time set to 0:00.
+    def beginning_of_year
+      change(:month => 1).beginning_of_month
+    end
+    alias :at_beginning_of_year :beginning_of_year
+
+    # Returns a new date/time representing the given day in the next week.
+    # Week is assumed to start on +start_day+, default is
+    # +Date.beginning_of_week+ or +config.beginning_of_week+ when set.
+    # DateTime objects have their time set to 0:00.
+    def next_week(start_day = Date.beginning_of_week)
+      first_hour{ weeks_since(1).beginning_of_week.days_since(days_span(start_day)) }
+    end
+
+    # Short-hand for months_since(1).
+    def next_month
+      months_since(1)
+    end
+
+    # Short-hand for months_since(3)
+    def next_quarter
+      months_since(3)
+    end
+
+    # Short-hand for years_since(1).
+    def next_year
+      years_since(1)
+    end
+
+    # Returns a new date/time representing the given day in the previous week.
+    # Week is assumed to start on +start_day+, default is
+    # +Date.beginning_of_week+ or +config.beginning_of_week+ when set.
+    # DateTime objects have their time set to 0:00.
+    def prev_week(start_day = Date.beginning_of_week)
+      first_hour{ weeks_ago(1).beginning_of_week.days_since(days_span(start_day)) }
+    end
+    alias_method :last_week, :prev_week
+
+    # Short-hand for months_ago(1).
+    def prev_month
+      months_ago(1)
+    end
+    alias_method :last_month, :prev_month
+
+    # Short-hand for months_ago(3).
+    def prev_quarter
+      months_ago(3)
+    end
+    alias_method :last_quarter, :prev_quarter
+
+    # Short-hand for years_ago(1).
+    def prev_year
+      years_ago(1)
+    end
+    alias_method :last_year, :prev_year
+
+    # Returns the number of days to the start of the week on the given day.
+    # Week is assumed to start on +start_day+, default is
+    # +Date.beginning_of_week+ or +config.beginning_of_week+ when set.
+    def days_to_week_start(start_day = Date.beginning_of_week)
+      start_day_number = DAYS_INTO_WEEK[start_day]
+      current_day_number = wday != 0 ? wday - 1 : 6
+      (current_day_number - start_day_number) % 7
+    end
+
+    # Returns a new date/time representing the start of this week on the given day.
+    # Week is assumed to start on +start_day+, default is
+    # +Date.beginning_of_week+ or +config.beginning_of_week+ when set.
+    # +DateTime+ objects have their time set to 0:00.
+    def beginning_of_week(start_day = Date.beginning_of_week)
+      result = days_ago(days_to_week_start(start_day))
+      acts_like?(:time) ? result.midnight : result
+    end
+    alias :at_beginning_of_week :beginning_of_week
+
+    # Returns Monday of this week assuming that week starts on Monday.
+    # +DateTime+ objects have their time set to 0:00.
+    def monday
+      beginning_of_week(:monday)
+    end
+
+    # Returns a new date/time representing the end of this week on the given day.
+    # Week is assumed to start on +start_day+, default is
+    # +Date.beginning_of_week+ or +config.beginning_of_week+ when set.
+    # DateTime objects have their time set to 23:59:59.
+    def end_of_week(start_day = Date.beginning_of_week)
+      last_hour{ days_since(6 - days_to_week_start(start_day)) }
+    end
+    alias :at_end_of_week :end_of_week
+
+    # Returns Sunday of this week assuming that week starts on Monday.
+    # +DateTime+ objects have their time set to 23:59:59.
+    def sunday
+      end_of_week(:monday)
+    end
+
+    # Returns a new date/time representing the end of the month.
+    # DateTime objects will have a time set to 23:59:59.
+    def end_of_month
+      last_day = ::Time.days_in_month(month, year)
+      last_hour{ days_since(last_day - day) }
+    end
+    alias :at_end_of_month :end_of_month
+
+    # Returns a new date/time representing the end of the year.
+    # DateTime objects will have a time set to 23:59:59.
+    def end_of_year
+      change(:month => 12).end_of_month
+    end
+    alias :at_end_of_year :end_of_year
+
+    private
+
+    def first_hour
+      result = yield
+      acts_like?(:time) ? result.change(:hour => 0) : result
+    end
+
+    def last_hour
+      result = yield
+      acts_like?(:time) ? result.end_of_day : result
+    end
+
+    def days_span(day)
+      (DAYS_INTO_WEEK[day] - DAYS_INTO_WEEK[Date.beginning_of_week]) % 7
+    end
+  end
+end

data/lib/active_support/core_ext/date_time.rb

@@ -0,0 +1,5 @@
+require 'active_support/core_ext/date_time/acts_like'
+require 'active_support/core_ext/date_time/calculations'
+require 'active_support/core_ext/date_time/conversions'
+require 'active_support/core_ext/date_time/zones'
+require 'active_support/core_ext/date_time/infinite_comparable'

data/lib/active_support/core_ext/date_time/acts_like.rb

@@ -1,4 +1,3 @@
-require 'date'
 require 'active_support/core_ext/object/acts_like'
 
 class DateTime

data/lib/active_support/core_ext/date_time/calculations.rb

@@ -1,46 +1,67 @@
-require 'rational' unless RUBY_VERSION >= '1.9.2'
+require 'active_support/deprecation'
 
 class DateTime
   class << self
-    # DateTimes aren't aware of DST rules, so use a consistent non-DST offset when creating a DateTime with an offset in the local zone
+    # *DEPRECATED*: Use +DateTime.civil_from_format+ directly.
     def local_offset
+      ActiveSupport::Deprecation.warn 'DateTime.local_offset is deprecated. Use DateTime.civil_from_format directly.'
+
       ::Time.local(2012).utc_offset.to_r / 86400
     end
 
-    # Returns <tt>Time.zone.now.to_datetime</tt> when <tt>Time.zone</tt> or <tt>config.time_zone</tt> are set, otherwise returns <tt>Time.now.to_datetime</tt>.
+    # Returns <tt>Time.zone.now.to_datetime</tt> when <tt>Time.zone</tt> or
+    # <tt>config.time_zone</tt> are set, otherwise returns
+    # <tt>Time.now.to_datetime</tt>.
     def current
       ::Time.zone ? ::Time.zone.now.to_datetime : ::Time.now.to_datetime
     end
   end
 
-  # Tells whether the DateTime object's datetime lies in the past
+  # Tells whether the DateTime object's datetime lies in the past.
   def past?
     self < ::DateTime.current
   end
 
-  # Tells whether the DateTime object's datetime lies in the future
+  # Tells whether the DateTime object's datetime lies in the future.
   def future?
     self > ::DateTime.current
   end
 
-  # Seconds since midnight: DateTime.now.seconds_since_midnight
+  # Seconds since midnight: DateTime.now.seconds_since_midnight.
   def seconds_since_midnight
     sec + (min * 60) + (hour * 3600)
   end
 
-  # Returns a new DateTime where one or more of the elements have been changed according to the +options+ parameter. The time options
-  # (hour, minute, sec) reset cascadingly, so if only the hour is passed, then minute and sec is set to 0. If the hour and
-  # minute is passed, then sec is set to 0.
+  # Returns the number of seconds until 23:59:59.
+  #
+  #   DateTime.new(2012, 8, 29,  0,  0,  0).seconds_until_end_of_day # => 86399
+  #   DateTime.new(2012, 8, 29, 12, 34, 56).seconds_until_end_of_day # => 41103
+  #   DateTime.new(2012, 8, 29, 23, 59, 59).seconds_until_end_of_day # => 0
+  def seconds_until_end_of_day
+    end_of_day.to_i - to_i
+  end
+
+  # Returns a new DateTime where one or more of the elements have been changed
+  # according to the +options+ parameter. The time options (<tt>:hour</tt>,
+  # <tt>:min</tt>, <tt>:sec</tt>) reset cascadingly, so if only the hour is
+  # passed, then minute and sec is set to 0. If the hour and minute is passed,
+  # then sec is set to 0. The +options+ parameter takes a hash with any of these
+  # keys: <tt>:year</tt>, <tt>:month</tt>, <tt>:day</tt>, <tt>:hour</tt>,
+  # <tt>:min</tt>, <tt>:sec</tt>, <tt>:offset</tt>, <tt>:start</tt>.
+  #
+  #   DateTime.new(2012, 8, 29, 22, 35, 0).change(day: 1)              # => DateTime.new(2012, 8, 1, 22, 35, 0)
+  #   DateTime.new(2012, 8, 29, 22, 35, 0).change(year: 1981, day: 1)  # => DateTime.new(1981, 8, 1, 22, 35, 0)
+  #   DateTime.new(2012, 8, 29, 22, 35, 0).change(year: 1981, hour: 0) # => DateTime.new(1981, 8, 29, 0, 0, 0)
   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
+      options.fetch(:year, year),
+      options.fetch(:month, month),
+      options.fetch(:day, day),
+      options.fetch(:hour, hour),
+      options.fetch(:min, options[:hour] ? 0 : min),
+      options.fetch(:sec, (options[:hour] || options[:min]) ? 0 : sec + sec_fraction),
+      options.fetch(:offset, offset),
+      options.fetch(:start, start)
     )
   end
 
@@ -51,24 +72,33 @@ class DateTime
   def advance(options)
     d = to_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)
+    seconds_to_advance = \
+      options.fetch(:seconds, 0) +
+      options.fetch(:minutes, 0) * 60 +
+      options.fetch(:hours, 0) * 3600
+
+    if seconds_to_advance.zero?
+      datetime_advanced_by_date
+    else
+      datetime_advanced_by_date.since seconds_to_advance
+    end
   end
 
-  # Returns a new DateTime representing the time a number of seconds ago
+  # Returns a new DateTime representing the time a number of seconds ago.
   # Do not use this method in combination with x.months, use months_ago instead!
   def ago(seconds)
     since(-seconds)
   end
 
-  # Returns a new DateTime representing the time a number of seconds since the instance time
-  # Do not use this method in combination with x.months, use months_since instead!
+  # Returns a new DateTime representing the time a number of seconds since the
+  # instance time. Do not use this method in combination with x.months, use
+  # months_since instead!
   def since(seconds)
     self + Rational(seconds.round, 86400)
   end
   alias :in :since
 
-  # Returns a new DateTime representing the start of the day (0:00)
+  # Returns a new DateTime representing the start of the day (0:00).
   def beginning_of_day
     change(:hour => 0)
   end
@@ -76,74 +106,52 @@ class DateTime
   alias :at_midnight :beginning_of_day
   alias :at_beginning_of_day :beginning_of_day
 
-  # Returns a new DateTime representing the end of the day (23:59:59)
+  # Returns a new DateTime representing the end of the day (23:59:59).
   def end_of_day
     change(:hour => 23, :min => 59, :sec => 59)
   end
+  alias :at_end_of_day :end_of_day
 
-  # Returns a new DateTime representing the start of the hour (hh:00:00)
+  # Returns a new DateTime representing the start of the hour (hh:00:00).
   def beginning_of_hour
     change(:min => 0)
   end
   alias :at_beginning_of_hour :beginning_of_hour
 
-  # Returns a new DateTime representing the end of the hour (hh:59:59)
+  # Returns a new DateTime representing the end of the hour (hh:59:59).
   def end_of_hour
     change(:min => 59, :sec => 59)
   end
+  alias :at_end_of_hour :end_of_hour
 
-  # 1.9.3 defines + and - on DateTime, < 1.9.3 do not.
-  if DateTime.public_instance_methods(false).include?(:+)
-    def plus_with_duration(other) #:nodoc:
-      if ActiveSupport::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 ActiveSupport::Duration === other
-        plus_with_duration(-other)
-      else
-        minus_without_duration(other)
-      end
-    end
-    alias_method :minus_without_duration, :-
-    alias_method :-, :minus_with_duration
+  # Returns a new DateTime representing the start of the minute (hh:mm:00).
+  def beginning_of_minute
+    change(:sec => 0)
   end
+  alias :at_beginning_of_minute :beginning_of_minute
 
-  # Adjusts DateTime to UTC by adding its offset value; offset is set to 0
-  #
-  # Example:
+  # Returns a new DateTime representing the end of the minute (hh:mm:59).
+  def end_of_minute
+    change(:sec => 59)
+  end
+  alias :at_end_of_minute :end_of_minute
+
+  # Adjusts DateTime to UTC by adding its offset value; offset is set to 0.
   #
-  #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24))       # => Mon, 21 Feb 2005 10:11:12 -0600
-  #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24)).utc   # => Mon, 21 Feb 2005 16:11:12 +0000
+  #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24))     # => Mon, 21 Feb 2005 10:11:12 -0600
+  #   DateTime.civil(2005, 2, 21, 10, 11, 12, Rational(-6, 24)).utc # => Mon, 21 Feb 2005 16:11:12 +0000
   def utc
     new_offset(0)
   end
   alias_method :getutc, :utc
 
-  # Returns true if offset == 0
+  # Returns +true+ if <tt>offset == 0</tt>.
   def utc?
     offset == 0
   end
 
-  # Returns the offset value in seconds
+  # Returns the offset value in seconds.
   def utc_offset
     (offset * 86400).to_i
   end
-
-  # Layers additional behavior on DateTime#<=> so that Time and ActiveSupport::TimeWithZone instances can be compared with a DateTime
-  def <=>(other)
-    if other.kind_of?(Infinity)
-      super
-    elsif other.respond_to? :to_datetime
-      super other.to_datetime
-    else
-      nil
-    end
-  end
 end