Undoing Alias Method Chaining

This is more of a quick rant on AliasMethodChain in Rails than a tutorial... Metaprogramming in Rails is powerful. It is a wonderful way to build onto a framework which itself is built on top of Ruby via metaprogramming. I've seen and heard many arguments describing metaprogramming as the root of all evil. The chaos that it can cause when not structured is a terrible thing to behold, certainly.

I won't say much about how we handle our system extensions at Groupon, except, that it is very structured with a centralized place to discover all of the extensions to Rails internals in a single place (expect a more formal description of our process later from our Team!). Also, the extension points that we chose to use have been the parts of Rails which are the least subject to change (and have demonstrated the greatest resiliency and consistency over the last 3-4 years of active development).

Anyway, this morning, I ran into one of the (very few) cases where testing truly required assertions at various points in an alias_method_chain stack. As you can imagine, if you are alias_method_chaining ActiveRecord::Base#find, for example, you'll most likely have architected your system in such a way, that every link in the chain is standard, unalterable behavior (we absolutely do not muck with #find, btw. It is already an atrocious method). For these cases, I employ this little hack...

ActiveSupport::CoreExtensions::Module.class_eval do
  def alias_method_chain_unlink(target, feature) 

    # Strip out punctuation on predicates or bang methods since
    # e.g. target?_without_feature is not a valid method name.
    aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
    yield(aliased_target, punctuation) if block_given?

    with_method, without_method = "#{aliased_target}_with_#{feature}#{punctuation}", "#{aliased_target}_without_#{feature}#{punctuation}"

    alias_method target, without_method

    case
    when public_method_defined?(without_method)
      public target
    when protected_method_defined?(without_method)
      protected target
    when private_method_defined?(without_method)
      private target
    end
  end
end

Notice its a natural inversion of 'alias_method_chain' implemention. This method would probably never fly with the core team, so it is merely a re-implementation/repurposing rather than an attempt to DRY the aliasing code.


As an example of what I'm talking about, imagine that you have this chain..

class User
  def cry
    puts "cry"
  end
end

User.new.cry
User.class_eval do
  def cry_with_emotion
    puts "WAH WAH WAH"
    
    cry_without_emotion
  end
  
  alias_method_chain :cry, :emotion
end

User.new.cry

Let us say that you want to alter the emotive nature of that extension in the same ruby session

User.class_eval do
  def cry_with_emotion # slightly less emotive
    puts "Wah Wah Wah"

    cry_without_emotion
  end
end

User.new.cry

User.class_eval do
  define_method :cry_with_emotion do
    puts "Wah Wah Wah"
  end
end
User.new.cry # no luck again eh??

As you can see, redefining an interstitial method does not automatically make it part of the chain! Try this on for size (after redefining your method).

User.class_eval do
  alias_method_chain_unlink :cry, :emotion

  alias_method_chain :cry, :emotion
end
User.new.cry

That works! If you can imagine it, this hack can serve to either allow you to remove something out of a long alias_method_chain, or, allow redefinition of chain link (for lack of a better term)! I might have more to say about metaprogramming in Ruby later, but for now, may this approach save someone as much time as it saved me!