CoffeeScript Design Patterns

Ports of Gang of Four design patterns in coffee.

Creational Patterns
Structural Patterns
- Adapter
- Bridge
- Composite
- Decorator
- Facade
- Flyweight
- Proxy
Behavioral Patterns
- Chain of Responsibility
- Command
- Interpreter
- Iterator
- Mediator
- Memento*
- Observer
- State*
- Strategy
- Template Method
- Visitor*
Foundational Classes
- List Class

* Unfinished pattern

Creational Patterns

Abstract Factory

class AbstractProductA
  constructor: (arg) ->
    console.log arg

class AbstractProductB
  constructor: (arg) ->
    console.log arg

class ConcreteProductA1 extends AbstractProductA
class ConcreteProductA2 extends AbstractProductA
class ConcreteProductB1 extends AbstractProductB
class ConcreteProductB2 extends AbstractProductB

class AbstractFactory
  createProductA: () ->
  createProductB: () ->

class ConcreteFactory1 extends AbstractFactory
  createProductA: () ->
    new ConcreteProductA1 "ConcreteProductA1"
  createProductB: () ->
    new ConcreteProductB1 "ConcreteProductB1"

class ConcreteFactory2 extends AbstractFactory
  createProductA: () ->
    new ConcreteProductA2 "ConcreteProductA2"
  createProductB: () ->
    new ConcreteProductB2 "ConcreteProductB2"

class Client
  constructor: (factory) ->
    @abstractProductA = factory.createProductA()
    @abstractProductB = factory.createProductB()

class Example
  @run: () ->
    factory1 = new ConcreteFactory1()
    client1 = new Client factory1
    factory2 = new ConcreteFactory2()
    client2 = new Client factory2

Example.run()

Builder

class Director
  constructor: (@builder) ->
  construct: (structure) ->
    for obj in structure
      console.log obj
      @builder.buildPart obj
    return

class Product
  constructor: () ->
    @result = ''
  append: (obj) ->
    @result += obj
  get: () ->
    @result

class Builder
  buildPart: () ->

class ConcreteBuilder extends Builder
  constructor: () ->
    @product = new Product()
  buildPart: (obj) ->
    @product.append obj.toUpperCase()
  getResult: () ->
    @product

class Client
  @run: () ->
    concreteBuilder = new ConcreteBuilder()
    director = new Director concreteBuilder
    director.construct "ohai"
    result = concreteBuilder.getResult()
    alert result.get()

Client.run()

Factory Method

class Product
class ConcreteProduct1 extends Product
class ConcreteProduct2 extends Product

class Creator
  factoryMethod: () ->
  operation: () ->
    product = @factoryMethod()

class ConcreteCreator extends Creator
  factoryMethod: (id) ->
    switch id
      when id is 1 then return new ConcreteProduct1()      
      when id is 2 then return new ConcreteProduct2()

class Example
  @run: () ->
    creator = new ConcreteCreator()
    console.log creator.factoryMethod 1
    console.log creator.factoryMethod 2
    console.log creator.factoryMethod 3

Example.run()

Prototype

class Client
  constructor: () ->
  operation: (prototype) ->
    p = prototype.clone()

class Prototype
  clone: () ->
    if Object.create
      Object.create @

    else # if < IE9
      Clone = () ->
      Clone:: = @
      new Clone()

  setProperty: (@property) ->
  logProperty: () -> console.log @property or '-'

class ConcretePrototype1 extends Prototype

class ConcretePrototype2 extends Prototype

class Example
  @run: () ->
    client = new Client()
    cp1 = new ConcretePrototype1()
    cp1Prototype = client.operation(cp1)

    cp1.setProperty 'original1'
    cp1Prototype.setProperty 'clone1'
    cp1.logProperty()
    cp1Prototype.logProperty()

Example.run()

Singleton

class Singleton
  @_instance: null
  @getInstance: ->
    @_instance ||= new @ arguments...

class Example
  @run: () ->
    class ExampleClass extends Singleton
      constructor: () ->
      properties: {}
      set: (key, val) ->
        @properties[key] = val
        return
      get: (key) ->
        @properties[key]

    example = ExampleClass.getInstance()
    example.set "Singleton", "This is a singleton value"
    console.log example.get "Singleton"

Example.run()

Structural Patterns

Adapter

class Target
  request: () ->
    console.log "Not fired"

