add interpreter pattern

Author: sensorario

behavioral/interpreter/README.md

@@ -0,0 +1,46 @@
+# Behavioral » Interpreter
+
+## Description
+
+The interpreter design pattern is used to solve business cases where it's
+useful to have a language to perform common operations. The most famous
+intepreter we can talk about is probably SQL.
+
+## Implementation
+
+The implementation is trivial. In the following examples I'll show a very
+simple usage of interpreter. In this case we use interpreter to calculate some
+mathematical operations. For example the sum and the multiplication operations.
+
+```go
+func TestSumOperator(t *testing.T) {
+	sentence := "5 + 3"
+	i := interpreter{}
+	_ = i.of(sentence)
+	if i.exec() != 8 {
+		t.Error([]string{
+			"La somma di 5 con 3",
+			"non dovrebbe essere",
+			strconv.Itoa(i.exec()),
+		})
+	}
+}
+```
+
+As you can see, given a sentence like `5 + 3` parsed, it is possible to exec
+the string and calculate the result.
+
+```go
+func TestMulOperator(t *testing.T) {
+	sentence := "5 * 3"
+	i := interpreter{}
+	_ = i.of(sentence)
+	if i.exec() != 15 {
+		t.Error([]string{
+			"Multiplication between 5 and 3",
+			"shouldnt be",
+			strconv.Itoa(i.exec()),
+		})
+	}
+}
+```

behavioral/interpreter/interpreter.go

@@ -0,0 +1,52 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+type interpreter struct {
+	sentence string
+}
+
+func (i *interpreter) tokens() []string {
+	return strings.Split(i.sentence, " ")
+}
+
+func (i *interpreter) exec() int {
+	sum := 0
+	tokens := i.tokens()
+	for k, item := range tokens {
+		if item == "*" {
+			fmt.Println(i.tokens())
+			a, _ := strconv.Atoi(string(tokens[k-1]))
+			b, _ := strconv.Atoi(string(tokens[k+1]))
+			return a * b
+		}
+
+		if item != "+" {
+			number, _ := strconv.Atoi(item)
+			sum += number
+		}
+	}
+	return sum
+}
+
+func (i *interpreter) contains(s string) bool {
+	return true
+}
+
+func (i *interpreter) of(s string) error {
+	if s == "normal" {
+		return errors.New("non va")
+	}
+	i.sentence = s
+	return nil
+}
+
+func (i *interpreter) numberOfWords() int {
+	s := i.tokens()
+	return len(s)
+}

behavioral/interpreter/interpreter_test.go

@@ -0,0 +1,89 @@
+package main
+
+import (
+	"strconv"
+	"testing"
+)
+
+func TestNodesCantBeNormalString(t *testing.T) {
+	sentence := "normal"
+	i := interpreter{}
+	err := i.of(sentence)
+	if err == nil {
+		t.Error("Si doveva spaccare")
+	}
+}
+
+func TestFoo(t *testing.T) {
+	sentence := "do something"
+	i := interpreter{}
+	_ = i.of(sentence)
+	if i.numberOfWords() != 2 {
+		t.Error("Guarda che ti stai sbagliando")
+	}
+}
+
+const (
+	PLUS = "+"
+)
+
+func TestPlusOperatorDetector(t *testing.T) {
+	sentence := "2 + 3"
+	i := interpreter{}
+	_ = i.of(sentence)
+	if i.contains(PLUS) != true {
+		t.Error("dovrebbe conoscere l'operatore +")
+	}
+}
+
+func TestSplitSentencesInSplice(t *testing.T) {
+	sentence := "2 + 3"
+	i := interpreter{}
+	_ = i.of(sentence)
+	expected := []string{"2", "+", "3"}
+	for ind, _ := range expected {
+		tok := i.tokens()
+		if expected[ind] != tok[ind] {
+			t.Error("non ci siamo")
+		}
+	}
+}
+
+func TestCountNumberOfOperators(t *testing.T) {
+	sentence := "2 + 3"
+	i := interpreter{}
+	_ = i.of(sentence)
+	expected := []string{"2", "+", "3"}
+	for ind, _ := range expected {
+		tok := i.tokens()
+		if expected[ind] != tok[ind] {
+			t.Error("non ci siamo")
+		}
+	}
+}
+
+func TestExec(t *testing.T) {
+	sentence := "5 + 3"
+	i := interpreter{}
+	_ = i.of(sentence)
+	if i.exec() != 8 {
+		t.Error([]string{
+			"La somma di 5 con 3",
+			"non dovrebbe essere",
+			strconv.Itoa(i.exec()),
+		})
+	}
+}
+
+func TestMulOperator(t *testing.T) {
+	sentence := "5 * 3"
+	i := interpreter{}
+	_ = i.of(sentence)
+	if i.exec() != 15 {
+		t.Error([]string{
+			"Multiplication between 5 and 3",
+			"shouldnt be",
+			strconv.Itoa(i.exec()),
+		})
+	}
+}