First version

6 files changed, 386 insertions, 0 deletions

diff --git a/envcfg.go b/envcfg.go
new file mode 100644
index 0000000..b91ea13
--- /dev/null
+++ b/envcfg.go
@@ -0,0 +1,40 @@
+// Package envcfg provides environment variable mapping to structs.
+//
+// Can be used to read configuration parameters from the environment.
+//
+// Fields for which environment variables can be found are overwritten, otherwise they are left to their previous
+// value.
+//
+// Can be used, for example, after gcfg to override settings provided in a configuration file.
+package envcfg
+
+import (
+        "errors"
+        "reflect"
+)
+
+const (
+        TAG     = "env"
+        ABS_TAG = "absenv"
+        SEP     = "_"
+)
+
+type node struct {
+        parent     *node
+        value      *reflect.Value
+        properties *reflect.StructField
+}
+
+var ErrInvalidConfigStruct = errors.New("invalid parameter: must map to a struct")
+
+func ReadInto(cfgStruct interface{}) (interface{}, []error) {
+        s := reflect.ValueOf(cfgStruct).Elem()
+
+        if s.Kind() != reflect.Struct {
+                return nil, []error{ErrInvalidConfigStruct}
+        }
+
+        _, errs := setStructFields(node{nil, &s, nil})
+
+        return cfgStruct, errs
+}
diff --git a/mapper.go b/mapper.go
new file mode 100644
index 0000000..ca6885b
--- /dev/null
+++ b/mapper.go
@@ -0,0 +1,86 @@
+package envcfg
+
+import (
+        "os"
+        "reflect"
+        "strconv"
+        "strings"
+)
+
+func getEnvName(n node) string {
+        name := n.properties.Tag.Get(TAG)
+        if name == "" {
+                name = n.properties.Name
+        }
+
+        abs, _ := strconv.ParseBool(n.properties.Tag.Get(ABS_TAG))
+        if !abs && n.parent != nil {
+                if n.parent.properties != nil {
+                        parentName := getEnvName(*n.parent)
+                        name = parentName + SEP + name
+                }
+        }
+
+        return strings.ToUpper(name)
+}
+
+func setValue(n node, v string) (node, error) {
+        switch n.value.Kind() {
+        case reflect.String:
+                n.value.SetString(v)
+
+        case reflect.Bool:
+                boolVal, err := strconv.ParseBool(v)
+                if err != nil {
+                        return n, err
+                }
+                n.value.SetBool(boolVal)
+
+        case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+                intVal, err := strconv.ParseInt(v, 0, n.value.Type().Bits())
+                if err != nil {
+                        return n, err
+                }
+                n.value.SetInt(intVal)
+
+        case reflect.Float32, reflect.Float64:
+                floatVal, err := strconv.ParseFloat(v, n.value.Type().Bits())
+                if err != nil {
+                        return n, err
+                }
+                n.value.SetFloat(floatVal)
+        }
+
+        return n, nil
+}
+
+func setFieldValue(n node) (node, error) {
+        if n.value.Kind() == reflect.Struct {
+                setStructFields(n)
+                return n, nil
+        }
+
+        v := os.Getenv(getEnvName(n))
+        if v != "" {
+                return setValue(n, v)
+        }
+
+        return n, nil
+}
+
+func setStructFields(n node) (node, []error) {
+        t := n.value.Type()
+        errs := []error{}
+
+        for i := 0; i < n.value.NumField(); i++ {
+                v := n.value.Field(i)
+                p := t.Field(i)
+
+                _, err := setFieldValue(node{&n, &v, &p})
+                if err != nil {
+                        errs = append(errs, err)
+                }
+        }
+
+        return n, errs
+}
diff --git a/nesting_test.go b/nesting_test.go
new file mode 100644
index 0000000..3fcc059
--- /dev/null
+++ b/nesting_test.go
@@ -0,0 +1,52 @@
+package envcfg
+
+import (
+        "os"
+        "testing"
+)
+
+type nestedStruct struct {
+        SubStruct struct {
+                Field string
+        }
+}
+
+func TestNestedMapping(t *testing.T) {
+        const ENV_KEY = "SUBSTRUCT_FIELD"
+        const ENV_VAL = "Remember: testing is the future!"
+
+        os.Clearenv()
+        os.Setenv(ENV_KEY, ENV_VAL)
+
+        s := nestedStruct{}
+
+        ReadInto(&s)
+
+        if s.SubStruct.Field != ENV_VAL {
+                t.Errorf("expected '%s', got '%s'", ENV_VAL, s.SubStruct.Field)
+        }
+}
+
+type deeplyNestedStruct struct {
+        SubStruct struct {
+                SubSubStruct struct {
+                        Field string
+                }
+        }
+}
+
+func TestDeeplyNestedMapping(t *testing.T) {
+        const ENV_KEY = "SUBSTRUCT_SUBSUBSTRUCT_FIELD"
+        const ENV_VAL = "Remember: testing is the future!"
+
+        os.Clearenv()
+        os.Setenv(ENV_KEY, ENV_VAL)
+
+        s := deeplyNestedStruct{}
+
+        ReadInto(&s)
+
+        if s.SubStruct.SubSubStruct.Field != ENV_VAL {
+                t.Errorf("expected '%s', got '%s'", ENV_VAL, s.SubStruct.SubSubStruct.Field)
+        }
+}
diff --git a/overwriting_test.go b/overwriting_test.go
new file mode 100644
index 0000000..1ed5daa
--- /dev/null
+++ b/overwriting_test.go
@@ -0,0 +1,67 @@
+package envcfg
+
+import (
+        "os"
+        "testing"
+)
+
+func TestKeeping(t *testing.T) {
+        const ORIG_VAL = "Remember: testing is the future!"
+
+        os.Clearenv()
+
+        s := struct{ Field string }{ORIG_VAL}
+
+        ReadInto(&s)
+
+        if s.Field != ORIG_VAL {
+                t.Errorf("expected '%s', got '%s'", ORIG_VAL, s.Field)
+        }
+}
+
+func TestOverwriting(t *testing.T) {
+        const ENV_KEY = "FIELD"
+        const ENV_VAL = "Remember: testing is the future!"
+        const ORIG_VAL = "Testing is pointless!"
+
+        os.Clearenv()
+        os.Setenv(ENV_KEY, ENV_VAL)
+
+        s := struct{ Field string }{ORIG_VAL}
+
+        ReadInto(&s)
+
+        if s.Field != ENV_VAL {
+                t.Errorf("expected '%s', got '%s'", ENV_VAL, s.Field)
+        }
+}
+
+type superStruct struct {
+        SubStruct nestedFields
+}
+
+type nestedFields struct {
+        KeepMe      string
+        OverwriteMe string
+}
+
+func TestMultiOverwriting(t *testing.T) {
+        const ENV_KEY = "SUBSTRUCT_OVERWRITEME"
+        const ENV_VAL = "Remember: testing is the future!"
+        const ORIG_VAL = "Testing is pointless!"
+
+        os.Clearenv()
+        os.Setenv(ENV_KEY, ENV_VAL)
+
+        s := superStruct{nestedFields{ORIG_VAL, ORIG_VAL}}
+
+        ReadInto(&s)
+
+        if s.SubStruct.KeepMe != ORIG_VAL {
+                t.Errorf("expected '%s', got '%s'", ORIG_VAL, s.SubStruct.KeepMe)
+        }
+
+        if s.SubStruct.OverwriteMe != ENV_VAL {
+                t.Errorf("expected '%s', got '%s'", ENV_VAL, s.SubStruct.OverwriteMe)
+        }
+}
diff --git a/tagging_test.go b/tagging_test.go
new file mode 100644
index 0000000..2fe2e33
--- /dev/null
+++ b/tagging_test.go
@@ -0,0 +1,70 @@
+package envcfg
+
+import (
+        "os"
+        "testing"