Initial commit

Author: sjohnsonaz

.gitignore

@@ -0,0 +1 @@
+*.log

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "makefile.extensionOutputFolder": "./.vscode"
+}

go.mod

@@ -0,0 +1,3 @@
+module github.com/sjohnsonaz/go-headwater
+
+go 1.18

injection.go

@@ -0,0 +1,64 @@
+package headwater
+
+type Injector[T any] interface {
+	Get() (bool, T)
+}
+
+type valueInjector[T any] struct {
+	value T
+}
+
+func (i *valueInjector[T]) Get() (bool, T) {
+	if i == nil {
+		return false, GetZero[T]()
+	}
+	return true, i.value
+}
+
+func CreateValue[T any](value T) Injector[T] {
+	return &valueInjector[T]{value}
+}
+
+type factory[T any] func() T
+
+type factoryInjector[T any] struct {
+	factory factory[T]
+}
+
+func (i *factoryInjector[T]) Get() (bool, T) {
+	if i == nil {
+		return false, GetZero[T]()
+	}
+	return true, i.factory()
+}
+
+func CreateFactory[T any](factory factory[T]) Injector[T] {
+	return &factoryInjector[T]{factory}
+}
+
+type singletonInjector[T any] struct {
+	factory factory[T]
+	value   T
+	ok      bool
+	done    bool
+}
+
+func (i *singletonInjector[T]) Get() (bool, T) {
+	if i == nil {
+		return false, GetZero[T]()
+	}
+	if !i.done {
+		i.done = true
+		i.ok = true
+		i.value = i.factory()
+	}
+	return i.ok, i.value
+}
+
+func CreateSingleton[T any](factory factory[T]) Injector[T] {
+	return &singletonInjector[T]{
+		factory: factory,
+		ok:      false,
+		done:    false,
+	}
+}

injection_test.go

@@ -0,0 +1,123 @@
+package headwater
+
+import "testing"
+
+type DataAccess struct {
+	Id int
+}
+
+type ApiClient struct {
+	Id  int
+	Url string
+}
+
+type Container struct {
+	Url        Injector[string]
+	DataAccess Injector[*DataAccess]
+	ApiClient  Injector[*ApiClient]
+}
+
+func CreateContainer() Container {
+	var id = 0
+	getId := func() int {
+		id += 1
+		return id
+	}
+	var injection Container
+	injection = Container{
+		Url: CreateValue("http://localhost"),
+		DataAccess: CreateFactory(func() *DataAccess {
+			return &DataAccess{
+				Id: getId(),
+			}
+		}),
+		ApiClient: CreateSingleton(func() *ApiClient {
+			ok, url := injection.Url.Get()
+			if !ok {
+				url = "http://127.0.0.1"
+			}
+
+			return &ApiClient{
+				Id:  getId(),
+				Url: url,
+			}
+		}),
+	}
+	return injection
+}
+
+func TestValueInjector(t *testing.T) {
+	container := CreateContainer()
+	ok, url := container.Url.Get()
+
+	if !ok {
+		t.Error("Received not ok")
+	}
+
+	want := "http://localhost"
+
+	if url != want {
+		t.Errorf("Received: %v, Expected %v", url, want)
+	}
+}
+
+func TestFactoryInjector(t *testing.T) {
+	container := CreateContainer()
+	ok, dataAccess := container.DataAccess.Get()
+
+	if !ok {
+		t.Error("Received not ok")
+	}
+
+	if dataAccess == nil {
+		t.Errorf("Received: %v", dataAccess)
+	}
+
+	ok, nextDataAccess := container.DataAccess.Get()
+
+	if !ok {
+		t.Error("Received not ok")
+	}
+
+	if dataAccess == nextDataAccess {
+		t.Errorf("Received the same instance")
+	}
+}
+
+func TestNestedInjector(t *testing.T) {
+	container := CreateContainer()
+	ok, apiClient := container.ApiClient.Get()
+
+	if !ok {
+		t.Error("Received not ok")
+	}
+
+	if apiClient == nil {
+		t.Errorf("Received: %v", apiClient)
+	}
+
+	want := "http://localhost"
+
+	if apiClient.Url != want {
+		t.Errorf("Received: %v, Expected %v", apiClient.Url, want)
+	}
+}
+
+func TestSingletonInjector(t *testing.T) {
+	container := CreateContainer()
+	ok, apiClient := container.ApiClient.Get()
+
+	if !ok {
+		t.Error("Received not ok")
+	}
+
+	ok, nextApiClient := container.ApiClient.Get()
+
+	if !ok {
+		t.Error("Received not ok")
+	}
+
+	if apiClient != nextApiClient {
+		t.Error("Received multiple instances")
+	}
+}

