/usr/lib/ruby/vendor_ruby/glib2/deprecatable.rb is in ruby-glib2 2.2.5-4build1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
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 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 | module GLib
module Deprecatable
unless respond_to?(:define_singleton_method)
def define_singleton_method(name, &block)
singleton_class = class << self; self; end
singleton_class.__send__(:define_method, name, &block)
end
end
@@deprecated_const = {}
def define_deprecated_const(deprecated_const, new_const = {})
@@deprecated_const[self] ||= {}
@@deprecated_const[self][deprecated_const.to_sym] = new_const
end
def define_deprecated_enums(enums, prefix = nil)
enums = module_eval(enums.to_s) rescue return
enums.constants.each do |const|
deprecated_const = prefix ? "#{prefix}_#{const}" : const
new_const = [enums, const].join('::')
define_deprecated_const(deprecated_const, new_const)
end
end
alias :define_deprecated_flags :define_deprecated_enums
def define_deprecated_singleton_method(deprecated_method, new_method = {}, &block)
__define_deprecated_method__(:singleton, deprecated_method, new_method, &block)
end
def define_deprecated_method(deprecated_method, new_method = {}, &block)
__define_deprecated_method__(:instance, deprecated_method, new_method, &block)
end
def define_deprecated_method_by_hash_args(deprecated_method, old_args, new_args, req_argc = 0, &block)
klass = self
alias_name = "__deprecatable_#{deprecated_method}__"
alias_method alias_name, deprecated_method
private alias_name
define_method(deprecated_method) do |*margs, &mblock|
if (margs.size == req_argc) || (margs.size == (req_argc + 1) && margs.last.is_a?(Hash))
else
margs = block.call(self, *margs, &mblock)
msg = "#{caller[0]}: '#{klass}##{deprecated_method}(#{old_args})' style has been deprecated."
warn "#{msg} Use '#{klass}##{deprecated_method}(#{new_args})' style."
end
__send__(alias_name, *margs, &mblock)
end
end
@@deprecated_signal = {}
def define_deprecated_signal(deprecated_signal, new_signal = {})
@@deprecated_signal[self] ||= {}
@@deprecated_signal[self][deprecated_signal.to_s.gsub('_', '-').to_sym] = new_signal
end
def self.extended(class_or_module)
GLib::Instantiatable.class_eval do
%w(signal_connect signal_connect_after).each do |connect_method|
alias_name = "__deprecatable_#{connect_method}__"
next if private_method_defined?(alias_name)
alias_method alias_name, connect_method
private alias_name
define_method(connect_method) do |signal, *margs, &mblock|
signal = signal.to_s.gsub('_', '-').to_sym
signals = @@deprecated_signal[self]
if new_signal = (signals || {})[signal]
msg = "#{caller[0]}: '#{signal}' signal has been deprecated."
case new_signal
when String, Symbol
warn "#{msg} Use '#{new_signal}' signal."
signal = new_signal
when Hash
if new_signal[:raise]
raise DeprecatedError.new("#{msg} #{new_signal[:raise]}")
elsif new_signal[:warn]
warn "#{msg} #{new_signal[:warn]}"
else
warn "#{msg} Don't use this signal anymore."
end
return
end
end
__send__(alias_name, signal, *margs, &mblock)
end
end
end
end
private
def const_missing(deprecated_const)
new_const = (@@deprecated_const[self] || {})[deprecated_const.to_sym]
if new_const.nil?
return super
end
msg = "#{caller[0]}: '#{[name, deprecated_const].join('::')}' has been deprecated."
case new_const
when String, Symbol
new_const_val = constant_get(new_const)
case new_const_val
when GLib::Enum, GLib::Flags
alt = " or ':#{new_const_val.nick.gsub('-', '_')}'"
end
warn "#{msg} Use '#{new_const}'#{alt}."
return const_set(deprecated_const, new_const_val)
when Hash
if new_const[:raise]
raise DeprecatedError.new("#{msg} #{new_const[:raise]}")
elsif new_const[:warn]
warn "#{msg} #{new_const[:warn]}"
else
warn "#{msg} Don't use this constant anymore."
end
return
else
super
end
end
def constant_get(const)
const.split('::').inject(Object){|r, c| r.const_get(c)}
end
def __define_deprecated_method__(type, deprecated_method, new_method = {}, &block)
def_method = type == :singleton ? :define_singleton_method : :define_method
sep = type == :singleton ? '.' : '#'
klass = self
__send__(def_method, deprecated_method) do |*margs, &mblock|
msg = "#{caller[0]}: '#{klass}#{sep}#{deprecated_method}' has been deprecated."
case new_method
when String, Symbol
warn "#{msg} Use '#{klass}#{sep}#{new_method}'."
__send__(new_method, *margs, &mblock)
when Hash
if new_method[:raise]
raise DeprecatedError.new("#{msg} #{new_method[:raise]}")
elsif new_method[:warn]
warn "#{msg} #{new_method[:warn]}"
block.call(self, *margs, &mblock) if block
end
end
end
end
end
class DeprecatedError < RuntimeError
end
end
|