1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
|
# frozen_string_literal: true
module ActiveSupport
class Deprecation
module DeprecatedConstantAccessor
def self.included(base)
require "active_support/inflector/methods"
extension = Module.new do
def const_missing(missing_const_name)
if class_variable_defined?(:@@_deprecated_constants)
if (replacement = class_variable_get(:@@_deprecated_constants)[missing_const_name.to_s])
replacement[:deprecator].warn(replacement[:message] || "#{name}::#{missing_const_name} is deprecated! Use #{replacement[:new]} instead.", caller_locations)
return ActiveSupport::Inflector.constantize(replacement[:new].to_s)
end
end
super
end
# Provides a way to rename constants with a deprecation cycle in which
# both the old and new names work, but using the old one prints a
# deprecation message.
#
# In order to rename <tt>A::B</tt> to <tt>C::D</tt>, you need to delete the
# definition of <tt>A::B</tt> and declare the deprecation in +A+:
#
# require "active_support/deprecation"
#
# module A
# include ActiveSupport::Deprecation::DeprecatedConstantAccessor
#
# deprecate_constant "B", "C::D", deprecator: ActiveSupport::Deprecation.new
# end
#
# The first argument is a constant name (no colons). It is the name of
# the constant you want to deprecate in the enclosing class or module.
#
# The second argument is the constant path of the replacement. That
# has to be a full path even if the replacement is defined in the same
# namespace as the deprecated one was.
#
# In both cases, strings and symbols are supported.
#
# The +deprecator+ keyword argument is the object that will print the
# deprecation message, an instance of ActiveSupport::Deprecation.
#
# With that in place, references to <tt>A::B</tt> still work, they
# evaluate to <tt>C::D</tt> now, and trigger a deprecation warning:
#
# DEPRECATION WARNING: A::B is deprecated! Use C::D instead.
# (called from ...)
#
# The message can be customized with the optional +message+ keyword
# argument.
#
# For this to work, a +const_missing+ hook is installed. When client
# code references the deprecated constant, the callback prints the
# message and constantizes the replacement.
#
# Caveat: If the deprecated constant name is reachable in a different
# namespace and Ruby constant lookup finds it, the hook won't be
# called and the deprecation won't work as intended. This may happen,
# for example, if an ancestor of the enclosing namespace has a
# constant with the same name. This is an unsupported edge case.
def deprecate_constant(old_constant_name, new_constant_path, deprecator:, message: nil)
class_variable_set(:@@_deprecated_constants, {}) unless class_variable_defined?(:@@_deprecated_constants)
class_variable_get(:@@_deprecated_constants)[old_constant_name.to_s] = { new: new_constant_path, message: message, deprecator: deprecator }
end
end
base.singleton_class.prepend extension
end
end
end
end
|
