what is the difference between alias_method and alias_method_chain?

alias-method, alias-method-chain, ruby, ruby-on-rails, ruby-on-rails-3

Solution

`alias_method_chain` behaves different than `alias_method`

If you have method `do_something` and you want to override it, keeping the old method, you can do:

alias_method_chain :do_something, :something_else

which is equivalent to:

alias_method :do_something_without_something_else, :do_something
alias_method :do_something, :do_something_with_something_else

this allows us to easily override method, adding for example custom logging. Imagine a `Foo` class with `do_something` method, which we want to override. We can do:

class Foo
  def do_something_with_logging(*args, &block)
    result = do_something_without_logging(*args, &block)
    custom_log(result)
    result
  end
  alias_method_chain :do_something, :logging
end

So to have your job done, you can do:

class A
  def foo_with_another
    'another foo'
  end
  alias_method_chain :foo, :another
end
a = A.new
a.foo # => "another foo"
a.foo_without_another # => "original"

Since it isn't very complicated, you can also do it with plain `alias_method`:

class A
  def new_foo
    'another foo'
  end
  alias_method :old_foo, :foo
  alias_method :foo, :new_foo
end
a = A.new
a.foo # => "another foo"
a.old_foo # => "original"

For more information, you can refer documentation.

Problem

I was working on my web-application and I wanted to override a method for example if the original class is ``` class A def foo 'original' end end ``` I want to override foo method it can be done like this ``` class A alias_method :old_foo, :foo def foo old_foo + ' and another foo' end end ``` and I can call both old and new methods like this ``` obj = A.new obj.foo #=> 'original and another foo' obj.old_foo #=> 'original' ``` so what is the use of alias_method_chain if I can access and keep both methods like the way I did ?

Original source