SWPatterns.com

Decorator - Ruby

The Decorator pattern dynamically adds responsibilities to an object without modifying its structure. It provides a flexible alternative to subclassing for extending functionality. This implementation uses Ruby’s dynamic nature and block-based approach to define decorators as classes that wrap the original object …

Composite - Ruby

The Composite pattern allows you to treat individual objects and compositions of objects uniformly. It defines a tree-like structure where each node can be either a leaf (individual object) or a branch (composite object containing other nodes). This removes the need for different code to handle individual objects …

Bridge - Ruby

The Bridge pattern is a structural design pattern that lets you split an abstraction from its implementation so that objects can have different implementations. This is useful when there is a need to avoid a hard coupling between an abstraction and its implementation, allowing both to vary independently.

The code …

Adapter - Ruby

The Adapter pattern converts the interface of a class into another interface clients expect. This allows classes with incompatible interfaces to collaborate. Our example adapts a LegacyRectangle class with a different area calculation method to the GeometricShape interface which requires a standardized area method. We …

Service Locator - Ruby

The Service Locator pattern provides a central point of access to various services within an application. Instead of a class directly creating or finding its dependencies, it asks the locator for them. This promotes loose coupling and makes it easier to swap implementations or manage dependencies.

The Ruby …

Dependency Injection - Ruby

Dependency Injection (DI) is a design pattern where a class receives its dependencies from external sources rather than creating them itself. This promotes loose coupling, making the class more testable, reusable, and maintainable. Our Ruby example demonstrates this. Instead of the ReportGenerator creating a …

Lazy Initialization - Ruby

The Lazy Initialization pattern delays the creation of an object until it’s actually needed, improving performance if the object is rarely used. This avoids unnecessary resource consumption during program startup. Our Ruby implementation uses a simple instance variable and a conditional assignment within a getter …

Object Pool - Ruby

The Object Pool pattern manages a group of reusable objects, reducing the overhead of frequent object creation and destruction. This is particularly useful for expensive-to-create objects. This Ruby implementation uses a simple array to store a pool of DatabaseConnection objects. checkout retrieves an available object …

Multiton - Ruby

The Multiton pattern ensures that only a limited number of instances of a class can exist. Unlike a Singleton which restricts to just one instance, a Multiton allows a specified quantity. This example uses a class variable @instances to store the created instances and a class method instance to manage their creation, …

Singleton - Ruby

The Singleton pattern ensures a class has only one instance and provides a global point of access to it. This is useful for managing resources like database connections, configuration settings, or a logger where multiple instances would be detrimental.

The Ruby implementation uses a class variable @@instance to store …