Convert Time extension modules to class reopens

3 files changed, 356 insertions, 380 deletions

diff --git a/activesupport/lib/active_support/core_ext/time.rb b/activesupport/lib/active_support/core_ext/time.rb
index 2bdad4c7a6..36022c2562 100644
--- a/activesupport/lib/active_support/core_ext/time.rb
+++ b/activesupport/lib/active_support/core_ext/time.rb
@@ -4,5 +4,8 @@ require 'time'
 require 'active_support/core_ext/time/publicize_conversion_methods'
 require 'active_support/core_ext/time/marshal_with_utc_flag'
 
+require 'active_support/core_ext/time/calculations'
+require 'active_support/core_ext/time/zones'
+
 require 'active_support/core_ext/util'
-ActiveSupport.core_ext Time, %w(behavior calculations conversions zones)
+ActiveSupport.core_ext Time, %w(behavior conversions)
diff --git a/activesupport/lib/active_support/core_ext/time/calculations.rb b/activesupport/lib/active_support/core_ext/time/calculations.rb
index 5ed750afcc..7819af3b50 100644
--- a/activesupport/lib/active_support/core_ext/time/calculations.rb
+++ b/activesupport/lib/active_support/core_ext/time/calculations.rb
@@ -1,303 +1,286 @@
 require 'active_support/duration'
 
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Time #:nodoc:
-      # Enables the use of time calculations within Time itself
-      module Calculations
-        def self.included(base) #:nodoc:
-          base.extend ClassMethods
-
-          base.class_eval do
-            alias_method :plus_without_duration, :+
-            alias_method :+, :plus_with_duration
-
-            alias_method :minus_without_duration, :-
-            alias_method :-, :minus_with_duration
-
-            alias_method :minus_without_coercion, :-
-            alias_method :-, :minus_with_coercion
-
-            alias_method :compare_without_coercion, :<=>
-            alias_method :<=>, :compare_with_coercion
-          end
-        end
-
-        COMMON_YEAR_DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
-
-        module ClassMethods
-          # Overriding case equality method so that it returns true for ActiveSupport::TimeWithZone instances
-          def ===(other)
-            other.is_a?(::Time)
-          end
-
-          # Return the number of days in the given month.
-          # If no year is specified, it will use the current year.
-          def days_in_month(month, year = now.year)
-            return 29 if month == 2 && ::Date.gregorian_leap?(year)
-            COMMON_YEAR_DAYS_IN_MONTH[month]
-          end
-
-          # Returns a new Time if requested year can be accommodated by Ruby's Time class
-          # (i.e., if year is within either 1970..2038 or 1902..2038, depending on system architecture);
-          # otherwise returns a DateTime
-          def time_with_datetime_fallback(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0, usec=0)
-            ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)
-          rescue
-            offset = utc_or_local.to_sym == :local ? ::DateTime.local_offset : 0
-            ::DateTime.civil(year, month, day, hour, min, sec, offset)
-          end
-
-          # Wraps class method +time_with_datetime_fallback+ with +utc_or_local+ set to <tt>:utc</tt>.
-          def utc_time(*args)
-            time_with_datetime_fallback(:utc, *args)
-          end
-
-          # Wraps class method +time_with_datetime_fallback+ with +utc_or_local+ set to <tt>:local</tt>.
-          def local_time(*args)
-            time_with_datetime_fallback(:local, *args)
-          end
-        end
-
-        # Tells whether the Time object's time lies in the past
-        def past?
-          self < ::Time.current
-        end
-
-        # Tells whether the Time object's time is today
-        def today?
-          self.to_date == ::Date.current
-        end
-
-        # Tells whether the Time object's time lies in the future
-        def future?
-          self > ::Time.current
-        end
-
-        # Seconds since midnight: Time.now.seconds_since_midnight
-        def seconds_since_midnight
-          self.to_i - self.change(:hour => 0).to_i + (self.usec/1.0e+6)
-        end
-
-        # Returns a new Time where one or more of the elements have been changed according to the +options+ parameter. The time options
-        # (hour, minute, sec, usec) reset cascadingly, so if only the hour is passed, then minute, sec, and usec is set to 0. If the hour and
-        # minute is passed, then sec and usec is set to 0.
-        def change(options)
-          ::Time.send(
-            self.utc? ? :utc_time : :local_time,
-            options[:year]  || self.year,
-            options[:month] || self.month,
-            options[:day]   || self.day,
-            options[:hour]  || self.hour,
-            options[:min]   || (options[:hour] ? 0 : self.min),
-            options[:sec]   || ((options[:hour] || options[:min]) ? 0 : self.sec),
-            options[:usec]  || ((options[:hour] || options[:min] || options[:sec]) ? 0 : self.usec)
-          )
-        end
-
-        # Uses Date to provide precise Time calculations for years, months, and days.
-        # The +options+ parameter takes a hash with any of these keys: <tt>:years</tt>,
-        # <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>,
-        # <tt>:minutes</tt>, <tt>:seconds</tt>.
-        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
-
-        # Returns a new Time representing the time a number of seconds ago, this is basically a wrapper around the Numeric extension
-        def ago(seconds)
-          self.since(-seconds)
-        end
-
-        # Returns a new Time representing the time a number of seconds since the instance time, this is basically a wrapper around
-        # the Numeric extension.
-        def since(seconds)
-          f = seconds.since(self)
-          if ActiveSupport::Duration === seconds
-            f
-          else
-            initial_dst = self.dst? ? 1 : 0
-            final_dst   = f.dst? ? 1 : 0
-            (seconds.abs >= 86400 && initial_dst != final_dst) ? f + (initial_dst - final_dst).hours : f
-          end
-        rescue
-          self.to_datetime.since(seconds)
-        end
-        alias :in :since
-
-        # Returns a new Time representing the time a number of specified months ago
-        def months_ago(months)
-          advance(:months => -months)
-        end
-
-        # Returns a new Time representing the time a number of specified months in the future
-        def months_since(months)
-          advance(:months => months)
-        end
-
-        # Returns a new Time representing the time a number of specified years ago
-        def years_ago(years)
-          advance(:years => -years)
-        end
-
-        # Returns a new Time representing the time a number of specified years in the future
-        def years_since(years)
-          advance(:years => years)
-        end
-
-        # Short-hand for years_ago(1)
-        def last_year
-          years_ago(1)
-        end
-
-        # Short-hand for years_since(1)
-        def next_year
-          years_since(1)
-        end
-
-
-        # Short-hand for months_ago(1)
-        def last_month
-          months_ago(1)
-        end
-
-        # Short-hand for months_since(1)
-        def next_month
-          months_since(1)
-        end
-
-        # Returns a new Time representing the "start" of this week (Monday, 0:00)
-        def beginning_of_week
-          days_to_monday = self.wday!=0 ? self.wday-1 : 6
-          (self - days_to_monday.days).midnight
-        end
-        alias :monday :beginning_of_week
-        alias :at_beginning_of_week :beginning_of_week
-
-        # Returns a new Time representing the end of this week (Sunday, 23:59:59)
-        def end_of_week
-          days_to_sunday = self.wday!=0 ? 7-self.wday : 0
-          (self + days_to_sunday.days).end_of_day
-        end
-        alias :at_end_of_week :end_of_week
-
-        # Returns a new Time representing the start of the given day in next week (default is Monday).
-        def next_week(day = :monday)
-          days_into_week = { :monday => 0, :tuesday => 1, :wednesday => 2, :thursday => 3, :friday => 4, :saturday => 5, :sunday => 6}
-          since(1.week).beginning_of_week.since(days_into_week[day].day).change(:hour => 0)
-        end
-
-        # Returns a new Time representing the start of the day (0:00)
-        def beginning_of_day
-          (self - self.seconds_since_midnight).change(:usec => 0)
-        end
-        alias :midnight :beginning_of_day
-        alias :at_midnight :beginning_of_day
-        alias :at_beginning_of_day :beginning_of_day
-
-        # Returns a new Time representing the end of the day (23:59:59)
-        def end_of_day
-          change(:hour => 23, :min => 59, :sec => 59)
-        end
-
-        # Returns a new Time representing the start of the month (1st of the month, 0:00)
-        def beginning_of_month
-          #self - ((self.mday-1).days + self.seconds_since_midnight)
-          change(:day => 1,:hour => 0, :min => 0, :sec => 0, :usec => 0)
-        end
-        alias :at_beginning_of_month :beginning_of_month
-
-        # Returns a new Time representing the end of the month (last day of the month, 0:00)
-        def end_of_month
-          #self - ((self.mday-1).days + self.seconds_since_midnight)
-          last_day = ::Time.days_in_month( self.month, self.year )
-          change(:day => last_day, :hour => 23, :min => 59, :sec => 59, :usec => 0)
-        end
-        alias :at_end_of_month :end_of_month
-
-        # Returns  a new Time representing the start of the quarter (1st of january, april, july, october, 0:00)
-        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
-
-        # Returns a new Time representing the end of the quarter (last day of march, june, september, december, 23:59:59)
-        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
-
-        # Returns  a new Time representing the start of the year (1st of january, 0:00)
-        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
-
-        # Returns a new Time representing the end of the year (31st of december, 23:59:59)
-        def end_of_year
-          change(:month => 12,:day => 31,:hour => 23, :min => 59, :sec => 59)
-        end
-        alias :at_end_of_year :end_of_year
-
-        # Convenience method which returns a new Time representing the time 1 day ago
-        def yesterday
-          advance(:days => -1)
-        end
-
-        # Convenience method which returns a new Time representing the time 1 day since the instance time
-        def tomorrow
-          advance(:days => 1)
-        end
-
-        def plus_with_duration(other) #:nodoc:
-          if ActiveSupport::Duration === other
-            other.since(self)
-          else
-            plus_without_duration(other)
-          end
-        end
-
-        def minus_with_duration(other) #:nodoc:
-          if ActiveSupport::Duration === other
-            other.until(self)
-          else
-            minus_without_duration(other)
-          end
-        end
-
-        # Time#- can also be used to determine the number of seconds between two Time instances.
-        # We're layering on additional behavior so that ActiveSupport::TimeWithZone instances
-        # are coerced into values that Time#- will recognize
-        def minus_with_coercion(other)
-          other = other.comparable_time if other.respond_to?(:comparable_time)
-          minus_without_coercion(other)
-        end
-
-        # Layers additional behavior on Time#<=> so that DateTime and ActiveSupport::TimeWithZone instances
-        # can be chronologically compared with a Time
-        def compare_with_coercion(other)
-          # if other is an ActiveSupport::TimeWithZone, coerce a Time instance from it so we can do <=> comparison
-          other = other.comparable_time if other.respond_to?(:comparable_time)
-          if other.acts_like?(:date)
-            # other is a Date/DateTime, so coerce self #to_datetime and hand off to DateTime#<=>
-            to_datetime.compare_without_coercion(other)
-          else
-            compare_without_coercion(other)
-          end
-        end
-      end
+class Time
+  COMMON_YEAR_DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+  DAYS_INTO_WEEK = { :monday => 0, :tuesday => 1, :wednesday => 2, :thursday => 3, :friday => 4, :saturday => 5, :sunday => 6 }
+
+  class << self
+    # Overriding case equality method so that it returns true for ActiveSupport::TimeWithZone instances
+    def ===(other)
+      other.is_a?(::Time)
+    end
+
+    # Return the number of days in the given month.
+    # If no year is specified, it will use the current year.
+    def days_in_month(month, year = now.year)
+      return 29 if month == 2 && ::Date.gregorian_leap?(year)
+      COMMON_YEAR_DAYS_IN_MONTH[month]
+    end
+
+    # Returns a new Time if requested year can be accommodated by Ruby's Time class
+    # (i.e., if year is within either 1970..2038 or 1902..2038, depending on system architecture);
+    # otherwise returns a DateTime
+    def time_with_datetime_fallback(utc_or_local, year, month=1, day=1, hour=0, min=0, sec=0, usec=0)
+      ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)
+    rescue
+      offset = utc_or_local.to_sym == :local ? ::DateTime.local_offset : 0
+      ::DateTime.civil(year, month, day, hour, min, sec, offset)
+    end
+
+    # Wraps class method +time_with_datetime_fallback+ with +utc_or_local+ set to <tt>:utc</tt>.
+    def utc_time(*args)
+      time_with_datetime_fallback(:utc, *args)
+    end
+
+    # Wraps class method +time_with_datetime_fallback+ with +utc_or_local+ set to <tt>:local</tt>.
+    def local_time(*args)
+      time_with_datetime_fallback(:local, *args)
+    end
+  end
+
+  # Tells whether the Time object's time lies in the past
+  def past?
+    self < ::Time.current
+  end
+
+  # Tells whether the Time object's time is today
+  def today?
+    to_date == ::Date.current
+  end
+
+  # Tells whether the Time object's time lies in the future
+  def future?
+    self > ::Time.current
+  end
+
+  # Seconds since midnight: Time.now.seconds_since_midnight
+  def seconds_since_midnight
+    to_i - change(:hour => 0).to_i + (usec / 1.0e+6)
+  end
+
+  # Returns a new Time where one or more of the elements have been changed according to the +options+ parameter. The time options
+  # (hour, minute, sec, usec) reset cascadingly, so if only the hour is passed, then minute, sec, and usec is set to 0. If the hour and
+  # minute is passed, then sec and usec is set to 0.
+  def change(options)
+    ::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
+
+  # Uses Date to provide precise Time calculations for years, months, and days.
+  # The +options+ parameter takes a hash with any of these keys: <tt>:years</tt>,
+  # <tt>:months</tt>, <tt>:weeks</tt>, <tt>:days</tt>, <tt>:hours</tt>,
+  # <tt>:minutes</tt>, <tt>:seconds</tt>.
+  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
+
+  # Returns a new Time representing the time a number of seconds ago, this is basically a wrapper around the Numeric extension
+  def ago(seconds)
+    since(-seconds)
+  end
+
+  # Returns a new Time representing the time a number of seconds since the instance time, this is basically a wrapper around
+  # the Numeric extension.
+  def since(seconds)
+    f = seconds.since(self)
+    if ActiveSupport::Duration === seconds
+      f
+    else
+      initial_dst = dst? ? 1 : 0
+      final_dst   = f.dst? ? 1 : 0
+      (seconds.abs >= 86400 && initial_dst != final_dst) ? f + (initial_dst - final_dst).hours : f
+    end
+  rescue
+    self.to_datetime.since(seconds)
+  end
+  alias :in :since
+
+  # Returns a new Time representing the time a number of specified months ago
+  def months_ago(months)
+    advance(:months => -months)
+  end
+
+  # Returns a new Time representing the time a number of specified months in the future
+  def months_since(months)
+    advance(:months => months)
+  end
+
+  # Returns a new Time representing the time a number of specified years ago
+  def years_ago(years)
+    advance(:years => -years)
+  end
+
+  # Returns a new Time representing the time a number of specified years in the future
+  def years_since(years)
+    advance(:years => years)
+  end
+
+  # Short-hand for years_ago(1)
+  def last_year
+    years_ago(1)
+  end
+
+  # Short-hand for years_since(1)
+  def next_year
+    years_since(1)
+  end
+
+
+  # Short-hand for months_ago(1)
+  def last_month
+    months_ago(1)
+  end
+
+  # Short-hand for months_since(1)
+  def next_month
+    months_since(1)
+  end
+
+  # Returns a new Time representing the "start" of this week (Monday, 0:00)
+  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
+
+  # Returns a new Time representing the end of this week (Sunday, 23:59:59)
+  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
+
+  # Returns a new Time representing the start of the given day in next week (default is Monday).
+  def next_week(day = :monday)
+    since(1.week).beginning_of_week.since(DAYS_INTO_WEEK[day].day).change(:hour => 0)
+  end
+
+  # Returns a new Time representing the start of the day (0:00)
+  def beginning_of_day
+    (self - seconds_since_midnight).change(:usec => 0)
+  end
+  alias :midnight :beginning_of_day
+  alias :at_midnight :beginning_of_day
+  alias :at_beginning_of_day :beginning_of_day
+
+  # Returns a new Time representing the end of the day (23:59:59)
+  def end_of_day
+    change(:hour => 23, :min => 59, :sec => 59)
+  end
+
+  # Returns a new Time representing the start of the month (1st of the month, 0:00)
+  def beginning_of_month
+    #self - ((self.mday-1).days + self.seconds_since_midnight)
+    change(:day => 1,:hour => 0, :min => 0, :sec => 0, :usec => 0)
+  end
+  alias :at_beginning_of_month :beginning_of_month
+
+  # Returns a new Time representing the end of the month (last day of the month, 0:00)
+  def end_of_month
+    #self - ((self.mday-1).days + self.seconds_since_midnight)
+    last_day = ::Time.days_in_month(month, year)
+    change(:day => last_day, :hour => 23, :min => 59, :sec => 59, :usec => 0)
+  end
+  alias :at_end_of_month :end_of_month
+
+  # Returns  a new Time representing the start of the quarter (1st of january, april, july, october, 0:00)
+  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
+
+  # Returns a new Time representing the end of the quarter (last day of march, june, september, december, 23:59:59)
+  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
+
+  # Returns  a new Time representing the start of the year (1st of january, 0:00)
+  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
+
+  # Returns a new Time representing the end of the year (31st of december, 23:59:59)
+  def end_of_year
+    change(:month => 12, :day => 31, :hour => 23, :min => 59, :sec => 59)
+  end
+  alias :at_end_of_year :end_of_year
+
+  # Convenience method which returns a new Time representing the time 1 day ago
+  def yesterday
+    advance(:days => -1)
+  end
+
+  # Convenience method which returns a new Time representing the time 1 day since the instance time
+  def tomorrow
+    advance(:days => 1)
+  end
+
+  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
+      other.until(self)
+    else
+      minus_without_duration(other)
+    end
+  end
+  alias_method :minus_without_duration, :-
+  alias_method :-, :minus_with_duration
+
+  # Time#- can also be used to determine the number of seconds between two Time instances.
+  # We're layering on additional behavior so that ActiveSupport::TimeWithZone instances
+  # are coerced into values that Time#- will recognize
+  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
+
+  # Layers additional behavior on Time#<=> so that DateTime and ActiveSupport::TimeWithZone instances
+  # can be chronologically compared with a Time
+  def compare_with_coercion(other)
+    # if other is an ActiveSupport::TimeWithZone, coerce a Time instance from it so we can do <=> comparison
+    other = other.comparable_time if other.respond_to?(:comparable_time)
+    if other.acts_like?(:date)
+      # other is a Date/DateTime, so coerce self #to_datetime and hand off to DateTime#<=>
+      to_datetime.compare_without_coercion(other)
+    else
+      compare_without_coercion(other)
     end
   end
