activesupport 4.2.0 → 5.0.0.1

data/lib/active_support/dependencies.rb

@@ -1,6 +1,6 @@
 require 'set'
 require 'thread'
-require 'thread_safe'
+require 'concurrent/map'
 require 'pathname'
 require 'active_support/core_ext/module/aliasing'
 require 'active_support/core_ext/module/attribute_accessors'
@@ -12,12 +12,40 @@ require 'active_support/core_ext/kernel/reporting'
 require 'active_support/core_ext/load_error'
 require 'active_support/core_ext/name_error'
 require 'active_support/core_ext/string/starts_ends_with'
+require "active_support/dependencies/interlock"
 require 'active_support/inflector'
 
 module ActiveSupport #:nodoc:
   module Dependencies #:nodoc:
     extend self
 
+    mattr_accessor :interlock
+    self.interlock = Interlock.new
+
+    # :doc:
+
+    # Execute the supplied block without interference from any
+    # concurrent loads.
+    def self.run_interlock
+      Dependencies.interlock.running { yield }
+    end
+
+    # Execute the supplied block while holding an exclusive lock,
+    # preventing any other thread from being inside a #run_interlock
+    # block at the same time.
+    def self.load_interlock
+      Dependencies.interlock.loading { yield }
+    end
+
+    # Execute the supplied block while holding an exclusive lock,
+    # preventing any other thread from being inside a #run_interlock
+    # block at the same time.
+    def self.unload_interlock
+      Dependencies.interlock.unloading { yield }
+    end
+
+    # :nodoc:
+
     # Should we turn on Ruby warnings on the first load of dependent files?
     mattr_accessor :warnings_on_first_load
     self.warnings_on_first_load = false
@@ -60,15 +88,6 @@ 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
-
     # 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
@@ -115,11 +134,11 @@ module ActiveSupport #:nodoc:
           next unless mod.is_a?(Module)
 
           # Get a list of the constants that were added
-          new_constants = mod.local_constants - original_constants
+          new_constants = mod.constants(false) - original_constants
 
-          # self[namespace] returns an Array of the constants that are being evaluated
+          # @stack[namespace] returns an Array of the constants that are being evaluated
           # for that namespace. For instance, if parent.rb requires child.rb, the first
-          # element of self[Object] will be an Array of the constants that were present
+          # element of @stack[Object] will be an Array of the constants that were present
           # before parent.rb was required. The second element will be an Array of the
           # constants that were present before child.rb was required.
           @stack[namespace].each do |namespace_constants|
@@ -128,7 +147,7 @@ module ActiveSupport #:nodoc:
 
           # Normalize the list of new constants, and add them to the list we will return
           new_constants.each do |suffix|
-            constants << ([namespace, suffix] - ["Object"]).join("::")
+            constants << ([namespace, suffix] - ["Object"]).join("::".freeze)
           end
         end
         constants
@@ -143,7 +162,7 @@ module ActiveSupport #:nodoc:
         @watching << namespaces.map do |namespace|
           module_name = Dependencies.to_constant_name(namespace)
           original_constants = Dependencies.qualified_const_defined?(module_name) ?
-            Inflector.constantize(module_name).local_constants : []
+            Inflector.constantize(module_name).constants(false) : []
 
           @stack[module_name] << original_constants
           module_name
@@ -234,7 +253,7 @@ module ActiveSupport #:nodoc:
       end
 
       def load_dependency(file)
-        if Dependencies.load? && ActiveSupport::Dependencies.constant_watch_stack.watching?
+        if Dependencies.load? && Dependencies.constant_watch_stack.watching?
           Dependencies.new_constants_in(Object) { yield }
         else
           yield
@@ -324,56 +343,58 @@ module ActiveSupport #:nodoc:
     end
 
     def clear
-      log_call
-      loaded.clear
-      loading.clear
-      remove_unloadable_constants!
+      Dependencies.unload_interlock do
+        loaded.clear
+        loading.clear
+        remove_unloadable_constants!
+      end
     end
 
     def require_or_load(file_name, const_path = nil)
