master > master: codego initialisiert

codego/core/environment/environment.go

@@ -0,0 +1,71 @@
+package environment
+
+import (
+	"errors"
+	"fmt"
+	"log"
+	"os"
+
+	"github.com/joho/godotenv"
+)
+
+var ENV_FILE_NAME string
+
+/* ---------------------------------------------------------------- *
+ * EXPORTS
+ * ---------------------------------------------------------------- */
+
+func ReadEnvKey(key string, optional ...string) string {
+	value, err := readEnvKey(key, optional...)
+	if err != nil {
+		log.Fatal(err)
+	}
+	return value
+}
+
+func ReadEnvKeyAllowMissing(key string, optional ...string) string {
+	value, _ := readEnvKey(key, optional...)
+	return value
+}
+
+func ReadEnvKeyDefault(key string, valueDefault string, optional ...string) string {
+	value, _ := readEnvKey(key, optional...)
+	if value == "" {
+		return valueDefault
+	}
+	return value
+}
+
+/* ---------------------------------------------------------------- *
+ * PRIVATE
+ * ---------------------------------------------------------------- */
+
+func loadEnvFile(path string) error {
+	if path == "" {
+		log.Fatal("Path name to environment file is not allowed to be empty!")
+	}
+	return godotenv.Load(path)
+}
+
+func getEnvKey(key string) string {
+	return os.Getenv(key)
+}
+
+func readEnvKey(key string, optional ...string) (string, error) {
+	var path string = ENV_FILE_NAME
+	var err error
+	var value string
+	if len(optional) > 0 {
+		path = optional[0]
+	}
+	err = loadEnvFile(path)
+	if err != nil {
+		log.Fatalf("Could not read environment file, \033[1m%s\033[0m!\n", path)
+	}
+	err = nil
+	value = getEnvKey(key)
+	if value == "" {
+		err = errors.New(fmt.Sprintf("Environment key \033[1m%s\033[0m missing or empty in environment file \033[1m%s\033[0m!", key, path))
+	}
+	return value, err
+}

codego/core/utils/utils.go

@@ -0,0 +1,84 @@
+package utils
+
+import (
+	"sort"
+	"strings"
+)
+
+/* ---------------------------------------------------------------- *
+ * EXPORTS
+ * ---------------------------------------------------------------- */
+
+func StrListContains(list []string, x string) bool {
+	for _, obj := range list {
+		if obj == x {
+			return true
+		}
+	}
+	return false
+}
+
+func Min2(x int, y int) int {
+	if x <= y {
+		return x
+	}
+	return y
+}
+
+func Max2(x int, y int) int {
+	if x >= y {
+		return x
+	}
+	return y
+}
+
+func SortStrings(list *[]string) {
+	sort.Slice(*list, func(i int, j int) bool {
+		u := strings.ToLower((*list)[i])
+		v := strings.ToLower((*list)[j])
+		cmp := strings.Compare(u, v)
+		return (cmp < 0)
+	})
+}
+
+func FilterStrings(list *[]string, f func(string) bool) []string {
+	var listFiltered = []string{}
+	for _, val := range *list {
+		if f(val) {
+			listFiltered = append(listFiltered, val)
+		}
+	}
+	return listFiltered
+}
+
+func UnionStrings2(list1 []string, list2 []string) []string {
+	var mark = make(map[string]bool)
+	for _, item := range list1 {
+		mark[item] = true
+	}
+	for _, item := range list2 {
+		mark[item] = true
+	}
+	var list = make([]string, len(mark))
+	var i int = 0
+	for item, _ := range mark {
+		list[i] = item
+		i++
+	}
+	return list
+}
+
+func UnionStringsTo(listTo *[]string, listFrom []string) {
+	var mark = make(map[string]bool)
+	for _, item := range listFrom {
+		mark[item] = true
+	}
+	for _, item := range *listTo {
+		mark[item] = false // signals suppression of duplicate addition
+	}
+	for item, isNew := range mark {
+		if isNew {
+			*listTo = append(*listTo, item)
+		}
+	}
+}

codego/core/utils/utils_test.go

@@ -0,0 +1,57 @@
+package utils_test
+
+/* ---------------------------------------------------------------- *
+ * UNIT TESTING
+ * ---------------------------------------------------------------- */
+
+import (
+	"logik/core/utils"
+	"strings"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+/* ---------------------------------------------------------------- *
+ * TESTCASE SortStrings
+ * ---------------------------------------------------------------- */
+
+func TestSortStrings(test *testing.T) {
+	var assert = assert.New(test)
+	var list = []string{"katze", "Hund", "baby", "Pluto", "Saturn", "Mond"}
+	utils.SortStrings(&list)
+	assert.Equal(list, []string{"baby", "Hund", "katze", "Mond", "Pluto", "Saturn"})
+}
+
+/* ---------------------------------------------------------------- *
+ * TESTCASE SortStrings
+ * ---------------------------------------------------------------- */
+
+func TestFilterStrings(test *testing.T) {
+	var assert = assert.New(test)
+	var list = []string{"abram", "aaron", "aardvark", "aarhus", "alaska", "eel", "aal"}
+	var list2 = utils.FilterStrings(&list, func(x string) bool { return strings.HasPrefix(x, "aa") })
+	assert.Equal(list2, []string{"aaron", "aardvark", "aarhus", "aal"})
+}
+
+/* ---------------------------------------------------------------- *
+ * TESTCASE UnionStrings2, UnionStringsTo
+ * ---------------------------------------------------------------- */
+
+func TestUnionStrings2(test *testing.T) {
+	var assert = assert.New(test)
+	var list1 = []string{"red", "blue", "blue", "green", "blue", "grey", "black", "green"}
+	var list2 = []string{"yellow", "orange", "lila", "red"}
+	var list = utils.UnionStrings2(list1, list2)
+	utils.SortStrings(&list)
+	assert.Equal(list, []string{"black", "blue", "green", "grey", "lila", "orange", "red", "yellow"})
+}
+
+func UnionStringsTo(test *testing.T) {
+	var assert = assert.New(test)
+	var list1 = []string{"red", "blue", "blue", "green"}
+	var list2 = []string{"yellow", "red", "black"}
+	utils.UnionStringsTo(&list1, list2)
+	utils.SortStrings(&list1)
+	assert.Equal(list1, []string{"black", "blue", "green", "red", "yellow"})
+}