design-patterns-ruby

<quick_start> <pattern_selection> Object Creation Problems → Creational Patterns

• Decouple creation from usage → Factory Method
• Families of related objects → Abstract Factory
• Complex objects with many params → Builder
• Clone without concrete class dependency → Prototype
• Single shared instance → Singleton

Structural Problems → Structural Patterns

• Incompatible interfaces → Adapter
• Multiple independent dimensions → Bridge
• Tree structures treated uniformly → Composite
• Add behavior dynamically → Decorator
• Simplify complex subsystems → Facade
• Memory with many similar objects → Flyweight
• Access control/logging/caching → Proxy

Behavioral Problems → Behavioral Patterns

• Multiple handlers in sequence → Chain of Responsibility
• Decouple UI from business logic → Command
• Traverse without exposing internals → Iterator
• Reduce chaotic dependencies → Mediator
• Undo/restore functionality → Memento
• Notify about state changes → Observer
• Behavior varies by state → State
• Switch algorithms at runtime → Strategy
• Algorithm skeleton with custom steps → Template Method
• Operations on complex structures → Visitor </pattern_selection>

<ruby_abstract_method> Ruby doesn't have built-in abstract methods. Use:

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

</ruby_abstract_method> </quick_start>

<when_to_use> Use this skill when encountering:

• "How do I create objects without specifying exact classes?" → Factory Method/Abstract Factory
• "Constructor has too many parameters" → Builder
• "Need to copy objects without knowing their concrete type" → Prototype
• "Ensure only one instance exists" → Singleton
• "Legacy class interface doesn't match what I need" → Adapter
• "Class explosion from combining multiple features" → Bridge
• "Work with tree/hierarchy uniformly" → Composite
• "Add features without modifying class" → Decorator
• "Simplify interaction with complex library" → Facade
• "Too many similar objects consuming memory" → Flyweight
• "Control access/add logging to object" → Proxy
• "Request goes through chain of handlers" → Chain of Responsibility
• "Need undo/redo or queue operations" → Command
• "Custom iteration over collection" → Iterator
• "Components too tightly coupled" → Mediator
• "Save and restore object state" → Memento
• "Notify multiple objects of changes" → Observer
• "Object behavior depends on state" → State
• "Swap algorithms at runtime" → Strategy
• "Subclasses customize algorithm steps" → Template Method
• "Add operations to class hierarchy" → Visitor </when_to_use>

<pattern_quick_reference> Factory Method - Define interface for creation, let subclasses decide type

class Creator
  def factory_method
    raise NotImplementedError
  end

  def operation
    product = factory_method
    "Working with #{product.operation}"
  end
end

class ConcreteCreator < Creator
  def factory_method
    ConcreteProduct.new
  end
end

File: Ruby/src/factory_method/conceptual/main.rb

Singleton (thread-safe)

class Singleton
  @instance_mutex = Mutex.new
  private_class_method :new

  def self.instance
    return @instance if @instance
    @instance_mutex.synchronize { @instance ||= new }
    @instance
  end
end

File: Ruby/src/singleton/conceptual/thread_safe/main.rb

See references/creational-patterns.md for Abstract Factory, Builder, Prototype.

def operation @component.operation end end

class ConcreteDecorator < Decorator def operation "Decorated(#{@component.operation})" end end

Stack decorators

decorated = DecoratorB.new(DecoratorA.new(ConcreteComponent.new))

File: `Ruby/src/decorator/conceptual/main.rb`