init - add project files
This commit is contained in:
28
vendor/github.com/caarlos0/env/v11/.editorconfig
generated
vendored
Normal file
28
vendor/github.com/caarlos0/env/v11/.editorconfig
generated
vendored
Normal file
@@ -0,0 +1,28 @@
|
||||
[*]
|
||||
charset = utf-8
|
||||
end_of_line = lf
|
||||
trim_trailing_whitespace = true
|
||||
max_line_length = 120
|
||||
|
||||
[{go.mod,go.sum,*.go}]
|
||||
insert_final_newline = true
|
||||
indent_size = tab
|
||||
indent_style = tab
|
||||
tab_width = 4
|
||||
|
||||
[Makefile]
|
||||
max_line_length = off
|
||||
insert_final_newline = true
|
||||
indent_size = tab
|
||||
indent_style = tab
|
||||
tab_width = 4
|
||||
|
||||
[*.md]
|
||||
max_line_length = off
|
||||
trim_trailing_whitespace = false
|
||||
indent_size = tab
|
||||
indent_style = space
|
||||
tab_width = 2
|
||||
|
||||
[.mailmap]
|
||||
max_line_length = off
|
||||
5
vendor/github.com/caarlos0/env/v11/.gitignore
generated
vendored
Normal file
5
vendor/github.com/caarlos0/env/v11/.gitignore
generated
vendored
Normal file
@@ -0,0 +1,5 @@
|
||||
coverage.txt
|
||||
bin
|
||||
card.png
|
||||
dist
|
||||
codecov*
|
||||
32
vendor/github.com/caarlos0/env/v11/.golangci.yml
generated
vendored
Normal file
32
vendor/github.com/caarlos0/env/v11/.golangci.yml
generated
vendored
Normal file
@@ -0,0 +1,32 @@
|
||||
linters-settings:
|
||||
gocritic:
|
||||
enabled-checks:
|
||||
- emptyStringTest
|
||||
- evalOrder
|
||||
- paramTypeCombine
|
||||
- preferStringWriter
|
||||
- sprintfQuotedString
|
||||
- stringConcatSimplify
|
||||
- yodaStyleExpr
|
||||
revive:
|
||||
rules:
|
||||
- name: line-length-limit
|
||||
arguments: [120]
|
||||
|
||||
issues:
|
||||
exclude-rules:
|
||||
- path: _test\.go
|
||||
linters:
|
||||
- revive
|
||||
text: "line-length-limit:"
|
||||
|
||||
linters:
|
||||
enable:
|
||||
- thelper
|
||||
- gofumpt
|
||||
- gocritic
|
||||
- tparallel
|
||||
- unconvert
|
||||
- unparam
|
||||
- wastedassign
|
||||
- revive
|
||||
5
vendor/github.com/caarlos0/env/v11/.goreleaser.yml
generated
vendored
Normal file
5
vendor/github.com/caarlos0/env/v11/.goreleaser.yml
generated
vendored
Normal file
@@ -0,0 +1,5 @@
|
||||
# yaml-language-server: $schema=https://goreleaser.com/static/schema-pro.json
|
||||
version: 2
|
||||
includes:
|
||||
- from_url:
|
||||
url: https://raw.githubusercontent.com/caarlos0/.goreleaserfiles/main/lib.yml
|
||||
7
vendor/github.com/caarlos0/env/v11/.mailmap
generated
vendored
Normal file
7
vendor/github.com/caarlos0/env/v11/.mailmap
generated
vendored
Normal file
@@ -0,0 +1,7 @@
|
||||
Carlos Alexandro Becker <caarlos0@users.noreply.github.com> Carlos A Becker <caarlos0@gmail.com>
|
||||
Carlos Alexandro Becker <caarlos0@users.noreply.github.com> Carlos A Becker <caarlos0@users.noreply.github.com>
|
||||
Carlos Alexandro Becker <caarlos0@users.noreply.github.com> Carlos Alexandro Becker <caarlos0@gmail.com>
|
||||
Carlos Alexandro Becker <caarlos0@users.noreply.github.com> Carlos Alexandro Becker <caarlos0@users.noreply.github.com>
|
||||
Carlos Alexandro Becker <caarlos0@users.noreply.github.com> Carlos Becker <caarlos0@gmail.com>
|
||||
dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> dependabot-preview[bot] <27856297+dependabot-preview[bot]@users.noreply.github.com>
|
||||
actions-user <actions@github.com> github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>
|
||||
21
vendor/github.com/caarlos0/env/v11/LICENSE.md
generated
vendored
Normal file
21
vendor/github.com/caarlos0/env/v11/LICENSE.md
generated
vendored
Normal file
@@ -0,0 +1,21 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2015-2024 Carlos Alexandro Becker
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
SOFTWARE.
|
||||
37
vendor/github.com/caarlos0/env/v11/Makefile
generated
vendored
Normal file
37
vendor/github.com/caarlos0/env/v11/Makefile
generated
vendored
Normal file
@@ -0,0 +1,37 @@
|
||||
SOURCE_FILES?=./...
|
||||
TEST_PATTERN?=.
|
||||
|
||||
export GO111MODULE := on
|
||||
|
||||
setup:
|
||||
go mod tidy
|
||||
.PHONY: setup
|
||||
|
||||
build:
|
||||
go build
|
||||
.PHONY: build
|
||||
|
||||
test:
|
||||
go test -v -failfast -race -coverpkg=./... -covermode=atomic -coverprofile=coverage.txt $(SOURCE_FILES) -run $(TEST_PATTERN) -timeout=2m
|
||||
.PHONY: test
|
||||
|
||||
cover: test
|
||||
go tool cover -html=coverage.txt
|
||||
.PHONY: cover
|
||||
|
||||
fmt:
|
||||
gofumpt -w -l .
|
||||
.PHONY: fmt
|
||||
|
||||
lint:
|
||||
golangci-lint run ./...
|
||||
.PHONY: lint
|
||||
|
||||
ci: build test
|
||||
.PHONY: ci
|
||||
|
||||
card:
|
||||
wget -O card.png -c "https://og.caarlos0.dev/**env**: parse envs to structs.png?theme=light&md=1&fontSize=100px&images=https://github.com/caarlos0.png"
|
||||
.PHONY: card
|
||||
|
||||
.DEFAULT_GOAL := ci
|
||||
156
vendor/github.com/caarlos0/env/v11/README.md
generated
vendored
Normal file
156
vendor/github.com/caarlos0/env/v11/README.md
generated
vendored
Normal file
@@ -0,0 +1,156 @@
|
||||
<p align="center">
|
||||
<img alt="GoReleaser Logo" src="https://becker.software/env.png" height="140" />
|
||||
<p align="center">A simple, zero-dependencies library to parse environment variables into structs.</p>
|
||||
</p>
|
||||
|
||||
###### Installation
|
||||
|
||||
```bash
|
||||
go get github.com/caarlos0/env/v11
|
||||
```
|
||||
|
||||
###### Getting started
|
||||
|
||||
```go
|
||||
type config struct {
|
||||
Home string `env:"HOME"`
|
||||
}
|
||||
|
||||
// parse
|
||||
var cfg config
|
||||
err := env.Parse(&cfg)
|
||||
|
||||
// parse with generics
|
||||
cfg, err := env.ParseAs[config]()
|
||||
```
|
||||
|
||||
You can see the full documentation and list of examples at [pkg.go.dev](https://pkg.go.dev/github.com/caarlos0/env/v11).
|
||||
|
||||
---
|
||||
|
||||
## Used and supported by
|
||||
|
||||
<p>
|
||||
<a href="https://encore.dev">
|
||||
<img src="https://user-images.githubusercontent.com/78424526/214602214-52e0483a-b5fc-4d4c-b03e-0b7b23e012df.svg" width="120px" alt="encore icon" />
|
||||
</a>
|
||||
<br/>
|
||||
<br/>
|
||||
<b>Encore – the platform for building Go-based cloud backends.</b>
|
||||
<br/>
|
||||
</p>
|
||||
|
||||
## Usage
|
||||
|
||||
### Caveats
|
||||
|
||||
> [!CAUTION]
|
||||
>
|
||||
> _Unexported fields_ will be **ignored** by `env`.
|
||||
> This is by design and will not change.
|
||||
|
||||
### Functions
|
||||
|
||||
- `Parse`: parse the current environment into a type
|
||||
- `ParseAs`: parse the current environment into a type using generics
|
||||
- `ParseWithOptions`: parse the current environment into a type with custom options
|
||||
- `ParseAsWithOptions`: parse the current environment into a type with custom options and using generics
|
||||
- `Must`: can be used to wrap `Parse.*` calls to panic on error
|
||||
- `GetFieldParams`: get the `env` parsed options for a type
|
||||
- `GetFieldParamsWithOptions`: get the `env` parsed options for a type with custom options
|
||||
|
||||
### Supported types
|
||||
|
||||
Out of the box all built-in types are supported, plus a few others that are commonly used.
|
||||
|
||||
Complete list:
|
||||
|
||||
- `bool`
|
||||
- `float32`
|
||||
- `float64`
|
||||
- `int16`
|
||||
- `int32`
|
||||
- `int64`
|
||||
- `int8`
|
||||
- `int`
|
||||
- `string`
|
||||
- `uint16`
|
||||
- `uint32`
|
||||
- `uint64`
|
||||
- `uint8`
|
||||
- `uint`
|
||||
- `time.Duration`
|
||||
- `time.Location`
|
||||
- `encoding.TextUnmarshaler`
|
||||
- `url.URL`
|
||||
|
||||
Pointers, slices and slices of pointers, and maps of those types are also supported.
|
||||
|
||||
You may also add custom parsers for your types.
|
||||
|
||||
### Tags
|
||||
|
||||
The following tags are provided:
|
||||
|
||||
- `env`: sets the environment variable name and optionally takes the tag options described below
|
||||
- `envDefault`: sets the default value for the field
|
||||
- `envPrefix`: can be used in a field that is a complex type to set a prefix to all environment variables used in it
|
||||
- `envSeparator`: sets the character to be used to separate items in slices and maps (default: `,`)
|
||||
- `envKeyValSeparator`: sets the character to be used to separate keys and their values in maps (default: `:`)
|
||||
|
||||
### `env` tag options
|
||||
|
||||
Here are all the options available for the `env` tag:
|
||||
|
||||
- `,expand`: expands environment variables, e.g. `FOO_${BAR}`
|
||||
- `,file`: instructs that the content of the variable is a path to a file that should be read
|
||||
- `,init`: initialize nil pointers
|
||||
- `,notEmpty`: make the field errors if the environment variable is empty
|
||||
- `,required`: make the field errors if the environment variable is not set
|
||||
- `,unset`: unset the environment variable after use
|
||||
|
||||
### Parse Options
|
||||
|
||||
There are a few options available in the functions that end with `WithOptions`:
|
||||
|
||||
- `Environment`: keys and values to be used instead of `os.Environ()`
|
||||
- `TagName`: specifies another tag name to use rather than the default `env`
|
||||
- `PrefixTagName`: specifies another prefix tag name to use rather than the default `envPrefix`
|
||||
- `DefaultValueTagName`: specifies another default tag name to use rather than the default `envDefault`
|
||||
- `RequiredIfNoDef`: set all `env` fields as required if they do not declare `envDefault`
|
||||
- `OnSet`: allows to hook into the `env` parsing and do something when a value is set
|
||||
- `Prefix`: prefix to be used in all environment variables
|
||||
- `UseFieldNameByDefault`: defines whether or not `env` should use the field name by default if the `env` key is missing
|
||||
- `FuncMap`: custom parse functions for custom types
|
||||
|
||||
### Documentation and examples
|
||||
|
||||
Examples are live in [pkg.go.dev](https://pkg.go.dev/github.com/caarlos0/env/v11),
|
||||
and also in the [example test file](./example_test.go).
|
||||
|
||||
## Current state
|
||||
|
||||
`env` is considered feature-complete.
|
||||
|
||||
I do not intent to add any new features unless they really make sense, and are
|
||||
requested by many people.
|
||||
|
||||
Eventual bug fixes will keep being merged.
|
||||
|
||||
## Badges
|
||||
|
||||
[](https://github.com/goreleaser/goreleaser/releases/latest)
|
||||
[](/LICENSE.md)
|
||||
[](https://github.com/caarlos0/env/actions?workflow=build)
|
||||
[](https://codecov.io/gh/caarlos0/env)
|
||||
[](http://godoc.org/github.com/caarlos0/env/v11)
|
||||
[](https://github.com/goreleaser)
|
||||
[](https://conventionalcommits.org)
|
||||
|
||||
## Related projects
|
||||
|
||||
- [envdoc](https://github.com/g4s8/envdoc) - generate documentation for environment variables from `env` tags
|
||||
|
||||
## Stargazers over time
|
||||
|
||||
[](https://starchart.cc/caarlos0/env)
|
||||
845
vendor/github.com/caarlos0/env/v11/env.go
generated
vendored
Normal file
845
vendor/github.com/caarlos0/env/v11/env.go
generated
vendored
Normal file
@@ -0,0 +1,845 @@
|
||||
// Package env is a simple, zero-dependencies library to parse environment
|
||||
// variables into structs.
|
||||
//
|
||||
// Example:
|
||||
//
|
||||
// type config struct {
|
||||
// Home string `env:"HOME"`
|
||||
// }
|
||||
// // parse
|
||||
// var cfg config
|
||||
// err := env.Parse(&cfg)
|
||||
// // or parse with generics
|
||||
// cfg, err := env.ParseAs[config]()
|
||||
//
|
||||
// Check the examples and README for more detailed usage.
|
||||
package env
|
||||
|
||||
import (
|
||||
"encoding"
|
||||
"fmt"
|
||||
"net/url"
|
||||
"os"
|
||||
"reflect"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
"unicode"
|
||||
)
|
||||
|
||||
// nolint: gochecknoglobals
|
||||
var (
|
||||
defaultBuiltInParsers = map[reflect.Kind]ParserFunc{
|
||||
reflect.Bool: func(v string) (interface{}, error) {
|
||||
return strconv.ParseBool(v)
|
||||
},
|
||||
reflect.String: func(v string) (interface{}, error) {
|
||||
return v, nil
|
||||
},
|
||||
reflect.Int: func(v string) (interface{}, error) {
|
||||
i, err := strconv.ParseInt(v, 10, 32)
|
||||
return int(i), err
|
||||
},
|
||||
reflect.Int16: func(v string) (interface{}, error) {
|
||||
i, err := strconv.ParseInt(v, 10, 16)
|
||||
return int16(i), err
|
||||
},
|
||||
reflect.Int32: func(v string) (interface{}, error) {
|
||||
i, err := strconv.ParseInt(v, 10, 32)
|
||||
return int32(i), err
|
||||
},
|
||||
reflect.Int64: func(v string) (interface{}, error) {
|
||||
return strconv.ParseInt(v, 10, 64)
|
||||
},
|
||||
reflect.Int8: func(v string) (interface{}, error) {
|
||||
i, err := strconv.ParseInt(v, 10, 8)
|
||||
return int8(i), err
|
||||
},
|
||||
reflect.Uint: func(v string) (interface{}, error) {
|
||||
i, err := strconv.ParseUint(v, 10, 32)
|
||||
return uint(i), err
|
||||
},
|
||||
reflect.Uint16: func(v string) (interface{}, error) {
|
||||
i, err := strconv.ParseUint(v, 10, 16)
|
||||
return uint16(i), err
|
||||
},
|
||||
reflect.Uint32: func(v string) (interface{}, error) {
|
||||
i, err := strconv.ParseUint(v, 10, 32)
|
||||
return uint32(i), err
|
||||
},
|
||||
reflect.Uint64: func(v string) (interface{}, error) {
|
||||
i, err := strconv.ParseUint(v, 10, 64)
|
||||
return i, err
|
||||
},
|
||||
reflect.Uint8: func(v string) (interface{}, error) {
|
||||
i, err := strconv.ParseUint(v, 10, 8)
|
||||
return uint8(i), err
|
||||
},
|
||||
reflect.Float64: func(v string) (interface{}, error) {
|
||||
return strconv.ParseFloat(v, 64)
|
||||
},
|
||||
reflect.Float32: func(v string) (interface{}, error) {
|
||||
f, err := strconv.ParseFloat(v, 32)
|
||||
return float32(f), err
|
||||
},
|
||||
}
|
||||
)
|
||||
|
||||
func defaultTypeParsers() map[reflect.Type]ParserFunc {
|
||||
return map[reflect.Type]ParserFunc{
|
||||
reflect.TypeOf(url.URL{}): parseURL,
|
||||
reflect.TypeOf(time.Nanosecond): parseDuration,
|
||||
reflect.TypeOf(time.Location{}): parseLocation,
|
||||
}
|
||||
}
|
||||
|
||||
func parseURL(v string) (interface{}, error) {
|
||||
u, err := url.Parse(v)
|
||||
if err != nil {
|
||||
return nil, newParseValueError("unable to parse URL", err)
|
||||
}
|
||||
return *u, nil
|
||||
}
|
||||
|
||||
func parseDuration(v string) (interface{}, error) {
|
||||
d, err := time.ParseDuration(v)
|
||||
if err != nil {
|
||||
return nil, newParseValueError("unable to parse duration", err)
|
||||
}
|
||||
return d, err
|
||||
}
|
||||
|
||||
func parseLocation(v string) (interface{}, error) {
|
||||
loc, err := time.LoadLocation(v)
|
||||
if err != nil {
|
||||
return nil, newParseValueError("unable to parse location", err)
|
||||
}
|
||||
return *loc, nil
|
||||
}
|
||||
|
||||
// ParserFunc defines the signature of a function that can be used within
|
||||
// `Options`' `FuncMap`.
|
||||
type ParserFunc func(v string) (interface{}, error)
|
||||
|
||||
// OnSetFn is a hook that can be run when a value is set.
|
||||
type OnSetFn func(tag string, value interface{}, isDefault bool)
|
||||
|
||||
// processFieldFn is a function which takes all information about a field and processes it.
|
||||
type processFieldFn func(
|
||||
refField reflect.Value,
|
||||
refTypeField reflect.StructField,
|
||||
opts Options,
|
||||
fieldParams FieldParams,
|
||||
) error
|
||||
|
||||
// Options for the parser.
|
||||
type Options struct {
|
||||
// Environment keys and values that will be accessible for the service.
|
||||
Environment map[string]string
|
||||
|
||||
// TagName specifies another tag name to use rather than the default 'env'.
|
||||
TagName string
|
||||
|
||||
// PrefixTagName specifies another prefix tag name to use rather than the default 'envPrefix'.
|
||||
PrefixTagName string
|
||||
|
||||
// DefaultValueTagName specifies another default tag name to use rather than the default 'envDefault'.
|
||||
DefaultValueTagName string
|
||||
|
||||
// RequiredIfNoDef automatically sets all fields as required if they do not
|
||||
// declare 'envDefault'.
|
||||
RequiredIfNoDef bool
|
||||
|
||||
// OnSet allows to run a function when a value is set.
|
||||
OnSet OnSetFn
|
||||
|
||||
// Prefix define a prefix for every key.
|
||||
Prefix string
|
||||
|
||||
// UseFieldNameByDefault defines whether or not `env` should use the field
|
||||
// name by default if the `env` key is missing.
|
||||
// Note that the field name will be "converted" to conform with environment
|
||||
// variable names conventions.
|
||||
UseFieldNameByDefault bool
|
||||
|
||||
// Custom parse functions for different types.
|
||||
FuncMap map[reflect.Type]ParserFunc
|
||||
|
||||
// Used internally. maps the env variable key to its resolved string value.
|
||||
// (for env var expansion)
|
||||
rawEnvVars map[string]string
|
||||
}
|
||||
|
||||
func (opts *Options) getRawEnv(s string) string {
|
||||
val := opts.rawEnvVars[s]
|
||||
if val == "" {
|
||||
val = opts.Environment[s]
|
||||
}
|
||||
return os.Expand(val, opts.getRawEnv)
|
||||
}
|
||||
|
||||
func defaultOptions() Options {
|
||||
return Options{
|
||||
TagName: "env",
|
||||
PrefixTagName: "envPrefix",
|
||||
DefaultValueTagName: "envDefault",
|
||||
Environment: toMap(os.Environ()),
|
||||
FuncMap: defaultTypeParsers(),
|
||||
rawEnvVars: make(map[string]string),
|
||||
}
|
||||
}
|
||||
|
||||
func mergeOptions[T any](target, source *T) {
|
||||
targetPtr := reflect.ValueOf(target).Elem()
|
||||
sourcePtr := reflect.ValueOf(source).Elem()
|
||||
|
||||
targetType := targetPtr.Type()
|
||||
for i := 0; i < targetPtr.NumField(); i++ {
|
||||
fieldName := targetType.Field(i).Name
|
||||
targetField := targetPtr.Field(i)
|
||||
sourceField := sourcePtr.FieldByName(fieldName)
|
||||
|
||||
if targetField.CanSet() && !isZero(sourceField) {
|
||||
// FuncMaps are being merged, while Environments must be overwritten
|
||||
if fieldName == "FuncMap" {
|
||||
if !sourceField.IsZero() {
|
||||
iter := sourceField.MapRange()
|
||||
for iter.Next() {
|
||||
targetField.SetMapIndex(iter.Key(), iter.Value())
|
||||
}
|
||||
}
|
||||
} else {
|
||||
targetField.Set(sourceField)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func isZero(v reflect.Value) bool {
|
||||
switch v.Kind() {
|
||||
case reflect.Func, reflect.Map, reflect.Slice:
|
||||
return v.IsNil()
|
||||
default:
|
||||
zero := reflect.Zero(v.Type())
|
||||
return v.Interface() == zero.Interface()
|
||||
}
|
||||
}
|
||||
|
||||
func customOptions(opts Options) Options {
|
||||
defOpts := defaultOptions()
|
||||
mergeOptions(&defOpts, &opts)
|
||||
return defOpts
|
||||
}
|
||||
|
||||
func optionsWithSliceEnvPrefix(opts Options, index int) Options {
|
||||
return Options{
|
||||
Environment: opts.Environment,
|
||||
TagName: opts.TagName,
|
||||
PrefixTagName: opts.PrefixTagName,
|
||||
DefaultValueTagName: opts.DefaultValueTagName,
|
||||
RequiredIfNoDef: opts.RequiredIfNoDef,
|
||||
OnSet: opts.OnSet,
|
||||
Prefix: fmt.Sprintf("%s%d_", opts.Prefix, index),
|
||||
UseFieldNameByDefault: opts.UseFieldNameByDefault,
|
||||
FuncMap: opts.FuncMap,
|
||||
rawEnvVars: opts.rawEnvVars,
|
||||
}
|
||||
}
|
||||
|
||||
func optionsWithEnvPrefix(field reflect.StructField, opts Options) Options {
|
||||
return Options{
|
||||
Environment: opts.Environment,
|
||||
TagName: opts.TagName,
|
||||
PrefixTagName: opts.PrefixTagName,
|
||||
DefaultValueTagName: opts.DefaultValueTagName,
|
||||
RequiredIfNoDef: opts.RequiredIfNoDef,
|
||||
OnSet: opts.OnSet,
|
||||
Prefix: opts.Prefix + field.Tag.Get(opts.PrefixTagName),
|
||||
UseFieldNameByDefault: opts.UseFieldNameByDefault,
|
||||
FuncMap: opts.FuncMap,
|
||||
rawEnvVars: opts.rawEnvVars,
|
||||
}
|
||||
}
|
||||
|
||||
// Parse parses a struct containing `env` tags and loads its values from
|
||||
// environment variables.
|
||||
func Parse(v interface{}) error {
|
||||
return parseInternal(v, setField, defaultOptions())
|
||||
}
|
||||
|
||||
// ParseWithOptions parses a struct containing `env` tags and loads its values from
|
||||
// environment variables.
|
||||
func ParseWithOptions(v interface{}, opts Options) error {
|
||||
return parseInternal(v, setField, customOptions(opts))
|
||||
}
|
||||
|
||||
// ParseAs parses the given struct type containing `env` tags and loads its
|
||||
// values from environment variables.
|
||||
func ParseAs[T any]() (T, error) {
|
||||
var t T
|
||||
err := Parse(&t)
|
||||
return t, err
|
||||
}
|
||||
|
||||
// ParseWithOptions parses the given struct type containing `env` tags and
|
||||
// loads its values from environment variables.
|
||||
func ParseAsWithOptions[T any](opts Options) (T, error) {
|
||||
var t T
|
||||
err := ParseWithOptions(&t, opts)
|
||||
return t, err
|
||||
}
|
||||
|
||||
// Must panic is if err is not nil, and returns t otherwise.
|
||||
func Must[T any](t T, err error) T {
|
||||
if err != nil {
|
||||
panic(err)
|
||||
}
|
||||
return t
|
||||
}
|
||||
|
||||
// GetFieldParams parses a struct containing `env` tags and returns information about
|
||||
// tags it found.
|
||||
func GetFieldParams(v interface{}) ([]FieldParams, error) {
|
||||
return GetFieldParamsWithOptions(v, defaultOptions())
|
||||
}
|
||||
|
||||
// GetFieldParamsWithOptions parses a struct containing `env` tags and returns information about
|
||||
// tags it found.
|
||||
func GetFieldParamsWithOptions(v interface{}, opts Options) ([]FieldParams, error) {
|
||||
var result []FieldParams
|
||||
err := parseInternal(
|
||||
v,
|
||||
func(_ reflect.Value, _ reflect.StructField, _ Options, fieldParams FieldParams) error {
|
||||
if fieldParams.OwnKey != "" {
|
||||
result = append(result, fieldParams)
|
||||
}
|
||||
return nil
|
||||
},
|
||||
customOptions(opts),
|
||||
)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func parseInternal(v interface{}, processField processFieldFn, opts Options) error {
|
||||
ptrRef := reflect.ValueOf(v)
|
||||
if ptrRef.Kind() != reflect.Ptr {
|
||||
return newAggregateError(NotStructPtrError{})
|
||||
}
|
||||
ref := ptrRef.Elem()
|
||||
if ref.Kind() != reflect.Struct {
|
||||
return newAggregateError(NotStructPtrError{})
|
||||
}
|
||||
|
||||
return doParse(ref, processField, opts)
|
||||
}
|
||||
|
||||
func doParse(ref reflect.Value, processField processFieldFn, opts Options) error {
|
||||
refType := ref.Type()
|
||||
|
||||
var agrErr AggregateError
|
||||
|
||||
for i := 0; i < refType.NumField(); i++ {
|
||||
refField := ref.Field(i)
|
||||
refTypeField := refType.Field(i)
|
||||
|
||||
if err := doParseField(refField, refTypeField, processField, opts); err != nil {
|
||||
if val, ok := err.(AggregateError); ok {
|
||||
agrErr.Errors = append(agrErr.Errors, val.Errors...)
|
||||
} else {
|
||||
agrErr.Errors = append(agrErr.Errors, err)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if len(agrErr.Errors) == 0 {
|
||||
return nil
|
||||
}
|
||||
|
||||
return agrErr
|
||||
}
|
||||
|
||||
func doParseField(
|
||||
refField reflect.Value,
|
||||
refTypeField reflect.StructField,
|
||||
processField processFieldFn,
|
||||
opts Options,
|
||||
) error {
|
||||
if !refField.CanSet() {
|
||||
return nil
|
||||
}
|
||||
if refField.Kind() == reflect.Ptr && refField.Elem().Kind() == reflect.Struct && !refField.IsNil() {
|
||||
return parseInternal(refField.Interface(), processField, optionsWithEnvPrefix(refTypeField, opts))
|
||||
}
|
||||
if refField.Kind() == reflect.Struct && refField.CanAddr() && refField.Type().Name() == "" {
|
||||
return parseInternal(refField.Addr().Interface(), processField, optionsWithEnvPrefix(refTypeField, opts))
|
||||
}
|
||||
|
||||
params, err := parseFieldParams(refTypeField, opts)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if params.Ignored {
|
||||
return nil
|
||||
}
|
||||
|
||||
if err := processField(refField, refTypeField, opts, params); err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if params.Init && isInvalidPtr(refField) {
|
||||
refField.Set(reflect.New(refField.Type().Elem()))
|
||||
refField = refField.Elem()
|
||||
}
|
||||
|
||||
if refField.Kind() == reflect.Struct {
|
||||
return doParse(refField, processField, optionsWithEnvPrefix(refTypeField, opts))
|
||||
}
|
||||
|
||||
if isSliceOfStructs(refTypeField) {
|
||||
return doParseSlice(refField, processField, optionsWithEnvPrefix(refTypeField, opts))
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func isSliceOfStructs(refTypeField reflect.StructField) bool {
|
||||
field := refTypeField.Type
|
||||
|
||||
// *[]struct
|
||||
if field.Kind() == reflect.Ptr {
|
||||
field = field.Elem()
|
||||
if field.Kind() == reflect.Slice && field.Elem().Kind() == reflect.Struct {
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
// []struct{}
|
||||
if field.Kind() == reflect.Slice && field.Elem().Kind() == reflect.Struct {
|
||||
return true
|
||||
}
|
||||
|
||||
return false
|
||||
}
|
||||
|
||||
func doParseSlice(ref reflect.Value, processField processFieldFn, opts Options) error {
|
||||
if opts.Prefix != "" && !strings.HasSuffix(opts.Prefix, string(underscore)) {
|
||||
opts.Prefix += string(underscore)
|
||||
}
|
||||
|
||||
var environments []string
|
||||
for environment := range opts.Environment {
|
||||
if strings.HasPrefix(environment, opts.Prefix) {
|
||||
environments = append(environments, environment)
|
||||
}
|
||||
}
|
||||
|
||||
if len(environments) > 0 {
|
||||
counter := 0
|
||||
for finished := false; !finished; {
|
||||
finished = true
|
||||
prefix := fmt.Sprintf("%s%d%c", opts.Prefix, counter, underscore)
|
||||
for _, variable := range environments {
|
||||
if strings.HasPrefix(variable, prefix) {
|
||||
counter++
|
||||
finished = false
|
||||
break
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
sliceType := ref.Type()
|
||||
var initialized int
|
||||
if reflect.Ptr == ref.Kind() {
|
||||
sliceType = sliceType.Elem()
|
||||
// Due to the rest of code the pre-initialized slice has no chance for this situation
|
||||
initialized = 0
|
||||
} else {
|
||||
initialized = ref.Len()
|
||||
}
|
||||
|
||||
var capacity int
|
||||
if capacity = initialized; counter > initialized {
|
||||
capacity = counter
|
||||
}
|
||||
result := reflect.MakeSlice(sliceType, capacity, capacity)
|
||||
for i := 0; i < capacity; i++ {
|
||||
item := result.Index(i)
|
||||
if i < initialized {
|
||||
item.Set(ref.Index(i))
|
||||
}
|
||||
if err := doParse(item, processField, optionsWithSliceEnvPrefix(opts, i)); err != nil {
|
||||
return err
|
||||
}
|
||||
}
|
||||
|
||||
if result.Len() > 0 {
|
||||
if reflect.Ptr == ref.Kind() {
|
||||
resultPtr := reflect.New(sliceType)
|
||||
resultPtr.Elem().Set(result)
|
||||
result = resultPtr
|
||||
}
|
||||
ref.Set(result)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
func setField(refField reflect.Value, refTypeField reflect.StructField, opts Options, fieldParams FieldParams) error {
|
||||
value, err := get(fieldParams, opts)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
|
||||
if value != "" {
|
||||
return set(refField, refTypeField, value, opts.FuncMap)
|
||||
}
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
const underscore rune = '_'
|
||||
|
||||
func toEnvName(input string) string {
|
||||
var output []rune
|
||||
for i, c := range input {
|
||||
if c == underscore {
|
||||
continue
|
||||
}
|
||||
if len(output) > 0 && unicode.IsUpper(c) {
|
||||
if len(input) > i+1 {
|
||||
peek := rune(input[i+1])
|
||||
if unicode.IsLower(peek) || unicode.IsLower(rune(input[i-1])) {
|
||||
output = append(output, underscore)
|
||||
}
|
||||
}
|
||||
}
|
||||
output = append(output, unicode.ToUpper(c))
|
||||
}
|
||||
return string(output)
|
||||
}
|
||||
|
||||
// FieldParams contains information about parsed field tags.
|
||||
type FieldParams struct {
|
||||
OwnKey string
|
||||
Key string
|
||||
DefaultValue string
|
||||
HasDefaultValue bool
|
||||
Required bool
|
||||
LoadFile bool
|
||||
Unset bool
|
||||
NotEmpty bool
|
||||
Expand bool
|
||||
Init bool
|
||||
Ignored bool
|
||||
}
|
||||
|
||||
func parseFieldParams(field reflect.StructField, opts Options) (FieldParams, error) {
|
||||
ownKey, tags := parseKeyForOption(field.Tag.Get(opts.TagName))
|
||||
if ownKey == "" && opts.UseFieldNameByDefault {
|
||||
ownKey = toEnvName(field.Name)
|
||||
}
|
||||
|
||||
defaultValue, hasDefaultValue := field.Tag.Lookup(opts.DefaultValueTagName)
|
||||
|
||||
result := FieldParams{
|
||||
OwnKey: ownKey,
|
||||
Key: opts.Prefix + ownKey,
|
||||
Required: opts.RequiredIfNoDef,
|
||||
DefaultValue: defaultValue,
|
||||
HasDefaultValue: hasDefaultValue,
|
||||
Ignored: ownKey == "-",
|
||||
}
|
||||
|
||||
for _, tag := range tags {
|
||||
switch tag {
|
||||
case "":
|
||||
continue
|
||||
case "file":
|
||||
result.LoadFile = true
|
||||
case "required":
|
||||
result.Required = true
|
||||
case "unset":
|
||||
result.Unset = true
|
||||
case "notEmpty":
|
||||
result.NotEmpty = true
|
||||
case "expand":
|
||||
result.Expand = true
|
||||
case "init":
|
||||
result.Init = true
|
||||
case "-":
|
||||
result.Ignored = true
|
||||
default:
|
||||
return FieldParams{}, newNoSupportedTagOptionError(tag)
|
||||
}
|
||||
}
|
||||
|
||||
return result, nil
|
||||
}
|
||||
|
||||
func get(fieldParams FieldParams, opts Options) (val string, err error) {
|
||||
var exists, isDefault bool
|
||||
|
||||
val, exists, isDefault = getOr(
|
||||
fieldParams.Key,
|
||||
fieldParams.DefaultValue,
|
||||
fieldParams.HasDefaultValue,
|
||||
opts.Environment,
|
||||
)
|
||||
|
||||
if fieldParams.Expand {
|
||||
val = os.Expand(val, opts.getRawEnv)
|
||||
}
|
||||
|
||||
opts.rawEnvVars[fieldParams.OwnKey] = val
|
||||
|
||||
if fieldParams.Unset {
|
||||
defer os.Unsetenv(fieldParams.Key)
|
||||
}
|
||||
|
||||
if fieldParams.Required && !exists && fieldParams.OwnKey != "" {
|
||||
return "", newVarIsNotSetError(fieldParams.Key)
|
||||
}
|
||||
|
||||
if fieldParams.NotEmpty && val == "" {
|
||||
return "", newEmptyVarError(fieldParams.Key)
|
||||
}
|
||||
|
||||
if fieldParams.LoadFile && val != "" {
|
||||
filename := val
|
||||
val, err = getFromFile(filename)
|
||||
if err != nil {
|
||||
return "", newLoadFileContentError(filename, fieldParams.Key, err)
|
||||
}
|
||||
}
|
||||
|
||||
if opts.OnSet != nil {
|
||||
if fieldParams.OwnKey != "" {
|
||||
opts.OnSet(fieldParams.Key, val, isDefault)
|
||||
}
|
||||
}
|
||||
return val, err
|
||||
}
|
||||
|
||||
// split the env tag's key into the expected key and desired option, if any.
|
||||
func parseKeyForOption(key string) (string, []string) {
|
||||
opts := strings.Split(key, ",")
|
||||
return opts[0], opts[1:]
|
||||
}
|
||||
|
||||
func getFromFile(filename string) (value string, err error) {
|
||||
b, err := os.ReadFile(filename)
|
||||
return string(b), err
|
||||
}
|
||||
|
||||
func getOr(key, defaultValue string, defExists bool, envs map[string]string) (val string, exists, isDefault bool) {
|
||||
value, exists := envs[key]
|
||||
switch {
|
||||
case (!exists || key == "") && defExists:
|
||||
return defaultValue, true, true
|
||||
case exists && value == "" && defExists:
|
||||
return defaultValue, true, true
|
||||
case !exists:
|
||||
return "", false, false
|
||||
}
|
||||
|
||||
return value, true, false
|
||||
}
|
||||
|
||||
func set(field reflect.Value, sf reflect.StructField, value string, funcMap map[reflect.Type]ParserFunc) error {
|
||||
if tm := asTextUnmarshaler(field); tm != nil {
|
||||
if err := tm.UnmarshalText([]byte(value)); err != nil {
|
||||
return newParseError(sf, err)
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
typee := sf.Type
|
||||
fieldee := field
|
||||
if typee.Kind() == reflect.Ptr {
|
||||
typee = typee.Elem()
|
||||
fieldee = field.Elem()
|
||||
}
|
||||
|
||||
parserFunc, ok := funcMap[typee]
|
||||
if ok {
|
||||
val, err := parserFunc(value)
|
||||
if err != nil {
|
||||
return newParseError(sf, err)
|
||||
}
|
||||
|
||||
fieldee.Set(reflect.ValueOf(val))
|
||||
return nil
|
||||
}
|
||||
|
||||
parserFunc, ok = defaultBuiltInParsers[typee.Kind()]
|
||||
if ok {
|
||||
val, err := parserFunc(value)
|
||||
if err != nil {
|
||||
return newParseError(sf, err)
|
||||
}
|
||||
|
||||
fieldee.Set(reflect.ValueOf(val).Convert(typee))
|
||||
return nil
|
||||
}
|
||||
|
||||
switch field.Kind() {
|
||||
case reflect.Slice:
|
||||
return handleSlice(field, value, sf, funcMap)
|
||||
case reflect.Map:
|
||||
return handleMap(field, value, sf, funcMap)
|
||||
}
|
||||
|
||||
return newNoParserError(sf)
|
||||
}
|
||||
|
||||
func handleSlice(field reflect.Value, value string, sf reflect.StructField, funcMap map[reflect.Type]ParserFunc) error {
|
||||
separator := sf.Tag.Get("envSeparator")
|
||||
if separator == "" {
|
||||
separator = ","
|
||||
}
|
||||
parts := strings.Split(value, separator)
|
||||
|
||||
typee := sf.Type.Elem()
|
||||
if typee.Kind() == reflect.Ptr {
|
||||
typee = typee.Elem()
|
||||
}
|
||||
|
||||
if _, ok := reflect.New(typee).Interface().(encoding.TextUnmarshaler); ok {
|
||||
return parseTextUnmarshalers(field, parts, sf)
|
||||
}
|
||||
|
||||
parserFunc, ok := funcMap[typee]
|
||||
if !ok {
|
||||
parserFunc, ok = defaultBuiltInParsers[typee.Kind()]
|
||||
if !ok {
|
||||
return newNoParserError(sf)
|
||||
}
|
||||
}
|
||||
|
||||
result := reflect.MakeSlice(sf.Type, 0, len(parts))
|
||||
for _, part := range parts {
|
||||
r, err := parserFunc(part)
|
||||
if err != nil {
|
||||
return newParseError(sf, err)
|
||||
}
|
||||
v := reflect.ValueOf(r).Convert(typee)
|
||||
if sf.Type.Elem().Kind() == reflect.Ptr {
|
||||
v = reflect.New(typee)
|
||||
v.Elem().Set(reflect.ValueOf(r).Convert(typee))
|
||||
}
|
||||
result = reflect.Append(result, v)
|
||||
}
|
||||
field.Set(result)
|
||||
return nil
|
||||
}
|
||||
|
||||
func handleMap(field reflect.Value, value string, sf reflect.StructField, funcMap map[reflect.Type]ParserFunc) error {
|
||||
keyType := sf.Type.Key()
|
||||
keyParserFunc, ok := funcMap[keyType]
|
||||
if !ok {
|
||||
keyParserFunc, ok = defaultBuiltInParsers[keyType.Kind()]
|
||||
if !ok {
|
||||
return newNoParserError(sf)
|
||||
}
|
||||
}
|
||||
|
||||
elemType := sf.Type.Elem()
|
||||
elemParserFunc, ok := funcMap[elemType]
|
||||
if !ok {
|
||||
elemParserFunc, ok = defaultBuiltInParsers[elemType.Kind()]
|
||||
if !ok {
|
||||
return newNoParserError(sf)
|
||||
}
|
||||
}
|
||||
|
||||
separator := sf.Tag.Get("envSeparator")
|
||||
if separator == "" {
|
||||
separator = ","
|
||||
}
|
||||
|
||||
keyValSeparator := sf.Tag.Get("envKeyValSeparator")
|
||||
if keyValSeparator == "" {
|
||||
keyValSeparator = ":"
|
||||
}
|
||||
|
||||
result := reflect.MakeMap(sf.Type)
|
||||
for _, part := range strings.Split(value, separator) {
|
||||
pairs := strings.SplitN(part, keyValSeparator, 2)
|
||||
if len(pairs) != 2 {
|
||||
return newParseError(sf, fmt.Errorf(`%q should be in "key%svalue" format`, part, keyValSeparator))
|
||||
}
|
||||
|
||||
key, err := keyParserFunc(pairs[0])
|
||||
if err != nil {
|
||||
return newParseError(sf, err)
|
||||
}
|
||||
|
||||
elem, err := elemParserFunc(pairs[1])
|
||||
if err != nil {
|
||||
return newParseError(sf, err)
|
||||
}
|
||||
|
||||
result.SetMapIndex(reflect.ValueOf(key).Convert(keyType), reflect.ValueOf(elem).Convert(elemType))
|
||||
}
|
||||
|
||||
field.Set(result)
|
||||
return nil
|
||||
}
|
||||
|
||||
func asTextUnmarshaler(field reflect.Value) encoding.TextUnmarshaler {
|
||||
if field.Kind() == reflect.Ptr {
|
||||
if field.IsNil() {
|
||||
field.Set(reflect.New(field.Type().Elem()))
|
||||
}
|
||||
} else if field.CanAddr() {
|
||||
field = field.Addr()
|
||||
}
|
||||
|
||||
tm, ok := field.Interface().(encoding.TextUnmarshaler)
|
||||
if !ok {
|
||||
return nil
|
||||
}
|
||||
return tm
|
||||
}
|
||||
|
||||
func parseTextUnmarshalers(field reflect.Value, data []string, sf reflect.StructField) error {
|
||||
s := len(data)
|
||||
elemType := field.Type().Elem()
|
||||
slice := reflect.MakeSlice(reflect.SliceOf(elemType), s, s)
|
||||
for i, v := range data {
|
||||
sv := slice.Index(i)
|
||||
kind := sv.Kind()
|
||||
if kind == reflect.Ptr {
|
||||
sv = reflect.New(elemType.Elem())
|
||||
} else {
|
||||
sv = sv.Addr()
|
||||
}
|
||||
tm := sv.Interface().(encoding.TextUnmarshaler)
|
||||
if err := tm.UnmarshalText([]byte(v)); err != nil {
|
||||
return newParseError(sf, err)
|
||||
}
|
||||
if kind == reflect.Ptr {
|
||||
slice.Index(i).Set(sv)
|
||||
}
|
||||
}
|
||||
|
||||
field.Set(slice)
|
||||
|
||||
return nil
|
||||
}
|
||||
|
||||
// ToMap Converts list of env vars as provided by os.Environ() to map you
|
||||
// can use as Options.Environment field
|
||||
func ToMap(env []string) map[string]string {
|
||||
return toMap(env)
|
||||
}
|
||||
|
||||
func isInvalidPtr(v reflect.Value) bool {
|
||||
return reflect.Ptr == v.Kind() && v.Elem().Kind() == reflect.Invalid
|
||||
}
|
||||
16
vendor/github.com/caarlos0/env/v11/env_tomap.go
generated
vendored
Normal file
16
vendor/github.com/caarlos0/env/v11/env_tomap.go
generated
vendored
Normal file
@@ -0,0 +1,16 @@
|
||||
//go:build !windows
|
||||
|
||||
package env
|
||||
|
||||
import "strings"
|
||||
|
||||
func toMap(env []string) map[string]string {
|
||||
r := map[string]string{}
|
||||
for _, e := range env {
|
||||
p := strings.SplitN(e, "=", 2)
|
||||
if len(p) == 2 {
|
||||
r[p[0]] = p[1]
|
||||
}
|
||||
}
|
||||
return r
|
||||
}
|
||||
29
vendor/github.com/caarlos0/env/v11/env_tomap_windows.go
generated
vendored
Normal file
29
vendor/github.com/caarlos0/env/v11/env_tomap_windows.go
generated
vendored
Normal file
@@ -0,0 +1,29 @@
|
||||
//go:build windows
|
||||
|
||||
package env
|
||||
|
||||
import "strings"
|
||||
|
||||
func toMap(env []string) map[string]string {
|
||||
r := map[string]string{}
|
||||
for _, e := range env {
|
||||
p := strings.SplitN(e, "=", 2)
|
||||
|
||||
// On Windows, environment variables can start with '='. If so, Split at next character.
|
||||
// See env_windows.go in the Go source: https://github.com/golang/go/blob/master/src/syscall/env_windows.go#L58
|
||||
prefixEqualSign := false
|
||||
if len(e) > 0 && e[0] == '=' {
|
||||
e = e[1:]
|
||||
prefixEqualSign = true
|
||||
}
|
||||
p = strings.SplitN(e, "=", 2)
|
||||
if prefixEqualSign {
|
||||
p[0] = "=" + p[0]
|
||||
}
|
||||
|
||||
if len(p) == 2 {
|
||||
r[p[0]] = p[1]
|
||||
}
|
||||
}
|
||||
return r
|
||||
}
|
||||
173
vendor/github.com/caarlos0/env/v11/error.go
generated
vendored
Normal file
173
vendor/github.com/caarlos0/env/v11/error.go
generated
vendored
Normal file
@@ -0,0 +1,173 @@
|
||||
package env
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"reflect"
|
||||
"strings"
|
||||
)
|
||||
|
||||
// An aggregated error wrapper to combine gathered errors.
|
||||
// This allows either to display all errors or convert them individually
|
||||
// List of the available errors
|
||||
// ParseError
|
||||
// NotStructPtrError
|
||||
// NoParserError
|
||||
// NoSupportedTagOptionError
|
||||
// VarIsNotSetError
|
||||
// EmptyVarError
|
||||
// LoadFileContentError
|
||||
// ParseValueError
|
||||
type AggregateError struct {
|
||||
Errors []error
|
||||
}
|
||||
|
||||
func newAggregateError(initErr error) error {
|
||||
return AggregateError{
|
||||
[]error{
|
||||
initErr,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
func (e AggregateError) Error() string {
|
||||
var sb strings.Builder
|
||||
|
||||
sb.WriteString("env:")
|
||||
|
||||
for _, err := range e.Errors {
|
||||
sb.WriteString(fmt.Sprintf(" %v;", err.Error()))
|
||||
}
|
||||
|
||||
return strings.TrimRight(sb.String(), ";")
|
||||
}
|
||||
|
||||
// Unwrap implements std errors.Join go1.20 compatibility
|
||||
func (e AggregateError) Unwrap() []error {
|
||||
return e.Errors
|
||||
}
|
||||
|
||||
// Is conforms with errors.Is.
|
||||
func (e AggregateError) Is(err error) bool {
|
||||
for _, ie := range e.Errors {
|
||||
if reflect.TypeOf(ie) == reflect.TypeOf(err) {
|
||||
return true
|
||||
}
|
||||
}
|
||||
return false
|
||||
}
|
||||
|
||||
// The error occurs when it's impossible to convert the value for given type.
|
||||
type ParseError struct {
|
||||
Name string
|
||||
Type reflect.Type
|
||||
Err error
|
||||
}
|
||||
|
||||
func newParseError(sf reflect.StructField, err error) error {
|
||||
return ParseError{sf.Name, sf.Type, err}
|
||||
}
|
||||
|
||||
func (e ParseError) Error() string {
|
||||
return fmt.Sprintf("parse error on field %q of type %q: %v", e.Name, e.Type, e.Err)
|
||||
}
|
||||
|
||||
// The error occurs when pass something that is not a pointer to a struct to Parse
|
||||
type NotStructPtrError struct{}
|
||||
|
||||
func (e NotStructPtrError) Error() string {
|
||||
return "expected a pointer to a Struct"
|
||||
}
|
||||
|
||||
// This error occurs when there is no parser provided for given type.
|
||||
type NoParserError struct {
|
||||
Name string
|
||||
Type reflect.Type
|
||||
}
|
||||
|
||||
func newNoParserError(sf reflect.StructField) error {
|
||||
return NoParserError{sf.Name, sf.Type}
|
||||
}
|
||||
|
||||
func (e NoParserError) Error() string {
|
||||
return fmt.Sprintf("no parser found for field %q of type %q", e.Name, e.Type)
|
||||
}
|
||||
|
||||
// This error occurs when the given tag is not supported.
|
||||
// Built-in supported tags: "", "file", "required", "unset", "notEmpty",
|
||||
// "expand", "envDefault", and "envSeparator".
|
||||
type NoSupportedTagOptionError struct {
|
||||
Tag string
|
||||
}
|
||||
|
||||
func newNoSupportedTagOptionError(tag string) error {
|
||||
return NoSupportedTagOptionError{tag}
|
||||
}
|
||||
|
||||
func (e NoSupportedTagOptionError) Error() string {
|
||||
return fmt.Sprintf("tag option %q not supported", e.Tag)
|
||||
}
|
||||
|
||||
// This error occurs when the required variable is not set.
|
||||
//
|
||||
// Deprecated: use VarIsNotSetError.
|
||||
type EnvVarIsNotSetError = VarIsNotSetError
|
||||
|
||||
// This error occurs when the required variable is not set.
|
||||
type VarIsNotSetError struct {
|
||||
Key string
|
||||
}
|
||||
|
||||
func newVarIsNotSetError(key string) error {
|
||||
return VarIsNotSetError{key}
|
||||
}
|
||||
|
||||
func (e VarIsNotSetError) Error() string {
|
||||
return fmt.Sprintf(`required environment variable %q is not set`, e.Key)
|
||||
}
|
||||
|
||||
// This error occurs when the variable which must be not empty is existing but has an empty value
|
||||
//
|
||||
// Deprecated: use EmptyVarError.
|
||||
type EmptyEnvVarError = EmptyVarError
|
||||
|
||||
// This error occurs when the variable which must be not empty is existing but has an empty value
|
||||
type EmptyVarError struct {
|
||||
Key string
|
||||
}
|
||||
|
||||
func newEmptyVarError(key string) error {
|
||||
return EmptyVarError{key}
|
||||
}
|
||||
|
||||
func (e EmptyVarError) Error() string {
|
||||
return fmt.Sprintf("environment variable %q should not be empty", e.Key)
|
||||
}
|
||||
|
||||
// This error occurs when it's impossible to load the value from the file.
|
||||
type LoadFileContentError struct {
|
||||
Filename string
|
||||
Key string
|
||||
Err error
|
||||
}
|
||||
|
||||
func newLoadFileContentError(filename, key string, err error) error {
|
||||
return LoadFileContentError{filename, key, err}
|
||||
}
|
||||
|
||||
func (e LoadFileContentError) Error() string {
|
||||
return fmt.Sprintf("could not load content of file %q from variable %s: %v", e.Filename, e.Key, e.Err)
|
||||
}
|
||||
|
||||
// This error occurs when it's impossible to convert value using given parser.
|
||||
type ParseValueError struct {
|
||||
Msg string
|
||||
Err error
|
||||
}
|
||||
|
||||
func newParseValueError(message string, err error) error {
|
||||
return ParseValueError{message, err}
|
||||
}
|
||||
|
||||
func (e ParseValueError) Error() string {
|
||||
return fmt.Sprintf("%s: %v", e.Msg, e.Err)
|
||||
}
|
||||
Reference in New Issue
Block a user