Why hooks enable framework building in Ruby

Introduction

Hooks let you add your own code at special points in a program. This helps build flexible frameworks that others can easily change or extend.

When you want to let users add custom actions without changing the main code.

When building a tool that needs to run extra steps before or after main tasks.

When you want to keep your code clean but allow others to add features.

When you want to create reusable parts that can be adapted for different needs.

Syntax

Ruby

class Framework
  def initialize
    @hooks = {}
  end

  def add_hook(name, &block)
    @hooks[name] ||= []
    @hooks[name] << block
  end

  def run_hook(name)
    return unless @hooks[name]
    @hooks[name].each(&:call)
  end
end

Hooks are usually stored as blocks (small pieces of code) that run later.

You add hooks by giving them a name and a block of code to run.

Examples

This adds a hook named before_save and runs it, printing a message.

Ruby

framework = Framework.new
framework.add_hook(:before_save) { puts "Prepare to save" }
framework.run_hook(:before_save)

Here, a hook runs after saving, showing a confirmation message.

Ruby

framework.add_hook(:after_save) do
  puts "Save complete!"
end
framework.run_hook(:after_save)

Sample Program

This program shows how hooks let you add multiple actions at start and finish points without changing the main work.

Ruby

class Framework
  def initialize
    @hooks = {}
  end

  def add_hook(name, &block)
    @hooks[name] ||= []
    @hooks[name] << block
  end

  def run_hook(name)
    return unless @hooks[name]
    @hooks[name].each(&:call)
  end
end

framework = Framework.new

framework.add_hook(:start) { puts "Starting process..." }
framework.add_hook(:start) { puts "Loading resources" }
framework.add_hook(:finish) { puts "Process finished!" }

framework.run_hook(:start)
puts "Main work happening"
framework.run_hook(:finish)

Important Notes

Hooks help keep code organized by separating core logic from extra features.

You can add many hooks with the same name to run multiple actions.

Hooks make frameworks flexible and easy to customize.

Summary

Hooks let you insert custom code at specific points.

This makes frameworks flexible and easy to extend.

Using hooks keeps your main code clean and reusable.

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