Metaprogramming Techniques

logged sets a flag, and method_added(name) wraps the method just defined. If the wrapper is defined with define_method in the same class before the flag is cleared, that definition fires method_added again, endlessly. Clear the flag first, or prepend the wrapper.

Call obj.method(:name).source_location. It returns the file and line of the definition that call would actually run, exposing a patch or prepended module; nil means the method is implemented in C.

A prepended module sits in front of the class, so its super reaches the original without renaming anything, and stacked patches compose. An alias chain snapshots the original; loaded twice, or added after a prepend on one method, it recurses into SystemStackError.

public_send, so private and protected helpers stay unreachable. Visibility alone is not an allowlist: inherited public methods such as instance_variable_set and send remain callable, so check the name against a frozen list of allowed actions before dispatching.

Marshal cannot serialize methods, so dumping an object whose singleton class holds methods raises TypeError. Integers, Floats and Symbols refuse singleton methods with TypeError, frozen objects with FrozenError, and nil, true and false patch their shared classes.

Default to not patching: helpers, wrapper objects or refinements. A justified global patch lives in one core_ext file per class as a named, prepended module that raises if the name exists, pinned by tests and checked in CI with -w and -W:performance.

Kernel#eval with a Binding runs the string in that binding's context: its self, its local variables and its constant scope. Locals the string creates stay in that binding, because the surrounding method's locals were fixed when it was parsed.

send behaves like send but lives on BasicObject under a name nobody overrides by accident. Library code that dispatches on objects it does not control uses it, because a class may define its own send and BasicObject subclasses have no Kernel#send.

Rake extends the top-level main object with private DSL methods: flat files work, but helper defs land on Object. RSpec runs each group block as a Class.new subclass body via module_exec, so helpers are methods, nesting is inheritance and examples get fresh instances.

It yields every heap object that is a Session or subclass instance and returns how many it yielded. The count can include unreachable objects the GC has not yet collected, so it is an upper bound, not a live count.

Integer#+ is a core method the interpreter and JIT run without a method call; redefining it, by def or prepend, flags it so every Integer + becomes a full call. Ruby warns only under -W:performance or Warning[:performance] = true.