DEV Community: rubyhub.io

Design Patterns in Ruby | ADAPTER

rubyhub.io — Wed, 22 May 2024 14:36:05 +0000

Overview

The adapter is a structural design pattern that allows two objects with incompatible interfaces to work together.

If you are interested in Ruby language, you will find more about refactoring and design patterns in this language here: https://www.rubyhub.io/. At the moment, the website is under construction, but more topics will appear there in the future.

Real World Example

Before I explain what it is and how to use the adapter pattern, think about what this name associates you with. If you’ve ever been to a country that uses other electrical sockets, you must have used an adapter similar to the one in the picture below.

So what is the purpose of using an adapter? The adapter allows you to connect a plug*(Adaptee)* to an electrical socket*(Target)* that do not fit together.

Coding Problem

First, we will create a simple User class that has two attributes, first_name and last_name, and a full_name method that returns the full name of the user.

class User
  attr_reader :first_name, :last_name

  def initialize(first_name, last_name)
    @first_name = first_name
    @last_name = last_name
  end

  def full_name
    "#{first_name} #{last_name}"
  end
end

Next, we will create a Greeter class, with a hello method that will allow us to greet the user.

class Greeter
  def self.hello(user)
    puts "Hello, #{user.full_name}!"
  end
end

mike = User.new('Michael', 'Scott')
Greeter.hello(mike) # => Hello, Michael Scott!

As we can see, everything in the example above works fine. Now let’s assume that we also want to say hello to every team. So let’s create a Team class.

class Team
  attr_reader :name

  def initialize(name)
    @name = name
  end
end

development = Team.new('Development')
Greeter.hello(development) # NoMethodError: undefined method `full_name'

The method will of course raise an error because the Team class doesn’t have a method that returns the full name.

Solution

Before we create a solution to this problem, we need to define three objects that we need in the Adapter pattern.

Target

The object we want to use. In this case, it will be the Greeter class.

Adaptee

The object we want to adapt to work with the target. In this case, it will be the Team class.

Adapter

An object that allows Adaptee to connect to a Target.

If we have already defined Target and Adaptee objects, we can prepare our Adapter class. To create it, just wrap Adaptee(Team) with a new class(Team Adapter) and then create a method(full_name) that will be compatible with the Greeter class interface.

class TeamAdapter
  attr_reader :team

  def initialize(team)
    @team = team
  end

  def full_name
    "#{team.name} Team"
  end
end

An adapter written in such a way can easily be used to work with the Greeter class.

dev_adapter = TeamAdapter.new(development)
Greeter.hello(dev_adapter) # => "Hello, Development Team!"

I am currently working on a book about design patterns in Ruby. If you are interested in this topic, you can sign up for my newsletter 📪️: https://mailchi.mp/e3dd49dfada1/medium. My subscribers will receive a link to my e-book for free immediately after its publication. 🆓

Design Patterns in Ruby | FLYWEIGHT 💿

rubyhub.io — Mon, 21 Aug 2023 04:00:00 +0000

Overview

Flyweight is a structural design pattern that allows you to reduce RAM consumption by sharing states between similar objects.

It is one of the lesser-used design patterns because of its use. With today’s computing power, we rarely think about the performance of our computers

Coding Example

Let’s assume we have a Canvas on which we want to draw. In order to draw something, we need to put some Color in the right places. So we’ll create a Color class that takes a hexadecimal value as the only attribute.

class Color
  attr_reader :hex

  def initialize(hex)
    @hex = hex
  end
end

Now let’s imagine we want to cover the entire canvas with a resolution of 1000 x 1000 in black.

class Canvas 
  def draw(x:, y:, color:)
    # Draw color on provided coordinates
  end
end

canvas = Canvas.new

1000.times do |x|
  1000.times do |y|
    canvas.draw(x: x, y: y, color: Color.new('#000000'))
  end
end

A canvas created in this way will create as many as a million objects of the Color class. However, we can avoid this with the Flyweight pattern, which allows us to do this using only one object.

So now let’s create a ColorFactory class that will be responsible for color distribution.

class ColorFactory
  attr_reader :colors

  def initialize
    @colors = {}
  end

  def find_color(hex)
    if colors.has_key?(hex)
      color = colors[hex]
    else
      color = Color.new(hex)
      colors[hex] = color
    end

    color
  end
end

