Ruby é uma linguagem dinâmica e utiliza algumas caracteristicas interessantes para manipular objetos e classes no seu ciclo de vida em run-time, como por exemplo usar singleton methods em um objeto, realizar mixin, adicionar métodos em uma classe e outras coisas legais. Para capturar esse eventos que alteram o comportamento de classes, módulos e objetos, Ruby provê alguns Hooks.

O que seriam Hook propriamente dito(pergunta clássica no curso de metaprogramação)? Hooks são métodos com um nome específico para capturar um mudança no objeto. Esses hooks podem ser definidos por uma API ou mesmo pela a especificação da linguagem. Um exemplo de API que utilize hooks são os callbacks do ActiveRecord, como after_save, before_save, etc, esses métodos são invocados automaticamente após a chamada “save” do model como descrito na especificação.

Hooks da Linguagem Ruby

O intuito deste poste é falar sobre alguns hooks da linguagem Ruby, vamos iniciar capturando o evento de herança de uma classe, isso pode ser muito útil se sua super-classe precisa conhecer a subclass. Para esse hook funcionar temos que definir o método self.inherited na superclass. Exemplo

class A
  def self.inherited(subclass)
    puts "Eu #{self} sendo herdada por #{subclass}"
  end
end

class B < A
end

#=> "Eu A sendo herdada por B"

O conteúdo do método inherited é executado pelo interpretador no momento em que a sub classe é carregada na vm. Lembra do final public class A{} em java? Para quem nunca usou java o final public class é forma de não permitir que uma classe seja herdada por outra. Em ruby você pode simular esse comportamento lançando uma exceção dentro do self.inherited, veja:

class A
  def self.inherited(subclass)
    raise "A classe #{self} nao pode ser herdada!"
  end
end

class B < A
end 

#E=> RuntimeError: A classe A nao pode ser herdada!
 

self.included

O self.inherited é usado apenas para classes, se você precisar detectar mix-in entre módulos e classes, defina o método self.included dentro do módulo que será mixado. O exemplo abaixo demonstra como capturar o evento de mix-in(include):

module M
  def self.included(from)
    puts "#{self} foi mixado por #{from} "
  end
end

class A
  include M
end

Particularmente acho o self.included muito útil, com ele podemos adicionar funcionalidades durante o mix-in. Por exemplo, vamos criar um plugin chamado Printable, na verdade é só um módulo com um pouco de metaprogramação para detectar os accessor(setters e getters) e definir um novo método com o prefixo print_ para imprimir o retorno do método original, seria basicamente assim.

class Person
  attr_accessor :name, :code
end

p = Person.new
p.name ="Foobar"
p.print_name #ainda não existe

Vamos detectar os accessor, se um método tem dois métodos com o mesmo nome mas sendo um terminado com o operador de atribuição(=) então é um acessor.

Antes vamos criar a funcionalidade apenas para classe Person

class Person
  attr_accessor :name, :code
end

#pegando os métodos de instância
methods = Person.instance_methods false
#=> ["code", "name=", "code=", "name"]

#detectando quais deles são accessors
 acessors=methods.select{|m| methods.include? "#{m}=" }
#=> ["code", "name"]

#definindo os métodos na classe
acessors.each do |acessor|
  Person.send :define_method, "print_#{acessor}" do
    puts "Printing #{send(acessor)}..."
  end
end

#Testando
p = Person.new
p.name = "FFUUUU"
p.code = 44444
p.print_name  #=> Printing FFUUUU ...
p.print_code  #=> Printing 44444 ...

Perfeito! Agora vamos criar um módulo e utilizar o hook self.included, com isso, quando uma classe necessitar dessa funcionalidade é só fazer o include de Printable, veja

module Printable
  def self.included(klazz)
    methods = klazz.instance_methods false
    acessors=methods.select{|m| methods.include? "#{m}=" }
    acessors.each do |acessor|
      klazz.send :define_method, "print_#{acessor}" do
      puts "Printing #{send(acessor)}..."
    end
  end
end

Fazendo mix-in em Person e em OtherClass

class Person
  attr_accessor :name, :code
    include Printable
  end

