call super based __callee__ value - ruby-on-rails

Question

Method super calls parent method based on __method__.
How to call parent method based on __callee__?
class SomeLogic
DICTIONARY = {
new_method_1: 'dictionary value 1',
new_method_2: 'dictionary value 2'
}
def initialize(method_name)
#method_name = method_name
end
def call
DICTIONARY[#method_name]
end
end
module M
extend ActiveSupport::Concern
def base_method
logic = SomeLogic.new(__callee__).call
if logic
logic
elsif defined?(__callee__)
super # here analogue of super needed
else
{}
end
end
alias_method :new_method_1, :base_method
alias_method :new_method_2, :base_method
alias_method :new_method_3, :base_method
end
class A
prepend M
def new_method_3
'foo'
end
end
Expected results:
A.new.new_method_1 # dictionary value 1
A.new.new_method_2 # dictionary value 2
A.new.new_method_3 # foo
Current results:
A.new.new_method_1 # dictionary value 1
A.new.new_method_2 # dictionary value 2
A.new.new_method_3 # no superclass method `base_method' for A

Answer 1

If you change
class A
prepend M
to
class A
include M
you will get the desired output

Answer 2

Okay so this is extremely convoluted but it will work as requested
class SomeLogic
DICTIONARY = {
new_method_1: 'dictionary value 1',
new_method_2: 'dictionary value 2'
}
def initialize(method_name)
#method_name = method_name
end
def call
DICTIONARY[#method_name]
end
end
module M
def self.prepended(base)
base.extend(ClassMethods)
end
def base_method(&block)
SomeLogic.new(__callee__).call ||
block&.call || # ruby < 2.3 block && block.call
{}
end
module ClassMethods
def method_added(method_name)
if M.instance_methods.include?(method_name)
orig = M.instance_method(method_name)
M.remove_method(method_name)
new = self.instance_method(method_name)
self.prepend(Module.new do
define_method(method_name) do
result = orig.bind(self).call(&new.bind(self))
end
end)
M.define_method(method_name, &orig.bind(M))
end
end
end
alias_method :new_method_1, :base_method
alias_method :new_method_2, :base_method
alias_method :new_method_3, :base_method
alias_method :new_method_4, :base_method
end
class A
prepend M
def new_method_3
'foo'
end
end
class B
prepend M
end
So when you define a new method we check to see if that method is already defined by M. If so then we capture that UnboundMethod remove the method from M, then we capture the new definition as an UnboundMethod then define the new method in an anonymous Module as Ms implementation passing the new method implementation as a proc to Ms implementation and prepend this module to the defining Class, then we place Ms implementation back into M so other classes still work.
Result:
p A.new.new_method_1
#=> 'dictionary value 1'
p A.new.new_method_2
#=> 'dictionary value 2'
p A.new.new_method_3
#=> 'foo'
p A.new.new_method_4
#=> {}
p B.new.new_method_3
#=> {}
If you would prefer include over prepend then M could look like
module M
def self.included(base)
super
base.extend(ClassMethods)
end
def base_method
if logic = SomeLogic.new(__callee__).call
logic
elsif self.class.instance_methods(false).include?(__callee__)
send(__callee__,true)
else
{}
end
end
module ClassMethods
def method_added(method_name)
return if #_adding_method # avoid stack level issues
if M.instance_methods.include?(method_name)
new = instance_method(method_name)
#_adding_method = true # avoid stack level issues
define_method(method_name) do |bypass_parent=false|
return super() unless bypass_parent
new.bind(self).call
end
#_adding_method = false
end
end
end
end