activesupport 2.1.2 → 2.2.2

data/lib/active_support/core_ext/rexml.rb

@@ -6,7 +6,7 @@ require 'rexml/entity'
 # This fix is identical to rexml-expansion-fix version 1.0.1
 
 # Earlier versions of rexml defined REXML::Version, newer ones REXML::VERSION
-unless (defined?(REXML::VERSION) ? REXML::VERSION : REXML::Version) > "3.1.7.2"
+unless REXML::Document.respond_to?(:entity_expansion_limit=)
   module REXML
     class Entity < Child
       undef_method :unnormalized
@@ -33,4 +33,4 @@ unless (defined?(REXML::VERSION) ? REXML::VERSION : REXML::Version) > "3.1.7.2"
       end
     end
   end
-end
+end

data/lib/active_support/core_ext/string.rb

@@ -1,11 +1,14 @@
+# encoding: utf-8
+
 require 'active_support/core_ext/string/inflections'
 require 'active_support/core_ext/string/conversions'
 require 'active_support/core_ext/string/access'
 require 'active_support/core_ext/string/starts_ends_with'
 require 'active_support/core_ext/string/iterators'
-require 'active_support/core_ext/string/unicode'
+require 'active_support/core_ext/string/multibyte'
 require 'active_support/core_ext/string/xchar'
 require 'active_support/core_ext/string/filters'
+require 'active_support/core_ext/string/behavior'
 
 class String #:nodoc:
   include ActiveSupport::CoreExtensions::String::Access
@@ -14,5 +17,6 @@ class String #:nodoc:
   include ActiveSupport::CoreExtensions::String::Inflections
   include ActiveSupport::CoreExtensions::String::StartsEndsWith
   include ActiveSupport::CoreExtensions::String::Iterators
-  include ActiveSupport::CoreExtensions::String::Unicode
+  include ActiveSupport::CoreExtensions::String::Behavior
+  include ActiveSupport::CoreExtensions::String::Multibyte
 end

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

@@ -11,7 +11,7 @@ module ActiveSupport #:nodoc:
           #   "hello".at(4)  # => "o"
           #   "hello".at(10) # => nil
           def at(position)
-            chars[position, 1].to_s
+            mb_chars[position, 1].to_s
           end
           
           # Returns the remaining of the string from the +position+ treating the string as an array (where 0 is the first character).
@@ -21,7 +21,7 @@ module ActiveSupport #:nodoc:
           #   "hello".from(2)  # => "llo"
           #   "hello".from(10) # => nil
           def from(position)
-            chars[position..-1].to_s
+            mb_chars[position..-1].to_s
           end
           
           # Returns the beginning of the string up to the +position+ treating the string as an array (where 0 is the first character).
@@ -31,7 +31,7 @@ module ActiveSupport #:nodoc:
           #   "hello".to(2)  # => "hel"
           #   "hello".to(10) # => "hello"
           def to(position)
-            chars[0..position].to_s
+            mb_chars[0..position].to_s
           end
 
           # Returns the first character of the string or the first +limit+ characters.
@@ -41,7 +41,7 @@ module ActiveSupport #:nodoc:
           #   "hello".first(2)  # => "he"
           #   "hello".first(10) # => "hello"
           def first(limit = 1)
-            chars[0..(limit - 1)].to_s
+            mb_chars[0..(limit - 1)].to_s
           end
           
           # Returns the last character of the string or the last +limit+ characters.
@@ -51,7 +51,7 @@ module ActiveSupport #:nodoc:
           #   "hello".last(2)  # => "lo"
           #   "hello".last(10) # => "hello"
           def last(limit = 1)
-            (chars[(-limit)..-1] || self).to_s
+            (mb_chars[(-limit)..-1] || self).to_s
           end
         end
       else

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

@@ -0,0 +1,13 @@
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      module Behavior
+        # Enable more predictable duck-typing on String-like classes. See
+        # Object#acts_like?.
+        def acts_like_string?
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -24,8 +24,8 @@ module ActiveSupport #:nodoc:
         #
         #   "posts".singularize            # => "post"
         #   "octopi".singularize           # => "octopus"
-        #   "sheep".singluarize            # => "sheep"
-        #   "word".singluarize             # => "word"
+        #   "sheep".singularize            # => "sheep"
+        #   "word".singularize             # => "word"
         #   "the blue mailmen".singularize # => "the blue mailman"
         #   "CamelOctopi".singularize      # => "CamelOctopus"
         def singularize
