activesupport 2.3.18 → 3.0.0.beta

data/lib/active_support/core_ext/class/attribute_accessors.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/array/extract_options'
+
 # Extends the class object with class and instance accessors for class attributes,
 # just like the native attr* accessors for instance attributes.
 #
@@ -8,54 +10,48 @@
 #  Person.hair_colors = [:brown, :black, :blonde, :red]
 class Class
   def cattr_reader(*syms)
-    options = syms.extract_options!
-    syms.each do |sym|
+    syms.flatten.each do |sym|
       next if sym.is_a?(Hash)
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}
-          @@#{sym}
-        end
+        unless defined? @@#{sym}  # unless defined? @@hair_colors
+          @@#{sym} = nil          #   @@hair_colors = nil
+        end                       # end
+                                  #
+        def self.#{sym}           # def self.hair_colors
+          @@#{sym}                #   @@hair_colors
+        end                       # end
+                                  #
+        def #{sym}                # def hair_colors
+          @@#{sym}                #   @@hair_colors
+        end                       # end
       EOS
-
-      unless options[:instance_reader] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}
-            @@#{sym}
-          end
-        EOS
-      end
     end
   end
 
   def cattr_writer(*syms)
     options = syms.extract_options!
-    syms.each do |sym|
+    syms.flatten.each do |sym|
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-        unless defined? @@#{sym}
-          @@#{sym} = nil
-        end
-
-        def self.#{sym}=(obj)
-          @@#{sym} = obj
-        end
+        unless defined? @@#{sym}                       # unless defined? @@hair_colors
+          @@#{sym} = nil                               #   @@hair_colors = nil
+        end                                            # end
+                                                       #
+        def self.#{sym}=(obj)                          # def self.hair_colors=(obj)
+          @@#{sym} = obj                               #   @@hair_colors = obj
+        end                                            # end
+                                                       #
+        #{"                                            #
+        def #{sym}=(obj)                               # def hair_colors=(obj)
+          @@#{sym} = obj                               #   @@hair_colors = obj
+        end                                            # end
+        " unless options[:instance_writer] == false }  # # instance writer above is generated unless options[:instance_writer] == false
       EOS
-
-      unless options[:instance_writer] == false
-        class_eval(<<-EOS, __FILE__, __LINE__ + 1)
-          def #{sym}=(obj)
-            @@#{sym} = obj
-          end
-        EOS
-      end
+      self.send("#{sym}=", yield) if block_given?
     end
   end
 
-  def cattr_accessor(*syms)
+  def cattr_accessor(*syms, &blk)
     cattr_reader(*syms)
-    cattr_writer(*syms)
+    cattr_writer(*syms, &blk)
   end
 end

data/lib/active_support/core_ext/class/delegating_attributes.rb

@@ -1,47 +1,41 @@
-# These class attributes behave something like the class
-# inheritable accessors.  But instead of copying the hash over at
-# the time the subclass is first defined,  the accessors simply
-# delegate to their superclass unless they have been given a 
-# specific value.  This stops the strange situation where values 
-# set after class definition don't get applied to subclasses.
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/array/extract_options'
+require 'active_support/core_ext/object/metaclass'
+
 class Class
