Što je metaprogramiranje u Rubyu?

Question

Accepted Answer

**Metaprogramiranje** je pisanje koda koji **piše ili mijenja kod tijekom izvršavanja** — dinamičko definiranje metoda, reagiranje na nedefinisane metode, te inspekcija/alteracija klasa u letu. Dinamička priroda Rubyja (sve je objekt, uključujući klase) čini ga izuzetno dobrim za metaprogramiranje, što je osnova "magije" koja se koristi u Rails-u.

## Dinamičko definiranje metoda

```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` kreira metode tijekom izvršavanja — ovdje generira pristupnike u petlji umjesto rukom pisanja svake metode. (Ovo je u osnovi kako `attr_accessor` radi interno.)

## method_missing — rukovanje nedefinisanim pozivima metoda

```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`** presreće pozive nedefinisanih metoda — omogućavajući dinamičke API-je gdje metode ne trebaju biti eksplicitno definirane (intenzivno korišteno u Rails-u, npr. dinamički pronalazi).

## Ostali alati za metaprogramiranje

```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
```

## Zašto je važno

Metaprogramiranje je jedna od najmoćnijih i najvećih karakteristika Rubyja, te razumijevanje toga je vrijedno kako za napredni razvoj u Rubyu tako — posebno — za shvaćanje kako **Rails i ostali Ruby okviri postižu svoju "magiju".** Izuzetna sposobnost metaprogramiranja u Rubyu (omogućena njegovom dinamičkom prirodom gdje je sve, uključujući klase, objekt koji se može manipulirati tijekom izvršavanja) dozvoljava da kod piše i mijenja kod u letu: **`define_method`** dinamički generira metode (izbjegavajući repetitivni ručno napisan kod — način na koji `attr_accessor` i Rails-ovi dinamički atributi funkcioniraju), a **`method_missing`** presreće nedefinisane pozive metoda (omogućavajući fleksibilne dinamičke API-je — mehanizam iza Rails-ovih dinamičkih pronalaza poput `find_by_name`, ActiveRecord metoda atributa, i mnogo više).

Razumijevanje ovih tehnika demistificira kako okviri poput Rails-a pružaju njihove naizgled magične, sažete API-je (gdje metode koje nikada eksplicitno niste definirali jednostavno rade), što je važno kako za učinkovitu upotrebu ovih okvira tako i za izgradnju vlastitih fleksibilnih, DSL-sličnih API-ja i biblioteka.

Znanje alata za metaprogramiranje (`define_method`, `method_missing`/`respond_to_missing?`, `send`, `const_get`, introspekcija) odražava napredna znanja iz Rubyja.

Mada je moćna, metaprogramiranje bi trebalo koristiti razumno (može učiniti kod teže pratljivim, debuggirati i statički analizirati — kompromis za njegovu fleksibilnost).

Razumijevanje metaprogramiranja — što je to (kod koji manipulira kodom tijekom izvršavanja), ključne tehnike, te da napajanje Rails-ovu magiju — je vrijedna znanja seniorske razine koja objašnjava kako funkcioniraju Ruby okviri koje koristite, omogućava naprednu metaprogramiranje i kreiranje DSL-a, te je oznaka dubokog Ruby stručnjaka i česta tema naprednog intervjua koja razlikuje programere koji zaista razumiju dinamičke sposobnosti Rubyja.