@@ -87,6 +87,25 @@ module ActiveSupport #:nodoc:
           Inflector.demodulize(self)
         end
 
+        # Replaces special characters in a string so that it may be used as part of a 'pretty' URL.
+        # 
+        # ==== Examples
+        #
+        #   class Person
+        #     def to_param
+        #       "#{id}-#{name.parameterize}"
+        #     end
+        #   end
+        # 
+        #   @person = Person.find(1)
+        #   # => #<Person id: 1, name: "Donald E. Knuth">
+        # 
+        #   <%= link_to(@person.name, person_path %>
+        #   # => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>
+        def parameterize
+          Inflector.parameterize(self)
+        end
+
         # Creates the name of a table like Rails does for models to table names. This method
         # uses the +pluralize+ method on the last word in the string.
         #

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

@@ -0,0 +1,81 @@
+# encoding: utf-8
+
+module ActiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module String #:nodoc:
+      # Implements multibyte methods for easier access to multibyte characters in a String instance.
+      module Multibyte
+        unless '1.9'.respond_to?(:force_encoding)
+          # == Multibyte proxy
+          #
+          # +mb_chars+ is a multibyte safe proxy for string methods.
+          #
+          # In Ruby 1.8 and older it creates and returns an instance of the ActiveSupport::Multibyte::Chars class which
+          # encapsulates the original string. A Unicode safe version of all the String methods are defined on this proxy
+          # class. If the proxy class doesn't respond to a certain method, it's forwarded to the encapsuled string.
+          #
+          #   name = 'Claus Müller'
+          #   name.reverse  #=> "rell??M sualC"
+          #   name.length   #=> 13
+          #
+          #   name.mb_chars.reverse.to_s   #=> "rellüM sualC"
+          #   name.mb_chars.length         #=> 12
+          #
+          # In Ruby 1.9 and newer +mb_chars+ returns +self+ because String is (mostly) encoding aware. This means that
+          # it becomes easy to run one version of your code on multiple Ruby versions.
+          #
+          # == Method chaining
+          #
+          # All the methods on the Chars proxy which normally return a string will return a Chars object. This allows
+          # method chaining on the result of any of these methods.
+          #
+          #   name.mb_chars.reverse.length #=> 12
+          #
+          # == Interoperability and configuration
+          #
+          # The Chars object tries to be as interchangeable with String objects as possible: sorting and comparing between
+          # String and Char work like expected. The bang! methods change the internal string representation in the Chars
+          # object. Interoperability problems can be resolved easily with a +to_s+ call.
+          #
+          # For more information about the methods defined on the Chars proxy see ActiveSupport::Multibyte::Chars. For
+          # information about how to change the default Multibyte behaviour see ActiveSupport::Multibyte.
+          def mb_chars
+            if ActiveSupport::Multibyte.proxy_class.wants?(self)
+              ActiveSupport::Multibyte.proxy_class.new(self)
+            else
+              self
+            end
+          end
+          
+          # Returns true if the string has UTF-8 semantics (a String used for purely byte resources is unlikely to have
+          # them), returns false otherwise.
+          def is_utf8?
+            ActiveSupport::Multibyte::Chars.consumes?(self)
+          end
+
+          unless '1.8.7 and later'.respond_to?(:chars)
+            def chars
+              ActiveSupport::Deprecation.warn('String#chars has been deprecated in favor of String#mb_chars.', caller)
+              mb_chars
+            end
+          end
+        else
+          def mb_chars #:nodoc
+            self
+          end
+          
+          def is_utf8? #:nodoc
+            case encoding
+            when Encoding::UTF_8
+              valid_encoding?
+            when Encoding::ASCII_8BIT, Encoding::US_ASCII
+              dup.force_encoding(Encoding::UTF_8).valid_encoding?
+            else
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+require 'active_support/duration'
+
 module ActiveSupport #:nodoc:
   module CoreExtensions #:nodoc:
     module Time #:nodoc:
@@ -9,13 +11,13 @@ module ActiveSupport #:nodoc:
           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
@@ -28,9 +30,9 @@ module ActiveSupport #:nodoc:
           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. 
+
+          # 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]
@@ -57,6 +59,21 @@ module ActiveSupport #:nodoc:
           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)
