O que é metaprogramação em Ruby?

Question

Accepted Answer

**Metaprogramação** é escrever código que **escreve ou modifica código em tempo de execução** — definindo métodos dinamicamente, respondendo a métodos indefinidos e inspecionando/alterando classes instantaneamente. A natureza dinâmica do Ruby (tudo é um objeto, incluindo classes) torna-o excepcionalmente bom em metaprogramação, o que potencia muito da "mágica" do Rails.

## Definindo métodos dinamicamente

```ruby
class Product
  # define methods programmatically at runtime
  [:name, :price, :sku].each do |attribute|
    define_method(attribute) do            # creates a getter method for each
      instance_variable_get("@#{attribute}")
    end
    define_method("#{attribute}=") do |value|   # and a setter
      instance_variable_set("@#{attribute}", value)
    end
  end
end
# → Product now has name/name=, price/price=, sku/sku= — generated, not hand-written
```

`define_method` cria métodos em tempo de execução — aqui gerando acessadores em um loop em vez de escrever cada um manualmente. (Isto é essencialmente como `attr_accessor` funciona internamente.)

## method_missing — manipular chamadas de método indefinido

```ruby
class DynamicConfig
  def initialize = @settings = {}

def method_missing(name, *args)         # called when an UNDEFINED method is invoked
    name_str = name.to_s
    if name_str.end_with?("=")            # a setter like config.timeout = 30
      @settings[name_str.chomp("=")] = args.first
    else                                  # a getter like config.timeout
      @settings[name_str]
    end
  end
  def respond_to_missing?(name, include_private = false) = true
end

config = DynamicConfig.new
config.timeout = 30      # no `timeout=` method defined → method_missing handles it
config.timeout           # 30 — also via method_missing
```

**`method_missing`** intercepta chamadas a métodos indefinidos — habilitando APIs dinâmicas onde métodos não precisam ser definidos explicitamente (usado extensivamente no Rails, ex. buscadores dinâmicos).

## Outras ferramentas de metaprogramação

```ruby
obj.send(:method_name, args)        # call a method by name (even private)
obj.respond_to?(:method_name)        # check if a method exists
Object.const_get("ClassName")        # get a class by name string
self.class.instance_methods          # introspect methods
user.define_singleton_method(:special) { ... }   # add a method to one object
```

## Por que isso importa

Metaprogramação é um dos recursos mais poderosos e distintos do Ruby, e compreendê-lo é valioso tanto para desenvolvimento Ruby avançado quanto — especialmente — para compreender como **Rails e outros frameworks Ruby alcançam sua "mágica".** A habilidade excepcional de metaprogramação do Ruby (habilitada por sua natureza dinâmica onde tudo, incluindo classes, é um objeto que pode ser manipulado em tempo de execução) permite que o código escreva e modifique código instantaneamente: **`define_method`** gera métodos dinamicamente (evitando código repetitivo escrito à mão — é como `attr_accessor` e atributos dinâmicos do Rails funcionam), e **`method_missing`** intercepta chamadas de método indefinido (habilitando APIs dinâmicas flexíveis — o mecanismo por trás de buscadores dinâmicos do Rails como `find_by_name`, métodos de atributos do ActiveRecord e muito mais).

Compreender essas técnicas desmistifica como frameworks como Rails fornecem suas APIs aparentemente mágicas e concisas (onde métodos que você nunca definiu explicitamente apenas funcionam), o que é importante tanto para usar esses frameworks efetivamente quanto para construir suas próprias APIs flexíveis, semelhantes a DSL e bibliotecas.

Conhecer as ferramentas de metaprogramação (`define_method`, `method_missing`/`respond_to_missing?`, `send`, `const_get`, introspecção) reflete conhecimento avançado de Ruby.

Embora poderosa, metaprogramação deve ser usada criteriosamente (pode tornar o código mais difícil de acompanhar, depurar e analisar estaticamente — o trade-off por sua flexibilidade).

Compreender metaprogramação — o que é (código que manipula código em tempo de execução), as técnicas-chave e que potencia a mágica do Rails — é conhecimento valioso de nível sênior que explica como funcionam os frameworks Ruby que você usa, permite criação avançada de metaprogramação e DSL, e é uma marca registrada de expertise profunda em Ruby e um tópico comum em entrevistas avançadas que distingue desenvolvedores que realmente entendem as capacidades dinâmicas do Ruby.