SWPatterns.com

Mediator - Ruby

The Mediator pattern defines an object that encapsulates how a set of objects interact. This promotes loose coupling by preventing objects from referring to each other explicitly, and lets the interactions be varied independently of the objects. Here, we mediate communication between Colleague objects representing …

Iterator - Ruby

The Iterator pattern provides a way to access the elements of an aggregate object sequentially without exposing the underlying representation. It defines a standard interface for iterating through objects, allowing you to traverse elements without knowing precisely how they are stored.

The Ruby implementation utilizes …

Interpreter - Ruby

The Interpreter pattern defines a way to evaluate a language, a simple one or a complex one. It’s useful when you have to embed logic into an application that can change during runtime. This example defines an interpreter for simple arithmetic expressions with integers, using addition and subtraction. The expression …

Command - Ruby

The Command pattern encapsulates a request as an object, allowing parameterization of clients with different requests, queueing or logging of requests, and support for undoable operations. This example represents simple calculator operations (add, subtract) as commands. Each command has an execute method that performs …

Chain of Responsibility - Ruby

The Chain of Responsibility pattern is a behavioral design pattern that allows you to pass a request along a chain of handlers. Each handler decides either to process the request or to pass it to the next handler in the chain. This decouples the sender of a request from its receivers, allowing multiple objects a chance …

Extension Object - Ruby

The Extension Object pattern allows you to add new functionality to existing classes without modifying their original source code, using techniques like monkey patching or reopening classes. This is particularly useful when dealing with third-party libraries or core Ruby classes where direct modification isn’t …

Module - Ruby

The Module pattern in Ruby provides a way to encapsulate related methods and constants, creating namespaces and avoiding naming conflicts. It’s akin to static classes in other languages, but with more flexibility. This implementation defines a StringExtensions module containing a method to check if a string is a …

Proxy - Ruby

The Proxy pattern provides a surrogate or placeholder for another object to control access to it. This is useful for scenarios like remote access, security checks, or lazy loading. Here, we have a Book class representing a resource and a BookProxy that intercepts requests to the Book. The proxy handles loading the …

Flyweight - Ruby

The Flyweight pattern aims to minimize memory usage by sharing common parts of objects. It’s useful when dealing with a large number of similar objects. The pattern separates the object’s state into intrinsic (shared) and extrinsic (unique) components. Intrinsic state is stored in the flyweight object, …

Facade - Ruby

The Facade pattern provides a simplified interface to a complex subsystem. It defines a high-level interface that hides the intricacies of the underlying components, making the system easier to use. This example demonstrates a facade for ordering a pizza. The PizzaOrderFacade encapsulates the interactions with the …