@@ -83,6 +100,16 @@ module ActiveSupport #:nodoc:
         # <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
@@ -106,7 +133,7 @@ module ActiveSupport #:nodoc:
             (seconds.abs >= 86400 && initial_dst != final_dst) ? f + (initial_dst - final_dst).hours : f
           end
         rescue
-          self.to_datetime.since(seconds)          
+          self.to_datetime.since(seconds)
         end
         alias :in :since
 
@@ -199,7 +226,7 @@ module ActiveSupport #:nodoc:
           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 })
@@ -208,7 +235,7 @@ module ActiveSupport #:nodoc:
 
         # Returns a new Time representing the end of the quarter (last day of march, june, september, december, 23:59:59)
         def end_of_quarter
-          change(:month => [3, 6, 9, 12].detect { |m| m >= self.month }).end_of_month
+          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
 
@@ -249,7 +276,7 @@ module ActiveSupport #:nodoc:
             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
@@ -257,11 +284,11 @@ module ActiveSupport #:nodoc:
           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 <=> comparision
+          # 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#<=>

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

@@ -30,6 +30,7 @@ module ActiveSupport #:nodoc:
         #   time.to_s(:time)                    # => "06:10:17"
         #
         #   time.to_formatted_s(:db)            # => "2007-01-18 06:10:17"
+        #   time.to_formatted_s(:number)        # => "20070118061017"
         #   time.to_formatted_s(:short)         # => "18 Jan 06:10"
         #   time.to_formatted_s(:long)          # => "January 18, 2007 06:10"
         #   time.to_formatted_s(:long_ordinal)  # => "January 18th, 2007 06:10"

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

@@ -78,7 +78,7 @@ module ActiveSupport #:nodoc:
         #
         #   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))
+          ActiveSupport::TimeWithZone.new(utc? ? self : getutc, ::Time.__send__(:get_zone, zone))
         end
       end
     end

data/lib/active_support/dependencies.rb

@@ -1,8 +1,3 @@
-require 'set'
-require 'active_support/core_ext/module/attribute_accessors'
-require 'active_support/core_ext/load_error'
-require 'active_support/core_ext/kernel'
-
 module ActiveSupport #:nodoc:
   module Dependencies #:nodoc:
     extend self
@@ -44,6 +39,10 @@ module ActiveSupport #:nodoc:
     mattr_accessor :explicitly_unloadable_constants
     self.explicitly_unloadable_constants = []
 
+    # The logger is used for generating information on the action run-time (including benchmarking) if available.
+    # Can be set to nil for no logging. Compatible with both Ruby's own Logger and Log4r loggers.
+    mattr_accessor :logger
+
     # Set to true to enable logging of const_missing and file loads
     mattr_accessor :log_activity
     self.log_activity = false
@@ -52,6 +51,167 @@ module ActiveSupport #:nodoc:
     mattr_accessor :constant_watch_stack
     self.constant_watch_stack = []
 