+  alias_method :compare_without_coercion, :<=>
+  alias_method :<=>, :compare_with_coercion
 end
diff --git a/activesupport/lib/active_support/core_ext/time/zones.rb b/activesupport/lib/active_support/core_ext/time/zones.rb
index 9d8eb73908..b7e43395d1 100644
--- a/activesupport/lib/active_support/core_ext/time/zones.rb
+++ b/activesupport/lib/active_support/core_ext/time/zones.rb
@@ -1,86 +1,76 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Time #:nodoc:
-      module Zones
-        def self.included(base) #:nodoc:
-          base.extend(ClassMethods) if base == ::Time # i.e., don't include class methods in DateTime
-        end
-        
-        module ClassMethods
-          attr_accessor :zone_default
-          
-          # Returns the TimeZone for the current request, if this has been set (via Time.zone=). 
-          # If <tt>Time.zone</tt> has not been set for the current request, returns the TimeZone specified in <tt>config.time_zone</tt>.
-          def zone
-            Thread.current[:time_zone] || zone_default
-          end
+class Time
+  class << self
+    attr_accessor :zone_default
+
+    # Returns the TimeZone for the current request, if this has been set (via Time.zone=). 
+    # If <tt>Time.zone</tt> has not been set for the current request, returns the TimeZone specified in <tt>config.time_zone</tt>.
+    def zone
+      Thread.current[:time_zone] || zone_default
+    end
+
+    # Sets <tt>Time.zone</tt> to a TimeZone object for the current request/thread. 
+    #
+    # This method accepts any of the following:
+    #
+    # * A Rails TimeZone object.
+    # * An identifier for a Rails TimeZone object (e.g., "Eastern Time (US & Canada)", <tt>-5.hours</tt>).
+    # * A TZInfo::Timezone object.
+    # * An identifier for a TZInfo::Timezone object (e.g., "America/New_York").
+    #
+    # Here's an example of how you might set <tt>Time.zone</tt> on a per request basis -- <tt>current_user.time_zone</tt>
+    # just needs to return a string identifying the user's preferred TimeZone:
+    #
+    #   class ApplicationController < ActionController::Base
+    #     before_filter :set_time_zone
+    #
+    #     def set_time_zone
+    #       Time.zone = current_user.time_zone
+    #     end
+    #   end
+    def zone=(time_zone)
+      Thread.current[:time_zone] = get_zone(time_zone)
+    end
+
+    # Allows override of <tt>Time.zone</tt> locally inside supplied block; resets <tt>Time.zone</tt> to existing value when done.
+    def use_zone(time_zone)
+      old_zone, ::Time.zone = ::Time.zone, get_zone(time_zone)
+      yield
+    ensure
+      ::Time.zone = old_zone
+    end
+
+    # Returns <tt>Time.zone.now</tt> when <tt>config.time_zone</tt> is set, otherwise just returns <tt>Time.now</tt>.
+    def current
+      ::Time.zone_default ? ::Time.zone.now : ::Time.now
+    end
 
