forked from kelseyhightower/envconfig
-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathenvconfig.go
123 lines (114 loc) · 3.29 KB
/
envconfig.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
// Copyright (c) 2013 Kelsey Hightower. All rights reserved.
// Use of this source code is governed by the MIT License that can be found in
// the LICENSE file.
package envconfig
import (
"errors"
"fmt"
"os"
"reflect"
"strconv"
"strings"
)
// ErrInvalidSpecification indicates that a specification is of the wrong type.
var ErrInvalidSpecification = errors.New("invalid specification must be a struct")
var CustomDecoders = make(map[string]func(envValue string, fieldValue, struc reflect.Value) error)
// A ParseError occurs when an environment variable cannot be converted to
// the type required by a struct field during assignment.
type ParseError struct {
KeyName string
FieldName string
TypeName string
Value string
DecoderErr error
}
func (e *ParseError) Error() string {
if e.DecoderErr != nil {
return fmt.Sprintf("envconfig.Process: processing %s for %s: error in custom decoder: %s", e.KeyName, e.FieldName, e.DecoderErr)
}
return fmt.Sprintf("envconfig.Process: assigning %s to %s: converting '%s' to type %s", e.KeyName, e.FieldName, e.Value, e.TypeName)
}
func Process(prefix string, spec interface{}) error {
s := reflect.ValueOf(spec).Elem()
if s.Kind() != reflect.Struct {
return ErrInvalidSpecification
}
typeOfSpec := s.Type()
for i := 0; i < s.NumField(); i++ {
f := s.Field(i)
if f.CanSet() {
var fieldName string
alt := typeOfSpec.Field(i).Tag.Get("envconfig")
if alt != "" {
fieldName = alt
} else {
fieldName = typeOfSpec.Field(i).Name
}
key := strings.ToUpper(fmt.Sprintf("%s_%s", prefix, fieldName))
value := os.Getenv(key)
if value == "" {
continue
}
if decoderFunc, ok := CustomDecoders[fieldName]; ok {
err := decoderFunc(value, f, s)
if err != nil {
return &ParseError{
KeyName: key,
FieldName: fieldName,
TypeName: f.Type().String(),
Value: value,
DecoderErr: err,
}
}
continue
}
switch f.Kind() {
case reflect.String:
f.SetString(value)
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
intValue, err := strconv.ParseInt(value, 0, f.Type().Bits())
if err != nil {
return &ParseError{
KeyName: key,
FieldName: fieldName,
TypeName: f.Type().String(),
Value: value,
}
}
f.SetInt(intValue)
case reflect.Bool:
boolValue, err := strconv.ParseBool(value)
if err != nil {
return &ParseError{
KeyName: key,
FieldName: fieldName,
TypeName: f.Type().String(),
Value: value,
}
}
f.SetBool(boolValue)
case reflect.Float32:
floatValue, err := strconv.ParseFloat(value, f.Type().Bits())
if err != nil {
return &ParseError{
KeyName: key,
FieldName: fieldName,
TypeName: f.Type().String(),
Value: value,
}
}
f.SetFloat(floatValue)
}
}
}
return nil
}
// Register a custom decoder function for a particular field. This function will be executed
// when a field by the same name is encountered.
func RegisterDecoder(fieldName string, f func(envValue string, fieldValue, struc reflect.Value) error) {
CustomDecoders[fieldName] = f
}
// Clear all custom decoders
func ClearDecoders() {
CustomDecoders = make(map[string]func(string, reflect.Value, reflect.Value) error)
}