-      log_call file_name, const_path
       file_name = $` if file_name =~ /\.rb\z/
       expanded = File.expand_path(file_name)
       return if loaded.include?(expanded)
 
-      # Record that we've seen this file *before* loading it to avoid an
-      # infinite loop with mutual dependencies.
-      loaded << expanded
-      loading << expanded
-
-      begin
-        if load?
-          log "loading #{file_name}"
+      Dependencies.load_interlock do
+        # Maybe it got loaded while we were waiting for our lock:
+        return if loaded.include?(expanded)
 
-          # Enable warnings if this file has not been loaded before and
-          # warnings_on_first_load is set.
-          load_args = ["#{file_name}.rb"]
-          load_args << const_path unless const_path.nil?
+        # Record that we've seen this file *before* loading it to avoid an
+        # infinite loop with mutual dependencies.
+        loaded << expanded
+        loading << expanded
 
-          if !warnings_on_first_load or history.include?(expanded)
-            result = load_file(*load_args)
+        begin
+          if load?
+            # Enable warnings if this file has not been loaded before and
+            # warnings_on_first_load is set.
+            load_args = ["#{file_name}.rb"]
+            load_args << const_path unless const_path.nil?
+
+            if !warnings_on_first_load or history.include?(expanded)
+              result = load_file(*load_args)
+            else
+              enable_warnings { result = load_file(*load_args) }
+            end
           else
-            enable_warnings { result = load_file(*load_args) }
+            result = require file_name
           end
-        else
-          log "requiring #{file_name}"
-          result = require file_name
+        rescue Exception
+          loaded.delete expanded
+          raise
+        ensure
+          loading.pop
         end
-      rescue Exception
-        loaded.delete expanded
-        raise
-      ensure
-        loading.pop
-      end
 
-      # Record history *after* loading so first load gets warnings.
-      history << expanded
-      result
+        # Record history *after* loading so first load gets warnings.
+        history << expanded
+        result
+      end
     end
 
     # Is the provided constant path defined?
     def qualified_const_defined?(path)
-      Object.qualified_const_defined?(path.sub(/^::/, ''), false)
+      Object.const_defined?(path, false)
     end
 
     # Given +path+, a filesystem path to a ruby file, return an array of
@@ -386,13 +407,13 @@ module ActiveSupport #:nodoc:
 
       bases.each do |root|
         expanded_root = File.expand_path(root)
-        next unless %r{\A#{Regexp.escape(expanded_root)}(/|\\)} =~ expanded_path
+        next unless expanded_path.start_with?(expanded_root)
 
-        nesting = expanded_path[(expanded_root.size)..-1]
-        nesting = nesting[1..-1] if nesting && nesting[0] == ?/
-        next if nesting.blank?
+        root_size = expanded_root.size
+        next if expanded_path[root_size] != ?/.freeze
 
-        paths << nesting.camelize
+        nesting = expanded_path[(root_size + 1)..-1]
+        paths << nesting.camelize unless nesting.blank?
       end
 
       paths.uniq!
@@ -401,7 +422,7 @@ module ActiveSupport #:nodoc:
 
     # Search for a file in autoload_paths matching the provided suffix.
     def search_for_file(path_suffix)
-      path_suffix = path_suffix.sub(/(\.rb)?$/, ".rb")
+      path_suffix = path_suffix.sub(/(\.rb)?$/, ".rb".freeze)
 
       autoload_paths.each do |root|
         path = File.join(root, path_suffix)
@@ -421,7 +442,7 @@ module ActiveSupport #:nodoc:
     end
 
     def load_once_path?(path)
-      # to_s works around a ruby1.9 issue where String#starts_with?(Pathname)
+      # to_s works around a ruby issue where String#starts_with?(Pathname)
       # will raise a TypeError: no implicit conversion of Pathname into String
       autoload_once_paths.any? { |base| path.starts_with? base.to_s }
     end
@@ -448,7 +469,6 @@ module ActiveSupport #:nodoc:
     # set of names that the file at +path+ may define. See
     # +loadable_constants_for_path+ for more details.
     def load_file(path, const_paths = loadable_constants_for_path(path))
-      log_call path, const_paths
       const_paths = [const_paths].compact unless const_paths.is_a? Array
       parent_paths = const_paths.collect { |const_path| const_path[/.*(?=::)/] || ::Object }
 
@@ -459,7 +479,6 @@ module ActiveSupport #:nodoc:
 
       autoloaded_constants.concat newly_defined_paths unless load_once_path?(path)
       autoloaded_constants.uniq!
-      log "loading #{path} defined #{newly_defined_paths * ', '}" unless newly_defined_paths.empty?
       result
     end
 
@@ -473,8 +492,6 @@ module ActiveSupport #:nodoc:
     # it is not possible to load the constant into from_mod, try its parent
     # module using +const_missing+.
     def load_missing_constant(from_mod, const_name)
-      log_call from_mod, const_name
-
       unless qualified_const_defined?(from_mod.name) && Inflector.constantize(from_mod.name).equal?(from_mod)
         raise ArgumentError, "A copy of #{from_mod} has been removed from the module tree but is still active!"
       end
@@ -486,7 +503,7 @@ module ActiveSupport #:nodoc:
 
       if file_path
         expanded = File.expand_path(file_path)
-        expanded.sub!(/\.rb\z/, '')
+        expanded.sub!(/\.rb\z/, ''.freeze)
 
         if loading.include?(expanded)
           raise "Circular dependency detected while autoloading constant #{qualified_name}"
@@ -550,7 +567,7 @@ module ActiveSupport #:nodoc:
 
     class ClassCache
       def initialize
-        @store = ThreadSafe::Cache.new
+        @store = Concurrent::Map.new
       end
 
       def empty?
@@ -607,7 +624,7 @@ module ActiveSupport #:nodoc:
     def autoloaded?(desc)
       return false if desc.is_a?(Module) && desc.anonymous?
       name = to_constant_name desc
-      return false unless qualified_const_defined? name
+      return false unless qualified_const_defined?(name)
       return autoloaded_constants.include?(name)
     end
 
@@ -638,25 +655,20 @@ module ActiveSupport #:nodoc:
     # exception, any new constants are regarded as being only partially defined
     # and will be removed immediately.
     def new_constants_in(*descs)
-      log_call(*descs)
-
       constant_watch_stack.watch_namespaces(descs)
-      aborting = true
+      success = false
 
       begin
         yield # Now yield to the code that is to define new constants.
-        aborting = false
+        success = true
       ensure
         new_constants = constant_watch_stack.new_constants
 
-        log "New constants: #{new_constants * ', '}"
-        return new_constants unless aborting
+        return new_constants if success
 
-        log "Error during loading, removing partially loaded constants "
-        new_constants.each { |c| remove_constant(c) }.clear
+        # Remove partially loaded constants.
+        new_constants.each { |c| remove_constant(c) }
       end
-
-      []
     end
 
     # Convert the provided const desc to a qualified constant name (as a string).
@@ -703,8 +715,6 @@ module ActiveSupport #:nodoc:
         parent = constantize(parent_name)
       end
 
-      log "removing constant #{const}"
-
       # In an autoloaded user.rb like this
       #
       #   autoload :Foo, 'foo'
@@ -725,7 +735,7 @@ module ActiveSupport #:nodoc:
         begin
           constantized = parent.const_get(to_remove, false)
         rescue NameError
-          log "the constant #{const} is not reachable anymore, skipping"
+          # The constant is no longer reachable, just skip it.
           return
         else
           constantized.before_remove_const if constantized.respond_to?(:before_remove_const)
@@ -735,27 +745,9 @@ module ActiveSupport #:nodoc:
       begin
         parent.instance_eval { remove_const to_remove }
       rescue NameError
-        log "the constant #{const} is not reachable anymore, skipping"
+        # The constant is no longer reachable, just skip it.
       end
     end
-
-    protected
-      def log_call(*args)
-        if log_activity?
-          arg_str = args.collect { |arg| arg.inspect } * ', '
-          /in `([a-z_\?\!]+)'/ =~ caller(1).first
-          selector = $1 || '<unknown>'
-          log "called #{selector}(#{arg_str})"
-        end
-      end
-
-      def log(msg)
-        logger.debug "Dependencies: #{msg}" if log_activity?
-      end
-
-      def log_activity?
-        logger && log_activity
-      end
   end
 end
 

