Ruby'de metaprogramlama nedir?

Question

Accepted Answer

**Metaprogramlama**, **çalışma zamanında kodu yazan veya değiştiren kod** yazmaktır — dinamik olarak metodları tanımlama, tanımlanmamış metodlara yanıt verme ve sınıfları anında inceleme/değiştirme. Ruby'nin dinamik doğası (her şey bir nesnedir, sınıflar da dahil olmak üzere) onu metaprogramlama açısından istisnai kılar ve bu, Rails'in "magic"inin çoğunu güçlendirir.

## Metodları dinamik olarak tanımlama

```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` çalışma zamanında metodları oluşturur — burada her birini elle yazmak yerine bir döngüde accessor'ları oluşturur. (Bu temelde `attr_accessor`'ün içsel olarak nasıl çalıştığıdır.)

## method_missing — tanımlanmamış metod çağrılarını işleme

```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`** tanımlanmamış metodlara yapılan çağrıları keser — metodların açık olarak tanımlanmasına gerek duyulmayan dinamik API'ler etkinleştirir (Rails'te yoğun olarak kullanılır, örn. dinamik finder'lar).

## Diğer metaprogramlama araçları

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

## Neden önemli

Metaprogramlama, Ruby'nin en güçlü ve ayırt edici özelliklerinden biridir ve bunu anlamak hem ileri Ruby geliştirmesi hem de — özellikle — **Rails ve diğer Ruby framework'lerinin "magic"ini nasıl başardıklarını** anlamak için değerlidir. Ruby'nin istisnai metaprogramlama yeteneği (dinamik doğasından kaynaklanır; burada her şey, sınıflar da dahil olmak üzere, çalışma zamanında manipüle edilebilen bir nesnedir) kodun anında kod yazmasını ve değiştirmesini sağlar: **`define_method`** metodları dinamik olarak oluşturur (tekrarlayan elle yazılan koddan kaçınır — `attr_accessor` ve Rails'in dinamik öznitelikleri nasıl çalışır), ve **`method_missing`** tanımlanmamış metod çağrılarını keser (esnek dinamik API'ler etkinleştirir — Rails'in `find_by_name` gibi dinamik finder'larının, ActiveRecord öznitelik metodlarının ve çoğu şeyin mekanizması).

Bu teknikler, Rails gibi framework'lerin görünürde sihirli, kısa API'ler sunmasını nasıl sağladığını anlamlandırır (hiçbir zaman açık olarak tanımlamadığınız metodlar çalışır), bu da hem bu framework'leri etkili bir şekilde kullanmak hem de kendi esnek, DSL benzeri API'ler ve kütüphaneler oluşturmak için önemlidir.

Metaprogramlama araçlarını bilmek (`define_method`, `method_missing`/`respond_to_missing?`, `send`, `const_get`, introspection) ileri Ruby bilgisini yansıtır.

Güçlü olmakla beraber, metaprogramlama ihtiyatlı olarak kullanılmalıdır (kodu takip etmeyi, hata ayıklamayı ve statik analizi zorlaştırabilir — esnekliğinin karşılığı).

Metaprogramlamayı anlamak — nedir (çalışma zamanında kodu manipüle eden kod), ana teknikler ve Rails'in magic'ini güçlendirdiğini — kendi kullandığınız Ruby framework'lerinin nasıl çalıştığını açıklayan, ileri metaprogramlama ve DSL oluşturmayı etkinleştiren ve Ruby'nin dinamik yeteneklerini gerçekten anlayan ve sık sık ileri olan interview konusu olan geliştirici türünü ayırt eden derin Ruby uzmanlığının hallmark'ı olan değerli üst düzey bilgidir.