activesupport 3.0.20 → 3.1.0

data/lib/active_support/core_ext/string/output_safety.rb

@@ -3,38 +3,28 @@ require 'active_support/core_ext/kernel/singleton_class'
 
 class ERB
   module Util
-    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;', "'" => '&#x27;' }
+    HTML_ESCAPE = { '&' => '&amp;',  '>' => '&gt;',   '<' => '&lt;', '"' => '&quot;' }
     JSON_ESCAPE = { '&' => '\u0026', '>' => '\u003E', '<' => '\u003C' }
 
-    if RUBY_VERSION >= '1.9'
-      # A utility method for escaping HTML tag characters.
-      # This method is also aliased as <tt>h</tt>.
-      #
-      # In your ERB templates, use this method to escape any unsafe content. For example:
-      #   <%=h @person.name %>
-      #
-      # ==== Example:
-      #   puts html_escape("is a > 0 & a < 10?")
-      #   # => is a &gt; 0 &amp; a &lt; 10?
-      def html_escape(s)
-        s = s.to_s
-        if s.html_safe?
-          s
-        else
-          s.gsub(/[&"'><]/, HTML_ESCAPE).html_safe
-        end
-      end
-    else
-      def html_escape(s) #:nodoc:
-        s = s.to_s
-        if s.html_safe?
-          s
-        else
-          s.gsub(/[&"'><]/n) { |special| HTML_ESCAPE[special] }.html_safe
-        end
+    # A utility method for escaping HTML tag characters.
+    # This method is also aliased as <tt>h</tt>.
+    #
+    # In your ERB templates, use this method to escape any unsafe content. For example:
+    #   <%=h @person.name %>
+    #
+    # ==== Example:
+    #   puts html_escape("is a > 0 & a < 10?")
+    #   # => is a &gt; 0 &amp; a &lt; 10?
+    def html_escape(s)
+      s = s.to_s
+      if s.html_safe?
+        s
+      else
+        s.to_s.gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;").html_safe
       end
     end
 
+    # Aliasing twice issues a warning "discarding old...". Remove first to avoid it.
     remove_method(:h)
     alias h html_escape
 
@@ -77,7 +67,7 @@ class Object
   end
 end
 
-class Fixnum
+class Numeric
   def html_safe?
     true
   end
@@ -85,7 +75,7 @@ end
 
 module ActiveSupport #:nodoc:
   class SafeBuffer < String
-    UNSAFE_STRING_METHODS = ["capitalize", "chomp", "chop", "delete", "downcase", "gsub", "lstrip", "next", "reverse", "rstrip", "slice", "squeeze", "strip", "sub", "succ", "swapcase", "tr", "tr_s", "upcase", "prepend"].freeze
+    UNSAFE_STRING_METHODS = ["capitalize", "chomp", "chop", "delete", "downcase", "gsub", "lstrip", "next", "reverse", "rstrip", "slice", "squeeze", "strip", "sub", "succ", "swapcase", "tr", "tr_s", "upcase"].freeze
 
     alias_method :original_concat, :concat
     private :original_concat
@@ -96,39 +86,23 @@ module ActiveSupport #:nodoc:
       end
     end
 
-    def [](*args)
-      return super if args.size < 2
-
-      if html_safe?
-        new_safe_buffer = super
-        new_safe_buffer.instance_eval { @html_safe = true }
-        new_safe_buffer
-      else
-        to_str[*args]
-      end
-    end
-
     def safe_concat(value)
-      raise SafeConcatError unless html_safe?
+      raise SafeConcatError if dirty?
       original_concat(value)
     end
 
     def initialize(*)
-      @html_safe = true
+      @dirty = false
       super
     end
 
     def initialize_copy(other)
       super
-      @html_safe = other.html_safe?
-    end
-
-    def clone_empty
-      self[0, 0]
+      @dirty = other.dirty?
     end
 
     def concat(value)
-      if !html_safe? || value.html_safe?
+      if dirty? || value.html_safe?
         super(value)
       else
         super(ERB::Util.h(value))
@@ -141,7 +115,7 @@ module ActiveSupport #:nodoc:
     end
 
     def html_safe?
-      defined?(@html_safe) && @html_safe
+      !dirty?
     end
 
     def to_s
@@ -152,23 +126,32 @@ module ActiveSupport #:nodoc:
       to_str
     end
 
+    def encode_with(coder)
+      coder.represent_scalar nil, to_str
+    end
+
     def to_yaml(*args)
+      return super() if defined?(YAML::ENGINE) && !YAML::ENGINE.syck?
       to_str.to_yaml(*args)
     end
 
     for unsafe_method in UNSAFE_STRING_METHODS
-      if 'String'.respond_to?(unsafe_method)
-        class_eval <<-EOT, __FILE__, __LINE__ + 1
-          def #{unsafe_method}(*args, &block)       # def capitalize(*args, &block)
-            to_str.#{unsafe_method}(*args, &block)  #   to_str.capitalize(*args, &block)
-          end                                       # end
-
-          def #{unsafe_method}!(*args)              # def capitalize!(*args)
-            @html_safe = false                      #   @html_safe = false
-            super                                   #   super
-          end                                       # end
-        EOT
-      end
+      class_eval <<-EOT, __FILE__, __LINE__
+        def #{unsafe_method}(*args)
+          super.to_str
+        end
+
+        def #{unsafe_method}!(*args)
+          @dirty = true
+          super
+        end
+      EOT
+    end
+
+    protected
+
+    def dirty?
+      @dirty
     end
   end
 end

data/lib/active_support/core_ext/string.rb

@@ -11,3 +11,4 @@ require 'active_support/core_ext/string/output_safety'
 require 'active_support/core_ext/string/exclude'
 require 'active_support/core_ext/string/encoding'
 require 'active_support/core_ext/string/strip'
+require 'active_support/core_ext/string/inquiry'

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

@@ -1,7 +1,6 @@
 require 'active_support/duration'
-require 'active_support/core_ext/date/acts_like'
-require 'active_support/core_ext/date/calculations'
-require 'active_support/core_ext/date_time/conversions'
+require 'active_support/core_ext/time/zones'
+require 'active_support/core_ext/time/conversions'
 
 class Time
   COMMON_YEAR_DAYS_IN_MONTH = [nil, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
@@ -10,7 +9,7 @@ class Time
   class << self
     # Overriding case equality method so that it returns true for ActiveSupport::TimeWithZone instances
     def ===(other)
-      super || (self == Time && other.is_a?(ActiveSupport::TimeWithZone))
+      other.is_a?(::Time)
     end
 
     # Return the number of days in the given month.
@@ -22,7 +21,7 @@ class Time
 
     # 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
+    # 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 = ::Time.send(utc_or_local, year, month, day, hour, min, sec, usec)
       # This check is needed because Time.utc(y) returns a time object in the 2000s for 0 <= y <= 138.
@@ -117,6 +116,11 @@ class Time
   end
   alias :in :since
 
+  # Returns a new Time representing the time a number of specified weeks ago.
+  def weeks_ago(weeks)
+    advance(:weeks => -weeks)
+  end
+
   # Returns a new Time representing the time a number of specified months ago
   def months_ago(months)
     advance(:months => -months)
@@ -172,6 +176,11 @@ class Time
   end
   alias :at_end_of_week :end_of_week
 
+  # Returns a new Time representing the start of the given day in the previous week (default is Monday).
+  def prev_week(day = :monday)
+    ago(1.week).beginning_of_week.since(DAYS_INTO_WEEK[day].day).change(:hour => 0)
+  end
+
   # 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)
@@ -180,7 +189,7 @@ class Time
   # Returns a new Time representing the start of the day (0:00)
   def beginning_of_day
     #(self - seconds_since_midnight).change(:usec => 0)
-    change(:hour => 0, :min => 0, :sec => 0, :usec => 0)
+    change(:hour => 0)
   end
   alias :midnight :beginning_of_day
   alias :at_midnight :beginning_of_day
@@ -194,7 +203,7 @@ class Time
   # 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)
+    change(:day => 1, :hour => 0)
   end
   alias :at_beginning_of_month :beginning_of_month
 
@@ -220,7 +229,7 @@ class Time
 
   # 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)
+    change(:month => 1, :day => 1, :hour => 0)
   end
   alias :at_beginning_of_year :beginning_of_year
 
@@ -273,14 +282,8 @@ class Time
   # 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
+    # we're avoiding Time#to_datetime cause it's expensive
+    other.is_a?(Time) ? compare_without_coercion(other.to_time) : to_datetime <=> other
   end
   alias_method :compare_without_coercion, :<=>
   alias_method :<=>, :compare_with_coercion

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

@@ -19,8 +19,8 @@ class Time
   #
   #   time = Time.now                     # => Thu Jan 18 06:10:17 CST 2007
   #
-  #   time.to_formatted_s(:time)          # => "06:10:17"
-  #   time.to_s(:time)                    # => "06:10:17"
+  #   time.to_formatted_s(:time)          # => "06:10"
+  #   time.to_s(:time)                    # => "06:10"
   #
   #   time.to_formatted_s(:db)            # => "2007-01-18 06:10:17"
   #   time.to_formatted_s(:number)        # => "20070118061017"
@@ -55,31 +55,9 @@ class Time
     utc? && alternate_utc_string || ActiveSupport::TimeZone.seconds_to_utc_offset(utc_offset, colon)
   end
 
-  # Converts a Time object to a Date, dropping hour, minute, and second precision.
-  #
-  #   my_time = Time.now  # => Mon Nov 12 22:59:51 -0500 2007
-  #   my_time.to_date     # => Mon, 12 Nov 2007
-  #
-  #   your_time = Time.parse("1/13/2009 1:13:03 P.M.")  # => Tue Jan 13 13:13:03 -0500 2009
-  #   your_time.to_date                                 # => Tue, 13 Jan 2009
-  def to_date
-    ::Date.new(year, month, day)
-  end unless method_defined?(:to_date)
-
   # A method to keep Time, Date and DateTime instances interchangeable on conversions.
   # In this case, it simply returns +self+.
   def to_time
     self
   end unless method_defined?(:to_time)
-
-  # Converts a Time instance to a Ruby DateTime instance, preserving UTC offset.
-  #
-  #   my_time = Time.now    # => Mon Nov 12 23:04:21 -0500 2007
-  #   my_time.to_datetime   # => Mon, 12 Nov 2007 23:04:21 -0500
-  #
-  #   your_time = Time.parse("1/13/2009 1:13:03 P.M.")  # => Tue Jan 13 13:13:03 -0500 2009
-  #   your_time.to_datetime                             # => Tue, 13 Jan 2009 13:13:03 -0500
-  def to_datetime
-    ::DateTime.civil(year, month, day, hour, min, sec, Rational(utc_offset, 86400))
-  end unless method_defined?(:to_datetime)
 end

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

@@ -19,40 +19,51 @@ class Time
     # * 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:
+    # Here's an example of how you might set <tt>Time.zone</tt> on a per request basis and reset it when the request is done.
+    # <tt>current_user.time_zone</tt> just needs to return a string identifying the user's preferred time zone:
     #
     #   class ApplicationController < ActionController::Base
-    #     before_filter :set_time_zone
+    #     around_filter :set_time_zone
     #
     #     def set_time_zone
-    #       Time.zone = current_user.time_zone
+    #       old_time_zone = Time.zone
+    #       Time.zone = current_user.time_zone if logged_in?
+    #       yield
+    #     ensure
+    #       Time.zone = old_time_zone
     #     end
     #   end
     def zone=(time_zone)
-      Thread.current[:time_zone] = get_zone(time_zone)
+      Thread.current[:time_zone] = find_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
+      new_zone = find_zone!(time_zone)
+      begin
+        old_zone, ::Time.zone = ::Time.zone, new_zone
+        yield
+      ensure
+        ::Time.zone = old_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
-        # 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
+    # Returns a TimeZone instance or nil, or raises an ArgumentError for invalid timezones.
+    def find_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)
       end
+      # Return if a TimeZone instance, or wrap in a TimeZone instance if a TZInfo::Timezone
+      time_zone.is_a?(ActiveSupport::TimeZone) ? time_zone : ActiveSupport::TimeZone.create(time_zone.name, nil, time_zone)
+    rescue TZInfo::InvalidTimezoneIdentifier
+      raise ArgumentError, "Invalid Timezone: #{time_zone}"
+    end
+
+    def find_zone(time_zone)
+      find_zone!(time_zone) rescue nil
+    end
   end
 
   # Returns the simultaneous time in <tt>Time.zone</tt>.
@@ -70,6 +81,6 @@ class Time
   def in_time_zone(zone = ::Time.zone)
     return self unless zone
 
-    ActiveSupport::TimeWithZone.new(utc? ? self : getutc, ::Time.__send__(:get_zone, zone))
+    ActiveSupport::TimeWithZone.new(utc? ? self : getutc, ::Time.find_zone!(zone))
   end
 end

data/lib/active_support/core_ext/uri.rb

@@ -20,3 +20,11 @@ if RUBY_VERSION >= '1.9'
     end
   end
 end
+
+module URI
+  class << self
+    def parser
+      @parser ||= URI.const_defined?(:Parser) ? URI::Parser.new : URI
+    end
+  end
+end

data/lib/active_support/dependencies.rb

@@ -5,6 +5,7 @@ require 'active_support/core_ext/module/aliasing'
 require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/core_ext/module/introspection'
 require 'active_support/core_ext/module/anonymous'
+require 'active_support/core_ext/module/deprecation'
 require 'active_support/core_ext/object/blank'
 require 'active_support/core_ext/load_error'
 require 'active_support/core_ext/name_error'
@@ -47,9 +48,6 @@ module ActiveSupport #:nodoc:
     mattr_accessor :autoloaded_constants
     self.autoloaded_constants = []
 
-    mattr_accessor :references
-    self.references = {}
-
     # An array of constant names that need to be unloaded on every request. Used
     # to allow arbitrary constants to be marked for unloading.
     mattr_accessor :explicitly_unloadable_constants
@@ -64,8 +62,8 @@ module ActiveSupport #:nodoc:
     self.log_activity = false
 
     # The WatchStack keeps a stack of the modules being watched as files are loaded.
-    # If a file in the process of being loaded (parent.rb) triggers the load of 
-    # another file (child.rb) the stack will ensure that child.rb handles the new 
+    # If a file in the process of being loaded (parent.rb) triggers the load of
+    # another file (child.rb) the stack will ensure that child.rb handles the new
     # constants.
     #
     # If child.rb is being autoloaded, its constants will be added to
@@ -83,13 +81,13 @@ module ActiveSupport #:nodoc:
         super { |h,k| h[k] = [] }
       end
 
-      # return a list of new constants found since the last call to watch_modules
+      # return a list of new constants found since the last call to watch_namespaces
       def new_constants
         constants = []
 
         # Grab the list of namespaces that we're looking for new constants under
         @watching.last.each do |namespace|
-          # Retrieve the constants that were present under the namespace when watch_modules
+          # Retrieve the constants that were present under the namespace when watch_namespaces
           # was originally called
           original_constants = self[namespace].last
 
@@ -115,7 +113,7 @@ module ActiveSupport #:nodoc:
         end
         constants
       ensure
-        # A call to new_constants is always called after a call to watch_modules
+        # A call to new_constants is always called after a call to watch_namespaces
         pop_modules(@watching.pop)
       end
 
@@ -166,7 +164,7 @@ module ActiveSupport #:nodoc:
       def const_missing(const_name, nesting = nil)
         klass_name = name.presence || "Object"
 
-        if !nesting
+        unless nesting
           # We'll assume that the nesting of Foo::Bar is ["Foo::Bar", "Foo"]
           # even though it might not be, such as in the case of
           # class Foo::Bar; Baz; end
@@ -480,7 +478,7 @@ module ActiveSupport #:nodoc:
         raise ArgumentError, "A copy of #{from_mod} has been removed from the module tree but is still active!"
       end
 
-      raise ArgumentError, "#{from_mod} is not missing constant #{const_name}!" if local_const_defined?(from_mod, const_name)
+      raise NameError, "#{from_mod} is not missing constant #{const_name}!" if local_const_defined?(from_mod, const_name)
 
       qualified_name = qualified_name_for from_mod, const_name
       path_suffix = qualified_name.underscore
@@ -516,7 +514,7 @@ module ActiveSupport #:nodoc:
     # to its class/module if it implements +before_remove_const+.
     #
     # The callback implementation should be restricted to cleaning up caches, etc.
-    # as the enviroment will be in an inconsistent state, e.g. other constants
+    # as the environment will be in an inconsistent state, e.g. other constants
     # may have already been unloaded and not accessible.
     def remove_unloadable_constants!
       autoloaded_constants.each { |const| remove_constant const }
@@ -525,31 +523,76 @@ module ActiveSupport #:nodoc:
       explicitly_unloadable_constants.each { |const| remove_constant const }
     end
 
-    class Reference
-      @@constants = Hash.new { |h, k| h[k] = Inflector.constantize(k) }
+    class ClassCache
+      def initialize
+        @store = Hash.new { |h, k| h[k] = Inflector.constantize(k) }
+      end
 
-      attr_reader :name
+      def empty?
+        @store.empty?
+      end
 
-      def initialize(name)
-        @name = name.to_s
-        @@constants[@name] = name if name.respond_to?(:name)
+      def key?(key)
+        @store.key?(key)
       end
 
-      def get
-        @@constants[@name]
+      def []=(key, value)
+        return unless key.respond_to?(:name)
+
+        raise(ArgumentError, 'anonymous classes cannot be cached') if key.name.blank?
+
+        @store[key.name] = value
       end
 
-      def self.clear!
-        @@constants.clear
+      def [](key)
+        key = key.name if key.respond_to?(:name)
+
+        @store[key]
+      end
+      alias :get :[]
+
+      class Getter # :nodoc:
+        def initialize(name)
+          @name = name
+        end
+
+        def get
+          Reference.get @name
+        end
+        deprecate :get
+      end
+
+      def new(name)
+        self[name] = name
+        Getter.new(name)
+      end
+      deprecate :new
+
+      def store(name)
+        self[name] = name
+        self
+      end
+
+      def clear!
+        @store.clear
       end
     end
 
+    Reference = ClassCache.new
+
     def ref(name)
-      references[name] ||= Reference.new(name)
+      Reference.new(name)
+    end
+    deprecate :ref
+
+    # Store a reference to a class +klass+.
+    def reference(klass)
+      Reference.store klass
     end
 
+    # Get the reference for class named +name+.
     def constantize(name)
-      ref(name).get
+      Reference.get(name)
     end
 
     # Determine if the given constant has been automatically loaded.
@@ -631,7 +674,8 @@ module ActiveSupport #:nodoc:
       parent = Inflector.constantize(names * '::')
 
       log "removing constant #{const}"
-      constantize(const).before_remove_const if constantize(const).respond_to?(:before_remove_const)
+      constantized = constantize(const)
+      constantized.before_remove_const if constantized.respond_to?(:before_remove_const)
       parent.instance_eval { remove_const to_remove }
 
       return true
@@ -639,7 +683,7 @@ module ActiveSupport #:nodoc:
 
     protected
       def log_call(*args)
-        if logger && log_activity
+        if log_activity?
           arg_str = args.collect { |arg| arg.inspect } * ', '
           /in `([a-z_\?\!]+)'/ =~ caller(1).first
           selector = $1 || '<unknown>'
@@ -648,9 +692,11 @@ module ActiveSupport #:nodoc:
       end
 
       def log(msg)
-        if logger && log_activity
-          logger.debug "Dependencies: #{msg}"
-        end
+        logger.debug "Dependencies: #{msg}" if log_activity?
+      end
+
+      def log_activity?
+        logger && log_activity
       end
   end
 end

data/lib/active_support/deprecation/behaviors.rb

@@ -7,10 +7,17 @@ module ActiveSupport
       # Whether to print a backtrace along with the warning.
       attr_accessor :debug
 
+      # Returns the set behavior or if one isn't set, defaults to +:stderr+
       def behavior
         @behavior ||= [DEFAULT_BEHAVIORS[:stderr]]
       end
 
+      # Sets the behavior to the specified value. Can be a single value or an array.
+      #
+      # Examples
+      #
+      #   ActiveSupport::Deprecation.behavior = :stderr
+      #   ActiveSupport::Deprecation.behavior = [:stderr, :log]
       def behavior=(behavior)
         @behavior = Array.wrap(behavior).map { |b| DEFAULT_BEHAVIORS[b] || b }
       end

data/lib/active_support/deprecation/proxy_wrappers.rb

@@ -58,7 +58,7 @@ module ActiveSupport
         end
     end
 
-    class DeprecatedConstantProxy < DeprecationProxy #:nodoc:
+    class DeprecatedConstantProxy < DeprecationProxy #:nodoc:all
       def initialize(old_const, new_const)
         @old_const = old_const
         @new_const = new_const

data/lib/active_support/deprecation/reporting.rb

@@ -3,6 +3,10 @@ module ActiveSupport
     class << self
       attr_accessor :silenced
 
+      # Outputs a deprecation warning to the output configured by <tt>ActiveSupport::Deprecation.behavior</tt>
+      #
+      #   ActiveSupport::Deprecation.warn("something broke!")
+      #   # => "DEPRECATION WARNING: something broke! (called from your_code.rb:1)"
       def warn(message = nil, callstack = caller)
         return if silenced
         deprecation_message(callstack, message).tap do |m|

data/lib/active_support/deprecation.rb

@@ -4,12 +4,12 @@ require 'active_support/deprecation/method_wrappers'
 require 'active_support/deprecation/proxy_wrappers'
 
 module ActiveSupport
-  module Deprecation #:nodoc:
+  module Deprecation
     class << self
       # The version the deprecated behavior will be removed, by default.
       attr_accessor :deprecation_horizon
     end
-    self.deprecation_horizon = '3.0'
+    self.deprecation_horizon = '3.2'
 
     # By default, warnings are not silenced and debugging is off.
     self.silenced = false