class OtherClass
  attr_accessor :a, :b
  include Printable
end

Testando

p = Person.new
p.name = "FOO"
p.print_name

obj = OtherClass.new
obj.a = "Hey Everybody!"
obj.b = "It's working"
obj.print_a
obj.print_b

Output

Printing FOO...
Printing Hey Everybody!...
Printing It's working...

self.method_added

Se você leu esse post até aqui provavelmente você conhece o method_missing, aquele que captura a nome do método e os parâmetros caso o objeto não responda a esse método. Pois é, não falaremos do method_missing nesse post, vamos falar do primo dele, o self.method_addded. O self.method_added é um hook que captura o evento quando um método é adicionado ao objeto ou classe. Exemplo.

class Foo
  def self.method_added(method)
    puts "Adicionado o metodo #{method} na classe #{self}"
  end

  def testing
    puts "testing"
  end
end
 #=> "Adicionado o metodo testing na classe Foo"

Veja que na própria classe o evento é disparado. Em uma herança, o mesmo comportamento

class Foo
  def self.method_added(method)
    puts "Adicionado o metodo #{method} na classe #{self}"
  end
end

class Bar < Foo
  def other_method
    puts "say hello"
  end
end

#=> Adicionado o metodo other_method na classe Bar

Ou ainda, você pode capturar singleton methods com o mesmo hook.

class Foo
  def self.method_added(method)
    puts "Adicionado o metodo #{method} na classe #{self}"
  end
end

foo = Foo.new

def foo.new_method
  puts "hey I'm adding ..."
end

Object.const_missing

Sabemos que o method_missing captura o evento quando o método não existe, podemos ter uma funcionalidade semelhante para constantes, com o Object.const_missing. Sempre que uma constante não for encontrada na vm, o const_missing recebe o nome da constante. Esse método deve ser definido em Object, dado que constantes o escopo é global. Veja

UmaConstante #E=> NameError: uninitialized constant UmaConstante

def Object.const_missing(const)
  puts "Hey nao encontrei #{const} mas nao vou lançar error"
end 

UmaConstante
#=> Hey nao encontrei UmaConstante mas nao vou lanar error

Embora isso seja uma coisa legal, se você apenas quer capturar o evento, uma boa prática é fazer a sua lógica usando a constante que está faltando e depois usar o super para lançar a exceção via Kernel. Portando algo como

UmaConstante #E=> NameError: uninitialized constant UmaConstante

def Object.const_missing(const)
  puts "Hey nao encontrei #{const} "
  super
end 

UmaConstante

#=> Hey nao encontrei UmaConstante
#=> NameError: uninitialized constant UmaConstante
#=>	 from (irb):119:in `const_missing'
#=>	 from (irb):122
#=>	 from :0

Se seu é convencionado utilizando o nome do arquivo em snake case e o nome da classe em camel, você pode fazer um plugin para carregar seus arquivos automaticamente caso a classe não esteja visível no trecho do seu código. Exemplo, no mesmo diretório 3 arquivos

Arquivo person.rb

class Person
  attr_accessor :name, :state
end

Arquivo state.rb

class State
  attr_accessor :code
end

Arquivo principal main.rb

p = Person.new
p.state = State.new

Rode com

ruby main.rb

De cara o erro

#E=> main.rb:1: uninitialized constant Person (NameError)

Pois não colocamos o requires necessários para cada arquivo.
Vamos fazer um algoritmo para carregar esses arquivos automaticamente usando Kernel.autoload.
Então no main.rb fica com o conteúdo:

def Object.const_missing(const)
  #convertendo CamelCase to snake_case
  filename = const.to_s.gsub(/([A-Z])/, ' \1').split(' ').join('_').downcase
  #Associando a constante ao nome do arquivo
  autoload const, filename
  #binding a nova constante
  Object.const_get const
end  

p = Person.new
p.state = State.new

Se você rodar novamente o main.rb vai funcionar.

Conclusão

No dia-a-dia e em projetos pequenos não é comum capturar eventos no nível de interpretação mas se você esta depurando um sistema ou mesmo desenvolvendo uma API, Hooks podem ser essenciais.