Why hooks enable framework building in Ruby - Quick Recap

Recall & Review

beginner

What is a hook in programming frameworks?

A hook is a place in the code where you can insert your own code to change or extend behavior without modifying the original code.

beginner

How do hooks help in building flexible frameworks?

Hooks let developers add custom features or change how things work without changing the core framework, making it easier to adapt and grow.

intermediate

Why is it better to use hooks instead of changing framework code directly?

Using hooks keeps the original framework code safe and stable, so updates don’t break custom changes and maintenance is easier.

intermediate

Give an example of a hook in Ruby frameworks.

In Ruby on Rails, callbacks like before_save are hooks that let you run code before saving a record, allowing customization without changing Rails itself.

advanced

What role do hooks play in separating concerns in framework design?

Hooks allow the core framework to focus on main tasks while letting users add extra behavior separately, keeping code clean and organized.

What is the main purpose of hooks in a framework?

A To slow down the program execution

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

C To delete parts of the framework

D To make the framework code unreadable

Hooks let you add or change behavior safely without modifying the core framework code.

Which of these is an example of a hook in Ruby on Rails?

A before_save callback

B print statement

C variable assignment

D class definition

before_save is a hook that runs code before saving a record in Rails.

Why do hooks improve framework maintenance?

A They make the framework code longer

B They remove bugs automatically

C They keep custom code separate from core code

D They prevent any changes

Hooks separate custom changes from core code, making updates safer and easier.

What does it mean that hooks enable separation of concerns?

A Hooks delete unnecessary code

B All code is mixed together

C Hooks slow down the program

D Core framework and custom behavior are handled separately

Hooks let the framework focus on main tasks while custom code handles extra behavior separately.

Which is NOT a benefit of using hooks in frameworks?

A Making the framework less flexible

B Allowing customization without core changes

C Improving code organization

D Helping with safe updates

Hooks increase flexibility, not reduce it.

Explain in your own words why hooks are important for building frameworks.

Think about how hooks let you add features without changing the main framework.

Describe how hooks help keep code organized in a framework.

Consider how hooks separate main tasks from extra behavior.

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