Implementing the Composite Pattern in Ruby

Welcome back! You have learned about the Adapter Pattern and how it helps make incompatible interfaces work together seamlessly. Now, let's dive into another crucial structural pattern that focuses on composition: the Composite Pattern.

The Composite Pattern allows you to build complex structures by combining objects into tree-like structures to represent part-whole hierarchies. This pattern is particularly useful when dealing with applications like file systems, GUI frameworks, or organizational structures where you need to treat individual objects and compositions of objects uniformly.

In this lesson, we will explore how to implement the Composite Pattern using Ruby. We will focus on an organizational structure scenario. You will learn how to create and manage employees, both individual developers and groups of developers managed by a manager. We'll look at defining classes with attributes, method definitions, and using arrays in Ruby. Here’s a snippet from the Ruby code you'll be working with:

We will start by creating an abstract Employee class with a show_details method:

class Employee
  def show_details
    raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
  end
end

Next, we will create a Developer class that inherits from the Employee class. The Developer class will have a show_details method that prints the developer's name and position:

class Developer < Employee
  def initialize(name, position)
    @name = name
    @position = position
  end
  
  def show_details
    puts "#{@name} works as #{@position}."
  end
end

Then, we will create a Manager class that inherits from the Employee class. The Manager class will have an array of Employee objects to manage multiple employees. It will also have methods to add, remove, and display employee details:

class Manager < Employee
  def initialize
    @employees = []
  end
  
  def add(employee)
    @employees << employee
  end

  def remove(employee)
    @employees.delete(employee)
  end
  
  def show_details
    @employees.each(&:show_details)
  end
end

Notice how the Manager can contain multiple Employee objects, allowing you to build a composite structure. Note that the @employees array can even contain other Manager objects, creating a nested hierarchy.

Now let's see how you can use the Composite Pattern to manage employees in an organization:

dev1 = Developer.new("Alice", "Software Engineer")
dev2 = Developer.new("Bob", "Frontend Developer")

manager = Manager.new
manager.add(dev1)
manager.add(dev2)

manager.show_details

In this example, Employee is an abstract class with a show_details method, which is implemented by both Developer and Manager classes. The Manager class can contain multiple employees, allowing you to build a composite structure.

Let's understand the key components of the Composite Pattern:

• Component: An abstract class that defines the interface for all objects in the composition. In our example, Employee is the component class.
• Leaf: A concrete class that represents individual objects in the composition. In our example, Developer is the leaf class.
• Composite: A concrete class that represents compositions of objects. In our example, Manager is the composite class.