This class will store the already created colors, but not in the form of an array, but in the form of a hash. The find_color method will check if a given color already exists and will create a new object only if it has not been created before and add it to the colors hash.

Now using the factory class we are able to create an all-black canvas using only one object.

class Canvas
  attr_reader :color_factory

  def initialize
    @color_factory = ColorFactory.new
  end

  def draw(x:, y:, color:)
    color = color_factory.find_color(color)

    # Draw color on provided coordinates
  end
end

canvas = Canvas.new

1000.times do |x|
  1000.times do |y|
    canvas.draw(x: x, y: y, color: '#000000')
  end
end

Ruby Design Patterns | STATE 🍽️

rubyhub.io — Fri, 18 Aug 2023 04:00:00 +0000

Overview

State is a behavioral design pattern that allows an object to change its behavior when its internal state changes.

As the name suggests, this pattern helps us work with the states of a given object. For today’s example, let’s take the states that orders in a restaurant go through. Our order will go through 4 states:

New
In Progress
Ready
Received

New

The first state appears when we create a new order. At this point, we will be able to perform two actions:

pay for the order
check order status

In Progress

This condition appears just after paying. In this state, we can only:

check order status

Ready

A state that says our order is ready for pickup. At this point, we can take two actions:

check order status
take the order

Received

The last state appears after receiving the order. At this point, we can:

check order status
rate the order

Code Example

We’ll first create a State class that implements all the methods we want to use on the Order class. Each of these methods will raise an error.

class State
  def initialize(order)
    @order = order
  end

  def pay
    raise 'You cannot use this method on this state'
  end

  def next_state
    raise 'You cannot use this method on this state'
  end

  def take
    raise 'You cannot use this method on this state'
  end

  def rate(number)
    raise 'You cannot use this method on this state'
  end
end

Having the main State class, we are able to create subclasses that will represent a particular State and implement only those methods that we want to use in a given state.

class NewState < State
  def pay
    puts 'Payment has been accepted'

    @order.state = InProgressState.new(@order)
  end
end

class InProgressState < State
  def next_state
    puts 'Order is ready to take'

    @order.state = ReadyState.new(@order)
  end
end

class ReadyState < State
  def take
    puts 'The order has been taken'

    @order.state = ReceivedState.new(@order)
  end
end

class ReceivedState < State
  def rate(number)
    puts "You rated the order to: #{number}"
  end
end

We have already created specific State classes, so now we can create our Order class. This class will contain all the methods we need, but in fact, they will be executed according to a specific state.

class Order
  attr_accessor :state

  def initialize
    @state = NewState.new(self)
  end

  def pay
    state.pay
  end

  def next_state
    state.next_state
  end

  def take
    state.take
  end

  def rate(number)
    state.rate(number)
  end

  def status
    state.class.name.gsub('State', '')
  end
end

The order created in this way allows the Order to use only those methods that are allowed in a given State.

order = Order.new
order.status # => "New"

order.take # => RuntimeError: You cannot use this method on this state

order.pay # => Payment has been accepted
order.status # => InProgress

order.next_state # => Order is ready to take
order.take # => The order has been taken

order.take # => RuntimeError: You cannot use this method on this state
order.rate(5) # => "You rated the order to: 5"

Ruby Design Patterns | BUILDER ⚒️

rubyhub.io — Wed, 16 Aug 2023 06:10:08 +0000

Overview

Builder is a creational design pattern that allows create complex objects step by step.

Introduction

When you hear the word builder, you probably think of a construction worker however, in this case, we should think of a builder as an object that is able to build new objects based on multiple elements. Imagine a restaurant that sells Tortillas. The owner had the idea that each customer would be able to compose their own tortillas and gave the customers several options to choose from:

Meat: chicken or mutton
Vegetables: cucumbers, tomatoes, and onions
Sauce: mild or spicy
Spicy sauce has 3 levels: medium, hot, and extra hot

Code Example

So let's create a Tortilla class that will have attributes such as meat, sauce, and vegetables that will be an array.

class Tortilla
  attr_accessor :meat, :vegetables, :sauce

  def initialize
    @vegetables = []
  end
end

In addition, we will create a few empty classes that will be represented by individual ingredients.

class Chicken; end
class Mutton; end
class Cucumber; end
class Onion; end
class Tomato; end
class MildSauce; end

We will also add an attribute to a spicy sauce that will determine its level of spiciness.