class Adaptee
  specificRequest: () ->
    console.log "Specific request"

class Adapter extends Target
  constructor: (@adaptee) ->
  request: () ->
    @adaptee.specificRequest()

class Client
  @run: () ->
    adaptee = new Adaptee()
    adapter = new Adapter adaptee
    adapter.request()

Client.run()

Bridge

class Abstraction
  constructor: (@imp) ->
  operation: () ->
    @imp.operationImp()

class RefinedAbstraction extends Abstraction

class Implementor
  operationImp: () ->

class ConcreteImplementorA extends Implementor
  operationImp: () ->
    console.log "ConcreteImplementorA::operationImp"

class ConcreteImplementorB extends Implementor
  operationImp: () ->
    console.log "ConcreteImplementorB::operationImp"

class Client
  @run: () ->
    concreteImplementorA = new ConcreteImplementorA()
    refinedAbstractionA = new RefinedAbstraction concreteImplementorA
    refinedAbstractionA.operation()

    concreteImplementorB = new ConcreteImplementorB()
    refinedAbstractionB = new RefinedAbstraction concreteImplementorB
    refinedAbstractionB.operation()

Client.run()

Composite

class Component
  constructor: () ->
    @list = []
  getComposite: () ->
  operation: () ->
  add: (component) ->

class Leaf extends Component

class Composite extends Component
  add: (component) ->
    @list.push component
  operation: () ->
    console.log @list
  getComposite: () ->
    @

class Client
  @run: () ->
    # Create a Composite object and add a Leaf
    composite = new Composite()
    leaf = new Leaf()
    composite.add leaf
    composite.operation()
    
    # Add a Composite to the Composite
    composite2 = new Composite()
    composite.add composite2
    composite.operation()

Client.run()

Decorator

class Component
  props: {}
  add: (key, val) ->
    @props[key] = val
  get: () ->
    @props
  process: () ->

class ConcreteComponent extends Component
  process: () ->

class Decorator extends Component
  constructor: (@component) ->
  process: () ->
    @component.process()

class ConcreteDecoratorA extends Decorator
  process: () ->
    @component.add "concreteDecoratorAProcess", true
    super()

class ConcreteDecoratorB extends Decorator
  process: () ->
    @component.add "concreteDecoratorBProcess", true
    super()

class Example
  @run: () ->
    cmpt = new ConcreteDecoratorA new ConcreteDecoratorB new ConcreteComponent()
    cmpt.process()

Example.run()

Facade

class Subsystem1
  constructor: () ->
    console.log 'subsystem1'

class Subsystem2
  constructor: () ->
    console.log 'subsystem2'

class Facade
  request: () ->
    s1 = new Subsystem1()
    s2 = new Subsystem2()

class Client
  @run: () ->
    facade = new Facade()
    facade.request()

Client.run()

Flyweight

class FlyweightFactory
  constructor: ->
    @flyweights = {}

  getFlyweight: (key) ->
    unless @flyweights[key]?
      @flyweights[key] = new ConcreteFlyweight key
    @flyweights[key]

class Flyweight
  constructor: (@key) ->
  operation: (extrinsicState) ->

class ConcreteFlyweight extends Flyweight
  intrinsicState: ""
  operation: (extrinsicState) ->
    @intrinsicState += "#{extrinsicState} "
    console.log @intrinsicState

class UnsharedConcreteFlyweight extends Flyweight
  allState: null

class Client
  @run: ->
    factory = new FlyweightFactory()
    foo = factory.getFlyweight "foo"
    bar = factory.getFlyweight "bar"
    baz = factory.getFlyweight "baz"
    qux = factory.getFlyweight "foo"
    foo.operation "red"
    bar.operation "green"
    baz.operation "blue"
    qux.operation "black"
 
Client.run()

Proxy

class Subject
  request: ->

class RealSubject extends Subject
  request: ->
    console.log "Real subject"

class Proxy extends Subject
  request: () ->
    unless @realSubject?
      @realSubject = new RealSubject()
    @realSubject.request()

class Client
  @run: ->
    proxy = new Proxy()
    proxy.request()

Client.run()

Behavioral Patterns

Chain of Responsibility

class Handler
  constructor: (@kind, @successor) ->
  handleRequest: ->
    if @successor
      @successor.handleRequest()

