Merge pull request #22 from bvwells/state

Implement state design pattern #15

Author: bvwells

README.md

@@ -68,7 +68,7 @@ Name       | Description                               | Status
 [`Mediator`](./behavioral/mediator.go) | Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it allows their interaction to vary independently. |
 [`Memento`](./behavioral/memento.go) | Without violating encapsulation, capture and externalize an object's internal state allowing the object to be restored to this state later. |
 [`Observer`](./behavioral/observer.go) | Define a one-to-many dependency between objects where a state change in one object results in all its dependents being notified and updated automatically. | Implemented
-[`State`](./behavioral/state.go) | Allow an object to alter its behavior when its internal state changes. The object will appear to change its class. |
+[`State`](./behavioral/state.go) | Allow an object to alter its behavior when its internal state changes. The object will appear to change its class. | Implemented
 [`Strategy`](./behavioral/strategy.go) | Define a family of algorithms, encapsulate each one, and make them interchangeable. Strategy lets the algorithm vary independently from clients that use it. | Implemented
 [`Template Method`](./behavioral/template_method.go) | Define the skeleton of an algorithm in an operation, deferring some steps to subclasses. Template method lets subclasses redefine certain steps of an algorithm without changing the algorithm's structure. | Implemented
 [`Visitor`](./behavioral/visitor.go) | Represent an operation to be performed on the elements of an object structure. Visitor lets a new operation be defined without changing the classes of the elements on which it operates. | Implemented

behavioral/state.go

@@ -1 +1,77 @@
 package behavioral
+
+import (
+	"fmt"
+)
+
+// Machine defines a machine which can be swwitched on and off.
+type Machine struct {
+	current State
+}
+
+// NewMachine creates a new machine.
+func NewMachine() *Machine {
+	fmt.Fprintf(outputWriter, "Machine is ready.\n")
+	return &Machine{NewOFF()}
+}
+
+// setCurrent sets the current state of the machine.
+func (m *Machine) setCurrent(s State) {
+	m.current = s
+}
+
+// On pushes the on button.
+func (m *Machine) On() {
+	m.current.On(m)
+}
+
+// Off pushes the off button.
+func (m *Machine) Off() {
+	m.current.Off(m)
+}
+
+// State describes the internal state of the machine.
+type State interface {
+	On(m *Machine)
+	Off(m *Machine)
+}
+
+// ON describes the on button state.
+type ON struct {
+}
+
+// NewON creates a new ON state.
+func NewON() State {
+	return &ON{}
+}
+
+// On does nothing.
+func (o *ON) On(m *Machine) {
+	fmt.Fprintf(outputWriter, "   already ON\n")
+}
+
+// Off switches the state from on to off.
+func (o *ON) Off(m *Machine) {
+	fmt.Fprintf(outputWriter, "   going from ON to OFF\n")
+	m.setCurrent(NewOFF())
+}
+
+// OFF describes the off button state.
+type OFF struct {
+}
+
+// NewOFF creates a new OFF state.
+func NewOFF() State {
+	return &OFF{}
+}
+
+// On switches the state from off to on.
+func (o *OFF) On(m *Machine) {
+	fmt.Fprintf(outputWriter, "   going from OFF to ON\n")
+	m.setCurrent(NewON())
+}
+
+// Off does nothing.
+func (o *OFF) Off(m *Machine) {
+	fmt.Fprintf(outputWriter, "   already OFF\n")
+}

behavioral/state_test.go

@@ -0,0 +1,28 @@
+package behavioral
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestState(t *testing.T) {
+
+	bufferOutputWriter := outputWriter
+	outputWriter = new(bytes.Buffer)
+	defer func() { outputWriter = bufferOutputWriter }()
+
+	machine := NewMachine()
+	machine.Off()
+	machine.On()
+	machine.On()
+	machine.Off()
+
+	assert.Equal(t, "Machine is ready.\n"+
+		"   already OFF\n"+
+		"   going from OFF to ON\n"+
+		"   already ON\n"+
+		"   going from ON to OFF\n", outputWriter.(*bytes.Buffer).String())
+
+}