iterator.go

@@ -0,0 +1,47 @@
+package headwater
+
+func ForEach[T any](array []T, callback func(item T)) {
+	for _, item := range array {
+		callback(item)
+	}
+}
+
+func Map[T any, U any](array []T, callback func(item T) U) []U {
+	var output []U = make([]U, len(array))
+	for index, item := range array {
+		result := callback(item)
+		output[index] = result
+	}
+	return output
+}
+
+func Reduce[T any, U any](array []T, callback func(target U, item T) U, target U) U {
+	var output U = target
+	for _, item := range array {
+		output = callback(output, item)
+	}
+	return output
+}
+
+func Filter[T any](array []T, callback func(item T) bool) []T {
+	var output []T = make([]T, 0)
+	for _, item := range array {
+		valid := callback(item)
+		if valid {
+			output = append(output, item)
+		}
+	}
+	return output
+}
+
+func Equal[T comparable](a, b []T) bool {
+	if len(a) != len(b) {
+		return false
+	}
+	for i, v := range a {
+		if v != b[i] {
+			return false
+		}
+	}
+	return true
+}

iterator_test.go

@@ -0,0 +1,92 @@
+package headwater
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestForEach(t *testing.T) {
+	items := []int64{0, 1, 2}
+	result := 0
+
+	ForEach(items, func(item int64) {
+		result++
+	})
+
+	want := 3
+
+	if result != want {
+		t.Errorf("Count is wrong.  Expected: %#v, Received: %#v", want, result)
+	}
+}
+
+// Map should create an array with a new value for each value of the original array
+func TestMapEach(t *testing.T) {
+	items := []int64{0, 1, 2}
+
+	result := Map(items, func(item int64) string {
+		return "" + fmt.Sprint(item)
+	})
+
+	want := []string{"0", "1", "2"}
+
+	if !Equal(want, result) {
+		t.Errorf("Count is wrong.  Expected: %#v, Received: %#v", want, result)
+	}
+}
+
+func TestNestedMap(t *testing.T) {
+	items := []int64{0, 1, 2}
+
+	result := Map(Map(Map(
+		items,
+		func(item int64) float64 {
+			return float64(item) / 2
+		}),
+		func(item float64) string {
+			return "" + fmt.Sprint(item)
+		}),
+		func(item string) string {
+			return "a" + item
+		})
+
+	want := []string{"a0", "a0.5", "a1"}
+
+	if !Equal(want, result) {
+		t.Errorf("Count is wrong.  Expected: %#v, Received: %#v", want, result)
+	}
+}
+
+func TestReduce(t *testing.T) {
+	items := []int{0, 1, 2}
+	target := 0
+
+	result := Reduce(items, func(target int, item int) int {
+		return target + item
+	}, target)
+
+	want := 3
+
+	if result != want {
+		t.Errorf("Count is wrong.  Expected: %#v, Received: %#v", want, result)
+	}
+}
+
+func TestFilter(t *testing.T) {
+	items := []int{0, 3, 1, 4, 2, 5}
+
+	result := Filter(items, func(item int) bool {
+		if item >= 3 {
+			return true
+		} else {
+			return false
+		}
+	})
+
+	out := fmt.Sprintf("%v, %v", items, result)
+	fmt.Println(out)
+
+	if !Equal(result, []int{3, 4, 5}) {
+		t.Error("Count is wrong")
+	}
+}

makefile

@@ -0,0 +1,3 @@
+.PHONY: test
+test:
+	go test ./...

mediator.go

@@ -0,0 +1,23 @@
+package headwater
+
+import (
+	"context"
+	"fmt"
+)
+
+type requestHandler[R any, T any] func(context context.Context, request R) (T, error)
+
+type Receiver[R any, T any] struct {
+	handler requestHandler[R, T]
+}
+
+func (eh *Receiver[R, T]) Send(context context.Context, request R) (T, error) {
+	if eh.handler == nil {
+		return GetZero[T](), fmt.Errorf("no handler for request: %T", request)
+	}
+	return eh.handler(context, request)
+}
+
+func (eh *Receiver[E, T]) SetHandler(handler requestHandler[E, T]) {
+	eh.handler = handler
+}