ruby-metaprogramming

Dynamic method definition in Ruby uses define_method to create methods at runtime based on conditions or data. This enables flexible APIs where methods are generated rather than hardcoded, useful for attribute accessors, DSLs, and adapters that need method coverage without explicit declarations.

method_missing intercepts calls to undefined methods, allowing you to handle them dynamically. Use it to create flexible interfaces, proxy objects, or catch typos; it powers ORMs and APIs that forward unknown methods to underlying data structures without pre-defining every accessor.

Reflection in Ruby lets you inspect object state, traverse class hierarchies, and modify behavior at runtime using methods like class, methods, instance_variables, and ancestors. This enables introspection-based frameworks, debugging tools, and metaprogramming that adapts code structure based on runtime discovery.

class_eval, instance_eval, and module_eval execute code blocks within a target context, giving access to its methods and variables. This powers macros, DSLs, and configuration blocks where code runs as if it were defined inside the target, enabling powerful compile-time customization.

Eigenclasses (singleton classes) hold methods unique to a single object or class. Define methods there to customize individual instances or add class methods without affecting the wider class hierarchy, useful for per-object behavior and advanced metaprogramming patterns.

Avoid metaprogramming when simpler patterns suffice—it reduces readability and debugging difficulty. Heavy use of method_missing, const_missing, and dynamic eval complicates static analysis and team onboarding; prefer explicit methods unless runtime flexibility or scale genuinely demands it.