Why hooks enable framework building in Ruby - Visual Breakdown

Concept Flow - Why hooks enable framework building

Define Hook Method

↓

User Code Calls Hook

↓

Framework Executes Hook Code

↓

Framework Adds Features

↓

User Sees Extended Behavior

↓

END

Hooks are special methods that user code calls, letting the framework add extra behavior at those points.

Execution Sample

Ruby

module Framework
  def self.hook(name)
    puts "Hook called: #{name}"
  end
end

Framework.hook(:start)

This code defines a hook method and calls it, showing how frameworks can run code at hook points.

Execution Table

Step	Action	Evaluation	Result
1	Define module Framework with method hook(name)	Method hook defined	Ready to call hook
2	Call Framework.hook(:start)	hook(:start) called	Prints 'Hook called: start'
3	End of code	No more instructions	Program ends

💡 All code executed, program ends normally

Variable Tracker

Variable	Start	After Call	Final
name	undefined	:start	:start

Key Moments - 2 Insights

Why does the framework define a hook method instead of running code directly?

Because the hook method lets user code decide when to call it, so the framework can add behavior at those points (see execution_table step 2).

What happens when the hook method is called with a name?

The framework runs code inside the hook method using the name to customize behavior (see execution_table step 2 output).

Visual Quiz - 3 Questions

Look at the execution_table, what is printed when Framework.hook(:start) is called?

A "Framework hook running"

B "start hook executed"

C "Hook called: start"

D Nothing is printed

💡 Hint

Check execution_table row 2 under Result column

At which step does the program finish running?

A After Step 3

B Step 1

C Step 3

D Step 2

💡 Hint

Look at exit_note and last row in execution_table

If the hook method was never called, what would happen?

A The program would crash

B The framework code inside hook would never run

C The program would print 'Hook called: start' anyway

D The hook method would run automatically

💡 Hint

Refer to execution_table step 2 where hook is called to run code

Concept Snapshot

Hooks are methods frameworks define for user code to call.
When called, hooks run framework code to add features.
This lets frameworks extend behavior without changing user code.
User controls when hooks run, framework controls what they do.
Hooks enable flexible, reusable framework building.

Full Transcript

Hooks are special methods defined by frameworks. User code calls these hooks at certain points. When a hook is called, the framework runs code inside it to add extra behavior. This way, frameworks can extend or change how programs work without changing user code directly. The example shows a hook method printing a message when called. This simple call-and-run pattern is why hooks enable building flexible frameworks.

Practice

1. What is the main reason hooks are useful in building Ruby frameworks?

easy

A. They replace the need for classes and modules

B. They allow custom code to run at specific points without changing core code

C. They speed up the program execution automatically

D. They make the program run without errors

Solution

1. Step 1: Understand what hooks do

   Hooks let you add your own code at certain points in a program without changing the main code.

2. Step 2: Why this helps frameworks

   This makes frameworks flexible and easy to extend because users can add features without touching core code.

3. Final Answer:

   They allow custom code to run at specific points without changing core code -> Option B

4. Quick Check:

   Hooks enable flexible extension = C [OK]

Hint: Hooks insert code at points without changing main code [OK]

Common Mistakes:

• Thinking hooks speed up code automatically
• Confusing hooks with replacing classes
• Believing hooks prevent all errors

2. Which of the following is the correct syntax to define a hook method named before_save in Ruby?

easy

A. def hook :before_save; puts 'Saving'; end

B. hook before_save { puts 'Saving' }

C. before_save do puts 'Saving' end

D. def before_save; puts 'Saving'; end

Solution

1. Step 1: Recognize Ruby method definition syntax

   Ruby methods are defined with def method_name; ... end.

2. Step 2: Match the hook method name

   The hook method before_save is correctly defined as def before_save; ... end.

3. Final Answer:

   def before_save; puts 'Saving'; end -> Option D

4. Quick Check:

   Ruby method syntax = A [OK]

Hint: Ruby methods use def name; ... end syntax [OK]

Common Mistakes:

• Using non-Ruby syntax like 'hook' keyword
• Missing 'def' keyword
• Incorrect block syntax without do/end

3. Given this Ruby code using a hook pattern:

class Framework
  def self.before_save(&block)
    @before_save_hook = block
  end

  def save
    self.class.instance_variable_get(:@before_save_hook)&.call
    puts 'Saving data'
  end
end

class User < Framework
  before_save { puts 'Validate user' }
end

User.new.save

What is the output when User.new.save is called?

medium

A. Validate user
Saving data

B. Saving data

C. NoMethodError

D. Validate user

Solution

1. Step 1: Understand the hook registration

   The before_save class method stores a block in @before_save_hook for the User class.

2. Step 2: Analyze the save method call

   When save is called, it calls the stored hook block (prints 'Validate user') then prints 'Saving data'.

3. Final Answer:

   Validate user Saving data -> Option A

4. Quick Check:

   Hook runs before save message = B [OK]

Hint: Hook block runs before main save output [OK]

Common Mistakes:

• Ignoring the hook call in save method
• Expecting only 'Saving data' output
• Confusing instance and class variables

4. Consider this Ruby code snippet:

class Framework
  def self.before_save(&block)
    @before_save_hook = block
  end

  def save
    @before_save_hook.call
    puts 'Saving data'
  end
end

class User < Framework
  before_save { puts 'Validate user' }
end

User.new.save

What is the error in this code?

medium

A. No error, code runs fine

B. Undefined method `before_save` for User:Class

C. NoMethodError because @before_save_hook is nil in instance

D. SyntaxError due to missing end

Solution

1. Step 1: Identify where @before_save_hook is stored

   The hook is stored as a class instance variable @before_save_hook, but save tries to call instance variable @before_save_hook.

2. Step 2: Understand the error cause

   The instance variable @before_save_hook is nil, so calling call on it causes NoMethodError.

3. Final Answer:

   NoMethodError because @before_save_hook is nil in instance -> Option C

4. Quick Check:

   Instance vs class variable mismatch = D [OK]

Hint: Class vars differ from instance vars; call on nil causes error [OK]

Common Mistakes:

• Thinking hook is stored in instance variable
• Assuming no error occurs
• Confusing syntax errors with runtime errors

5. You want to build a Ruby framework that allows users to add multiple hooks for before_save and run them all in order before saving. Which approach best supports this?

hard

A. Store hooks in an array and call each block in sequence before saving

B. Store a single block in a class variable and overwrite it each time

C. Use global variables to store hooks and call them randomly

D. Define multiple methods named before_save and rely on Ruby to call all

Solution

1. Step 1: Understand the need for multiple hooks

   To support many hooks, you must keep all hook blocks, not overwrite them.

2. Step 2: Choose a data structure to hold hooks

   An array can store multiple blocks, allowing iteration and calling each in order.

3. Step 3: Why other options fail

   Overwriting loses hooks, global variables cause conflicts, and Ruby does not call multiple methods with same name automatically.

4. Final Answer:

   Store hooks in an array and call each block in sequence before saving -> Option A

5. Quick Check:

   Multiple hooks need array storage = A [OK]

Hint: Use array to keep and run multiple hooks in order [OK]

Common Mistakes:

• Overwriting hooks instead of storing all
• Using global variables causing conflicts
• Expecting Ruby to call duplicate method names