class SpicySauce
  attr_reader :level

  def initialize(level)
    @level = level
  end
end

Now we need to prepare a builder class that will help us create our tortilla.

class TortillaBuilder
  attr_reader :tortilla

  def initialize(tortilla)
    @tortilla = tortilla
  end

  def select_chicken
    tortilla.meat = Chicken.new
  end

  def select_mutton
    tortilla.meat = Mutton.new
  end

  def add_cucumber
    tortilla.vegetables << Cucumber.new
  end

  def add_tomato
    tortilla.vegetables << Tomato.new
  end

  def add_onion
    tortilla.vegetables << Onion.new
  end

  def select_garlic_sauce
    tortilla.sauce = GarlicSauce.new
  end

  def select_spicy_sauce(level = :hot)
    tortilla.sauce = SpicySauce.new(level)
  end
end

Now, using the builder class, we want to create a tortilla that will contain:

Chicken meat
Two cucumbers
One Tomato
Extra spicy sauce

builder = TortillaBuilder.new(Tortilla.new)

builder.select_chicken
builder.add_cucumber
builder.add_cucumber
builder.add_tomato
builder.select_spicy_sauce(level: :extra_hot)

At this point, we have created an interface that allows us to quickly and easily create a new object with freely chosen properties.

Ruby Design Patterns | SINGLETON 👴🏼

rubyhub.io — Fri, 11 Aug 2023 13:30:54 +0000

Overview

Singleton is a creational design pattern responsible for the fact that a class can only have one instance.

Real World Example

As an example of today’s pattern, I chose the head of the Catholic Church, the Pope. However, I do not mean the Pope as a person, but as an institution. As we know from history the first Pope was St. Peter, and from that time to the present day, this office is held by various persons. However, it is impossible for more than one Pope to exist at the same time. This institution imposes in advance that this position may only be occupied by one person at a time.

Code Example

Let’s move the above example to the programming world and create a Pope class that can pray through the pray! method.

class Pope
  def pray!
    puts 'In nomine Patris, et Filii, et Spiritus Sancti...'
  end
end

pope = Pope.new
pope.pray! # => 'In nomine Patris, et Filii, et Spiritus Sancti...'

new_pope = Pope.new
new_pope.pray! # => 'In nomine Patris, et Filii, et Spiritus Sancti...'

pope == new_pope # => false

As we can see with the standard approach, we are able to create more than one instance of the Pope class. This is why we need to use the Singleton pattern to prevent creating more than one instance of a given class.

class Pope
  @@instance = new

  def self.instance
    @@instance
  end

  def pray!
    puts 'In nomine Patris, et Filii, et Spiritus Sancti...'
  end

  private_class_method :new
end

pope = Pope.new # => NoMethodError: private method 'new' called for Pope:Class
Pope.instance.pray! # => "In nomine Patris..."

As you can see in the example above, we can’t directly create a class with the new method, which is now private, and we need to use the instance method instead. By comparing two instances to each other, we can make sure that they are the same instance.

pope = Pope.instance
new_pope = Pope.instance
pope == new_pope # => true

Singleton pattern is so popular that there is a Singleton module in the standard Ruby library, thanks to which we will not have to focus on pattern configuration.

class Pope
  include Singleton

  def pray!
    puts 'In nomine Patris, et Filii, et Spiritus Sancti...'
  end
end

This code works in exactly the same way as the code presented at the beginning of this article.

Ruby Design Patterns | PROTOTYPE 🐑

rubyhub.io — Tue, 08 Aug 2023 16:58:58 +0000

Overview

Prototype is a creational design pattern that allows you to create a copy of the object.

Real World Example