+    # Module includes this module
+    module ModuleConstMissing #:nodoc:
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          unless defined? const_missing_without_dependencies
+            alias_method_chain :const_missing, :dependencies
+          end
+        end
+      end
+
+      def self.excluded(base) #:nodoc:
+        base.class_eval do
+          if defined? const_missing_without_dependencies
+            undef_method :const_missing
+            alias_method :const_missing, :const_missing_without_dependencies
+            undef_method :const_missing_without_dependencies
+          end
+        end
+      end
+
+      # Use const_missing to autoload associations so we don't have to
+      # require_association when using single-table inheritance.
+      def const_missing_with_dependencies(class_id)
+        ActiveSupport::Dependencies.load_missing_constant self, class_id
+      end
+
+      def unloadable(const_desc = self)
+        super(const_desc)
+      end
+    end
+
+    # Class includes this module
+    module ClassConstMissing #:nodoc:
+      def const_missing(const_name)
+        if [Object, Kernel].include?(self) || parent == self
+          super
+        else
+          begin
+            begin
+              Dependencies.load_missing_constant self, const_name
+            rescue NameError
+              parent.send :const_missing, const_name
+            end
+          rescue NameError => e
+            # Make sure that the name we are missing is the one that caused the error
+            parent_qualified_name = Dependencies.qualified_name_for parent, const_name
+            raise unless e.missing_name? parent_qualified_name
+            qualified_name = Dependencies.qualified_name_for self, const_name
+            raise NameError.new("uninitialized constant #{qualified_name}").copy_blame!(e)
+          end
+        end
+      end
+    end
+
+    # Object includes this module
+    module Loadable #:nodoc:
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          unless defined? load_without_new_constant_marking
+            alias_method_chain :load, :new_constant_marking
+          end
+        end
+      end
+
+      def self.excluded(base) #:nodoc:
+        base.class_eval do
+          if defined? load_without_new_constant_marking
+            undef_method :load
+            alias_method :load, :load_without_new_constant_marking
+            undef_method :load_without_new_constant_marking
+          end
+        end
+      end
+
+      def require_or_load(file_name)
+        Dependencies.require_or_load(file_name)
+      end
+
+      def require_dependency(file_name)
+        Dependencies.depend_on(file_name)
+      end
+
+      def require_association(file_name)
+        Dependencies.associate_with(file_name)
+      end
+
+      def load_with_new_constant_marking(file, *extras) #:nodoc:
+        if Dependencies.load?
+          Dependencies.new_constants_in(Object) { load_without_new_constant_marking(file, *extras) }
+        else
+          load_without_new_constant_marking(file, *extras)
+        end
+      rescue Exception => exception  # errors from loading file
+        exception.blame_file! file
+        raise
+      end
+
+      def require(file, *extras) #:nodoc:
+        if Dependencies.load?
+          Dependencies.new_constants_in(Object) { super }
+        else
+          super
+        end
+      rescue Exception => exception  # errors from required file
+        exception.blame_file! file
+        raise
+      end
+
+      # Mark the given constant as unloadable. Unloadable constants are removed each
+      # time dependencies are cleared.
+      #
+      # Note that marking a constant for unloading need only be done once. Setup
+      # or init scripts may list each unloadable constant that may need unloading;
+      # each constant will be removed for every subsequent clear, as opposed to for
+      # the first clear.
+      #
+      # The provided constant descriptor may be a (non-anonymous) module or class,
+      # or a qualified constant name as a string or symbol.
+      #
+      # Returns true if the constant was not previously marked for unloading, false
+      # otherwise.
+      def unloadable(const_desc)
+        Dependencies.mark_for_unload const_desc
+      end
+    end
+
+    # Exception file-blaming
+    module Blamable #:nodoc:
+      def blame_file!(file)
+        (@blamed_files ||= []).unshift file
+      end
+
+      def blamed_files
+        @blamed_files ||= []
+      end
+
+      def describe_blame
+        return nil if blamed_files.empty?
+        "This error occurred while loading the following files:\n   #{blamed_files.join "\n   "}"
+      end
+
+      def copy_blame!(exc)
+        @blamed_files = exc.blamed_files.clone
+        self
+      end
+    end
+
+    def hook!
+      Object.instance_eval { include Loadable }
+      Module.instance_eval { include ModuleConstMissing }
+      Class.instance_eval { include ClassConstMissing }
+      Exception.instance_eval { include Blamable }
+      true
+    end
+
+    def unhook!
+      ModuleConstMissing.excluded(Module)
+      Loadable.excluded(Object)
+      true
+    end
+
     def load?
       mechanism == :load
     end
@@ -153,6 +313,12 @@ module ActiveSupport #:nodoc:
         nesting = expanded_path[(expanded_root.size)..-1]
         nesting = nesting[1..-1] if nesting && nesting[0] == ?/
         next if nesting.blank?
