:sparkles: (Go) builder pattern

Go/design-patterns/builder/builder.go

···
+package builder
+
+type IBuilder interface {
+    setWindowType()
+    setDoorType()
+    setNumFloor()
+    getHouse() House
+}
+
+func getBuilder(builderType string) IBuilder {
+    if builderType == "normal" {
+        return newNormalBuilder()
+    }
+
+    if builderType == "igloo" {
+        return newIglooBuilder()
+    }
+
+    return nil
+}

Go/design-patterns/builder/builder_test.go

···
+package builder
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestBuilder(t *testing.T) {
+
+    tests := []struct{
+        builder  string
+        expected House
+    }{
+        {
+            builder: "normal",
+            expected: House{
+                windowType: "Wooden Window",
+                doorType:   "Wooden Door",
+                floor:      2,
+            },
+        },
+        {
+            builder: "igloo",
+            expected: House{
+                windowType: "Snow Window",
+                doorType:   "Snow Door",
+                floor:      1,
+            },
+        },
+    }
+
+    for _, test := range tests {
+        t.Run(fmt.Sprintf("should create a %s house with a builder using a director", test.builder), func(t *testing.T) {
+            builder := getBuilder(test.builder)
+            director := newDirector(builder)
+            house := director.buildHouse()
+
+            assertHouse(t, house, test.expected)
+        })
+    }
+}
+
+func assertHouse(t testing.TB, got, want House) {
+    t.Helper()
+
+    if got != want {
+        t.Errorf("expected house to be %+v, got %+v", want, got)
+    }
+}

Go/design-patterns/builder/director.go

···
+package builder
+
+type Director struct {
+    builder IBuilder
+}
+
+func newDirector(b IBuilder) *Director {
+    return &Director{
+        builder: b,
+    }
+}
+
+func (d *Director) setBuilder(b IBuilder) {
+    d.builder = b
+}
+
+func (d *Director) buildHouse() House {
+    d.builder.setDoorType()
+    d.builder.setWindowType()
+    d.builder.setNumFloor()
+    return d.builder.getHouse()
+}

Go/design-patterns/builder/house.go

···
+package builder
+
+type House struct {
+    windowType string
+    doorType   string
+    floor      int
+}

Go/design-patterns/builder/iglooBuilder.go

···
+package builder
+
+type IglooBuilder struct {
+    windowType string
+    doorType   string
+    floor      int
+}
+
+func newIglooBuilder() *IglooBuilder {
+    return &IglooBuilder{}
+}
+
+func (b *IglooBuilder) setWindowType() {
+    b.windowType = "Snow Window"
+}
+
+func (b *IglooBuilder) setDoorType() {
+    b.doorType= "Snow Door"
+}
+
+func (b *IglooBuilder) setNumFloor() {
+    b.floor = 1
+}
+
+func (b *IglooBuilder) getHouse() House {
+    return House{
+        doorType:   b.doorType,
+        windowType: b.windowType,
+        floor:      b.floor,
+    }
+}
+

Go/design-patterns/builder/normalBuilder.go

···
+package builder
+
+type NormalBuilder struct {
+    windowType string
+    doorType   string
+    floor      int
+}
+
+func newNormalBuilder() *NormalBuilder {
+    return &NormalBuilder{}
+}
+
+func (b *NormalBuilder) setWindowType() {
+    b.windowType = "Wooden Window"
+}
+
+func (b *NormalBuilder) setDoorType() {
+    b.doorType= "Wooden Door"
+}
+
+func (b *NormalBuilder) setNumFloor() {
+    b.floor = 2
+}
+
+func (b *NormalBuilder) getHouse() House {
+    return House{
+        doorType:   b.doorType,
+        windowType: b.windowType,
+        floor:      b.floor,
+    }
+}