class ConcreteHandler1 extends Handler
  handleRequest: ->
    console.log "#{@kind} handled"

class ConcreteHandler2 extends Handler

class Client
  @run: ->
    concreteHandler1 = new ConcreteHandler1 "foo"
    concreteHandler2 = new ConcreteHandler2 "bar", concreteHandler1
    concreteHandler2.handleRequest()

Client.run()

Command

class Command
  execute: () ->

class Invoker
  execute: (command) ->
    command.execute()

class Receiver
  action1: () -> console.log "action1"
  action2: () -> console.log "action2"

class ConcreteCommandA extends Command
  constructor: (@receiver) ->
  execute: () ->
    @receiver.action1()

class ConcreteCommandB extends Command
  constructor: (@receiver) ->
  execute: () ->
    @receiver.action2()

class Client
  @run: (action) ->
    receiver = new Receiver()
    ccmdA = new ConcreteCommandA receiver
    ccmdB = new ConcreteCommandB receiver
    invoker = new Invoker()
    invoker.execute ccmdA if action is 1
    invoker.execute ccmdB if action is 2

class Example
  @run: () ->
    Client.run 1
    Client.run 2

Example.run()

Interpreter

class Context
  constructor: (@name) ->
  getName: () ->
    @name

class AbstractExpression
  constructor: () ->
    @expressions = []
  interpret: (@context) ->

class TerminalExpression extends AbstractExpression
  interpret: (@context) ->
    console.log "Terminal expression for #{@context.getName()}"

class NonterminalExpression extends AbstractExpression
  addExpression: (expression) ->
    @expressions.push expression

  interpret: (@context) ->
    console.log "Nonterminal expression for #{@context.getName()}"
    for expression in @expressions
      expression.interpret @context

class Client
  @run: () ->
    context = new Context '*le context'
    root = new NonterminalExpression()
    root.addExpression new TerminalExpression()
    root.addExpression new TerminalExpression()
    root.interpret context

Client.run()

Iterator

class Iterator
  first: () ->
  next: () ->
  isDone: () ->
  currentItem: () ->

class ConcreteIterator extends Iterator
  constructor: (@list) ->
    @current = 0
  first: () ->
    @current = 0
  next: () ->
    @current += 1
  isDone: () ->
    @current >= @list.count()
  currentItem: () ->
    throw new Error "IteratorOutOfBounds" if @isDone()
    @list.get @current
    
class Aggregate
  createIterator: () ->

class ConcreteAggregate extends Aggregate
  createIterator: (items) ->
    list = new List()
    for key, val of items
      val.__POINTER__ = key
      list.append val
    new ConcreteIterator list

class Client
  @run: () ->
    aggregate = new ConcreteAggregate()
    iterator = aggregate.createIterator items

    while not iterator.isDone()
      current = iterator.currentItem()
      # Do something with the item here...
      iterator.next()

Client.run()

Mediator

class Colleague
  constructor: (@mediator) ->
  changed: () ->
    @mediator.colleagueChanged @

class ConcreteColleague1 extends Colleague
  event: () ->
    @changed()

class ConcreteColleague2 extends Colleague
  event: () ->
    @changed()

class Mediator
  colleagueChanged: (colleague) ->

class ConcreteMediator extends Mediator
  createColleagues: () ->
    @colleague1 = new ConcreteColleague1 @
    @colleague2 = new ConcreteColleague2 @
    @colleague1.event()
    @colleague2.event()

  colleagueChanged: (colleague) ->
    if colleague instanceof ConcreteColleague1
      console.log "colleague1 changed"
    else if colleague instanceof ConcreteColleague2
      console.log "colleague2 changed"

class Example
  @run: () ->
    m = new ConcreteMediator()
    m.createColleagues()

Example.run()

Memento

class Memento
  constructor: (@state) ->
  getState: -> @state

class Originator
  constructor: (@state) ->

  setMemento: (memento) ->
    @state = memento.getState()
    return

  createMemento: ->
    new Memento @state

  _changeState: (@state) ->
  _showState: ->
    console.log @state

class Caretaker
  constructor: (@originator) ->

  doCommand: ->
    @state = @originator.createMemento()
    @originator.setMemento @state

  undoCommand: ->
    @originator.setMemento @state

