---
title: 'Building Reusable Object-Oriented Systems: Composition'
teaser: Using composition to build modular object-oriented systems.
tags: web,ruby,good code
author: Joël Quenneville
published_on: 2016-11-02
---

In two recent posts, we've used [single inheritance] and [multiple inheritance]
to build  an API client that fetches directors from a fictional
`movie-facts.com` API. Sometimes we read from a cache instead of making HTTP
requests and sometimes we need to make multiple requests to a paginated feed and
combine them into a de-paginated set.

Let's take a completely different approach to solving the problem. Instead of
building up a single object that does all of the things via inheritance, we are
going to cut it up into several smaller object focused on a single
responsibility and combine them together via composition.

[single inheritance]: reusable-oo-inheritance
[multiple inheritance]: reusable-oo-modules

## Client

The client is a high-level object that creates `Director` instances based on
data from the API. It is not concerned with how to make requests or de-paginate
them, instead leaving that work up to other objects that are passed in.

```ruby
module MovieFacts
  class Client
    def initialize(driver, depaginator)
      @driver = driver
      @depaginator = depaginator
    end

    def directors
      fetch_data("/directors").map { |director| Director.new(director) }
    end

    def director(name)
      Director.new(fetch_data("/directors/#{name}"))
    end

    private

    def fetch_data(path)
      @depaginator.depaginate @driver.fetch_data(path)
    end
  end
end
```

## Driver

This object is concerned with the nuts and bolts of fetching the data. There are
multiple implementations, all of which implement the same interface (i.e. they
are all **duck types** of each other).

```ruby
module MovieFacts
  class HttpDriver
    def fetch_data
      # fetch data over HTTP
      # cache results
    end
  end
end
```

```ruby
module MovieFacts
  class CacheDriver
    def fetch_data
      # read data from cache
    end
  end
end
```

## Depaginator

The depaginator is an object that takes paginated data and combines it into a
single array. Sometimes we don't want to de-paginate so we provide a no-op
version. Once again, both implementations implement the same interface.

```ruby
module MovieFacts
  class Depaginator
    def depaginate(data)
      # depaginate the data
    end
  end
end
```

```ruby
module MovieFacts
  class NoopDepaginator
    def depaginate(data)
      data # just return the data without de-paginating it
    end
  end
end
```

## Putting it all together

Combining all our pieces together, we have an architecture that looks like:

![Composition](https://images.thoughtbot.com/reusable-oo-composition/fgT6i9sRm1Qy5XD35qMw_composition.png)

This is completely modular and can be extended in any way we wish. There is no
fear of combinatorial explosion here. Each responsibility is nicely encapsulated
in its own object which means it can be refactored any time without affecting
any of the collaborating objects.

1. Do we need to fetch from a different source? Just create a new driver.
1. Do we want to convert our multiple pages of data into a lazy stream?
   Implement a new de-paginator.
1. Need to do another thing to the data as before turning it into `Director`
   objects? Pass in another object to the `Client`.
1. Need to refactor the implementation of one of the objects? Do so without
   fear. The only dependency between them is the public interface.

## Decorators

We've [blogged about decorators] in the past. They exist in a weird spot between
inheritance and composition. You could even say that they use composition to
implement inheritance.

Decoration allows you to layer on functionality, building up an object that
responds to methods provided the inner object and all of the decorators. Because
any decorator can be layered on top of any other decorator we are safe from
combinatorial explosion. We also have encapsulation between each of the layers
since they can only communicate to each other via each other's public interface.

We could modify the composition-based implementation above to use decoration:

The client now just takes in an object that responds to `fetch_data`. That could
be a driver or a driver that's been decorated with the depaginator.

```ruby
module MovieFacts
  class Client
    def initialize(driver)
      @driver = driver # may or may not be decorated with a depaginator
    end

    def directors
      @driver.fetch_data("/directors").map { |director| Director.new(director) }
    end

    def director(name)
      Director.new(@driver.fetch_data("/directors/#{name}"))
    end
  end
end
```

The drivers would stay the same as before. The depaginator is turned into a
decorator. We no longer need a `NoopPaginator` because we can get the same
effect by passing in an undecorated driver.

```ruby
module MovieFacts
  class Depaginator < SimpleDelegator
    def fetch_data(path)
      data = __get_obj__.fetch_data(path)
      # depaginate the data
    end
  end
end
```

[blogged about decorators]: https://thoughtbot.com/blog/evaluating-alternative-decorator-implementations-in

## Advantages and limitations

A composition-based approach allows us to build smaller, self-contained objects
that respect encapsulation, and can be endlessly combined with each other to
solve the combinatorial explosion problem.

Composition's main strength, combining small objects, is also its greatest
weakness. Combining many small objects can be a lot of work. Taken to an
extreme, you need to create dedicated factory objects just to figure out which
objects to combine with each other. Although you've made each individual object
easier to understand because it stands on its own and is small, inderection is
increased in the system overall as you try to follow the execution path of a
method from one collaborator to the next.

## Further Reading

This article is part 3 of 4 in a series on building reusable object-oriented
software.

1. [Simple Inheritance](reusable-oo-inheritance)
1. [Mixins/Multiple Inheritance](reusable-oo-modules)
1. [Composition (this article)](reusable-oo-composition)
1. [Composition vs Inheritance](reusable-oo-composition-vs-inheritance)