activesupport 3.0.20 → 3.1.0

data/lib/active_support/concern.rb

@@ -1,39 +1,109 @@
-# A typical module looks like this
-#
-#   module M
-#     def self.included(base)
-#       base.send(:extend, ClassMethods)
-#       base.send(:include, InstanceMethods)
-#       scope :foo, :conditions => { :created_at => nil }
-#     end
-#
-#     module ClassMethods
-#       def cm; puts 'I am a class method'; end
-#     end
-#
-#     module InstanceMethods
-#       def im; puts 'I am an instance method'; end
-#     end
-#   end
-#
-# By using <tt>ActiveSupport::Concern</tt> the above module could instead be written as:
-#
-#   module M
-#     extend ActiveSupport::Concern
-#
-#     included do
-#       scope :foo, :conditions => { :created_at => nil }
-#     end
-#
-#     module ClassMethods
-#       def cm; puts 'I am a class method'; end
-#     end
-#
-#     module InstanceMethods
-#       def im; puts 'I am an instance method'; end
-#     end
-#   end
 module ActiveSupport
+  # A typical module looks like this:
+  #
+  #   module M
+  #     def self.included(base)
+  #       base.extend ClassMethods
+  #       base.send(:include, InstanceMethods)
+  #       scope :disabled, where(:disabled => true)
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #
+  #     module InstanceMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be written as:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module M
+  #     extend ActiveSupport::Concern
+  #
+  #     included do
+  #       scope :disabled, where(:disabled => true)
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #
+  #     module InstanceMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module and a +Bar+
+  # module which depends on the former, we would typically write the following:
+  #
+  #   module Foo
+  #     def self.included(base)
+  #       base.class_eval do
+  #         def self.method_injected_by_foo
+  #           ...
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Foo # We need to include this dependency for Bar
+  #     include Bar # Bar is the module that Host really needs
+  #   end
+  #
+  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We could try to hide
+  # these from +Host+ directly including +Foo+ in +Bar+:
+  #
+  #   module Bar
+  #     include Foo 
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar
+  #   end
+  #
+  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt> is the +Bar+ module,
+  # not the +Host+ class. With <tt>ActiveSupport::Concern</tt>, module dependencies are properly resolved:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module Foo
+  #     extend ActiveSupport::Concern
+  #     included do
+  #       class_eval do
+  #         def self.method_injected_by_foo
+  #           ...
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     extend ActiveSupport::Concern
+  #     include Foo
+  #
+  #     included do
+  #       self.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar # works, Bar takes care now of its dependencies
+  #   end
+  #
   module Concern
     def self.extended(base)
       base.instance_variable_set("@_dependencies", [])

data/lib/active_support/configurable.rb

@@ -2,14 +2,37 @@ require 'active_support/concern'
 require 'active_support/ordered_options'
 require 'active_support/core_ext/kernel/singleton_class'
 require 'active_support/core_ext/module/delegation'
+require 'active_support/core_ext/array/extract_options'
 
 module ActiveSupport
+  # Configurable provides a <tt>config</tt> method to store and retrieve
+  # configuration options as an <tt>OrderedHash</tt>.
   module Configurable
     extend ActiveSupport::Concern
 
