Merge pull request #8 from sensorario/template

add template pattern

Author: sensorario

README.md

@@ -9,6 +9,7 @@
  * [Chain of responsiblity](behavioral/chain) [:notebook:](https://en.wikipedia.org/wiki/Chain-of-responsibility_pattern)
  * [Strategy](behavioral/strategy) [:notebook:](https://en.wikipedia.org/wiki/Strategy_pattern)
  * [Command](behavioral/command) [:notebook:](https://en.wikipedia.org/wiki/Command_pattern)
+ * [Template](behavioral/template) [:notebook:](https://en.wikipedia.org/wiki/Template_pattern)
 
 ## [Creational](creational)
 

behavioral/README.md

@@ -7,3 +7,4 @@ We are going to deal with behaviors instead of define structures or encapsulate
  * [Strategy](strategy) [:notebook:](https://en.wikipedia.org/wiki/Strategy_pattern)
  * [Chain of Responsibility](chain) [:notebook:](https://en.wikipedia.org/wiki/Chain-of-responsibility_pattern)
  * [Command](command) [:notebook:](https://en.wikipedia.org/wiki/Command_pattern)
+ * [Template](template) [:notebook:](https://en.wikipedia.org/wiki/Template_pattern)

behavioral/template/README.md

@@ -0,0 +1,65 @@
+# Template
+
+## Description
+
+Strategy pattern consists in a different way to solve same problem with
+different strategies. In Strategy entire algorithm is store in different
+classes. In Template pattern, instead, the algorithm is just one. The template
+defines steps but some other steps are deferred to user.
+
+## Implementation
+
+In this case the template is a sort of flow of steps to solve a problem. While
+in strategy pattern each strategy implements entire solution, in this case the
+template define the steps execution but defer one or more steps to the user. In
+this case, the deferred step is called `templateSteps`.
+
+```go
+type TheTemplate interface {
+	first() string
+	second() string
+	templateSteps(MessageRetriever) string
+}
+```
+
+The `MessageRetriever` is an interface with `Message()` method. The template
+pattern here will joins strings. While first and third steps are implemented,
+the custom step is implemented by user.
+
+```go
+type MessageRetriever interface {
+	Message() string
+}
+```
+
+Now let's implement a concrete `Template`.
+
+```go
+type Template struct{}
+```
+
+In this case first and second steps are defined. The `templateSteps` will join
+different strings receiving the third step from outside.
+
+```go
+func (t *Template) first() string {
+	return "hello"
+}
+
+func (t *Template) second() string {
+	return "template"
+}
+```
+
+```go
+func (t *Template) templateSteps(m MessageRetriever) string {
+	return strings.Join(
+		[]string{
+			t.first(),
+			m.Message(),
+			t.second(),
+		},
+		" ",
+	)
+}
+```

behavioral/template/template.go

@@ -0,0 +1,71 @@
+package template
+
+import "strings"
+
+type MessageRetriever interface {
+	Message() string
+}
+
+type TheTemplate interface {
+	first() string
+	second() string
+	customStep(MessageRetriever) string
+}
+
+type Template struct{}
+
+func (t *Template) first() string {
+	return "hello"
+}
+
+func (t *Template) second() string {
+	return "template"
+}
+
+func (t *Template) customStep(m MessageRetriever) string {
+	return strings.Join(
+		[]string{
+			t.first(),
+			m.Message(),
+			t.second(),
+		},
+		" ",
+	)
+}
+
+type Anonymous struct{}
+
+func (a *Anonymous) first() string {
+	return "hello"
+}
+
+func (a *Anonymous) second() string {
+	return "template"
+}
+
+func (a *Anonymous) customStep(f func() string) string {
+	return strings.Join(
+		[]string{
+			a.first(),
+			f(),
+			a.second(),
+		},
+		" ",
+	)
+}
+
+type Wrapper struct {
+	myFunc func() string
+}
+
+func (a *Wrapper) Message() string {
+	if a.myFunc != nil {
+		return a.myFunc()
+	}
+
+	return ""
+}
+
+func MessageRetrieverAdapter(f func() string) MessageRetriever {
+	return &Wrapper{myFunc: f}
+}

behavioral/template/template_test.go

@@ -0,0 +1,48 @@
+package template
+
+import (
+	"strings"
+	"testing"
+)
+
+type EmbedTemplate struct {
+	Template
+}
+
+func (m *EmbedTemplate) Message() string {
+	return "world"
+}
+
+func TestCustomStepIsCalled(t *testing.T) {
+	t.Run("Using interfaces", func(t *testing.T) {
+		s := &EmbedTemplate{}
+		res := s.customStep(s)
+		check(res, " world ", t)
+	})
+
+	t.Run("Define custom step via anonymous function", func(t *testing.T) {
+		m := new(Anonymous)
+		res := m.customStep(func() string {
+			return "world"
+		})
+		check(res, " world ", t)
+	})
+
+	t.Run("Using anonymous functions adapted to an interface", func(t *testing.T) {
+		customStepStep := MessageRetrieverAdapter(func() string {
+			return "world"
+		})
+		if customStepStep == nil {
+			t.Fatal("Can not continue with a nil custom step")
+		}
+		template := Template{}
+		res := template.customStep(customStepStep)
+		check(res, " world ", t)
+	})
+}
+
+func check(res string, expected string, t *testing.T) {
+	if !strings.Contains(res, expected) {
+		t.Errorf("Expected string '%s' was not found on returned string '%s'\n", expected, res)
+	}
+}