feat: reuse the fields created by struct initialization

Don't always create new fields for each call of resolve, instead pass
the pointer of the fields to the subsequent calls.

Author: ggicci

helper_test.go

@@ -17,8 +17,9 @@ func exeEnvReader(rtm *owl.DirectiveRuntime) error {
 	if len(rtm.Directive.Argv) == 0 {
 		return nil
 	}
-	value := os.Getenv(rtm.Directive.Argv[0])
-	rtm.Value.Elem().SetString(value)
+	if value, ok := os.LookupEnv(rtm.Directive.Argv[0]); ok {
+		rtm.Value.Elem().SetString(value)
+	}
 	return nil
 }
 

owl_test.go

@@ -31,7 +31,6 @@ func TestOwlUseCaseEnvReader(t *testing.T) {
 	// Resolve.
 	gotValue, err := resolver.Resolve()
 	assert.NoError(err)
-	assert.NotNil(gotValue)
 	gotConfig, ok := gotValue.Interface().(*EnvConfig)
 	assert.True(ok)
 	assert.Equal("/home/ggicci/.owl", gotConfig.Workspace)
@@ -84,7 +83,6 @@ func TestOwlUseCaseConfigLoader(t *testing.T) {
 	// Resolve.
 	gotValue, err := resolver.Resolve(owl.WithValue("ConfigFile", filename))
 	assert.NoError(err)
-	assert.NotNil(gotValue)
 
 	gotConfig, ok := gotValue.Interface().(*MyAppConfig)
 	assert.True(ok)
@@ -103,7 +101,6 @@ func TestOwlUseCaseConfigLoader(t *testing.T) {
 	// Resolve again.
 	gotValue, err = resolver.Resolve(owl.WithValue("ConfigFile", filename))
 	assert.NoError(err)
-	assert.NotNil(gotValue)
 
 	gotConfig, ok = gotValue.Interface().(*MyAppConfig)
 	assert.True(ok)

resolver.go

@@ -124,7 +124,11 @@ func (r *Resolver) Namespace() *Namespace {
 
 // Find finds a field resolver by path. e.g. "Pagination.Page", "User.Name", etc.
 func (r *Resolver) Lookup(path string) *Resolver {
-	return findResolver(r, strings.Split(path, "."))
+	var paths []string
+	if path != "" {
+		paths = strings.Split(path, ".")
+	}
+	return findResolver(r, paths)
 }
 
 func findResolver(root *Resolver, path []string) *Resolver {
@@ -173,15 +177,14 @@ func (r *Resolver) Resolve(opts ...Option) (reflect.Value, error) {
 	for _, opt := range opts {
 		ctx = opt.Apply(ctx)
 	}
-	return r.resolve(ctx)
+	rootValue := reflect.New(r.Type)
+	return rootValue, r.resolve(ctx, rootValue)
 }
 
-func (root *Resolver) resolve(ctx context.Context) (reflect.Value, error) {
-	rootValue := reflect.New(root.Type)
-
+func (root *Resolver) resolve(ctx context.Context, rootValue reflect.Value) error {
 	// Run the directives on current field.
 	if err := root.runDirectives(ctx, rootValue); err != nil {
-		return rootValue, err
+		return err
 	}
 
 	// Resolve the children fields.
@@ -195,18 +198,15 @@ func (root *Resolver) resolve(ctx context.Context) (reflect.Value, error) {
 		}
 
 		for _, child := range root.Children {
-			fieldValue, err := child.resolve(ctx)
-			if err != nil {
-				return rootValue, &ResolveError{
+			if err := child.resolve(ctx, underlyingValue.Elem().Field(child.Index).Addr()); err != nil {
+				return &ResolveError{
 					Err:      err,
 					Resolver: child,
 				}
 			}
-			underlyingValue.Elem().Field(child.Index).Set(fieldValue.Elem())
 		}
 	}
-
-	return rootValue, nil
+	return nil
 }
 
 func (r *Resolver) runDirectives(ctx context.Context, rv reflect.Value) error {
@@ -316,7 +316,11 @@ func buildResolver(typ reflect.Type, field reflect.StructField, parent *Resolver
 				return nil, fmt.Errorf("build resolver for %q failed: %w", strings.Join(path, "."), err)
 			}
 			child.Index = i
-			root.Children = append(root.Children, child)
+
+			// Skip the field if it has no children and no directives.
+			if len(child.Children) > 0 || len(child.Directives) > 0 {
+				root.Children = append(root.Children, child)
+			}
 		}
 	}
 	return root, nil

resolver_test.go

@@ -5,6 +5,7 @@ import (
 	"errors"
 	"fmt"
 	"os"
+	"reflect"
 	"testing"
 
 	"github.com/ggicci/owl"
@@ -61,13 +62,14 @@ func (s *BuildResolverTreeTestSuite) Test_0_Lookup_IsLeaf() {
 	assert := assert.New(s.T())
 	for _, expected := range s.expected {
 		resolver := s.tree.Lookup(expected.LookupPath)
-		assert.Nil(s.tree.Lookup("SomeNonExistingPath"))
 		assert.NotNil(resolver)
 		assert.Equal(expected.Index, resolver.Index)
 		assert.Equal(expected.NumFields, len(resolver.Children))
 		assert.Equal(expected.Directives, resolver.Directives)
 		assert.Equal(expected.Leaf, resolver.IsLeaf())
 	}
+
+	assert.Nil(s.tree.Lookup("SomeNonExistingPath"))
 }
 
 func (s *BuildResolverTreeTestSuite) Test_1_GetDirective() {
@@ -159,6 +161,70 @@ func TestNew_NormalCasesSuites(t *testing.T) {
 	))
 }
 
+func TestNew_SkipFieldsHavingNoDirectives(t *testing.T) {
+	type AnotherForm struct {
+		Username   string      `owl:"form=username"`
+		Password   string      `owl:"form=password"`
+		Hidden     string      // should be ignored
+		Pagination *Pagination // should not be ignored
+	}
+
+	suite.Run(t, NewBuildResolverTreeTestSuite(
+		AnotherForm{},
+		[]*expectedResolver{
+			{
+				Index:      -1,
+				LookupPath: "",
+				NumFields:  3,
+				Directives: nil,
+				Leaf:       false,
+			},
+			{
+				Index:      0,
+				LookupPath: "Username",
+				Directives: []*owl.Directive{
+					owl.NewDirective("form", "username"),
+				},
+				Leaf: true,
+			},
+			{
+				Index:      1,
+				LookupPath: "Password",
+				NumFields:  0,
+				Directives: []*owl.Directive{
+					owl.NewDirective("form", "password"),
+				},
+				Leaf: true,
+			},
+			{
+				Index:      3, // Pagination is the 4th field, Hidden is the 3rd field.
+				LookupPath: "Pagination",
+				NumFields:  2,
+				Directives: nil,
+				Leaf:       false,
+			},
+			{
+				Index:      0,
+				LookupPath: "Pagination.Page",
+				NumFields:  0,
+				Directives: []*owl.Directive{
+					owl.NewDirective("form", "page"),
+				},
+				Leaf: true,
+			},
+			{
+				Index:      1,
+				LookupPath: "Pagination.Size",
+				NumFields:  0,
+				Directives: []*owl.Directive{
+					owl.NewDirective("form", "size"),
+				},
+				Leaf: true,
+			},
+		},
+	))
+}
+
 func TestNew_WithNilType(t *testing.T) {
 	_, err := owl.New(nil)
 	assert.ErrorIs(t, err, owl.ErrUnsupportedType)
@@ -368,7 +434,6 @@ func TestResolve_UnexportedField(t *testing.T) {
 	// Resolve.
 	gotValue, err := resolver.Resolve()
 	assert.NoError(t, err)
-	assert.NotNil(t, gotValue)
 	gotUser, ok := gotValue.Interface().(*User)
 	assert.True(t, ok)
 	assert.Equal(t, "owl", gotUser.Name)
@@ -465,6 +530,44 @@ func TestResolve_DirectiveRuntimeContext(t *testing.T) {
 	assert.ErrorContains(t, err, "field is required")
 }
 
+func TestResolve_NestedExecution(t *testing.T) {
+	type User struct {
+		Name string `owl:"env=OWL_TEST_NAME"`
+		Role string `owl:"env=OWL_TEST_ROLE"`
+	}
+
+	type Request struct {
+		// NOTE: Login will be created and updated by login directive,
+		// and its fields will also be updated by env directive.
+		Login  User   `owl:"login"`
+		Action string `owl:"env=OWL_TEST_ACTION"`
+	}
+
+	expected := &Request{
+		Login: User{
+			Name: "owl",   // set by env
+			Role: "admin", // set by login
+		},
+		Action: "addAccount",
+	}
+
+	ns := owl.NewNamespace()
+	ns.RegisterDirectiveExecutor("env", owl.DirectiveExecutorFunc(exeEnvReader))
+	ns.RegisterDirectiveExecutor("login", owl.DirectiveExecutorFunc(func(dr *owl.DirectiveRuntime) error {
+		u := User{Name: "hello", Role: "admin"}
+		dr.Value.Elem().Set(reflect.ValueOf(u))
+		return nil
+	}))
+	os.Setenv("OWL_TEST_NAME", "owl")
+	os.Setenv("OWL_TEST_ACTION", "addAccount")
+
+	resolver, err := owl.New(Request{}, owl.WithNamespace(ns))
+	assert.NoError(t, err)
+	gotValue, err := resolver.Resolve()
+	assert.NoError(t, err)
+	assert.Equal(t, expected, gotValue.Interface().(*Request))
+}
+
 func TestIterate(t *testing.T) {
 	resolver, err := owl.New(UserSignUpForm{})
 	assert.NoError(t, err)