-          # Sets <tt>Time.zone</tt> to a TimeZone object for the current request/thread. 
-          #
-          # This method accepts any of the following:
-          #
-          # * A Rails TimeZone object.
-          # * An identifier for a Rails TimeZone object (e.g., "Eastern Time (US & Canada)", <tt>-5.hours</tt>).
-          # * A TZInfo::Timezone object.
-          # * An identifier for a TZInfo::Timezone object (e.g., "America/New_York").
-          #
-          # Here's an example of how you might set <tt>Time.zone</tt> on a per request basis -- <tt>current_user.time_zone</tt>
-          # just needs to return a string identifying the user's preferred TimeZone:
-          #
-          #   class ApplicationController < ActionController::Base
-          #     before_filter :set_time_zone
-          #
-          #     def set_time_zone
-          #       Time.zone = current_user.time_zone
-          #     end
-          #   end
-          def zone=(time_zone)
-            Thread.current[:time_zone] = get_zone(time_zone)
-          end
-          
-          # Allows override of <tt>Time.zone</tt> locally inside supplied block; resets <tt>Time.zone</tt> to existing value when done.
-          def use_zone(time_zone)
-            old_zone, ::Time.zone = ::Time.zone, get_zone(time_zone)
-            yield
-          ensure
-            ::Time.zone = old_zone
-          end
-          
-          # Returns <tt>Time.zone.now</tt> when <tt>config.time_zone</tt> is set, otherwise just returns <tt>Time.now</tt>.
-          def current
-            ::Time.zone_default ? ::Time.zone.now : ::Time.now
-          end
-          
-          private
-            def get_zone(time_zone)
-              return time_zone if time_zone.nil? || time_zone.is_a?(TimeZone)
-              # lookup timezone based on identifier (unless we've been passed a TZInfo::Timezone)
-              unless time_zone.respond_to?(:period_for_local)
-                time_zone = TimeZone[time_zone] || TZInfo::Timezone.get(time_zone) rescue nil
-              end
-              # Return if a TimeZone instance, or wrap in a TimeZone instance if a TZInfo::Timezone
-              if time_zone
-                time_zone.is_a?(TimeZone) ? time_zone : TimeZone.create(time_zone.name, nil, time_zone)
-              end
-            end
+    private
+      def get_zone(time_zone)
+        return time_zone if time_zone.nil? || time_zone.is_a?(ActiveSupport::TimeZone)
+        # lookup timezone based on identifier (unless we've been passed a TZInfo::Timezone)
+        unless time_zone.respond_to?(:period_for_local)
+          time_zone = ActiveSupport::TimeZone[time_zone] || TZInfo::Timezone.get(time_zone) rescue nil
         end
