In Ruby, what's the best way to execute a block around a child method?

Question

I have a parent class:

class Base
  def my_method
    block_method do
      # EXECUTE WHATEVER'S IN THE CHILD VERSION OF my_method
      # HOW TO DO?
    end
  end

  def block_method
    original_foo = 'foo'
    foo = 'CUSTOM FOO'

    yield

    foo = original_foo
  end
end

and some child classes--currently five and there will be more:

class ChildA < Base
  def my_method
    puts 'apple'
    puts 'aardvark'
  end
end

class ChildE < Base
  def my_method
    puts 'eel'
    puts 'elephant'
  end
end

I want to change what a variable refers to just for the duration of each Child's #my_method.

My thought is to do this by wrapping the functionality of each Child's #my_method in a block. But I'd rather do that in the parent class than have to wrap each child class's #my_method in the exact same block.

Any insights on how I can do this?

If there's some opposite of super, I guess that would be one way to accomplish what I want to do.

Answer 1

You could give the idea of what you are calling "some opposite of super" using a module and prepend like so:

module MethodThing
  # added to remove binding from class since 
  # #my_method relies on the existence of #foo and #foo=
  def self.prepended(base)
    base.attr_reader(:foo) unless base.method_defined?(:foo)
    base.attr_writer(:foo) unless base.method_defined?(:foo=)
  end
  def my_method
    puts "Before: #{foo}"
    original_foo = foo
    self.foo= 'CUSTOM FOO'
    begin
      super
    rescue NoMethodError
      warn "(skipped) #{self.class}##{__method__} not defined"
    end
    self.foo = original_foo
    puts "After: #{foo}"
  end
end

Prepend the module on inheritance

class Base 
  def self.inherited(child)
    child.prepend(MethodThing)
  end

  attr_accessor :foo 
  def initialize
    @foo = 12
  end
end


class ChildA < Base
  def my_method
      puts 'apple'
      puts "During: #{foo}"
      puts 'aardvark'
  end
end

class ChildE < Base
end

Output:

ChildA.new.my_method
# Before: 12
# apple
# During: CUSTOM FOO
# aardvark
# After: 12
ChildE.new.my_method
# Before: 12
# (skipped) ChildE#my_method not defined
# After: 12

There are other strange ways to accomplish this with inheritance as well such as

class Base
 class << self
   attr_accessor :delegate_my_method
   def method_added(method_name)
     if method_name.to_s == "my_method" && self.name != "Base"
       warn "#{self.name}#my_method has been overwritten use delegate_my_method instead" 
     end
   end
 end
 attr_accessor :foo       

 def my_method
   puts "Before: #{foo}"
    original_foo = foo
    self.foo= 'CUSTOM FOO'
    begin
      method(self.class.delegate_my_method.to_s).()
    rescue NameError, TypeError
      warn "(skipped) #{self.class} method delegation not defined"
    end
    self.foo = original_foo
    puts "After: #{foo}"
 end
end

class ChildA < Base
  self.delegate_my_method = :delegation_method

  def delegation_method
    puts 'apple'
    puts "During: #{foo}"
    puts 'aardvark'
  end
end 

I could probably keep going with stranger and stranger ways to solve this problem but I think these will get you where you need to go.

Answer 2

One option would be to define a private or nodoc method which the parent class can call and is defined in each of the children.

class Parent
  def my_method
    block_method do
      my_method_behavior
    end
  end

  def block_method
    original_foo = @foo
    @foo = 'CUSTOM FOO'

    yield

    @foo = original_foo
  end
end

class Child1 < Parent
  def my_method_behavior
    puts @foo
  end
end

class Child2 < Parent
  def my_method_behavior
    puts @foo
  end
end