Method chaining patterns in Ruby - Step-by-Step Execution

Concept Flow - Method chaining patterns

Start with object

↓

Call method1

↓

method1 returns self or new object

↓

Call method2 on returned object

↓

method2 returns self or new object

↓

Call method3 on returned object

↓

Final result or object returned

Method chaining calls multiple methods one after another on the same object or returned objects, each returning self or a new object to continue the chain.

Execution Sample

Ruby

class Chain
  def initialize(val)
    @val = val
  end
  def add(x)
    @val += x
    self
  end
  def multiply(x)
    @val *= x
    self
  end
  def result
    @val
  end
end

c = Chain.new(2).add(3).multiply(4).result

This code creates a Chain object, adds 3, multiplies by 4, then gets the result using method chaining.

Execution Table

Step	Action	Object State (@val)	Return Value	Chain Progress
1	Chain.new(2)	2	Chain object with @val=2	Start object created
2	add(3)	5	self (Chain object with @val=5)	Continue chaining
3	multiply(4)	20	self (Chain object with @val=20)	Continue chaining
4	result	20	20 (final value)	Chain ends with value

💡 All methods return self except result which returns the final value, ending the chain.

Variable Tracker

Variable	Start	After add(3)	After multiply(4)	Final
@val	2	5	20	20
c	Chain object @val=2	Chain object @val=5	Chain object @val=20	Chain object @val=20

Key Moments - 3 Insights

Why do methods like add and multiply return self instead of a value?

Returning self allows the next method to be called on the same object, enabling chaining as shown in execution_table rows 2 and 3.

What happens if a method in the chain does not return self?

The chain breaks because the next method is called on the returned value, which may not be the expected object. See exit_note explaining chain ends when result returns a value.

How does the final result method differ from other methods in the chain?

The final method returns a value (like a number) instead of self, ending the chain and providing the output, as shown in execution_table row 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of @val after step 2?

A 5

B 2

C 20

D 3

💡 Hint

Check the 'Object State (@val)' column at step 2 in the execution_table.

At which step does the method chain end?

A Step 2

B Step 3

C Step 4

D Step 1

💡 Hint

Look at the 'Chain Progress' column to see when the chain ends with a final value.

If multiply method returned a number instead of self, what would happen at step 3?

A Chain would continue normally

B Chain would break and next method calls would fail

C The value of @val would reset to 0

D The object would be duplicated

💡 Hint

Refer to key_moments about why methods must return self to continue chaining.

Concept Snapshot

Method chaining calls multiple methods in a row on the same object.
Each method returns self or a new object to allow chaining.
Final method usually returns a value to end the chain.
Common in Ruby for clean, readable code.
Example: obj.method1.method2.method3
Use self return to keep chaining going.

Full Transcript

Method chaining in Ruby means calling several methods one after another on the same object. Each method returns self or a new object so the next method can be called immediately. In the example, we create a Chain object with value 2. Then add(3) changes the value to 5 and returns self. Next multiply(4) changes value to 20 and returns self. Finally, result returns the value 20, ending the chain. Returning self is key to keep chaining working. If a method returns something else, the chain breaks. This pattern makes code clean and easy to read by linking method calls together.

Practice

1. What is the main purpose of method chaining in Ruby?

easy

A. To call multiple methods on the same object in one line

B. To create new objects automatically

C. To run methods in parallel threads

D. To convert objects into strings

Solution

1. Step 1: Understand method chaining concept

   Method chaining allows calling several methods one after another on the same object without repeating the object name.

2. Step 2: Identify the main purpose

   The main goal is to write shorter, cleaner code by linking method calls in one line.

3. Final Answer:

   To call multiple methods on the same object in one line -> Option A

4. Quick Check:

   Method chaining = calling multiple methods on one object [OK]

Hint: Method chaining links calls on one object in one line [OK]

Common Mistakes:

• Thinking it creates new objects automatically
• Confusing with threading or parallel execution
• Believing it converts objects to strings

2. Which of the following is the correct syntax for method chaining in Ruby?

easy

A. object|method1|method2|method3

B. object.method1.method2.method3

C. object::method1::method2::method3

D. object->method1->method2->method3

Solution

1. Step 1: Recall Ruby method call syntax

   In Ruby, methods are called on objects using dot notation: object.method.

2. Step 2: Identify chaining syntax

   Method chaining uses multiple dots to call methods one after another on the same object.

3. Final Answer:

   object.method1.method2.method3 -> Option B

4. Quick Check:

   Ruby chaining uses dots between methods [OK]

Hint: Use dots (.) to chain methods in Ruby [OK]

Common Mistakes:

• Using arrows (->) which is not Ruby syntax
• Using double colons (::) which are for constants or modules
• Using pipes (|) which are not method call operators

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

class Box
  def initialize(value)
    @value = value
  end

  def add(x)
    @value += x
    self
  end

  def multiply(x)
    @value *= x
    self
  end

  def value
    @value
  end
end

box = Box.new(2)
result = box.add(3).multiply(4).value
puts result

medium

A. 20

B. 14

C. 10

D. 8

Solution

1. Step 1: Trace the add method

   Start with @value = 2. add(3) adds 3: 2 + 3 = 5, returns self.

2. Step 2: Trace the multiply method

   multiply(4) multiplies @value by 4: 5 * 4 = 20, returns self.

3. Step 3: Call value method

   value returns @value which is 20.

4. Final Answer:

   20 -> Option A

5. Quick Check:

   2 + 3 = 5; 5 * 4 = 20 [OK]

Hint: Follow each method step-by-step, remember self returns object [OK]

Common Mistakes:

• Forgetting that add and multiply return self
• Calculating operations in wrong order
• Returning intermediate values instead of final

4. Identify the error in the following Ruby code that tries to chain methods:

class Person
  def initialize(name)
    @name = name
  end

  def greet
    puts "Hello, #{@name}!"
  end

  def farewell
    puts "Goodbye, #{@name}!"
  end
end

p = Person.new("Sam")
p.greet.farewell

medium

A. initialize method missing return statement

B. farewell method is misspelled

C. Cannot create Person object with new

D. greet method does not return self, so chaining fails

Solution

1. Step 1: Check method return values

   greet prints a message but returns nil (default for puts).

2. Step 2: Understand chaining requirement

   For chaining, greet must return self to allow calling farewell next.

3. Final Answer:

   greet method does not return self, so chaining fails -> Option D

4. Quick Check:

   Method chaining needs methods to return self [OK]

Hint: Ensure methods return self to chain calls [OK]

Common Mistakes:

• Assuming puts returns self
• Thinking initialize needs explicit return
• Believing object creation is the problem

5. You want to create a Ruby class TextFormatter that allows chaining methods to transform a string. The methods are:
- upcase: converts text to uppercase
- reverse: reverses the text
- append(str): adds str to the end

Which implementation correctly supports chaining all these methods and returns the final string with result?

hard

A. Each method prints the modified string and returns nil

B. Each method returns the modified string directly without returning self

C. Each method modifies @text, returns self; add a result method returning @text

D. Each method returns a new TextFormatter object with modified text

Solution

1. Step 1: Understand chaining requirements

   To chain methods, each must return self (the object) so next method can be called.

2. Step 2: Provide final output method

   Since methods return self, a separate method (like result) should return the final string.

3. Final Answer:

   Each method modifies @text, returns self; add a result method returning @text -> Option C

4. Quick Check:

   Return self to chain, separate method to get final string [OK]

Hint: Return self in methods, separate method returns final value [OK]

Common Mistakes:

• Returning strings breaks chaining
• Printing inside methods returns nil
• Returning new objects breaks original chain