-  def superclass_delegating_reader(*names)
-    class_name_to_stop_searching_on = self.superclass.name.blank? ? "Object" : self.superclass.name
-    names.each do |name|
-      class_eval <<-EOS
-      def self.#{name}                                            # def self.only_reader
-        if defined?(@#{name})                                     #   if defined?(@only_reader)
-          @#{name}                                                #     @only_reader
-        elsif superclass < #{class_name_to_stop_searching_on} &&  #   elsif superclass < Object &&
-              superclass.respond_to?(:#{name})                    #         superclass.respond_to?(:only_reader)
-          superclass.#{name}                                      #     superclass.only_reader
-        end                                                       #   end
-      end                                                         # end
-      def #{name}                                                 # def only_reader
-        self.class.#{name}                                        #   self.class.only_reader
-      end                                                         # end
-      def self.#{name}?                                           # def self.only_reader?
-        !!#{name}                                                 #   !!only_reader
-      end                                                         # end
-      def #{name}?                                                # def only_reader?
-        !!#{name}                                                 #   !!only_reader
-      end                                                         # end
-      EOS
-    end
+  def superclass_delegating_accessor(name, options = {})
+    # Create private _name and _name= methods that can still be used if the public
+    # methods are overridden. This allows
+    _superclass_delegating_accessor("_#{name}")
+
+    # Generate the public methods name, name=, and name?
+    # These methods dispatch to the private _name, and _name= methods, making them
+    # overridable
+    metaclass.send(:define_method, name) { send("_#{name}") }
+    metaclass.send(:define_method, "#{name}?") { !!send("_#{name}") }
+    metaclass.send(:define_method, "#{name}=") { |value| send("_#{name}=", value) }
+
+    # If an instance_reader is needed, generate methods for name and name= on the
+    # class itself, so instances will be able to see them
+    define_method(name) { send("_#{name}") } if options[:instance_reader] != false
+    define_method("#{name}?") { !!send("#{name}") } if options[:instance_reader] != false
   end
 
-  def superclass_delegating_writer(*names)
-    names.each do |name|
-      class_eval <<-EOS
-        def self.#{name}=(value)  # def self.only_writer=(value)
-          @#{name} = value        #   @only_writer = value
-        end                       # end
-      EOS
-    end
+private
+
+  # Take the object being set and store it in a method. This gives us automatic
+  # inheritance behavior, without having to store the object in an instance
+  # variable and look up the superclass chain manually.
+  def _stash_object_in_method(object, method, instance_reader = true)
+    metaclass.send(:define_method, method) { object }
+    define_method(method) { object } if instance_reader
   end
 
-  def superclass_delegating_accessor(*names)
-    superclass_delegating_reader(*names)
-    superclass_delegating_writer(*names)
+  def _superclass_delegating_accessor(name, options = {})
+    metaclass.send(:define_method, "#{name}=") do |value|
+      _stash_object_in_method(value, name, options[:instance_reader] != false)
+    end
+    self.send("#{name}=", nil)
   end
+
 end

data/lib/active_support/core_ext/class/inheritable_attributes.rb

@@ -1,3 +1,6 @@
+require 'active_support/core_ext/object/duplicable'
+require 'active_support/core_ext/array/extract_options'
+
 # Retain for backward compatibility.  Methods are now included in Class.
 module ClassInheritableAttributes # :nodoc:
 end
@@ -8,16 +11,19 @@ end
 # children, which is unlike the regular class-level attributes that are shared across the entire hierarchy.
 class Class # :nodoc:
   def class_inheritable_reader(*syms)
+    options = syms.extract_options!
     syms.each do |sym|
       next if sym.is_a?(Hash)
-      class_eval <<-EOS
-        def self.#{sym}                        # def self.before_add_for_comments
-          read_inheritable_attribute(:#{sym})  #   read_inheritable_attribute(:before_add_for_comments)
-        end                                    # end
-                                               #
-        def #{sym}                             # def before_add_for_comments
-          self.class.#{sym}                    #   self.class.before_add_for_comments
-        end                                    # end
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        def self.#{sym}                                # def self.after_add
+          read_inheritable_attribute(:#{sym})          #   read_inheritable_attribute(:after_add)
+        end                                            # end
+                                                       #
+        #{"                                            #
+        def #{sym}                                     # def after_add
+          self.class.#{sym}                            #   self.class.after_add
+        end                                            # end
+        " unless options[:instance_reader] == false }  # # the reader above is generated unless options[:instance_reader] == false
       EOS
     end
   end
@@ -25,7 +31,7 @@ class Class # :nodoc:
   def class_inheritable_writer(*syms)
     options = syms.extract_options!
     syms.each do |sym|
-      class_eval <<-EOS
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         def self.#{sym}=(obj)                          # def self.color=(obj)
           write_inheritable_attribute(:#{sym}, obj)    #   write_inheritable_attribute(:color, obj)
         end                                            # end
@@ -42,7 +48,7 @@ class Class # :nodoc:
   def class_inheritable_array_writer(*syms)
     options = syms.extract_options!
     syms.each do |sym|
-      class_eval <<-EOS
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         def self.#{sym}=(obj)                          # def self.levels=(obj)
           write_inheritable_array(:#{sym}, obj)        #   write_inheritable_array(:levels, obj)
         end                                            # end
@@ -59,7 +65,7 @@ class Class # :nodoc:
   def class_inheritable_hash_writer(*syms)
     options = syms.extract_options!
     syms.each do |sym|
-      class_eval <<-EOS
+      class_eval(<<-EOS, __FILE__, __LINE__ + 1)
         def self.#{sym}=(obj)                          # def self.nicknames=(obj)
           write_inheritable_hash(:#{sym}, obj)         #   write_inheritable_hash(:nicknames, obj)
         end                                            # end
@@ -109,11 +115,6 @@ class Class # :nodoc:
     write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
   end
 
-  def write_inheritable_hiwa(key, hash)
-    write_inheritable_attribute(key, {}.with_indifferent_access) if read_inheritable_attribute(key).nil?
-    write_inheritable_attribute(key, read_inheritable_attribute(key).merge(hash))
-  end
-
   def read_inheritable_attribute(key)
     inheritable_attributes[key]
   end
@@ -143,3 +144,86 @@ class Class # :nodoc:
     alias inherited_without_inheritable_attributes inherited
     alias inherited inherited_with_inheritable_attributes
 end
+
+class Class
+  # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for.
+  # @return <Array[#to_s]> Array of attributes converted into inheritable_readers.
+  #
+  # @api public
+  #
+  # @todo Do we want to block instance_reader via :instance_reader => false
+  # @todo It would be preferable that we do something with a Hash passed in
+  #   (error out or do the same as other methods above) instead of silently
+  #   moving on). In particular, this makes the return value of this function
+  #   less useful.
+  def extlib_inheritable_reader(*ivars, &block)
+    options = ivars.extract_options!
+
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}
+          return @#{ivar} if self.object_id == #{self.object_id} || defined?(@#{ivar})
+          ivar = superclass.#{ivar}
+          return nil if ivar.nil? && !#{self}.instance_variable_defined?("@#{ivar}")
+          @#{ivar} = ivar.duplicable? ? ivar.dup : ivar
+        end
+      RUBY
+      unless options[:instance_reader] == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}
+            self.class.#{ivar}
+          end
+        RUBY
+      end
+      instance_variable_set(:"@#{ivar}", yield) if block_given?
+    end
+  end
+
+  # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of the attributes that were made into inheritable writers.
+  #
+  # @api public
+  #
+  # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it
+  #   class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere.
+  def extlib_inheritable_writer(*ivars)
+    options = ivars.extract_options!
+
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}=(obj)
+          @#{ivar} = obj
+        end
+      RUBY
+      unless options[:instance_writer] == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}=(obj) self.class.#{ivar} = obj end
+        RUBY
+      end
+
+      self.send("#{ivar}=", yield) if block_given?
+    end
+  end
+
+  # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of attributes turned into inheritable accessors.
+  #
+  # @api public
+  def extlib_inheritable_accessor(*syms, &block)
+    extlib_inheritable_reader(*syms)
+    extlib_inheritable_writer(*syms, &block)
+  end
+end

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

@@ -0,0 +1,8 @@
+require 'active_support/core_ext/object/acts_like'
+
+class Date
+  # Duck-types as a Date-like class. See Object#acts_like?.
+  def acts_like_date?
+    true
+  end
+end

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

@@ -1,241 +1,221 @@
-module ActiveSupport #:nodoc:
-  module CoreExtensions #:nodoc:
-    module Date #:nodoc:
-      # Enables the use of time calculations within Date itself
-      module Calculations
-        def self.included(base) #:nodoc:
-          base.extend ClassMethods
-
-          base.instance_eval do
-            alias_method :plus_without_duration, :+
-            alias_method :+, :plus_with_duration
-
-            alias_method :minus_without_duration, :-
-            alias_method :-, :minus_with_duration
-          end
-        end
-
-        module ClassMethods
-          # Returns a new Date representing the date 1 day ago (i.e. yesterday's date).
-          def yesterday
-            ::Date.today.yesterday
-          end
-
-          # Returns a new Date representing the date 1 day after today (i.e. tomorrow's date).
-          def tomorrow
-            ::Date.today.tomorrow
-          end
-
-          # Returns Time.zone.today when config.time_zone is set, otherwise just returns Date.today.
-          def current
-            ::Time.zone_default ? ::Time.zone.today : ::Date.today
-          end
-        end
-
-        # Tells whether the Date object's date lies in the past
-        def past?
-          self < ::Date.current
-        end
-
-        # Tells whether the Date object's date is today
-        def today?
-          self.to_date == ::Date.current # we need the to_date because of DateTime
-        end
-
-        # Tells whether the Date object's date lies in the future
-        def future?
-          self > ::Date.current
-        end
-
-        # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
-        # and then subtracts the specified number of seconds
-        def ago(seconds)
-          to_time.since(-seconds)
-        end
-
-        # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
-        # and then adds the specified number of seconds
-        def since(seconds)
-          to_time.since(seconds)
-        end
-        alias :in :since
-
-        # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
-        def beginning_of_day
-          to_time
-        end
-        alias :midnight :beginning_of_day
-        alias :at_midnight :beginning_of_day
-        alias :at_beginning_of_day :beginning_of_day
-
-        # Converts Date to a Time (or DateTime if necessary) with the time portion set to the end of the day (23:59:59)
-        def end_of_day
-          to_time.end_of_day
-        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
-            plus_with_duration(-other)
-          else
-            minus_without_duration(other)
-          end
-        end
-
-        # Provides precise Date 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>.
-        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
-
-        # Returns a new Date where one or more of the elements have been changed according to the +options+ parameter.
-        #
-        # Examples:
-        #
-        #   Date.new(2007, 5, 12).change(:day => 1)                  # => Date.new(2007, 5, 1)
-        #   Date.new(2007, 5, 12).change(:year => 2005, :month => 1) # => Date.new(2005, 1, 12)
-        def change(options)
-          ::Date.new(
-            options[:year]  || self.year,
-            options[:month] || self.month,
-            options[:day]   || self.day
-          )
-        end
-
-        # Returns a new Date/DateTime representing the time a number of specified months ago
-        def months_ago(months)
-          advance(:months => -months)
-        end
-
-        # Returns a new Date/DateTime representing the time a number of specified months in the future
-        def months_since(months)
-          advance(:months => months)
-        end
-
-        # Returns a new Date/DateTime representing the time a number of specified years ago
-        def years_ago(years)
-          advance(:years => -years)
-        end
-
-        # Returns a new Date/DateTime representing the time a number of specified years in the future
-        def years_since(years)
-          advance(:years => years)
-        end
-
-        def last_year # :nodoc:
-          ActiveSupport::Deprecation.warn("Date#last_year is deprecated and has been removed in Rails 3, please use Date#prev_year instead", caller)
-          prev_year
-        end
-
-        # Short-hand for years_ago(1)
-        def prev_year
-          years_ago(1)
-        end unless method_defined?(:prev_year)
-
-        # Short-hand for years_since(1)
-        def next_year
-          years_since(1)
-        end
-
-        def last_month # :nodoc:
-          ActiveSupport::Deprecation.warn("Date#last_month is deprecated and has been removed in Rails 3, please use Date#prev_month instead", caller)
-          prev_month
-        end
-
-        # Short-hand for months_ago(1)
-        def prev_month
-          months_ago(1)
-        end unless method_defined?(:prev_month)
-
-        # Short-hand for months_since(1)
-        def next_month
-          months_since(1)
-        end
-
-        # Returns a new Date/DateTime representing the "start" of this week (i.e, Monday; DateTime objects will have time set to 0:00)
-        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
-
-        # Returns a new Date/DateTime representing the end of this week (Sunday, DateTime objects will have time set to 23:59:59)
-        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
-
-        # Returns a new Date/DateTime 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}
-          result = (self + 7).beginning_of_week + days_into_week[day]
-          self.acts_like?(:time) ? result.change(:hour => 0) : result
-        end
-
-        # Returns a new ; DateTime objects will have time set to 0:00DateTime representing the start of the month (1st of the month; DateTime objects will have time set to 0:00)
-        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
-
-        # Returns a new Date/DateTime representing the end of the month (last day of the month; DateTime objects will have time set to 0:00)
-        def end_of_month
-          last_day = ::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
-
-        # Returns a new Date/DateTime representing the start of the quarter (1st of january, april, july, october; DateTime objects will have time set to 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 Date/DateTime representing the end of the quarter (last day of march, june, september, december; DateTime objects will have time set to 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 Date/DateTime representing the start of the year (1st of january; DateTime objects will have time set to 0:00)
-        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
-
-        # Returns a new Time representing the end of the year (31st of december; DateTime objects will have time set to 23:59:59)
-        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
-
-        # Convenience method which returns a new Date/DateTime representing the time 1 day ago
-        def yesterday
-          self - 1
-        end
-
-        # Convenience method which returns a new Date/DateTime representing the time 1 day since the instance time
-        def tomorrow
-          self + 1
-        end
-      end
+require 'date'
+require 'active_support/duration'
+require 'active_support/core_ext/time/zones'
+require 'active_support/core_ext/object/acts_like'
+
+class Date
+  class << self
+    # Returns a new Date representing the date 1 day ago (i.e. yesterday's date).
+    def yesterday
+      ::Date.today.yesterday
     end
+
+    # Returns a new Date representing the date 1 day after today (i.e. tomorrow's date).
+    def tomorrow
+      ::Date.today.tomorrow
+    end
+
+    # Returns Time.zone.today when config.time_zone is set, otherwise just returns Date.today.
+    def current
+      ::Time.zone_default ? ::Time.zone.today : ::Date.today
+    end
+  end
+
+  # Tells whether the Date object's date lies in the past
+  def past?
+    self < ::Date.current
+  end
+
+  # Tells whether the Date object's date is today
+  def today?
+    self.to_date == ::Date.current # we need the to_date because of DateTime
+  end
+
+  # Tells whether the Date object's date lies in the future
+  def future?
+    self > ::Date.current
+  end
+
+  # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
+  # and then subtracts the specified number of seconds
+  def ago(seconds)
+    to_time.since(-seconds)
+  end
+
+  # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
+  # and then adds the specified number of seconds
+  def since(seconds)
+    to_time.since(seconds)
+  end
+  alias :in :since
+
+  # Converts Date to a Time (or DateTime if necessary) with the time portion set to the beginning of the day (0:00)
+  def beginning_of_day
+    to_time
+  end
+  alias :midnight :beginning_of_day
+  alias :at_midnight :beginning_of_day
+  alias :at_beginning_of_day :beginning_of_day
+
+  # Converts Date to a Time (or DateTime if necessary) with the time portion set to the end of the day (23:59:59)
+  def end_of_day
+    to_time.end_of_day
+  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
+      plus_with_duration(-other)
+    else
+      minus_without_duration(other)
+    end
+  end
+  alias_method :minus_without_duration, :-
+  alias_method :-, :minus_with_duration
+
+  # Provides precise Date 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>.
+  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
+
+  # Returns a new Date where one or more of the elements have been changed according to the +options+ parameter.
+  #
+  # Examples:
+  #
+  #   Date.new(2007, 5, 12).change(:day => 1)                  # => Date.new(2007, 5, 1)
+  #   Date.new(2007, 5, 12).change(:year => 2005, :month => 1) # => Date.new(2005, 1, 12)
+  def change(options)
+    ::Date.new(
+      options[:year]  || self.year,
+      options[:month] || self.month,
+      options[:day]   || self.day
+    )
+  end
+
+  # Returns a new Date/DateTime representing the time a number of specified months ago
+  def months_ago(months)
+    advance(:months => -months)
+  end
+
+  # Returns a new Date/DateTime representing the time a number of specified months in the future
+  def months_since(months)
+    advance(:months => months)
+  end
+
+  # Returns a new Date/DateTime representing the time a number of specified years ago
+  def years_ago(years)
+    advance(:years => -years)
+  end
+
+  # Returns a new Date/DateTime 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 unless method_defined?(:next_year)
+
+  # 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 unless method_defined?(:next_month)
+
+  # Returns a new Date/DateTime representing the "start" of this week (i.e, Monday; DateTime objects will have time set to 0:00)
+  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
+
+  # Returns a new Date/DateTime representing the end of this week (Sunday, DateTime objects will have time set to 23:59:59)
+  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
+
+  # Returns a new Date/DateTime 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}
+    result = (self + 7).beginning_of_week + days_into_week[day]
+    self.acts_like?(:time) ? result.change(:hour => 0) : result
+  end
+
+  # Returns a new ; DateTime objects will have time set to 0:00DateTime representing the start of the month (1st of the month; DateTime objects will have time set to 0:00)
+  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
+
+  # Returns a new Date/DateTime representing the end of the month (last day of the month; DateTime objects will have time set to 0:00)
+  def end_of_month
+    last_day = ::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
+
+  # Returns a new Date/DateTime representing the start of the quarter (1st of january, april, july, october; DateTime objects will have time set to 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 Date/DateTime representing the end of the quarter (last day of march, june, september, december; DateTime objects will have time set to 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 Date/DateTime representing the start of the year (1st of january; DateTime objects will have time set to 0:00)
+  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
+
+  # Returns a new Time representing the end of the year (31st of december; DateTime objects will have time set to 23:59:59)
+  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
+
+  # Convenience method which returns a new Date/DateTime representing the time 1 day ago
+  def yesterday
+    self - 1
+  end
+
+  # Convenience method which returns a new Date/DateTime representing the time 1 day since the instance time
+  def tomorrow
+    self + 1
   end
 end