Co je metaprogramování v Ruby?

Question

Accepted Answer

**Metaprogramování** je psaní kódu, který **píše nebo upravuje kód za běhu** — dynamické definování metod, reagování na nedefinované metody a zkoumání/úprava tříd za chodu. Dynamická povaha Ruby (vše je objekt, včetně tříd) jej činí mimořádně dobrým v metaprogramování, které pohání velkou část „magie“ Railsu.

## Dynamické definování metod

```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` vytváří metody za běhu — zde generuje přístupové metody ve smyčce místo psaní každé ručně. (V podstatě takto interně funguje `attr_accessor`.)

## method_missing — zpracování volání nedefinovaných metod

```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`** zachytává volání nedefinovaných metod — umožňuje dynamická API, kde metody nemusí být explicitně definovány (hojně využíváno v Railsu, např. dynamické vyhledávače).

## Další nástroje metaprogramová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
```

## Proč je to důležité

Metaprogramování je jednou z nejmocnějších a nejcharakterističtějších vlastností Ruby a jeho pochopení je cenné jak pro pokročilý vývoj v Ruby, tak — zejména — pro porozumění tomu, jak **Rails a další Ruby frameworky dosahují své „magie“.** Mimořádná schopnost metaprogramování v Ruby (umožněná jeho dynamickou povahou, kde vše, včetně tříd, je objekt, který lze za běhu manipulovat) umožňuje kódu psát a upravovat kód za chodu: **`define_method`** generuje metody dynamicky (vyhýbá se opakujícímu se ručně psanému kódu — takto funguje `attr_accessor` a dynamické atributy Railsu) a **`method_missing`** zachytává volání nedefinovaných metod (umožňuje flexibilní dynamická API — mechanismus stojící za dynamickými vyhledávači Railsu jako `find_by_name`, atributovými metodami ActiveRecordu a mnohem více).

Pochopení těchto technik odhaluje, jak frameworky jako Rails poskytují svá zdánlivě magická, stručná API (kde metody, které jste nikdy explicitně nedefinovali, prostě fungují), což je důležité jak pro efektivní používání těchto frameworků, tak pro vytváření vlastních flexibilních API a knihoven podobných DSL.

Znalost nástrojů metaprogramování (`define_method`, `method_missing`/`respond_to_missing?`, `send`, `const_get`, introspekce) odráží pokročilou znalost Ruby.

Ačkoli je metaprogramování mocné, mělo by se používat uvážlivě (může ztížit sledování, ladění a statickou analýzu kódu — to je cena za jeho flexibilitu).

Pochopení metaprogramování — co to je (kód, který manipuluje s kódem za běhu), klíčových technik a toho, že pohání magii Railsu — je cennou znalostí na seniorní úrovni, která vysvětluje, jak fungují Ruby frameworky, které používáte, umožňuje pokročilé metaprogramování a tvorbu DSL a je znakem hluboké odbornosti v Ruby a běžným pokročilým pohovorovým tématem, které odlišuje vývojáře, kteří skutečně rozumí dynamickým schopnostem Ruby.