+    class Configuration < ActiveSupport::InheritableOptions
+      def compile_methods!
+        self.class.compile_methods!(keys)
+      end
+
+      # compiles reader methods so we don't have to go through method_missing
+      def self.compile_methods!(keys)
+        keys.reject { |m| method_defined?(m) }.each do |key|
+          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{key}; _get(#{key.inspect}); end
+          RUBY
+        end
+      end
+    end
+
     module ClassMethods
       def config
-        @_config ||= ActiveSupport::InheritableOptions.new(superclass.respond_to?(:config) ? superclass.config : {})
+        @_config ||= if respond_to?(:superclass) && superclass.respond_to?(:config)
+          superclass.config.inheritable_copy
+        else
+          # create a new "anonymous" class that will host the compiled reader methods
+          Class.new(Configuration).new
+        end
       end
 
       def configure
@@ -29,20 +52,39 @@ module ActiveSupport
       #   user.allowed_access # => true
       #
       def config_accessor(*names)
+        options = names.extract_options!
+
         names.each do |name|
-          code, line = <<-RUBY, __LINE__ + 1
-            def #{name}; config.#{name}; end
-            def #{name}=(value); config.#{name} = value; end
-          RUBY
+          reader, line = "def #{name}; config.#{name}; end", __LINE__
+          writer, line = "def #{name}=(value); config.#{name} = value; end", __LINE__
 
-          singleton_class.class_eval code, __FILE__, line
-          class_eval code, __FILE__, line
+          singleton_class.class_eval reader, __FILE__, line
+          singleton_class.class_eval writer, __FILE__, line
+          class_eval reader, __FILE__, line unless options[:instance_reader] == false
+          class_eval writer, __FILE__, line unless options[:instance_writer] == false
         end
       end
     end
 
+    # Reads and writes attributes from a configuration <tt>OrderedHash</tt>.
+    #
+    #   require 'active_support/configurable'
+    #
+    #   class User
+    #     include ActiveSupport::Configurable
+    #   end
+    #
+    #   user = User.new
+    #
+    #   user.config.allowed_access = true
+    #   user.config.level = 1
+    #
+    #   user.config.allowed_access # => true
+    #   user.config.level          # => 1
+    #
     def config
-      @_config ||= ActiveSupport::InheritableOptions.new(self.class.config)
+      @_config ||= self.class.config.inheritable_copy
     end
   end
 end
+

data/lib/active_support/core_ext/array/access.rb

@@ -3,10 +3,10 @@ class Array
   #
   #   %w( a b c d ).from(0)  # => %w( a b c d )
   #   %w( a b c d ).from(2)  # => %w( c d )
-  #   %w( a b c d ).from(10) # => nil
+  #   %w( a b c d ).from(10) # => %w()
   #   %w().from(0)           # => %w()
   def from(position)
-    self[position..-1]
+    self[position, length] || []
   end
 
   # Returns the beginning of the array up to +position+.

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

@@ -37,12 +37,12 @@ class Array
   # Converts a collection of elements into a formatted string by calling
   # <tt>to_s</tt> on all elements and joining them:
   #
-  #   Blog.find(:all).to_formatted_s # => "First PostSecond PostThird Post"
+  #   Blog.all.to_formatted_s # => "First PostSecond PostThird Post"
   #
   # Adding in the <tt>:db</tt> argument as the format yields a prettier
   # output:
   #
-  #   Blog.find(:all).to_formatted_s(:db) # => "First Post,Second Post,Third Post"
+  #   Blog.all.to_formatted_s(:db) # => "First Post,Second Post,Third Post"
   def to_formatted_s(format = :default)
     case format
       when :db

data/lib/active_support/core_ext/array/random_access.rb

@@ -1,12 +1,15 @@
 class Array
-  # Backport of Array#sample based on Marc-Andre Lafortune's http://github.com/marcandre/backports/
+  # Backport of Array#sample based on Marc-Andre Lafortune's https://github.com/marcandre/backports/
   # Returns a random element or +n+ random elements from the array.
-  # If the array is empty and +n+ is nil, returns <tt>nil</tt>. if +n+ is passed, returns <tt>[]</tt>.
+  # If the array is empty and +n+ is nil, returns <tt>nil</tt>.
+  # If +n+ is passed and its value is less than 0, it raises an +ArgumentError+ exception.
+  # If the value of +n+ is equal or greater than 0 it returns <tt>[]</tt>.
   #
-  #   [1,2,3,4,5,6].sample    # => 4
-  #   [1,2,3,4,5,6].sample(3) # => [2, 4, 5]
-  #              [].sample    # => nil
-  #              [].sample(3) # => []
+  #   [1,2,3,4,5,6].sample     # => 4
+  #   [1,2,3,4,5,6].sample(3)  # => [2, 4, 5]
+  #   [1,2,3,4,5,6].sample(-3) # => ArgumentError: negative array size
+  #              [].sample     # => nil
+  #              [].sample(3)  # => []
   def sample(n=nil)
     return self[Kernel.rand(size)] if n.nil?
     n = n.to_int
@@ -24,4 +27,4 @@ class Array
     result[n..size] = []
     result
   end unless method_defined? :sample
-end
+end

data/lib/active_support/core_ext/array/uniq_by.rb

@@ -1,8 +1,7 @@
 class Array
-  # Return an unique array based on the criteria given as a proc.
+  # Returns an unique array based on the criteria given as a +Proc+.
   #
-  #   [1, 2, 3, 4].uniq_by { |i| i.odd? }
-  #   # => [1, 2]
+  #   [1, 2, 3, 4].uniq_by { |i| i.odd? } # => [1, 2]
   #
   def uniq_by
     hash, array = {}, []

data/lib/active_support/core_ext/array/wrap.rb

@@ -14,7 +14,7 @@ class Array
   # This method is similar in purpose to <tt>Kernel#Array</tt>, but there are some differences:
   #
   # * If the argument responds to +to_ary+ the method is invoked. <tt>Kernel#Array</tt>
-  # moves on to try +to_a+ if the returned value is +nil+, but <tt>Arraw.wrap</tt> returns
+  # moves on to try +to_a+ if the returned value is +nil+, but <tt>Array.wrap</tt> returns
   # such a +nil+ right away.
   # * If the returned value from +to_ary+ is neither +nil+ nor an +Array+ object, <tt>Kernel#Array</tt>
   # raises an exception, while <tt>Array.wrap</tt> does not, it just returns the value.

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

@@ -11,8 +11,6 @@ class BigDecimal
   YAML_TAG = 'tag:yaml.org,2002:float'
   YAML_MAPPING = { 'Infinity' => '.Inf', '-Infinity' => '-.Inf', 'NaN' => '.NaN' }
 
-  yaml_as YAML_TAG
-
   # This emits the number without any scientific notation.
   # This is better than self.to_f.to_s since it doesn't lose precision.
   #

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

@@ -80,13 +80,22 @@ class Class
             remove_possible_method(:#{name})
             define_method(:#{name}) { val }
           end
+
+          if singleton_class?
+            class_eval do
+              remove_possible_method(:#{name})
+              def #{name}
+                defined?(@#{name}) ? @#{name} : singleton_class.#{name}
+              end
+            end
+          end
           val
         end
 
         if instance_reader
           remove_possible_method :#{name}
           def #{name}
-            defined?(@#{name}) ? @#{name} : singleton_class.#{name}
+            defined?(@#{name}) ? @#{name} : self.class.#{name}
           end
 
           def #{name}?
@@ -98,4 +107,9 @@ class Class
       attr_writer name if instance_writer
     end
   end
+
+  private
+  def singleton_class?
+    !name || '' == name
+  end
 end

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

@@ -1,8 +1,10 @@
 require 'active_support/core_ext/object/duplicable'
 require 'active_support/core_ext/array/extract_options'
+require 'active_support/deprecation'
 
 # Retained for backward compatibility.  Methods are now included in Class.
 module ClassInheritableAttributes # :nodoc:
+  DEPRECATION_WARNING_MESSAGE = "class_inheritable_attribute is deprecated, please use class_attribute method instead. Notice their behavior are slightly different, so refer to class_attribute documentation first"
 end
 
 # It is recommended to use <tt>class_attribute</tt> over methods defined in this file. Please
@@ -36,6 +38,7 @@ end
 #   Person.new.hair_colors             # => NoMethodError
 class Class # :nodoc:
   def class_inheritable_reader(*syms)
+    ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
     options = syms.extract_options!
     syms.each do |sym|
       next if sym.is_a?(Hash)
@@ -54,6 +57,7 @@ class Class # :nodoc:
   end
 
   def class_inheritable_writer(*syms)
+    ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
     options = syms.extract_options!
     syms.each do |sym|
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
@@ -71,6 +75,7 @@ class Class # :nodoc:
   end
 
   def class_inheritable_array_writer(*syms)
+    ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
     options = syms.extract_options!
     syms.each do |sym|
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
@@ -88,6 +93,7 @@ class Class # :nodoc:
   end
 
   def class_inheritable_hash_writer(*syms)
+    ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
     options = syms.extract_options!
     syms.each do |sym|
       class_eval(<<-EOS, __FILE__, __LINE__ + 1)
@@ -145,6 +151,7 @@ class Class # :nodoc:
   end
 
   def reset_inheritable_attributes
+    ActiveSupport::Deprecation.warn ClassInheritableAttributes::DEPRECATION_WARNING_MESSAGE
     @inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
   end
 
@@ -158,9 +165,9 @@ class Class # :nodoc:
       if inheritable_attributes.equal?(EMPTY_INHERITABLE_ATTRIBUTES)
         new_inheritable_attributes = EMPTY_INHERITABLE_ATTRIBUTES
       else
-        new_inheritable_attributes = inheritable_attributes.inject({}) do |memo, (key, value)|
-          memo.update(key => value.duplicable? ? value.dup : value)
-        end
+        new_inheritable_attributes = Hash[inheritable_attributes.map do |(key, value)|
+          [key, value.duplicable? ? value.dup : value]
+        end]
       end
 
       child.instance_variable_set('@inheritable_attributes', new_inheritable_attributes)
@@ -169,86 +176,3 @@ 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/class/subclasses.rb

@@ -2,49 +2,35 @@ require 'active_support/core_ext/module/anonymous'
 require 'active_support/core_ext/module/reachable'
 
 class Class #:nodoc:
-  # Rubinius
-  if defined?(Class.__subclasses__)
-    alias :subclasses :__subclasses__
+  begin
+    ObjectSpace.each_object(Class.new) {}
 
     def descendants
       descendants = []
-      __subclasses__.each do |k|
-        descendants << k
-        descendants.concat k.descendants
+      ObjectSpace.each_object(class << self; self; end) do |k|
+        descendants.unshift k unless k == self
       end
       descendants
     end
-  else # MRI
-    begin
-      ObjectSpace.each_object(Class.new) {}
-
-      def descendants
-        descendants = []
-        ObjectSpace.each_object(class << self; self; end) do |k|
-          descendants.unshift k unless k == self
-        end
-        descendants
-      end
-    rescue StandardError # JRuby
-      def descendants
-        descendants = []
-        ObjectSpace.each_object(Class) do |k|
-          descendants.unshift k if k < self
-        end
-        descendants.uniq!
-        descendants
+  rescue StandardError # JRuby
+    def descendants
+      descendants = []
+      ObjectSpace.each_object(Class) do |k|
+        descendants.unshift k if k < self
       end
+      descendants.uniq!
+      descendants
     end
+  end
 
-    # Returns an array with the direct children of +self+.
-    #
-    #   Integer.subclasses # => [Bignum, Fixnum]
-    def subclasses
-      subclasses, chain = [], descendants
-      chain.each do |k|
-        subclasses << k unless chain.any? { |c| c > k }
-      end
-      subclasses
+  # Returns an array with the direct children of +self+.
+  #
+  #   Integer.subclasses # => [Bignum, Fixnum]
+  def subclasses
+    subclasses, chain = [], descendants
+    chain.each do |k|
+      subclasses << k unless chain.any? { |c| c > k }
     end
+    subclasses
   end
 end

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

@@ -5,6 +5,8 @@ require 'active_support/core_ext/date/zones'
 require 'active_support/core_ext/time/zones'
 
 class Date
+  DAYS_INTO_WEEK = { :monday => 0, :tuesday => 1, :wednesday => 2, :thursday => 3, :friday => 4, :saturday => 5, :sunday => 6 }
+
   if RUBY_VERSION < '1.9'
     undef :>>
 
@@ -127,6 +129,11 @@ class Date
     )
   end
 
+  # Returns a new Date/DateTime representing the time a number of specified weeks ago.
+  def weeks_ago(weeks)
+    advance(:weeks => -weeks)
+  end
+
   # Returns a new Date/DateTime representing the time a number of specified months ago.
   def months_ago(months)
     advance(:months => -months)
@@ -185,16 +192,21 @@ class Date
   alias :sunday :end_of_week
   alias :at_end_of_week :end_of_week
 
+  # Returns a new Date/DateTime representing the start of the given day in the previous week (default is Monday).
+  def prev_week(day = :monday)
+    result = (self - 7).beginning_of_week + DAYS_INTO_WEEK[day]
+    self.acts_like?(:time) ? result.change(:hour => 0) : result
+  end
+
   # 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]
+    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)
+    self.acts_like?(:time) ? change(:day => 1, :hour => 0) : change(:day => 1)
   end
   alias :at_beginning_of_month :beginning_of_month
 
@@ -219,13 +231,13 @@ class Date
 
   # 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)
+    self.acts_like?(:time) ? change(:month => 1, :day => 1, :hour => 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)
+    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
 

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

@@ -1,6 +1,7 @@
 require 'date'
 require 'active_support/inflector/methods'
 require 'active_support/core_ext/date/zones'
+require 'active_support/core_ext/module/remove_method'
 
 class Date
   DATE_FORMATS = {
@@ -13,10 +14,10 @@ class Date
   }
 
   # Ruby 1.9 has Date#to_time which converts to localtime only.
-  remove_method :to_time if method_defined?(:to_time)
+  remove_possible_method :to_time
 
   # Ruby 1.9 has Date#xmlschema which converts to a string without the time component.
-  remove_method :xmlschema if method_defined?(:xmlschema)
+  remove_possible_method :xmlschema
 
   # Convert to a formatted string. See DATE_FORMATS for predefined formats.
   #
@@ -93,6 +94,12 @@ class Date
     ::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
   end