Why hooks enable framework building in Ruby - Test Your Understanding

Practice - 5 Tasks

1fill in blank

easy

Complete the code to define a hook method that can be overridden.

Ruby

def [1]
  # default behavior
end

Drag options to blanks, or click blank then click option'

Ahook_method

Brun

Cinitialize

Dexecute

Attempts:

3 left

💡 Hint

Common Mistakes

Using a method name that is too specific or already reserved.

Not defining a method at all.

The method hook_method is a placeholder that can be overridden by subclasses or users to customize behavior.

2fill in blank

medium

Complete the code to call the hook method inside another method.

Ruby

def perform
  puts 'Starting task'
  [1]
  puts 'Task finished'
end

Drag options to blanks, or click blank then click option'

Aexecute_hook

Brun_hook

Chook_method

Dstart_hook

Attempts:

3 left

💡 Hint

Common Mistakes

Calling a method that is not defined.

Forgetting to call the hook method.

The perform method calls hook_method to allow customization during execution.

3fill in blank

hard

Fix the error in the subclass to override the hook method correctly.

Ruby

class CustomTask < BaseTask
  def [1]
    puts 'Custom behavior'
  end
end

Drag options to blanks, or click blank then click option'

Aperform

Brun

Cinitialize

Dhook_method

Attempts:

3 left

💡 Hint

Common Mistakes

Overriding the wrong method name.

Not overriding the hook method at all.

Overriding hook_method in the subclass allows custom behavior during perform.

4fill in blank

hard

Fill both blanks to define a base class with a hook and a method that calls it.

Ruby

class BaseTask
  def [1]
    # default hook
  end

  def [2]
    puts 'Begin'
    [1]
    puts 'End'
  end
end

Drag options to blanks, or click blank then click option'

Ahook_method

Bperform

Cexecute

Drun

Attempts:

3 left

💡 Hint

Common Mistakes

Mixing up method names.

Not calling the hook inside the action method.

The base class defines hook_method as the hook and perform to call it.

5fill in blank

hard

Fill all three blanks to create a subclass that overrides the hook and runs the task.

Ruby

class CustomTask < BaseTask
  def [1]
    puts 'Custom action'
  end
end

task = CustomTask.new
[2]
task.[3]

Drag options to blanks, or click blank then click option'

Ahook_method

Btask

Cperform

Dnew

Attempts:

3 left

💡 Hint

Common Mistakes

Using wrong method names.

Not creating an instance before calling perform.

The subclass overrides hook_method. We create an instance task and call perform to run it.

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