Book Notes: Metaprogramming Ruby

2017-11-27

The Object Model

All classes ultimately inherit from Object, which inherits from BasicObject
Constants
- Unique reference to a scope
- Constants can be duplicated as long as they are within different module scopes - akin to folders / files are modules / constants
Class names are nothing but Constants
Modules are basically packages of methods
Classes are like Modules, except with new, allocate, and superclass that allow for hierarchal structures
Objects are just a collection of instance methods and a reference to a class
The methods of an object live within the object’s class
A class is just an instance of Class
How do method calls work?
- Needs to 1. find the method and 2. execute with self
- The receiver is the object a method is called on
- Lookup - The method chain is as follows:
  1. receiver
  2. receiver class
  3. receiver class included modules
  4. Repeat 2 & 3 with the superclass as receiver
- Execution
  - Every line of Ruby code is executed inside an object called the current object
  - When a method call is executed, a reference to the receiver is saved to be used as self later

Open Classes
- class is more like a scope operator than a class declaration
- Can use class to “re-open” a class and add / redefine methods
- Use with caution - hard to track down origin of bugs, monkey-patching is usually a code smell

Dynamic Dispatch
- Use send to dynamically call a method when calling the method directly may not be possible with dot notation
Dynamic Methods
- Methods can be defined at runtime with define_method
Dynamic Proxy
- Override method_missing to capture method calls and respond appropriately
- Creates “Ghost methods”, which won’t be seen through introspection
- Can override responds_to? to make Ghost methods discoverable
Blank Slate
- Remove all inherited methods with undef_method
- Fixes any potential method naming conflicts

Powerful for controlling scope
Part of the “callable objects” family, which includes procs and lambdas
Each method exposes a callable block_given? method, which will return true when a block was passed in as an argument to the method
Each method exposes a callable yield method, which will execute the block passed to the method
Closures
- Blocks contain both code and a set of variable bindings
- When you define a block, it grabs the bindings in scope at that moment
- Can introspectively look at variables with the Kernel#local_variables method
Scope
- As soon as you enter a new scope, previous bindings are replaced by a new set, opposite of Java and C#
- Scope gates include class definition, module definition, and def method definition
- Exiting a scope, local variables defined are no longer visible
Object#instance_eval evaluates a block within the scope of an object
A Proc is a block converted into an object, since blocks are not objects themselves
The & converts a Proc to a block. It can capture a block passed into a method. If the variable does not use the & operator, it is a Proc
Difference between Procs and Lambdas
- return
  - Lambdas simply returns from the lambda
  - Procs return from the scope where the proc was defined
- Arity
  - Lambdas are less tolerant than procs when it comes to arguments
  - Procs will usually raise an ArgumentError when called with the wrong arity
  - Lambdas will fill empty arguments with nil

Flat Scope
- Circumvent scope gates by dynamically defining classes, modules, and methods
- Use Class.new instead of class, define_method instead of def
Shared Scope
- Use define_method to share the scope between methods / classes, protecting that variable from being accessed by other objects
Context Probe
- Use instance_eval to access private methods and instance variables
Clean Rooms
- An empty environment (read: Object) to evaluate blocks within

In a class or module definition, the class / module itself takes the role of self
{class, module}_eval executes a block within the context of the class / module
Class Instance Variables are only accessible by the class (since they are defined with the class as self), not by an object instance or a subclass
Class Variables can be accessed by subclasses and instance methods, which belong to the class hierarchy. These are defined by @@{name}
Eigenclasses are the “UFOs” of the Ruby world
- Each instance of a class (including instances of Class) gets its own special “copy” of the class, called an eigenclass
- This allows these classes to be flexible (add / remove methods) without affecting other instances of the base class
- Eigenclasses exist in the method lookup chain, and exist as the class for each instance of a class or module
- The superclass of the eigenclass of an object is the object’s class
- The superclass of the eigenclass of a class is the eigenclass of the class’s superclass

Singleton Methods
- Define a method on a specific object, using def {object}.{method_name}. This is how class methods work, with class self as the object
Class Macros
- instance methods defined on Class or Module that can be called in the class definition. Example is attr_accessor
Around Alias
- Use alias to create a copy of a method, overwrite the original method name and call the new method name

eval takes a string of code and executes the string
- Dangerous! Arbitrary code injection abound

Hook Methods
- Methods called when events such as inheriting and including occur
- Includes Class#inherited, Module#included, Module#method_added, Module#method_undefined, Module#method_removed, etc.