Extend for class methods in Ruby - Step-by-Step Execution

Concept Flow - Extend for class methods

Define Module with methods

↓

Create Class

↓

Extend Class with Module

↓

Call Module methods on Class

↓

Methods run as class methods

This flow shows how a module's methods become class methods when a class extends that module.

Execution Sample

Ruby

module Greetings
  def hello
    "Hello from class!"
  end
end

class Person
  extend Greetings
end

puts Person.hello

This code adds the module's method as a class method to Person and calls it.

Execution Table

Step	Action	Evaluation	Result
1	Define module Greetings with method hello	Module created	Module Greetings with method hello defined
2	Define class Person	Class created	Class Person defined
3	Extend Person with Greetings	Person gains module methods as class methods	Person.hello method available
4	Call Person.hello	Method runs	"Hello from class!" printed
5	End of program	No more code	Program ends

💡 Program ends after printing the class method result

Variable Tracker

Variable	Start	After extend	After method call	Final
Person	Class defined	Has class method hello	Method called	Class unchanged

Key Moments - 2 Insights

Why does Person.hello work after extend but not before?

Because extend adds module methods as class methods to Person, shown in step 3 of execution_table.

Is the hello method available to instances of Person?

No, extend adds methods only to the class itself, not its instances.

Visual Quiz - 3 Questions

Look at the execution_table, what happens at step 3?

A Person gains instance methods from Greetings

B Person loses all methods

C Person gains class methods from Greetings

D Greetings module is deleted

💡 Hint

See step 3 in execution_table where extend adds module methods as class methods

At which step is the method hello actually called?

A Step 4

B Step 3

C Step 2

D Step 5

💡 Hint

Step 4 shows calling Person.hello and printing the result

If we used include instead of extend, what would change?

A hello becomes a class method

B hello becomes an instance method

C hello is not added at all

D Program crashes

💡 Hint

Extend adds class methods; include adds instance methods

Concept Snapshot

Use extend to add module methods as class methods.
Syntax: class MyClass; extend MyModule; end
Methods in MyModule become callable on MyClass itself.
Unlike include, which adds instance methods.
Useful to share behavior at class level.

Full Transcript

This example shows how to use extend in Ruby to add methods from a module as class methods to a class. First, a module Greetings is defined with a method hello. Then, a class Person is defined. Using extend Greetings inside Person adds the hello method as a class method. When Person.hello is called, it runs the module method and prints the message. The execution table traces each step: defining the module, defining the class, extending the class, calling the method, and ending the program. The variable tracker shows Person gains the class method after extend. Key moments clarify that extend adds class methods, not instance methods. The quiz tests understanding of when methods are added and called, and the difference between extend and include. The snapshot summarizes the key points for quick reference.

Practice

1. What does the extend keyword do in Ruby when used inside a class?

easy

A. Includes the module's constants only

B. Adds the module's methods as instance methods to the class

C. Adds the module's methods as class methods to the class

D. Removes methods from the class

Solution

1. Step 1: Understand extend usage

   The extend keyword adds methods from a module as class methods to the class that calls it.

2. Step 2: Differentiate from include

   Unlike include, which adds methods as instance methods, extend adds them as class methods.

3. Final Answer:

   Adds the module's methods as class methods to the class -> Option C

4. Quick Check:

   extend = class methods [OK]

Hint: Remember: extend = class methods, include = instance methods [OK]

Common Mistakes:

• Confusing extend with include
• Thinking extend adds instance methods
• Assuming extend removes methods

2. Which of the following is the correct syntax to add module methods as class methods using extend?

easy

A. class MyClass; def self.extend MyModule; end

B. class MyClass; include MyModule; end

C. class MyClass; MyModule.extend(self); end

D. class MyClass; extend MyModule; end

Solution

1. Step 1: Identify correct extend usage

   The correct syntax is to call extend inside the class body with the module name.

2. Step 2: Check each option

   class MyClass; extend MyModule; end uses extend MyModule inside the class, which is correct syntax.

3. Final Answer:

   class MyClass; extend MyModule; end -> Option D

4. Quick Check:

   Correct extend syntax = class MyClass; extend MyModule; end [OK]

Hint: Use 'extend ModuleName' inside class body for class methods [OK]

Common Mistakes:

• Using include instead of extend
• Calling extend on module instead of class
• Incorrect method definition syntax

3. What will be the output of the following Ruby code?

module Greetings
  def hello
    "Hello from module"
  end
end

class Person
  extend Greetings
end

puts Person.hello

medium

A. NoMethodError: undefined method 'hello' for Person

B. Hello from module

C. Hello from module called on instance

D. SyntaxError

Solution

1. Step 1: Understand extend Greetings effect

   The module's method hello becomes a class method of Person.

2. Step 2: Check method call

   Person.hello calls the class method, which exists and returns "Hello from module".

3. Final Answer:

   Hello from module -> Option B

4. Quick Check:

   Class method from extend = "Hello from module" [OK]

Hint: extend adds module methods as class methods, so Person.hello works [OK]

Common Mistakes:

• Thinking hello is an instance method
• Calling hello on an instance instead of class
• Expecting NoMethodError

4. Identify the error in this Ruby code snippet:

module Tools
  def tool_name
    "Hammer"
  end
end

class Worker
  extend Tools

  def self.tool_name
    "Wrench"
  end
end

puts Worker.tool_name

medium

A. No error; output is 'Wrench'

B. NoMethodError because tool_name is undefined

C. SyntaxError due to extend usage

D. Output is 'Hammer' ignoring class method

Solution

1. Step 1: Analyze method definitions

   The module Tools defines tool_name, which is added as a class method to Worker by extend Tools.

2. Step 2: Check method override

   Worker defines its own class method tool_name, which overrides the module method.

3. Final Answer:

   No error; output is 'Wrench' -> Option A

4. Quick Check:

   Class method override works; output = 'Wrench' [OK]

Hint: Class methods override extended module methods if defined later [OK]

Common Mistakes:

• Assuming module method overrides class method
• Expecting NoMethodError
• Confusing instance and class methods

5. You want to share a method info as a class method across multiple classes without repeating code. Which approach using extend is best?

module InfoModule
  def info
    "Shared class info"
  end
end

class Alpha
  # What to do here?
end

class Beta
  # What to do here?
end

hard

A. Add extend InfoModule inside both Alpha and Beta classes

B. Add include InfoModule inside both Alpha and Beta classes

C. Define def self.info separately in Alpha and Beta

D. Use InfoModule.extend(self) outside classes

Solution

1. Step 1: Understand sharing class methods

   Using extend InfoModule inside each class adds info as a class method.

2. Step 2: Evaluate options

   Add extend InfoModule inside both Alpha and Beta classes correctly uses extend in both classes to share the method without repetition.

3. Final Answer:

   Add extend InfoModule inside both Alpha and Beta classes -> Option A

4. Quick Check:

   Use extend in each class to share class methods [OK]

Hint: Use extend inside each class to share class methods from a module [OK]

Common Mistakes:

• Using include instead of extend for class methods
• Defining methods separately instead of sharing
• Calling extend on module instead of class