os: add env struct reflectorv0.4.0

1 files changed, 118 insertions, 0 deletions

diff --git a/os/reflective_env.go b/os/reflective_env.go
new file mode 100644
index 0000000..60f15e4
--- /dev/null
+++ b/os/reflective_env.go
@@ -0,0 +1,118 @@
+package secrets
+
+import (
+        "fmt"
+        "os"
+        "reflect"
+        "strconv"
+)
+
+func parseSetInt[T int | int8 | int16 | int32 | int64](f reflect.Value, v string, size int) error {
+        iv, err := strconv.ParseInt(v, 0, size)
+        if err != nil {
+                return err
+        }
+        f.Set(reflect.ValueOf(T(iv)))
+        return nil
+}
+
+func parseSetUint[T uint | uint8 | uint16 | uint32 | uint64](f reflect.Value, v string, size int) error {
+        iv, err := strconv.ParseUint(v, 0, size)
+        if err != nil {
+                return err
+        }
+        f.Set(reflect.ValueOf(T(iv)))
+        return nil
+}
+
+func parseSetFloat[T float32 | float64](f reflect.Value, v string, size int) error {
+        iv, err := strconv.ParseFloat(v, size)
+        if err != nil {
+                return err
+        }
+        f.Set(reflect.ValueOf(T(iv)))
+        return nil
+}
+
+func UnmarshalEnvironment(into any) error {
+        t := reflect.TypeOf(into).Elem()
+        o := reflect.ValueOf(into).Elem()
+
+        for i := 0; i < t.NumField(); i++ {
+                tf := t.Field(i)
+                f := o.FieldByName(tf.Name)
+
+                envName := tf.Tag.Get("env")
+                if envName == "" {
+                        continue
+                }
+
+                envValue, ok := os.LookupEnv(envName)
+                if !ok {
+                        continue
+                }
+
+                switch typ := f.Type().Kind(); typ {
+                case reflect.Bool:
+                        b, err := strconv.ParseBool(envValue)
+                        if err != nil {
+                                return err
+                        }
+                        f.Set(reflect.ValueOf(b))
+                case reflect.String:
+                        f.Set(reflect.ValueOf(envValue))
+                case reflect.Int:
+                        if err := parseSetInt[int](f, envValue, 64); err != nil {
+                                return err
+                        }
+                case reflect.Int8:
+                        if err := parseSetInt[int8](f, envValue, 8); err != nil {
+                                return err
+                        }
+                case reflect.Int16:
+                        if err := parseSetInt[int16](f, envValue, 16); err != nil {
+                                return err
+                        }
+                case reflect.Int32:
+                        if err := parseSetInt[int32](f, envValue, 32); err != nil {
+                                return err
+                        }
+                case reflect.Int64:
+                        if err := parseSetInt[int64](f, envValue, 64); err != nil {
+                                return err
+                        }
+                case reflect.Uint:
+                        if err := parseSetUint[uint](f, envValue, 64); err != nil {
+                                return err
+                        }
+                case reflect.Uint8:
+                        if err := parseSetUint[uint8](f, envValue, 8); err != nil {
+                                return err
+                        }
+                case reflect.Uint16:
+                        if err := parseSetUint[uint16](f, envValue, 16); err != nil {
+                                return err
+                        }
+                case reflect.Uint32:
+                        if err := parseSetUint[uint32](f, envValue, 32); err != nil {
+                                return err
+                        }
+                case reflect.Uint64:
+                        if err := parseSetUint[uint64](f, envValue, 64); err != nil {
+                                return err
+                        }
+                case reflect.Float32:
+                        if err := parseSetFloat[float32](f, envValue, 32); err != nil {
+                                return err
+                        }
+                case reflect.Float64:
+                        if err := parseSetFloat[float64](f, envValue, 64); err != nil {
+                                return err
+                        }
+                default:
+                        return fmt.Errorf("UnmarshalEnvironment: unabled to handle type: %s", typ)
+                }
+        }
+
+        return nil
+}