-        
-        # Returns the simultaneous time in <tt>Time.zone</tt>.
-        #
-        #   Time.zone = 'Hawaii'         # => 'Hawaii'
-        #   Time.utc(2000).in_time_zone  # => Fri, 31 Dec 1999 14:00:00 HST -10:00
-        #
-        # This method is similar to Time#localtime, except that it uses <tt>Time.zone</tt> as the local zone
-        # instead of the operating system's time zone.
-        #
-        # 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>.
-        #
-        #   Time.utc(2000).in_time_zone('Alaska')  # => Fri, 31 Dec 1999 15:00:00 AKST -09:00
-        def in_time_zone(zone = ::Time.zone)
-          ActiveSupport::TimeWithZone.new(utc? ? self : getutc, ::Time.__send__(:get_zone, zone))
+        # Return if a TimeZone instance, or wrap in a TimeZone instance if a TZInfo::Timezone
+        if time_zone
+          time_zone.is_a?(ActiveSupport::TimeZone) ? time_zone : ActiveSupport::TimeZone.create(time_zone.name, nil, time_zone)
         end
       end
-    end
   end
-end
\ No newline at end of file
+
+  # Returns the simultaneous time in <tt>Time.zone</tt>.
+  #
+  #   Time.zone = 'Hawaii'         # => 'Hawaii'
+  #   Time.utc(2000).in_time_zone  # => Fri, 31 Dec 1999 14:00:00 HST -10:00
+  #
+  # This method is similar to Time#localtime, except that it uses <tt>Time.zone</tt> as the local zone
+  # instead of the operating system's time zone.
+  #
+  # 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>.
+  #
+  #   Time.utc(2000).in_time_zone('Alaska')  # => Fri, 31 Dec 1999 15:00:00 AKST -09:00
+  def in_time_zone(zone = ::Time.zone)
+    ActiveSupport::TimeWithZone.new(utc? ? self : getutc, ::Time.__send__(:get_zone, zone))
+  end
+end