Template Method Pattern in Ruby: Mastering Behavioral Design Patterns

6.10 Template Method Pattern

Introduction

The Template Method Pattern is a behavioral design pattern that defines the skeleton of an algorithm in a method, deferring some steps to subclasses. This pattern allows subclasses to redefine certain steps of an algorithm without changing its structure. It is particularly useful for code reuse and enforcing method sequences, ensuring that the overall algorithm remains consistent while allowing flexibility in specific steps.

Intent

The primary intent of the Template Method Pattern is to define the outline of an algorithm in a base class and allow subclasses to implement specific steps. This pattern promotes code reuse by encapsulating the invariant parts of an algorithm in a base class and deferring the variant parts to subclasses.

Problem Addressed

In software development, it is common to encounter scenarios where multiple classes share a similar algorithmic structure but differ in specific steps. Without a structured approach, this can lead to code duplication and maintenance challenges. The Template Method Pattern addresses these issues by:

• Encapsulating Invariant Steps: It defines the common steps of an algorithm in a base class, ensuring consistency across different implementations.
• Allowing Customization: Subclasses can override specific steps, providing flexibility without altering the overall algorithm.
• Promoting Code Reuse: By centralizing the common logic, the pattern reduces code duplication and enhances maintainability.

Implementing the Template Method Pattern in Ruby

Ruby’s dynamic nature and support for object-oriented programming make it an ideal language for implementing the Template Method Pattern. Let’s explore how to implement this pattern using Ruby’s inheritance and modules.

Defining Abstract Methods

In Ruby, abstract methods are typically defined by raising a NotImplementedError in the base class. This signals that subclasses must implement these methods.

 1class AbstractClass
 2  def template_method
 3    step_one
 4    step_two
 5    step_three
 6  end
 7
 8  def step_one
 9    raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
10  end
11
12  def step_two
13    raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
14  end
15
16  def step_three
17    raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
18  end
19end

Subclassing to Implement Specific Steps

Subclasses inherit from the base class and implement the abstract methods.

 1class ConcreteClassA < AbstractClass
 2  def step_one
 3    puts "ConcreteClassA: Step One"
 4  end
 5
 6  def step_two
 7    puts "ConcreteClassA: Step Two"
 8  end
 9
10  def step_three
11    puts "ConcreteClassA: Step Three"
12  end
13end
14
15class ConcreteClassB < AbstractClass
16  def step_one
17    puts "ConcreteClassB: Step One"
18  end
19
20  def step_two
21    puts "ConcreteClassB: Step Two"
22  end
23
24  def step_three
25    puts "ConcreteClassB: Step Three"
26  end
27end

Using Modules for Reusability

Ruby modules can be used to define shared behavior, allowing multiple classes to include the same template method logic.

 1module TemplateMethod
 2  def template_method
 3    step_one
 4    step_two
 5    step_three
 6  end
 7end
 8
 9class ConcreteClassC
10  include TemplateMethod
11
12  def step_one
13    puts "ConcreteClassC: Step One"
14  end
15
16  def step_two
17    puts "ConcreteClassC: Step Two"
18  end
19
20  def step_three
21    puts "ConcreteClassC: Step Three"
22  end
23end

Benefits of the Template Method Pattern

The Template Method Pattern offers several benefits:

• Code Reuse: By defining the common algorithm in a base class, code duplication is minimized, and maintenance becomes easier.
• Enforcing Method Sequences: The pattern ensures that the algorithm’s steps are executed in a specific order, maintaining consistency across different implementations.
• Flexibility: Subclasses can customize specific steps, allowing for variations without altering the overall structure.

Visualizing the Template Method Pattern

To better understand the Template Method Pattern, let’s visualize it using a class diagram.

    classDiagram
	    class AbstractClass {
	        +template_method()
	        +step_one()
	        +step_two()
	        +step_three()
	    }
	    class ConcreteClassA {
	        +step_one()
	        +step_two()
	        +step_three()
	    }
	    class ConcreteClassB {
	        +step_one()
	        +step_two()
	        +step_three()
	    }
	    AbstractClass <|-- ConcreteClassA
	    AbstractClass <|-- ConcreteClassB

Diagram Description: The diagram illustrates the relationship between the AbstractClass and its subclasses ConcreteClassA and ConcreteClassB. The template_method is defined in the AbstractClass, while the subclasses implement the specific steps.

Ruby Unique Features

Ruby’s dynamic nature and metaprogramming capabilities offer unique advantages when implementing the Template Method Pattern:

• Dynamic Method Definition: Ruby allows methods to be defined and redefined at runtime, providing flexibility in implementing abstract methods.
• Modules and Mixins: Ruby modules can be used to share behavior across classes, enhancing code reuse and reducing duplication.
• Duck Typing: Ruby’s duck typing allows objects to be used interchangeably if they implement the required methods, providing flexibility in subclass implementations.

Differences and Similarities with Other Patterns

The Template Method Pattern is often compared to other behavioral patterns, such as the Strategy Pattern. While both patterns allow for variations in behavior, the Template Method Pattern defines the algorithm’s structure in a base class, whereas the Strategy Pattern encapsulates the algorithm in separate strategy classes.

Try It Yourself

To deepen your understanding of the Template Method Pattern, try modifying the code examples:

• Add New Steps: Introduce additional steps in the algorithm and implement them in the subclasses.
• Use Modules: Refactor the code to use modules for shared behavior.
• Experiment with Duck Typing: Create new subclasses that implement the required methods without inheriting from the base class.

Knowledge Check

• What is the primary intent of the Template Method Pattern?
• How does the Template Method Pattern promote code reuse?
• What are the benefits of using modules in Ruby for the Template Method Pattern?

Conclusion

The Template Method Pattern is a powerful tool for defining the skeleton of an algorithm while allowing subclasses to customize specific steps. By leveraging Ruby’s unique features, such as dynamic method definition and modules, developers can implement this pattern effectively, promoting code reuse and maintaining consistency across implementations. Remember, this is just the beginning. As you progress, you’ll build more complex and interactive applications. Keep experimenting, stay curious, and enjoy the journey!

Quiz: Template Method Pattern