// processField gets tagName and the field, recursively checks if the field has the given
// tag, if yes, sets it otherwise ignores
func (t *TagLoader) processField(tagName string, field *structs.Field) error {
switch {
case field.Kind() == reflect.Struct && !implementsTextUnmarshaler(field):
for _, f := range field.Fields() {
if err := t.processField(tagName, f); err != nil {
return err
}
}
case field.Kind() == reflect.Ptr:
field.InitElem()
return t.processField(tagName, field)
default:
defaultVal := field.Tag(t.DefaultTagName)
if defaultVal == "" {
return nil
}
err := fieldSet(field, defaultVal)
if err != nil {
return err
}
}
return nil
}
// processField gets leading name for the env variable and combines the current
// field's name and generates environemnt variable names recursively
func (e *EnvironmentLoader) processField(prefix string, field *structs.Field) error {
fieldName := e.generateFieldName(prefix, field)
switch field.Kind() {
case reflect.Struct:
for _, f := range field.Fields() {
if err := e.processField(fieldName, f); err != nil {
return err
}
}
default:
envTag := field.Tag(e.EnvTagName)
var v string
if envTag != "" {
v = os.Getenv(envTag)
}
if v == "" {
v = os.Getenv(fieldName)
}
if v == "" {
return nil
}
if err := fieldSet(field, v); err != nil {
return err
}
}
return nil
}
func (e *RequiredValidator) processField(fieldName string, field *structs.Field) error {
fieldName += field.Name()
switch field.Kind() {
case reflect.Struct:
// this is used for error messages below, when we have an error at the
// child properties add parent properties into the error message as well
fieldName += "."
for _, f := range field.Fields() {
if err := e.processField(fieldName, f); err != nil {
return err
}
}
default:
val := field.Tag(e.RequiredTagName)
if val != "true" && val != "1" {
return nil
}
if field.IsZero() {
return fmt.Errorf("Field '%s' is required", fieldName)
}
}
return nil
}
func (e *SelectionValidator) processField(fieldName string, field *structs.Field) error {
fieldName += field.Name()
switch field.Kind() {
case reflect.Struct:
// this is used for error messages below, when we have an error at the
// child properties add parent properties into the error message as well
fieldName += "."
for _, f := range field.Fields() {
if err := e.processField(fieldName, f); err != nil {
return err
}
}
default:
if field.IsZero() {
return nil
}
selectionStr := field.Tag(e.SelectTagName)
if selectionStr == "" {
return nil
}
err := validateSelection(field, selectionStr)
if err != nil {
return err
}
}
return nil
}
func (e *RangeValidator) processField(fieldName string, field *structs.Field) error {
fieldName += field.Name()
switch field.Kind() {
case reflect.Struct:
// this is used for error messages below, when we have an error at the
// child properties add parent properties into the error message as well
fieldName += "."
for _, f := range field.Fields() {
if err := e.processField(fieldName, f); err != nil {
return err
}
}
default:
if field.IsZero() { //if not initialized, we won't validate it
return nil
}
minStr := field.Tag(e.MinTagName)
maxStr := field.Tag(e.MaxTagName)
if minStr == "" && maxStr == "" {
return nil
}
err := validateRange(field, minStr, maxStr)
if err != nil {
return err
}
}
return nil
}
// processField gets tagName and the field, recursively checks if the field has the given
// tag, if yes, sets it otherwise ignores
func (t *TagLoader) processFieldDefaultValue(field *structs.Field) error {
//first process each subfield of a struct field
switch field.Kind() {
case reflect.Struct:
for _, f := range field.Fields() {
if err := t.processFieldDefaultValue(f); err != nil {
return err
}
}
default:
//Set default value for the field itself, including struct field
// If there's a default value tag for struct field, it should be in Json format
defaultVal := field.Tag(t.DefaultTagName)
if defaultVal == "" {
return nil
}
err := fieldSet(field, defaultVal)
if err != nil {
return err
}
}
return nil
}
func getBsonName(field *structs.Field) string {
tag := field.Tag("bson")
if tag == "" || tag == "-" {
return ""
}
tags := strings.Split(tag, ",")
return tags[0]
}
func (b *Builder) keyFromField(f *structs.Field) string {
tag := f.Tag(b.Tag)
if i := strings.IndexRune(tag, ','); i != -1 {
tag = tag[:i]
}
switch tag {
case "-":
return ""
case "":
return b.fieldFunc(f.Name())
}
return tag
}
// processField generates a flag based on the given field and fieldName. If a
// nested struct is detected, a flag for each field of that nested struct is
// generated too.
func (f *FlagLoader) processField(flagSet *flag.FlagSet, fieldName string, field *structs.Field) error {
if f.CamelCase {
fieldName = strings.Join(camelcase.Split(fieldName), "-")
}
switch field.Kind() {
case reflect.Struct:
for _, ff := range field.Fields() {
flagName := field.Name() + "-" + ff.Name()
if f.Flatten {
// first check if it's set or not, because if we have duplicate
// we don't want to break the flag. Panic by giving a readable
// output
flagSet.VisitAll(func(fl *flag.Flag) {
if strings.ToLower(ff.Name()) == fl.Name {
// already defined
panic(fmt.Sprintf("flag '%s' is already defined in outer struct", fl.Name))
}
})
flagName = ff.Name()
}
if err := f.processField(flagSet, flagName, ff); err != nil {
return err
}
}
default:
// First see tag, if exists, use tag instead of fieldname
flagTag := field.Tag(f.FlagTagName)
if flagTag != "" {
fieldName = flagTag
} else if f.Prefix != "" {
fieldName = f.Prefix + "-" + fieldName
}
// we only can get the value from expored fields, unexported fields panics
if field.IsExported() {
flagSet.Var(newFieldValue(field), flagName(fieldName), flagUsage(fieldName))
}
}
return nil
}
// processField gets tagName and the field, recursively checks if the field has the given
// tag, if yes, sets it otherwise ignores
func (t *TagLoader) processField(tagName string, field *structs.Field) error {
switch field.Kind() {
case reflect.Struct:
for _, f := range field.Fields() {
if err := t.processField(tagName, f); err != nil {
return err
}
}
default:
defaultVal := field.Tag(t.DefaultTagName)
if defaultVal == "" {
return nil
}
err := fieldSet(field, defaultVal)
if err != nil {
return err
}
}
return nil
}