+        nesting_camel = nesting.camelize
+        begin
+          qualified_const_defined?(nesting_camel)
+        rescue NameError
+          next
+        end
 
         [
           nesting.camelize,
@@ -339,7 +505,7 @@ module ActiveSupport #:nodoc:
           initial_constants = if qualified_const_defined?(mod_name)
             mod_name.constantize.local_constant_names
           else
-           []
+            []
           end
         else
           raise Argument, "#{desc.inspect} does not describe a module!"
@@ -387,7 +553,7 @@ module ActiveSupport #:nodoc:
     ensure
       # Remove the stack frames that we added.
       if defined?(watch_frames) && ! watch_frames.blank?
-        frame_ids = watch_frames.collect(&:object_id)
+        frame_ids = watch_frames.collect { |frame| frame.object_id }
         constant_watch_stack.delete_if do |watch_frame|
           frame_ids.include? watch_frame.object_id
         end
@@ -436,8 +602,8 @@ module ActiveSupport #:nodoc:
 
     protected
       def log_call(*args)
-        if defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER && log_activity
-          arg_str = args.collect(&:inspect) * ', '
+        if logger && log_activity
+          arg_str = args.collect { |arg| arg.inspect } * ', '
           /in `([a-z_\?\!]+)'/ =~ caller(1).first
           selector = $1 || '<unknown>'
           log "called #{selector}(#{arg_str})"
@@ -445,109 +611,11 @@ module ActiveSupport #:nodoc:
       end
 
       def log(msg)
-        if defined?(RAILS_DEFAULT_LOGGER) && RAILS_DEFAULT_LOGGER && log_activity
-          RAILS_DEFAULT_LOGGER.debug "Dependencies: #{msg}"
+        if logger && log_activity
+          logger.debug "Dependencies: #{msg}"
         end
       end
   end
 end
 
-Object.instance_eval do
-  define_method(:require_or_load)     { |file_name| ActiveSupport::Dependencies.require_or_load(file_name) } unless Object.respond_to?(:require_or_load)
-  define_method(:require_dependency)  { |file_name| ActiveSupport::Dependencies.depend_on(file_name) }       unless Object.respond_to?(:require_dependency)
-  define_method(:require_association) { |file_name| ActiveSupport::Dependencies.associate_with(file_name) }  unless Object.respond_to?(:require_association)
-end
-
-class Module #:nodoc:
-  # Rename the original handler so we can chain it to the new one
-  alias :rails_original_const_missing :const_missing
-
-  # Use const_missing to autoload associations so we don't have to
-  # require_association when using single-table inheritance.
-  def const_missing(class_id)
-    ActiveSupport::Dependencies.load_missing_constant self, class_id
-  end
-
-  def unloadable(const_desc = self)
-    super(const_desc)
-  end
-
-end
-
-class Class
-  def const_missing(const_name)
-    if [Object, Kernel].include?(self) || parent == self
-      super
-    else
-      begin
-        begin
-          ActiveSupport::Dependencies.load_missing_constant self, const_name
-        rescue NameError
-          parent.send :const_missing, const_name
-        end
-      rescue NameError => e
-        # Make sure that the name we are missing is the one that caused the error
-        parent_qualified_name = ActiveSupport::Dependencies.qualified_name_for parent, const_name
-        raise unless e.missing_name? parent_qualified_name
-        qualified_name = ActiveSupport::Dependencies.qualified_name_for self, const_name
-        raise NameError.new("uninitialized constant #{qualified_name}").copy_blame!(e)
-      end
-    end
-  end
-end
-
-class Object
-  alias_method :load_without_new_constant_marking, :load
-
-  def load(file, *extras) #:nodoc:
-    ActiveSupport::Dependencies.new_constants_in(Object) { super }
-  rescue Exception => exception  # errors from loading file
-    exception.blame_file! file
-    raise
-  end
-
-  def require(file, *extras) #:nodoc:
-    ActiveSupport::Dependencies.new_constants_in(Object) { super }
-  rescue Exception => exception  # errors from required file
-    exception.blame_file! file
-    raise
-  end
-
-  # Mark the given constant as unloadable. Unloadable constants are removed each
-  # time dependencies are cleared.
-  #
-  # Note that marking a constant for unloading need only be done once. Setup
-  # or init scripts may list each unloadable constant that may need unloading;
-  # each constant will be removed for every subsequent clear, as opposed to for
-  # the first clear.
-  #
-  # The provided constant descriptor may be a (non-anonymous) module or class,
-  # or a qualified constant name as a string or symbol.
-  #
-  # Returns true if the constant was not previously marked for unloading, false
-  # otherwise.
-  def unloadable(const_desc)
-    ActiveSupport::Dependencies.mark_for_unload const_desc
-  end
-end
-
-# Add file-blaming to exceptions
-class Exception #:nodoc:
-  def blame_file!(file)
-    (@blamed_files ||= []).unshift file
-  end
-
-  def blamed_files
-    @blamed_files ||= []
-  end
-
-  def describe_blame
-    return nil if blamed_files.empty?
-    "This error occurred while loading the following files:\n   #{blamed_files.join "\n   "}"
-  end
-
-  def copy_blame!(exc)
-    @blamed_files = exc.blamed_files.clone
-    self
-  end
-end
+ActiveSupport::Dependencies.hook!