From aa679a8f16d625eea54239348ab77cd745bc3767 Mon Sep 17 00:00:00 2001
From: Klimov Sergey <klim0v-sergey@yandex.ru>
Date: Wed, 6 Feb 2019 23:11:29 +0300
Subject: [PATCH 1/3] implement abstract factory pattern

---
 creational/abstract-factory.md | 134 +++++++++++++++++++++++++++++++++
 1 file changed, 134 insertions(+)
 create mode 100644 creational/abstract-factory.md

diff --git a/creational/abstract-factory.md b/creational/abstract-factory.md
new file mode 100644
index 0000000..7605dd9
--- /dev/null
+++ b/creational/abstract-factory.md
@@ -0,0 +1,134 @@
+# Abstract Factory Pattern
+
+The abstract factory pattern provides a way to encapsulate a group of individual factories 
+that have a common theme without specifying their concrete classes.
+
+## Implementation
+
+
+```go
+package main
+
+import (
+	"fmt"
+)
+
+type AbstractFactory interface {
+	CreateProductA() AbstractProductA
+	CreateProductB() AbstractProductB
+}
+
+type ConcreteFactory1 struct {
+}
+
+func NewConcreteFactory1() *ConcreteFactory1 {
+	return &ConcreteFactory1{}
+}
+
+func (ConcreteFactory1) CreateProductA() AbstractProductA {
+	return NewConcreteProductA1()
+}
+
+func (ConcreteFactory1) CreateProductB() AbstractProductB {
+	return NewConcreteProductB1()
+}
+
+type ConcreteFactory2 struct {
+}
+
+func NewConcreteFactory2() *ConcreteFactory2 {
+	return &ConcreteFactory2{}
+}
+
+func (ConcreteFactory2) CreateProductA() AbstractProductA {
+	return NewConcreteProductA2()
+}
+
+func (ConcreteFactory2) CreateProductB() AbstractProductB {
+	return NewConcreteProductB2()
+}
+
+type AbstractProductA interface {
+	UsefulFunctionA() string
+}
+
+type AbstractProductB interface {
+	UsefulFunctionB() string
+	AnotherUsefulFunctionB(collaborator AbstractProductA) string
+}
+
+type ConcreteProductA1 struct {
+}
+
+func NewConcreteProductA1() *ConcreteProductA1 {
+	return &ConcreteProductA1{}
+}
+
+func (ConcreteProductA1) UsefulFunctionA() string {
+	return "The result of the product A2."
+}
+
+type ConcreteProductA2 struct {
+}
+
+func NewConcreteProductA2() *ConcreteProductA2 {
+	return &ConcreteProductA2{}
+}
+
+func (ConcreteProductA2) UsefulFunctionA() string {
+	return "The result of the product A2."
+}
+
+type ConcreteProductB1 struct {
+}
+
+func NewConcreteProductB1() *ConcreteProductB1 {
+	return &ConcreteProductB1{}
+}
+
+func (ConcreteProductB1) UsefulFunctionB() string {
+	return "The result of the product B1."
+}
+
+func (ConcreteProductB1) AnotherUsefulFunctionB(collaborator AbstractProductA) string {
+	return "The result of the product B2."
+}
+
+type ConcreteProductB2 struct {
+}
+
+func NewConcreteProductB2() *ConcreteProductB2 {
+	return &ConcreteProductB2{}
+}
+
+func (ConcreteProductB2) UsefulFunctionB() string {
+	return "The result of the product B2."
+}
+
+func (ConcreteProductB2) AnotherUsefulFunctionB(collaborator AbstractProductA) string {
+	result := collaborator.UsefulFunctionA()
+	return fmt.Sprintf("The result of the B2 collaborating with the (%s)", result)
+}
+```
+
+## Usage
+
+```go
+
+func clientCode(factory AbstractFactory) {
+	productA := factory.CreateProductA()
+	productB := factory.CreateProductB()
+	fmt.Println(productB.UsefulFunctionB())
+	fmt.Println(productB.AnotherUsefulFunctionB(productA))
+}
+
+func main() {
+	fmt.Println("Client: Testing client code with the first factory type:")
+	clientCode(NewConcreteFactory1())
+
+	fmt.Println()
+
+	fmt.Println("Client: Testing the same client code with the second factory type:")
+	clientCode(NewConcreteFactory2())
+}
+```

From 936c02967e67d4ed0b09c7fcc31368ec3a400e7c Mon Sep 17 00:00:00 2001
From: Klimov Sergey <klim0v-sergey@yandex.ru>
Date: Wed, 6 Feb 2019 23:14:44 +0300
Subject: [PATCH 2/3] Update README.md

---
 README.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/README.md b/README.md
index 7d9f5f7..30ebd71 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,7 @@ A curated collection of idiomatic design & application patterns for Go language.
 
 | Pattern | Description | Status |
 |:-------:|:----------- |:------:|
-| [Abstract Factory](/creational/abstract_factory.md) | Provides an interface for creating families of releated objects | ✘ |
+| [Abstract Factory](/creational/abstract_factory.md) | Provides an interface for creating families of releated objects | ✔ |
 | [Builder](/creational/builder.md) | Builds a complex object using simple objects | ✔ |
 | [Factory Method](/creational/factory.md) | Defers instantiation of an object to a specialized function for creating instances | ✔ |
 | [Object Pool](/creational/object-pool.md) | Instantiates and maintains a group of objects instances of the same type | ✔ |

From 3a9d6d18115fc3886b28ede18accc5f37f5e6c55 Mon Sep 17 00:00:00 2001
From: Klimov Sergey <klim0v-sergey@yandex.ru>
Date: Wed, 6 Feb 2019 23:20:22 +0300
Subject: [PATCH 3/3] Rename abstract-factory.md to abstract_factory.md

---
 creational/{abstract-factory.md => abstract_factory.md} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename creational/{abstract-factory.md => abstract_factory.md} (100%)

diff --git a/creational/abstract-factory.md b/creational/abstract_factory.md
similarity index 100%
rename from creational/abstract-factory.md
rename to creational/abstract_factory.md