Ruby reflection composition: call original method from redefined method - ruby

Question

A bit of context first
I have a class Phone that defines a method advertise like this:
class Phone
def advertise(phone_call)
'ringtone'
end
end
I would like to have some adaptations for this method.
For example when the user is in a quiet environment, the phone should vibrate and not ring.
To do so, I define modules like
module DiscreetPhone
def advertise_quietly (phone_call)
'vibrator'
end
end
Then my program can do
# add the module to the class so that we can redefine the method
Phone.include(DiscreetPhone)
# redefine the method with its adaptation
Phone.send(:define_method, :advertise, DiscreetPhone.instance_method(:advertise_quietly ))
Of course for this example I hardcoded the class and module's name but they should be parameters of a function.
And so, an execution example would give:
phone = Phone.new
phone.advertise(a_call) # -> 'ringtone'
# do some adaptation stuff to redefine the method
...
phone.advertise(a_call) # -> 'vibrator'
Finally coming to my question
I want to have an adaptation that call the original function and append something to its result. I would like to write it like
module ScreeningPhone
def advertise_with_screening (phone_call)
proceed + ' with screening'
end
end
But I don't know what the proceed call should do or even where should I define it.
I'm using Ruby 2.3.0 on Windows.
proceed could be replaced by something else but I'd like to keep it as clean as possible in the module that defines the adaptation.

Answer 1

You can do this by prepending your module instead of including it.
Instead of using define_method as a sort of ersatz alias_method, just call the method advertise in your modules too.
Within your advertise method, you can call super to call up the inheritance hierarchy.

Answer 2

In my opinion, this approach is way too complex, and an inappropriate use of Modules.
I recommend thinking about a simpler way to implement this.
One simple way is to just include all the methods in the Phone class.
Or, you could use a hash as a lookup table for ring strategies:
class Phone
attr_accessor :ring_strategy
RING_STRATEGIES = {
ringtone: -> { ring_with_tone },
discreet: -> { ring_quietly },
screening: -> { ring_with_tone; ring_screening_too }
# ...
}
def initialize(ring_strategy = :ringtone)
#ring_strategy = ring_strategy
end
def ring
RING_STRATEGIES[:ring_strategy].()
end
end