Metaprogramming Techniques

Writing class String again reopens the existing String class instead of creating one, so the def adds a method to String itself. Every string in the process, including older strings and strings inside gems, can then call it.

Pass the name as a Symbol or String to send or public_send, with any arguments after it. send calls the method even if it is private or protected; public_send calls only public methods and raises NoMethodError otherwise.

def gateway.charge defines a singleton method: it is stored in gateway's own singleton class, which Ruby checks before Gateway, so only that object uses it. Every other Gateway instance still finds Gateway#charge.

def takes a literal name and starts a fresh local scope. define_method takes the name as a Symbol or String value and uses a block as the body, so the body is a closure that sees the defining scope's local variables.

With instance_eval, self inside the block becomes the DSL object, so bare calls like threshold 90 reach it, but the caller's instance variables and helper methods do not. Yielding a builder keeps self and makes calls explicit: r.threshold 90.

respond_to? and method consult respond_to_missing? for names not in any method table. Without it, a ghost method works when called but respond_to? says false and method(:name) raises NameError, so code that checks before calling skips a working object.

Override method_missing to return the stored value when the name is a known key, handle key= writers, and call bare super for every other name. Without super, typos return nil silently instead of raising NoMethodError.

Override self.inherited(subclass) on ReportFormat, call super, and append the subclass to a registry; it fires at class Csv < ReportFormat, before Csv's body runs. Class#subclasses (Ruby 3.1+) returns only direct, still-alive subclasses, with no extra metadata.

Widget.public_instance_methods(false) lists the public instance methods defined in Widget itself. It leaves out superclass and mixin methods, private and protected ones, class methods, and names served only by method_missing.

The definition loaded last wins, for every caller in the process: reopening Integer overwrites the single minutes entry in Integer's method table. Ruby raises nothing; only with warnings on (ruby -w) does it print 'method redefined; discarding old minutes'.

A class is an object, so a class method is a singleton method of the class object, stored in its singleton class. class << self opens that singleton class, so def, attr_accessor and private inside it act at class level.

Both set self to Report. They differ in the default definee: a def inside Report.instance_eval becomes a singleton method, Report.x, while a def inside Report.class_eval becomes an instance method, Report.new.x.

Loop over a frozen STATUSES list with each and call define_method(:"#{s}?") { status == s } for every entry. Each iteration's block captures its own s, so every predicate compares against its own status.

A class macro is an ordinary method called on the class: inside a class body self is the class, so alert_on :cpu, above: 90 calls a class-level method. It runs once, as the class body executes, recording settings or defining methods.

instance_eval sets self to the builder while the block runs, so @ivars and bare method calls resolve against the builder, not your object. Local variables still work because the block stays a closure over its scope.

After lookup fails, Ruby calls method_missing on the receiver with the name as a Symbol, the arguments and the block. BasicObject's default raises NoMethodError, or NameError when the name was a bare identifier that could have been a local variable.

Ruby calls inherited(subclass) on the parent when a class is subclassed, method_added(name) after an instance method is defined, method_removed or method_undefined after remove_method or undef_method, and singleton_method_added(name) when an object gains a singleton method.

A Proc or lambda body is copied and given lambda semantics, so arity is strict and return leaves the method. An UnboundMethod body reuses an existing definition, but only from the same class, an ancestor or a module; otherwise TypeError.

define_singleton_method adds a method to one object's singleton class, so only that object gets it. Called on a class object it creates a class method, which makes it the tool for generating class-level method families from a list.

String code has no file of its own. The file and line arguments set what backtraces, SyntaxError messages and FILE report; without them Ruby 4.0 labels the code (eval at caller.rb:N) and counts lines from 1 inside the string.

Ruby calls const_missing(name) on the module where a constant lookup failed; the default raises NameError. An override's return value becomes the expression's value but is not stored, so it runs again next time. const_source_location returns the defining file and line.

const_get splits the string on :: and looks up each segment in the module found so far, raising NameError if one is missing or malformed. Module#name returns nil for an anonymous class until it is assigned to a constant.

They read and write an object's instance variable by name, such as :@total, bypassing its methods. instance_variables lists only variables already assigned, and attr_accessor defines methods without creating the variable.

Collect and re-pass all three channels: def run(name, *args, **opts, &block) with public_send(name, *args, **opts, &block), or def run(name, ...) with public_send(name, ...). Collecting only *args turns keywords into a positional Hash since Ruby 3.0.

obj.singleton_class returns the object's singleton class, creating it if needed. singleton_class? says whether a module is one. Class#attached_object, since Ruby 3.2, returns the owning object and raises TypeError on an ordinary class.

A define_method body is a closure: it keeps its whole defining scope alive, shares captured variables across calls, and YJIT compiles fewer call shapes for it, such as calls passing a block. Only hot paths, big closures or Ractor code justify rewriting.

A catch-all method_missing stores every unknown call, so sevrity :high becomes a setting nobody reads. Define keywords as real methods so typos raise NoMethodError with a did_you_mean hint, validate each rule after its block, and point errors at the user's line.

A string is parsed when class_eval runs, resolves constants inside Money and can interpolate method names into def. A block is parsed with the file, keeps lexical constant lookup and closes over objects, but needs define_method for computed names.

Each ghost call pays a failed lookup, a second dispatch to method_missing and the handler's own string checks, and YJIT does not compile such a call site. Defining a real method on the first miss makes later calls ordinary, compilable method calls.