feat: Add support of []uint8 (#81)

Author: obalunenko

README.md

@@ -2,8 +2,9 @@
 [![Go Reference](https://pkg.go.dev/badge/github.com/obalunenko/getenv.svg)](https://pkg.go.dev/github.com/obalunenko/getenv)
 [![Go Report Card](https://goreportcard.com/badge/github.com/obalunenko/getenv)](https://goreportcard.com/report/github.com/obalunenko/getenv)
 [![codecov](https://codecov.io/gh/obalunenko/getenv/branch/master/graph/badge.svg)](https://codecov.io/gh/obalunenko/getenv)
-![coverbadger-tag-do-not-edit](https://img.shields.io/badge/coverage-97.56%25-brightgreen?longCache=true&style=flat)
+![coverbadger-tag-do-not-edit](https://img.shields.io/badge/coverage-97.66%25-brightgreen?longCache=true&style=flat)
 [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=obalunenko_getenv&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=obalunenko_getenv)
+
 # getenv
 
 Package getenv provides functionality for loading environment variables and parse them into go builtin types.
@@ -22,6 +23,7 @@ Types supported:
 - int64
 - []int64
 - uint8
+- []uint8
 - uint16
 - uint64
 - []uint64
@@ -51,6 +53,7 @@ package main
 
 import (
 	"fmt"
+	url "net/url"
 	"os"
 	"time"
 
@@ -114,6 +117,14 @@ func main() {
 	val = getenv.EnvOrDefault(key, time.Second)
 	fmt.Printf("[%T]: %v\n", val, val)
 
+	// url.URL
+	if err := os.Setenv(key, "https://test:abcd123@golangbyexample.com:8000/tutorials/intro?type=advance&compact=false#history"); err != nil {
+		panic(err)
+	}
+
+	val = getenv.EnvOrDefault(key, url.URL{})
+	fmt.Printf("[%T]: %v\n", val, val)
+
 }
 
 ```
@@ -126,4 +137,5 @@ Output:
 [time.Time]: 2022-01-20 00:00:00 +0000 UTC
 [[]float64]: [26.89 0.67]
 [time.Duration]: 2h35m0s
+[url.URL]: {https  test:abcd123 golangbyexample.com:8000 /tutorials/intro  false false type=advance&compact=false history }
 ```

getenv.go

@@ -14,6 +14,7 @@
 // - int64
 // - []int64
 // - uint8
+// - []uint8
 // - uint16
 // - uint64
 // - []uint64

getenv_test.go

@@ -2344,6 +2344,119 @@ func TestInt16OrDefault(t *testing.T) {
 	}
 }
 
+func TestUint8SliceOrDefault(t *testing.T) {
+	type args struct {
+		key        string
+		defaultVal []uint8
+		sep        string
+	}
+
+	type expected struct {
+		val []uint8
+	}
+
+	var tests = []struct {
+		name     string
+		precond  precondition
+		args     args
+		expected expected
+	}{
+		{
+			name: "env not set - default returned",
+			precond: precondition{
+				setenv: setenv{
+					isSet: false,
+					val:   "1,27",
+				},
+			},
+			args: args{
+				key:        testEnvKey,
+				defaultVal: []uint8{99},
+				sep:        ",",
+			},
+			expected: expected{
+				val: []uint8{99},
+			},
+		},
+		{
+			name: "env set - env value returned",
+			precond: precondition{
+				setenv: setenv{
+					isSet: true,
+					val:   "1,2",
+				},
+			},
+			args: args{
+				key:        testEnvKey,
+				defaultVal: []uint8{99},
+				sep:        ",",
+			},
+			expected: expected{
+				val: []uint8{1, 2},
+			},
+		},
+		{
+			name: "env set, no separator - default value returned",
+			precond: precondition{
+				setenv: setenv{
+					isSet: true,
+					val:   "1,2",
+				},
+			},
+			args: args{
+				key:        testEnvKey,
+				defaultVal: []uint8{99},
+				sep:        "",
+			},
+			expected: expected{
+				val: []uint8{99},
+			},
+		},
+		{
+			name: "env set, wrong separator - default value returned",
+			precond: precondition{
+				setenv: setenv{
+					isSet: true,
+					val:   "1,2",
+				},
+			},
+			args: args{
+				key:        testEnvKey,
+				defaultVal: []uint8{99},
+				sep:        "|",
+			},
+			expected: expected{
+				val: []uint8{99},
+			},
+		},
+		{
+			name: "empty env value set - default returned",
+			precond: precondition{
+				setenv: setenv{
+					isSet: true,
+					val:   "",
+				},
+			},
+			args: args{
+				key:        testEnvKey,
+				defaultVal: []uint8{99},
+			},
+			expected: expected{
+				val: []uint8{99},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			tt.precond.maybeSetEnv(t, tt.args.key)
+
+			got := getenv.EnvOrDefault(tt.args.key, tt.args.defaultVal, option.WithSeparator(tt.args.sep))
+			assert.Equal(t, tt.expected.val, got)
+		})
+	}
+}
+
 func TestInt16SliceOrDefault(t *testing.T) {
 	type args struct {
 		key        string

internal/constraint.go

@@ -23,7 +23,7 @@ type (
 
 	// Uint is a constraint for unsigned integer and slice of unsigned integers.
 	Uint interface {
-		uint | []uint | uint8 | uint16 | uint32 | []uint32 | uint64 | []uint64
+		uint | []uint | uint8 | []uint8 | uint16 | uint32 | []uint32 | uint64 | []uint64
 	}
 
 	// Float is a constraint for floats and slice of floats.

internal/iface.go

@@ -16,7 +16,7 @@ func NewEnvParser(v any) EnvParser {
 		p = newStringParser(t)
 	case int, []int, int8, []int8, int16, []int16, int32, []int32, int64, []int64:
 		p = newIntParser(t)
-	case uint, []uint, uint8, uint16, uint32, []uint32, uint64, []uint64:
+	case uint, []uint, uint8, []uint8, uint16, uint32, []uint32, uint64, []uint64:
 		p = newUintParser(t)
 	case bool:
 		p = boolParser(t)
@@ -83,6 +83,8 @@ func newUintParser(v any) EnvParser {
 	switch t := v.(type) {
 	case uint8:
 		return uint8Parser(t)
+	case []uint8:
+		return uint8SliceParser(t)
 	case uint:
 		return uintParser(t)
 	case []uint:
@@ -335,6 +337,16 @@ func (i uintSliceParser) ParseEnv(key string, defaltVal any, options Parameters)
 	return val
 }
 
+type uint8SliceParser []uint8
+
+func (i uint8SliceParser) ParseEnv(key string, defaltVal any, options Parameters) any {
+	sep := options.Separator
+
+	val := uint8SliceOrDefault(key, defaltVal.([]uint8), sep)
+
+	return val
+}
+
 type uint32SliceParser []uint32
 
 func (i uint32SliceParser) ParseEnv(key string, defaltVal any, options Parameters) any {

internal/iface_test.go

@@ -159,6 +159,14 @@ func TestNewEnvParser(t *testing.T) {
 			want:      int16SliceParser([]int16{1}),
 			wantPanic: assert.NotPanics,
 		},
+		{
+			name: "[]uint8",
+			args: args{
+				v: []uint8{1},
+			},
+			want:      uint8SliceParser([]uint8{1}),
+			wantPanic: assert.NotPanics,
+		},
 		{
 			name: "[]int8",
 			args: args{
@@ -694,6 +702,25 @@ func Test_ParseEnv(t *testing.T) {
 			},
 			want: 12,
 		},
+		{
+			name: "uint8SliceParser",
+			s:    uint8SliceParser(nil),
+			precond: precondition{
+				setenv: setenv{
+					isSet: true,
+					val:   "12,89",
+				},
+			},
+			args: args{
+				key:       testEnvKey,
+				defaltVal: []uint8{99},
+				in2: Parameters{
+					Separator: ",",
+					Layout:    "",
+				},
+			},
+			want: []uint8{12, 89},
+		},
 		{
 			name: "int8SliceParser",
 			s:    int8SliceParser(nil),

internal/parsers.go

@@ -543,6 +543,34 @@ func uintSliceOrDefault(key string, defaultVal []uint, sep string) []uint {
 	return val
 }
 
+// uint8SliceOrDefault retrieves the uint8 slice value of the environment variable named
+// by the key and separated by sep.
+// If variable not set or value is empty - defaultVal will be returned.
+func uint8SliceOrDefault(key string, defaultVal []uint8, sep string) []uint8 {
+	valraw := stringSliceOrDefault(key, nil, sep)
+	if valraw == nil {
+		return defaultVal
+	}
+
+	val := make([]uint8, 0, len(valraw))
+
+	const (
+		base    = 10
+		bitsize = 8
+	)
+
+	for _, s := range valraw {
+		v, err := strconv.ParseUint(s, base, bitsize)
+		if err != nil {
+			return defaultVal
+		}
+
+		val = append(val, uint8(v))
+	}
+
+	return val
+}
+
 // uint32SliceOrDefault retrieves the uint32 slice value of the environment variable named
 // by the key and separated by sep.
 // If variable not set or value is empty - defaultVal will be returned.