class Client
  @run: ->
    originator = new Originator "foo"
    caretaker = new Caretaker originator
    originator._showState()

    caretaker.doCommand()

    originator._changeState "bar"
    originator._showState()

    caretaker.undoCommand()
    originator._showState()

Client.run()

Observer

class Subject
  constructor: () ->
    @counter = 0
    @observers = new List()
  attach: (o) ->
    o.__POINTER__ = @counter
    @observers.append o
    @counter += 1
  detach: (o) ->
    @observers.remove o
  notify: () ->
    i = new ConcreteIterator @observers
    while not i.isDone()
      i.currentItem().update @
      i.next()

class Observer
  update: (theChangedSubject) ->

class ConcreteSubject extends Subject

class ConcreteObserver extends Observer
  update: (theChangedSubject) ->
    console.log "Updated"

class Example
  @run: () ->
    subject = new ConcreteSubject()
    observer = new ConcreteObserver()
    subject.attach observer 
    subject.notify()

Example.run()

State

Strategy

class Context
  constructor: (@strategy) ->
  contextInterface: () ->
    @strategy.algorithmInterface()

class Strategy
  algorithmInterface: () ->

class ConcreteStrategyA extends Strategy
  algorithmInterface: () ->
    console.log "ConcreteStrategyA"

class ConcreteStrategyB extends Strategy
  algorithmInterface: () ->
    console.log "ConcreteStrategyB"

class ConcreteStrategyC extends Strategy
  algorithmInterface: () ->
    console.log "ConcreteStrategyC"

class Example
  @run: () ->
    context = new Context new ConcreteStrategyA
    resultA = context.contextInterface()

    context = new Context new ConcreteStrategyB
    resultB = context.contextInterface()

    context = new Context new ConcreteStrategyC
    resultC = context.contextInterface()

Example.run()

Template Method

class AbstractClass
  templateMethod: () ->
    @primitiveOperation1()
    @primitiveOperation2()

  primitiveOperation1: () ->
  primitiveOperation2: () ->

class ConcreteClass extends AbstractClass
  primitiveOperation1: () ->
    console.log "primitiveOperation1"
  primitiveOperation2: () ->
    console.log "primitiveOperation2"

# Static Template Method
class StaticAbstractClass
  @templateMethod: () ->
    cls = new @()
    cls.primitiveOperation1()
    cls.primitiveOperation2()
  primitiveOperation1: () ->
  primitiveOperation2: () ->

class StaticConcreteClass extends StaticAbstractClass
  primitiveOperation1: () ->
    console.log "primitiveOperation1"
  primitiveOperation2: () ->
    console.log "primitiveOperation2"

class Example
  @run: () ->
    concrete = new ConcreteClass()
    concrete.templateMethod()

    StaticConcreteClass.templateMethod()

Example.run()

Visitor

Foundational Classes

List Class

class List
  constructor: () ->
    # A list of pointers
    @items = []
    
    # Objects passed in by pointer
    @objects = {}

  # Returns the number of objects in the list
  count: () ->
    @items.length

  # Returns the object at the given length
  get: (index) ->
    @objects[@items[index]]
    
  # Returns the first object in the list
  first: () ->
    @objects[@items[0]]

  # Returns the last object in the list
  last: () ->
    @objects[@items[@items.length - 1]]

  # Adds the argument to the list, making it the last item
  append: (item) ->
    pointer = item.__POINTER__
    @items.push pointer
    @objects[pointer] = item

  # Removes the given element from the list.
  remove: (item) ->
    pointer = item.__POINTER__
    delete @objects[pointer]
    index = pointer in @items
    # delete @items[index] if index isnt -1
    @items.splice index, 1

  # Removes the last element from the list
  removeLast: () ->
    @remove @last

  # Removes the first element from the list
  removeFirst: () ->
    @remove @first

  # Removes all elements from the list
  removeAll: () ->
    @items = []
    @objects = {}

list = new List()
list.append __POINTER__: "uniqueid", other: "properties"

Zaggen/coffeescript-design-patterns

CoffeeScript Design Patterns

Creational Patterns

Abstract Factory

Builder

Factory Method

Prototype

Singleton

Structural Patterns

Adapter

Bridge

Composite

Decorator

Facade

Flyweight

Proxy

Behavioral Patterns

Chain of Responsibility

Command

Interpreter

Iterator

Mediator

Memento

Observer

State

Strategy

Template Method

Visitor

Foundational Classes

List Class