Execute method like before_filter in Rails

Question

I try to write a metaprogramming for execute a method before 'master' method. Why ? Because, I have several class and it's ugly to repeat the call in the head of the method

Case :

class MyClass
  include MySuperModule
  before :method, call: before_method

  def before_method
    puts "Before.."
  end
end

class SomeClass < MyClass
  def method
    puts "Method.."
  end
end

module MySuperModule
  # the awesome code
end

Output :

SomeClass.new.method => "Before.. Method.."

So, I try write a module with ClassMethodsor method_missingwithout success.

You mean every time, when you would call `method`, before that `before_method` should be called... Am I right ? — Arup Rakshit, May 15 '14 at 13:39
possible duplicate of [Is it possible to do a before\_action in Ruby (like in Rails)?](http://stackoverflow.com/questions/23444964/is-it-possible-to-do-a-before-action-in-ruby-like-in-rails) — Uri Agassi, May 15 '14 at 13:48
Try this - http://nicksda.apotomo.de/2010/09/hooks-and-callbacks-for-ruby-but-simple/ — Arup Rakshit, May 15 '14 at 13:51
@UriAgassi thanks, I have passed all my day to try and search a elegante answer about my case, without success. I have a already used in other context, ActiveSupport::Callbacks. — hypee, May 15 '14 at 13:51

Max · Accepted Answer · 2014-05-15T14:38:21.477

You don't need a gem for simple metaprogramming like this. What you can do is redefine the "after" method to call the "before" method and then the original "after" method.

This works even when using before multiple times on the same method or when creating a chain of before calls.

module MySuperModule
  def before meth, opts
    old_method = instance_method(meth)
    define_method(meth) do
      send opts[:call]
      old_method.bind(self).call
    end
  end
end

class MyClass
  extend MySuperModule

  def foo
    puts "foo"
  end

  def bar
    puts "bar"
  end

  def baz
    puts "baz"
  end

  before :foo, call: :bar
  before :bar, call: :baz
end

MyClass.new.foo
# baz
# bar
# foo

mdesantis · Answer 2 · 2014-05-15T14:55:54.370

1

If it is just for subclassing purposes you can take advantage of Module#prepend:

class Superclass
  def self.inherited(subclass)
    # subclass.send :prepend, Module.new { on Ruby < 2.1
    subclass.prepend Module.new {
      def method
        before_method
        super
      end
    }
  end

  def before_method
    puts 'Before'
  end
end

class Subclass < Superclass
  def method
    puts 'Method'
  end
end

Subclass.new.method
#=> Before
#=> Method

edited May 15 '14 at 14:55

answered May 15 '14 at 14:22

mdesantis

8,257
4
31
63

I get: tryit.rb:3:in `inherited': private method `prepend' called for Subclass:Class (NoMethodError) – John C May 15 '14 at 14:44
ruby 2.0.0p0 (2013-02-24 revision 39474) [x86_64-darwin12.2.1] @Threeve – John C May 15 '14 at 14:53
2

`prepend` is declared `private` on Ruby 2.0; I use 2.1.1 and it works. I'll update the answer. Thanks – mdesantis May 15 '14 at 14:54
@mdesantis I try your answer, it works but I prefer the Max proposition, thank you for your attention ! – hypee May 15 '14 at 15:49

score 0 · Answer 3 · answered May 15 '14 at 13:49

0

What you are looking for is Aspect oriented programming support for ruby. There are several gems implementing this, like aquarium.

answered May 15 '14 at 13:49

Uri Agassi

36,848
14
76
93

score 0 · Answer 4 · answered May 15 '14 at 14:27

Another way to do this is to use the rcapture gem. It is pretty awesome.

Eg:

require 'rcapture'
class A
  # Makes the class intercept able
  include RCapture::Interceptable
  def first
    puts 'first'
  end
  def second
    puts 'second'
  end
end

# injects methods to be called before each specified instance method.
A.capture_pre :methods => [:first, :second] do
  puts "hello"
end

n = A.new
n.first
n.second

produces:

hello
first
hello
second

Arnaldo Ignacio Gaspar Véjar · Answer 5 · 2014-05-15T15:35:25.833

0

Maybe you can use a decorator. In ruby there is a nice gem called 'drapeer'. See Drapper Link

edited May 15 '14 at 15:35

answered May 15 '14 at 15:11

Arnaldo Ignacio Gaspar Véjar

1,277
9
17

Thanks for the proposition, I know this gem, and I already use it ;), in the context, in the context, it's not appropriate. – hypee May 15 '14 at 15:39
Oh, sorry about that, i thought that could be an alternative. The @max solution (+1) is very simple and solid than the whole load of a gem. – Arnaldo Ignacio Gaspar Véjar May 15 '14 at 16:22

alkalinecoffee · Answer 6 · 2014-05-15T14:58:00.337

Every call in ruby runs through set_trace_func so you can hook into that and call exactly what you want. Not the prettiest solution and there are better ways but it does work. Another option is the Hooks gem, though I haven't tried it myself, it looks like it should give you the ability to do what you want.

module MySuperModule
  # the awesome code
end

class MyClass
  include MySuperModule

  def before_method
    puts "Before.."
  end
end

class SomeClass < MyClass
  def method
    puts "Method.."
  end
end

set_trace_func proc { |event, file, line, id, binding, class_name|
  if event == "call" && class_name == SomeClass && id == :method
    caller = binding.eval("self")
    caller.send(:before_method)
  end
}

SomeClass.new.method
  #=> Before..
  #=> Method..

Execute method like before_filter in Rails

6 Answers6