data/lib/active_support/deprecation/behaviors.rb

@@ -1,6 +1,8 @@
 require "active_support/notifications"
 
 module ActiveSupport
+  # Raised when <tt>ActiveSupport::Deprecation::Behavior#behavior</tt> is set with <tt>:raise</tt>.
+  # You would set <tt>:raise</tt>, as a behaviour to raise errors and proactively report exceptions from deprecations.
   class DeprecationException < StandardError
   end
 
@@ -9,7 +11,7 @@ module ActiveSupport
     DEFAULT_BEHAVIORS = {
       raise: ->(message, callstack) {
         e = DeprecationException.new(message)
-        e.set_backtrace(callstack)
+        e.set_backtrace(callstack.map(&:to_s))
         raise e
       },
 
@@ -20,7 +22,7 @@ module ActiveSupport
 
       log: ->(message, callstack) {
         logger =
-            if defined?(Rails) && Rails.logger
+            if defined?(Rails.logger) && Rails.logger
               Rails.logger
             else
               require 'active_support/logger'
@@ -38,6 +40,18 @@ module ActiveSupport
       silence: ->(message, callstack) {},
     }
 
+    # Behavior module allows to determine how to display deprecation messages.
+    # You can create a custom behavior or set any from the +DEFAULT_BEHAVIORS+
+    # constant. Available behaviors are:
+    #
+    # [+raise+]   Raise <tt>ActiveSupport::DeprecationException</tt>.
+    # [+stderr+]  Log all deprecation warnings to +$stderr+.
+    # [+log+]     Log all deprecation warnings to +Rails.logger+.
+    # [+notify+]  Use +ActiveSupport::Notifications+ to notify +deprecation.rails+.
+    # [+silence+] Do nothing.
+    #
+    # Setting behaviors only affects deprecations that happen after boot time.
+    # For more information you can read the documentation of the +behavior=+ method.
     module Behavior
       # Whether to print a backtrace along with the warning.
       attr_accessor :debug

data/lib/active_support/deprecation/method_wrappers.rb

@@ -9,35 +9,61 @@ module ActiveSupport
       #   module Fred
       #     extend self
       #
-      #     def foo; end
-      #     def bar; end
-      #     def baz; end
+      #     def aaa; end
+      #     def bbb; end
+      #     def ccc; end
+      #     def ddd; end
+      #     def eee; end
       #   end
       #
-      #   ActiveSupport::Deprecation.deprecate_methods(Fred, :foo, bar: :qux, baz: 'use Bar#baz instead')
-      #   # => [:foo, :bar, :baz]
+      # Using the default deprecator:
+      #   ActiveSupport::Deprecation.deprecate_methods(Fred, :aaa, bbb: :zzz, ccc: 'use Bar#ccc instead')
+      #   # => [:aaa, :bbb, :ccc]
       #
-      #   Fred.foo
-      #   # => "DEPRECATION WARNING: foo is deprecated and will be removed from Rails 4.1."
+      #   Fred.aaa
+      #   # DEPRECATION WARNING: aaa is deprecated and will be removed from Rails 5.1. (called from irb_binding at (irb):10)
+      #   # => nil
       #
-      #   Fred.bar
-      #   # => "DEPRECATION WARNING: bar is deprecated and will be removed from Rails 4.1 (use qux instead)."
+      #   Fred.bbb
+      #   # DEPRECATION WARNING: bbb is deprecated and will be removed from Rails 5.1 (use zzz instead). (called from irb_binding at (irb):11)
+      #   # => nil
       #
-      #   Fred.baz
-      #   # => "DEPRECATION WARNING: baz is deprecated and will be removed from Rails 4.1 (use Bar#baz instead)."
+      #   Fred.ccc
+      #   # DEPRECATION WARNING: ccc is deprecated and will be removed from Rails 5.1 (use Bar#ccc instead). (called from irb_binding at (irb):12)
+      #   # => nil
+      #
+      # Passing in a custom deprecator:
+      #   custom_deprecator = ActiveSupport::Deprecation.new('next-release', 'MyGem')
+      #   ActiveSupport::Deprecation.deprecate_methods(Fred, ddd: :zzz, deprecator: custom_deprecator)
+      #   # => [:ddd]
+      #
+      #   Fred.ddd
+      #   DEPRECATION WARNING: ddd is deprecated and will be removed from MyGem next-release (use zzz instead). (called from irb_binding at (irb):15)
+      #   # => nil
+      #
+      # Using a custom deprecator directly:
+      #   custom_deprecator = ActiveSupport::Deprecation.new('next-release', 'MyGem')
+      #   custom_deprecator.deprecate_methods(Fred, eee: :zzz)
+      #   # => [:eee]
+      #
+      #   Fred.eee
+      #   DEPRECATION WARNING: eee is deprecated and will be removed from MyGem next-release (use zzz instead). (called from irb_binding at (irb):18)
+      #   # => nil
       def deprecate_methods(target_module, *method_names)
         options = method_names.extract_options!
-        deprecator = options.delete(:deprecator) || ActiveSupport::Deprecation.instance
+        deprecator = options.delete(:deprecator) || self
         method_names += options.keys
 
-        method_names.each do |method_name|
-          target_module.alias_method_chain(method_name, :deprecation) do |target, punctuation|
-            target_module.send(:define_method, "#{target}_with_deprecation#{punctuation}") do |*args, &block|
+        mod = Module.new do
+          method_names.each do |method_name|
+            define_method(method_name) do |*args, &block|
               deprecator.deprecation_warning(method_name, options[method_name])
-              send(:"#{target}_without_deprecation#{punctuation}", *args, &block)
+              super(*args, &block)
             end
           end
         end
+
+        target_module.prepend(mod)
       end
     end
   end

data/lib/active_support/deprecation/proxy_wrappers.rb

@@ -20,20 +20,22 @@ module ActiveSupport
 
       private
         def method_missing(called, *args, &block)
-          warn caller, called, args
+          warn caller_locations, called, args
           target.__send__(called, *args, &block)
         end
     end
 
-    # This DeprecatedObjectProxy transforms object to deprecated object.
+    # DeprecatedObjectProxy transforms an object into a deprecated one. It
+    # takes an object, a deprecation message and optionally a deprecator. The
+    # deprecator defaults to +ActiveSupport::Deprecator+ if none is specified.
     #
-    #   @old_object = DeprecatedObjectProxy.new(Object.new, "Don't use this object anymore!")
-    #   @old_object = DeprecatedObjectProxy.new(Object.new, "Don't use this object anymore!", deprecator_instance)
+    #   deprecated_object = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(Object.new, "This object is now deprecated")
+    #   # => #<Object:0x007fb9b34c34b0>
     #
-    # When someone executes any method except +inspect+ on proxy object this will
-    # trigger +warn+ method on +deprecator_instance+.
-    #
-    # Default deprecator is <tt>ActiveSupport::Deprecation</tt>
+    #   deprecated_object.to_s
+    #   DEPRECATION WARNING: This object is now deprecated.
+    #   (Backtrace)
+    #   # => "#<Object:0x007fb9b34c34b0>"
     class DeprecatedObjectProxy < DeprecationProxy
       def initialize(object, message, deprecator = ActiveSupport::Deprecation.instance)
         @object = object
@@ -51,13 +53,16 @@ module ActiveSupport
         end
     end
 
-    # This DeprecatedInstanceVariableProxy transforms instance variable to
-    # deprecated instance variable.
+    # DeprecatedInstanceVariableProxy transforms an instance variable into a
+    # deprecated one. It takes an instance of a class, a method on that class
+    # and an instance variable. It optionally takes a deprecator as the last
+    # argument. The deprecator defaults to +ActiveSupport::Deprecator+ if none
+    # is specified.
     #
     #   class Example
-    #     def initialize(deprecator)
-    #       @request = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :request, :@request, deprecator)
-    #       @_request = :a_request
+    #     def initialize
+    #       @request = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :request, :@request)
+    #       @_request = :special_request
     #     end
     #
     #     def request
@@ -69,12 +74,17 @@ module ActiveSupport
     #     end
     #   end
     #
-    # When someone execute any method on @request variable this will trigger
-    # +warn+ method on +deprecator_instance+ and will fetch <tt>@_request</tt>
-    # variable via +request+ method and execute the same method on non-proxy
-    # instance variable.
+    #   example = Example.new
+    #   # => #<Example:0x007fb9b31090b8 @_request=:special_request, @request=:special_request>
+    #
+    #   example.old_request.to_s
+    #   # => DEPRECATION WARNING: @request is deprecated! Call request.to_s instead of
+    #      @request.to_s
+    #      (Backtrace information…)
+    #      "special_request"
     #
-    # Default deprecator is <tt>ActiveSupport::Deprecation</tt>.
+    #   example.request.to_s
+    #   # => "special_request"
     class DeprecatedInstanceVariableProxy < DeprecationProxy
       def initialize(instance, method, var = "@#{method}", deprecator = ActiveSupport::Deprecation.instance)
         @instance = instance
@@ -93,15 +103,23 @@ module ActiveSupport
         end
     end
 
-    # This DeprecatedConstantProxy transforms constant to deprecated constant.
+    # DeprecatedConstantProxy transforms a constant into a deprecated one. It
+    # takes the names of an old (deprecated) constant and of a new constant
+    # (both in string form) and optionally a deprecator. The deprecator defaults
+    # to +ActiveSupport::Deprecator+ if none is specified. The deprecated constant
+    # now returns the value of the new one.
+    #
+    #   PLANETS = %w(mercury venus earth mars jupiter saturn uranus neptune pluto)
     #
-    #   OLD_CONST = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('OLD_CONST', 'NEW_CONST')
-    #   OLD_CONST = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('OLD_CONST', 'NEW_CONST', deprecator_instance)
+    #   (In a later update, the original implementation of `PLANETS` has been removed.)
     #
-    # When someone use old constant this will trigger +warn+ method on
-    # +deprecator_instance+.
+    #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
+    #   PLANETS = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('PLANETS', 'PLANETS_POST_2006')
     #
-    # Default deprecator is <tt>ActiveSupport::Deprecation</tt>.
+    #   PLANETS.map { |planet| planet.capitalize }
+    #   # => DEPRECATION WARNING: PLANETS is deprecated! Use PLANETS_POST_2006 instead.
+    #        (Backtrace information…)
+    #        ["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"]
     class DeprecatedConstantProxy < DeprecationProxy
       def initialize(old_const, new_const, deprecator = ActiveSupport::Deprecation.instance)
         @old_const = old_const
@@ -109,6 +127,11 @@ module ActiveSupport
         @deprecator = deprecator
       end
 
+      # Returns the class of the new constant.
+      #
+      #   PLANETS_POST_2006 = %w(mercury venus earth mars jupiter saturn uranus neptune)
+      #   PLANETS = ActiveSupport::Deprecation::DeprecatedConstantProxy.new('PLANETS', 'PLANETS_POST_2006')
+      #   PLANETS.class # => Array
       def class
         target.class
       end

data/lib/active_support/deprecation/reporting.rb

@@ -1,3 +1,5 @@
+require 'rbconfig'
+
 module ActiveSupport
   class Deprecation
     module Reporting
@@ -14,7 +16,7 @@ module ActiveSupport
       def warn(message = nil, callstack = nil)
         return if silenced
 
-        callstack ||= caller(2)
+        callstack ||= caller_locations(2)
         deprecation_message(callstack, message).tap do |m|
           behavior.each { |b| b.call(m, callstack) }
         end
@@ -37,7 +39,7 @@ module ActiveSupport
       end
 
       def deprecation_warning(deprecated_method_name, message = nil, caller_backtrace = nil)
-        caller_backtrace ||= caller(2)
+        caller_backtrace ||= caller_locations(2)
         deprecated_method_warning(deprecated_method_name, message).tap do |msg|
           warn(msg, caller_backtrace)
         end
@@ -63,7 +65,6 @@ module ActiveSupport
 
         def deprecation_message(callstack, message = nil)
           message ||= "You are using deprecated behavior which will be removed from the next major or minor release."
-          message += '.' unless message =~ /\.$/
           "DEPRECATION WARNING: #{message} #{deprecation_caller_message(callstack)}"
         end
 
@@ -79,8 +80,19 @@ module ActiveSupport
         end
 
         def extract_callstack(callstack)
-          rails_gem_root = File.expand_path("../../../../..", __FILE__) + "/"
-          offending_line = callstack.find { |line| !line.start_with?(rails_gem_root) } || callstack.first
+          return _extract_callstack(callstack) if callstack.first.is_a? String
+
+          offending_line = callstack.find { |frame|
+            frame.absolute_path && !ignored_callstack(frame.absolute_path)
+          } || callstack.first
+
+          [offending_line.path, offending_line.lineno, offending_line.label]
+        end
+
+        def _extract_callstack(callstack)
+          warn "Please pass `caller_locations` to the deprecation API" if $VERBOSE
+          offending_line = callstack.find { |line| !ignored_callstack(line) } || callstack.first
+
           if offending_line
             if md = offending_line.match(/^(.+?):(\d+)(?::in `(.*?)')?/)
               md.captures
@@ -89,6 +101,12 @@ module ActiveSupport
             end
           end
         end
+
+        RAILS_GEM_ROOT = File.expand_path("../../../../..", __FILE__) + "/"
+
+        def ignored_callstack(path)
+          path.start_with?(RAILS_GEM_ROOT) || path.start_with?(RbConfig::CONFIG['rubylibdir'])
+        end
     end
   end
 end