Sometimes the name Clone can be found instead of the name Prototype, and this is what I will use for the example below because, in my opinion, it is more appropriate. So we probably all know the story of the first cloned sheep named Dolly(https://en.wikipedia.org/wiki/Dolly_(sheep)). But what does it mean she was a clone? Which means she was biologically the same as the sheep from which the cells were taken (let’s call her Molly).

So, to create our clone(Dolly), we need two things:

The object we can clone(Molly)
A method that will allow us to clone this object(clone)

Coding Problem

First, let’s define a Sheep class that will allow us to create a new sheep.

class Sheep
  attr_reader :genome, :name

  def initialize(name:)
    @name = name
    @genome = Random.new_seed
  end
end

molly = Sheep.new(name: 'Molly')
molly.genome # => 58277341567052563563790228364424051023

dolly = Sheep.new(name: 'Dolly')
molly.genome == dolly.genome # => false

As you can see in the example above, I used a special method that assigns a unique genome encrypted in the form of a sequence of 39 digits. At this point, we are unable to create objects with two identical genomes.

Solution

Using the Prototype pattern, we will add a clone method to our class that will allow us to clone our object. This method will be responsible for assigning the same genome to the newly cloned sheep. To create a new clone, we will also have to enter a new name for our new sheep.

class Sheep
  attr_reader :genome
  attr_writer :name

  def initialize(name:)
    @name = name
    @genome = Random.new_seed
  end

  def clone(name:)
    new_sheep = dup
    new_sheep.name = name

    new_sheep
  end
end

dolly = molly.clone(name: 'Dolly')
molly.genome == dolly.genome # => true

This method allows you to easily clone our sheep and give it a new name.

Caution

However, it should be remembered that in Ruby the Prototype pattern is implemented in the standard library, so when creating the clone method, we overwrite the existing one. In some cases, overriding this method can be useful because the default method only makes a shallow copy of the object.

Ruby Design Patterns | ADAPTER 🔌

rubyhub.io — Fri, 04 Aug 2023 06:38:32 +0000

Overview

The adapter is a structural design pattern that allows two objects with incompatible interfaces to work together.

Real World Example

So what is the purpose of using an adapter? The adapter allows you to connect a plug(Adaptee) to an electrical socket(Target) that do not fit together.

Coding Problem

First, we will create a simple User class that has two attributes, first_name and last_name, and a full_name method that returns the full name of the user.



class User
  attr_reader :first_name, :last_name

  def initialize(first_name, last_name)
    @first_name = first_name
    @last_name = last_name
  end

  def full_name
    "#{first_name} #{last_name}"
  end
end

Now we want to prepare a class that will greet new users, so let's create a Greeter class with a hello method that will allow us to greet the user.



class Greeter
  def self.hello(user)
    puts "Hello, #{user.full_name}!"
  end
end

mike = User.new('Michael', 'Scott')
Greeter.hello(mike) # => Hello, Michael Scott!

As we can see, everything in the example above works fine. Now let’s assume that we also want to say hello to new teams.

First we need to create a Team class.



class Team
  attr_reader :name

  def initialize(name)
    @name = name
  end
end

development = Team.new('Development')
Greeter.hello(development) # NoMethodError: undefined method `full_name'
```

The method will of course raise an error because the **Team** class doesn’t have a method that returns the full name.

## Solution
Before we create a solution to this problem, we need to define three objects that we need in the **Adapter** pattern.

## Target
The object we want to use. In this case, it will be the **Greeter** class.

## Adaptee
The object we want to adapt to work with the target. In this case, it will be the **Team** class.

## Adapter
An object that allows **Adaptee** to connect to a **Target**.

If we have already defined **Target** and **Adaptee** objects, we can prepare our **Adapter** class. To create it, just wrap **Adaptee(Team)** with a new class(**Team Adapter**) and then create a method(**full_name**) that will be compatible with the **Greeter** class interface.

```ruby
class TeamAdapter
  attr_reader :team

  def initialize(team)
    @team = team
  end

  def full_name
    "#{team.name} Team"
  end
end
```

An adapter written in such a way can easily be used to work with the **Greeter** class.

```ruby
dev_adapter = TeamAdapter.new(development)
Greeter.hello(dev_adapter) # => "Hello, Development Team!"
```

DEV Community: rubyhub.io

Design Patterns in Ruby | ADAPTER

Overview

Real World Example

Coding Problem

Solution

Target

Adaptee

Adapter

Design Patterns in Ruby | FLYWEIGHT 💿

Overview

Coding Example

Ruby Design Patterns | STATE 🍽️

Overview

New

In Progress

Ready

Received

Code Example

Ruby Design Patterns | BUILDER ⚒️

Overview

Introduction

Code Example

Ruby Design Patterns | SINGLETON 👴🏼

Overview

Real World Example

Code Example

Ruby Design Patterns | PROTOTYPE 🐑

Overview

Real World Example

Coding Problem

Solution

Caution

More reading

Ruby Design Patterns | ADAPTER 🔌

Overview

Real World Example

Coding Problem