¿Qué es la metaprogramación en Ruby?

Question

Accepted Answer

**Metaprogramación** es escribir código que **escribe o modifica código en tiempo de ejecución** — definiendo métodos dinámicamente, respondiendo a métodos indefinidos, e inspeccionando/alterando clases sobre la marcha. La naturaleza dinámica de Ruby (todo es un objeto, incluyendo clases) lo hace excepcionalmente bueno en metaprogramación, que es lo que potencia mucha de la "magia" de Rails.

## Definiendo métodos dinámicamente

```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` crea métodos en tiempo de ejecución — aquí generando accessores en un bucle en lugar de escribir cada uno manualmente. (Esto es esencialmente cómo funciona `attr_accessor` internamente.)

## method_missing — manejar llamadas a métodos indefinidos

```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 llamadas a métodos indefinidos — habilitando APIs dinámicas donde los métodos no necesitan ser definidos explícitamente (utilizado ampliamente en Rails, por ejemplo buscadores dinámicos).

## Otras herramientas de metaprogramación

```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 qué es importante

La metaprogramación es una de las características más poderosas y distintivas de Ruby, y comprenderla es valiosa tanto para el desarrollo avanzado de Ruby como — especialmente — para comprender cómo **Rails y otros frameworks de Ruby logran su "magia".** La excepcional capacidad de metaprogramación de Ruby (habilitada por su naturaleza dinámica donde todo, incluyendo clases, es un objeto que puede ser manipulado en tiempo de ejecución) permite que el código escriba y modifique código sobre la marcha: **`define_method`** genera métodos dinámicamente (evitando código repetitivo escrito manualmente — es cómo funcionan `attr_accessor` y los atributos dinámicos de Rails), y **`method_missing`** intercepta llamadas a métodos indefinidos (habilitando APIs dinámicas flexibles — el mecanismo detrás de los buscadores dinámicos de Rails como `find_by_name`, los métodos de atributos de ActiveRecord, y mucho más).

Entender estas técnicas desmitifica cómo frameworks como Rails proporcionan sus APIs aparentemente mágicas y concisas (donde métodos que nunca definiste explícitamente simplemente funcionan), lo cual es importante tanto para usar estos frameworks efectivamente como para construir tus propias APIs flexibles y similares a DSLs y librerías.

Conocer las herramientas de metaprogramación (`define_method`, `method_missing`/`respond_to_missing?`, `send`, `const_get`, introspection) refleja conocimiento avanzado de Ruby.

Aunque poderosa, la metaprogramación debe usarse juiciosamente (puede hacer que el código sea más difícil de seguir, depurar, y analizar estáticamente — el compromiso por su flexibilidad).

Entender la metaprogramación — qué es (código que manipula código en tiempo de ejecución), las técnicas clave, y que potencia la magia de Rails — es conocimiento valioso de nivel senior que explica cómo funcionan los frameworks de Ruby que usas, habilita la metaprogramación avanzada y la creación de DSLs, y es un distintivo de experiencia profunda en Ruby y un tema de entrevista avanzada común que distingue a desarrolladores que realmente entienden las capacidades dinámicas de Ruby.