Skip to content

Add user-defined tag naming #53

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
johnnybubonic wants to merge 3 commits into
base: master
Choose a base branch
from
Open

Add user-defined tag naming #53

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
3bdd36b
Add user-defined tag naming
johnnybubonic Nov 20, 2024
36bbebb
linting upstream fails on backtick quoting, apparently?
johnnybubonic Nov 20, 2024
9cc0c25
adding suggested/requested changes and performing for Set calls in se…
johnnybubonic Dec 5, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
238 changes: 159 additions & 79 deletions README.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,6 +24,7 @@ Initialize structs with default values
- Recursively initializes fields in a struct
- Dynamically sets default values by [`defaults.Setter`](./setter.go) interface
- Preserves non-initial values from being reset with a default value
- User-Definable tag name


Usage
Expand All @@ -43,30 +44,30 @@ import (
type Gender string

type Sample struct {
Name string `default:"John Smith"`
Age int `default:"27"`
Gender Gender `default:"m"`
Name string `default:"John Smith" default_alt:"Jane Doe"`
Copy link
Owner

@creasty creasty Dec 6, 2024 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Would you please revert these changes?
"User-Definable tag name" should not be this library's primary use case.

The same goes for example/main.go — Although it might be useful to have a separate file.

Age int `default:"27" default_alt:"28"`
Gender Gender `default:"m" default_alt:"f"`
Working bool `default:"true"`

SliceInt []int `default:"[1, 2, 3]"`
SlicePtr []*int `default:"[1, 2, 3]"`
SliceString []string `default:"[\"a\", \"b\"]"`
SliceInt []int `default:"[1, 2, 3]" default_alt:"[4, 5, 6]"`
SlicePtr []*int `default:"[1, 2, 3]" default_alt:"[4, 5, 6]"`
SliceString []string `default:"[\"a\", \"b\"]" default_alt:"[\"c\", \"d\"]"`

MapNull map[string]int `default:"{}"`
Map map[string]int `default:"{\"key1\": 123}"`
MapOfStruct map[string]OtherStruct `default:"{\"Key2\": {\"Foo\":123}}"`
MapOfPtrStruct map[string]*OtherStruct `default:"{\"Key3\": {\"Foo\":123}}"`
MapOfStructWithTag map[string]OtherStruct `default:"{\"Key4\": {\"Foo\":123}}"`
MapNull map[string]int `default:"{}"` // Using default_alt would leave as a nil map
Map map[string]int `default:"{\"key1\": 123}" default_alt:"{\"key1\": 456}"`
MapOfStruct map[string]OtherStruct `default:"{\"Key2\": {\"Foo\":123}}" default_alt:"{\"Key2\": {\"Foo\":456}}"`
MapOfPtrStruct map[string]*OtherStruct `default:"{\"Key3\": {\"Foo\":123}}" default_alt:"{\"Key3\": {\"Foo\":456}}"`
MapOfStructWithTag map[string]OtherStruct `default:"{\"Key4\": {\"Foo\":123}}" default_alt:"{\"Key4\": {\"Foo\":456}}"`

Struct OtherStruct `default:"{\"Foo\": 123}"`
StructPtr *OtherStruct `default:"{\"Foo\": 123}"`
Struct OtherStruct `default:"{\"Foo\": 123}" default:"{\"Foo\": 456}"`
StructPtr *OtherStruct `default:"{\"Foo\": 123}" default:"{\"Foo\": 456}"`

NoTag OtherStruct // Recurses into a nested struct by default
NoOption OtherStruct `default:"-"` // no option
}

type OtherStruct struct {
Hello string `default:"world"` // Tags in a nested struct also work
Hello string `default:"world" default_alt:"person"` // Tags in a nested struct also work
Foo int `default:"-"`
Random int `default:"-"`
}
Expand All @@ -91,70 +92,149 @@ func main() {
fmt.Println(string(out))

// Output:
// {
// "Name": "John Smith",
// "Age": 27,
// "Gender": "m",
// "Working": true,
// "SliceInt": [
// 1,
// 2,
// 3
// ],
// "SlicePtr": [
// 1,
// 2,
// 3
// ],
// "SliceString": [
// "a",
// "b"
// ],
// "MapNull": {},
// "Map": {
// "key1": 123
// },
// "MapOfStruct": {
// "Key2": {
// "Hello": "world",
// "Foo": 123,
// "Random": 5577006791947779410
// }
// },
// "MapOfPtrStruct": {
// "Key3": {
// "Hello": "world",
// "Foo": 123,
// "Random": 8674665223082153551
// }
// },
// "MapOfStructWithTag": {
// "Key4": {
// "Hello": "world",
// "Foo": 123,
// "Random": 6129484611666145821
// }
// },
// "Struct": {
// "Hello": "world",
// "Foo": 123,
// "Random": 4037200794235010051
// },
// "StructPtr": {
// "Hello": "world",
// "Foo": 123,
// "Random": 3916589616287113937
// },
// "NoTag": {
// "Hello": "world",
// "Foo": 0,
// "Random": 6334824724549167320
// },
// "NoOption": {
// "Hello": "",
// "Foo": 0,
// "Random": 0
// }
// }
/*
{
"Name": "John Smith",
"Age": 27,
"Gender": "m",
"Working": true,
"SliceInt": [
1,
2,
3
],
"SlicePtr": [
1,
2,
3
],
"SliceString": [
"a",
"b"
],
"MapNull": {},
"Map": {
"key1": 123
},
"MapOfStruct": {
"Key2": {
"Hello": "world",
"Foo": 123,
"Random": 7924310560672650386
}
},
"MapOfPtrStruct": {
"Key3": {
"Hello": "world",
"Foo": 123,
"Random": 5864827752208870454
}
},
"MapOfStructWithTag": {
"Key4": {
"Hello": "world",
"Foo": 123,
"Random": 9020930397672710767
}
},
"Struct": {
"Hello": "world",
"Foo": 123,
"Random": 2100809313953071154
},
"StructPtr": {
"Hello": "world",
"Foo": 123,
"Random": 4589638854976076769
},
"NoTag": {
"Hello": "world",
"Foo": 0,
"Random": 93481895446446669
},
"NoOption": {
"Hello": "",
"Foo": 0,
"Random": 0
}
}
*/

// Or with a specific tag name:
otherObj := &Sample{}
if err = defaults.SetWithTag(otherObj, "default_alt"); err != nil {
panic(err)
}

out, err = json.MarshalIndent(otherObj, "", " ")
if err != nil {
panic(err)
}
fmt.Println(string(out))

// Output:
/*
{
"Name": "Jane Doe",
"Age": 28,
"Gender": "f",
"Working": false,
"SliceInt": [
4,
5,
6
],
"SlicePtr": [
4,
5,
6
],
"SliceString": [
"c",
"d"
],
"MapNull": null,
"Map": {
"key1": 456
},
"MapOfStruct": {
"Key2": {
"Hello": "person",
"Foo": 456,
"Random": 3527321973631593020
}
},
"MapOfPtrStruct": {
"Key3": {
"Hello": "person",
"Foo": 456,
"Random": 6391170103701304261
}
},
"MapOfStructWithTag": {
"Key4": {
"Hello": "person",
"Foo": 456,
"Random": 5779747168002044569
}
},
"Struct": {
"Hello": "person",
"Foo": 0,
"Random": 4391597250420769051
},
"StructPtr": null,
"NoTag": {
"Hello": "person",
"Foo": 0,
"Random": 5000048969203402981
},
"NoOption": {
"Hello": "person",
"Foo": 0,
"Random": 4800395242796521920
}
}
*/
}
```
47 changes: 34 additions & 13 deletions defaults.go
View file
Open in desktop
Copy link
Owner

@creasty creasty Dec 6, 2024

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

We'd also like to add minimum specs for testing user-specified tag names.
Do note that we don't want to extend the existing struct; create a new struct to test with.

Original file line number Diff line number Diff line change
Expand Up @@ -6,25 +6,38 @@ import (
"errors"
"reflect"
"strconv"
"strings"
"time"
)

var (
errInvalidTag = errors.New("invalid tag name")
errInvalidType = errors.New("not a struct pointer")
)

const (
fieldName = "default"
)

// Set initializes members in a struct referenced by a pointer.
// Maps and slices are initialized by `make` and other primitive types are set with default values.
// `ptr` should be a struct pointer
func Set(ptr interface{}) error {
func Set(ptr interface{}) (err error) {

err = SetWithTag(ptr, "default")

return
}

// SetWithTag initializes members in a struct referenced by a pointer using an explicit tag name.
// Maps and slices are initialized by `make` and other primitive types are set with default values.
// `ptr` should be a struct pointer
func SetWithTag(ptr interface{}, runtimeTag string) error {
Copy link
Owner

@creasty creasty Dec 6, 2024

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

nit: runtimeTag sounds a bit off to me. Reflection at its essence is about runtime.
tagName should suffice.


if reflect.TypeOf(ptr).Kind() != reflect.Ptr {
return errInvalidType
}

if strings.TrimSpace(runtimeTag) == "" {
return errInvalidTag
}

v := reflect.ValueOf(ptr).Elem()
t := v.Type()

Expand All @@ -33,8 +46,8 @@ func Set(ptr interface{}) error {
}

for i := 0; i < t.NumField(); i++ {
if defaultVal := t.Field(i).Tag.Get(fieldName); defaultVal != "-" {
if err := setField(v.Field(i), defaultVal); err != nil {
if defaultVal := t.Field(i).Tag.Get(runtimeTag); defaultVal != "-" {
if err := setField(v.Field(i), defaultVal, runtimeTag); err != nil {
return err
}
}
Expand All @@ -51,7 +64,15 @@ func MustSet(ptr interface{}) {
}
}

func setField(field reflect.Value, defaultVal string) error {
// MustSetWithTag function is a wrapper of SetWithTag function
// It will call Set and panic if err not equals nil.
func MustSetWithTag(ptr interface{}, runtimeTag string) {
if err := SetWithTag(ptr, runtimeTag); err != nil {
panic(err)
}
}

func setField(field reflect.Value, defaultVal string, tagName string) error {
if !field.CanSet() {
return nil
}
Expand Down Expand Up @@ -160,16 +181,16 @@ func setField(field reflect.Value, defaultVal string) error {
switch field.Kind() {
case reflect.Ptr:
if isInitial || field.Elem().Kind() == reflect.Struct {
setField(field.Elem(), defaultVal)
setField(field.Elem(), defaultVal, tagName)
callSetter(field.Interface())
}
case reflect.Struct:
if err := Set(field.Addr().Interface()); err != nil {
if err := SetWithTag(field.Addr().Interface(), tagName); err != nil {
return err
}
case reflect.Slice:
for j := 0; j < field.Len(); j++ {
if err := setField(field.Index(j), ""); err != nil {
if err := setField(field.Index(j), "", tagName); err != nil {
return err
}
}
Expand All @@ -181,14 +202,14 @@ func setField(field reflect.Value, defaultVal string) error {
case reflect.Ptr:
switch v.Elem().Kind() {
case reflect.Struct, reflect.Slice, reflect.Map:
if err := setField(v.Elem(), ""); err != nil {
if err := setField(v.Elem(), "", tagName); err != nil {
return err
}
}
case reflect.Struct, reflect.Slice, reflect.Map:
ref := reflect.New(v.Type())
ref.Elem().Set(v)
if err := setField(ref.Elem(), ""); err != nil {
if err := setField(ref.Elem(), "", tagName); err != nil {
return err
}
field.SetMapIndex(e, ref.Elem().Convert(v.Type()))
Expand Down
Loading