feat(arg): support recursive from (#284)

Adds support for recursive from resolving, with no inf recursion
prevention. Callers should assume that inf recursion will NOT be
supported in the future (not to mention it wouldn't work anyways...)

A future PR will add from strack tracing to limit the depth and prevent
inf recurison.

Closes #283.

Author: jaredallard

internal/codegen/tpl_stencil_arg.go

@@ -19,7 +19,6 @@
 package codegen
 
 import (
-	"context"
 	"fmt"
 
 	"go.rgst.io/stencil/v2/internal/dotnotation"
@@ -34,10 +33,6 @@ func (s *TplStencil) Arg(pth string) (interface{}, error) {
 		return nil, fmt.Errorf("path cannot be empty")
 	}
 
-	// This is a TODO because I don't know if template functions
-	// can even get a context passed to them
-	ctx := context.TODO()
-
 	mf := s.t.Module.Manifest
 	if _, ok := mf.Arguments[pth]; !ok {
 		return "", fmt.Errorf("module %q doesn't list argument %q as an argument in its manifest", s.t.Module.Name, pth)
@@ -47,7 +42,7 @@ func (s *TplStencil) Arg(pth string) (interface{}, error) {
 	// If there's a "from" we should handle that now before anything else,
 	// so that its definition is used.
 	if arg.From != "" {
-		fromArg, err := s.resolveFrom(ctx, pth, &arg)
+		fromArg, err := s.resolveFrom(pth, &arg)
 		if err != nil {
 			return "", err
 		}
@@ -120,8 +115,8 @@ func (s *TplStencil) resolveDefault(pth string, arg *configuration.Argument) (in
 }
 
 // resolveFrom resoles the "from" field of an argument
-func (s *TplStencil) resolveFrom(_ context.Context, pth string, arg *configuration.Argument) (*configuration.Argument, error) {
-	foundModuleInDeps := false
+func (s *TplStencil) resolveFrom(pth string, arg *configuration.Argument) (*configuration.Argument, error) {
+	var foundModuleInDeps bool
 	// Ensure that the module imports the referenced module
 	for _, m := range s.t.Module.Manifest.Modules {
 		if m.Name == arg.From {
@@ -160,6 +155,17 @@ func (s *TplStencil) resolveFrom(_ context.Context, pth string, arg *configurati
 			s.t.Module.Name, pth, arg.From,
 		)
 	}
+
+	// If we are, ourselves, a from then we need to resolve it again.
+	if fromArg.From != "" {
+		// Reusing 'pth' is safe because from key's must be equal.
+		recurFromArg, err := s.resolveFrom(pth, &fromArg)
+		if err != nil {
+			return nil, fmt.Errorf("recursive from resolve failed for module %s -> %s: %w", arg.From, fromArg.From, err)
+		}
+		return recurFromArg, nil
+	}
+
 	return &fromArg, nil
 }
 

internal/codegen/tpl_stencil_arg_test.go

@@ -82,9 +82,16 @@ func fakeTemplateMultipleModules(t *testing.T, manifestArgs map[string]interface
 			continue
 		}
 
+		// Depend on all modules that come after us to allow for from calls.
+		var deps []*configuration.TemplateRepository
+		for j := i; j < len(args); j++ {
+			deps = append(deps, &configuration.TemplateRepository{Name: fmt.Sprintf("test-%d", j)})
+		}
+
 		man := &configuration.TemplateRepositoryManifest{
 			Name:      fmt.Sprintf("test-%d", i),
 			Arguments: args[i],
+			Modules:   deps,
 		}
 		m, err := modulestest.NewModuleFromTemplates(man, "testdata/args/test.tpl")
 		if err != nil {
@@ -124,7 +131,7 @@ func fakeTemplateMultipleModules(t *testing.T, manifestArgs map[string]interface
 	// which we've created earlier after loading the module in the
 	// NewModuleFromTemplates call. This won't be used, but it's
 	// enough to set up the correct environment for running template test functions.
-	tpls, err := test.s.getTemplates(context.Background(), log)
+	tpls, err := test.s.getTemplates(t.Context(), log)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -304,6 +311,72 @@ func TestTplStencil_Arg(t *testing.T) {
 			want:    nil,
 			wantErr: true,
 		},
+		{
+			name: "should support recursive from",
+			fields: fakeTemplateMultipleModules(t,
+				map[string]interface{}{
+					"hello": "world",
+				},
+				// test-0
+				map[string]configuration.Argument{
+					"hello": {
+						From: "test-1",
+					},
+				},
+				// test-1
+				map[string]configuration.Argument{
+					"hello": {
+						From: "test-2",
+					},
+				},
+				// test-2
+				map[string]configuration.Argument{
+					"hello": {
+						Schema: map[string]interface{}{
+							"type": "string",
+						},
+					},
+				},
+			),
+			args: args{
+				pth: "hello",
+			},
+			want:    "world",
+			wantErr: false,
+		},
+		{
+			name: "should support recursive from schema fail",
+			fields: fakeTemplateMultipleModules(t,
+				map[string]interface{}{
+					"hello": "world",
+				},
+				// test-0
+				map[string]configuration.Argument{
+					"hello": {
+						From: "test-1",
+					},
+				},
+				// test-1
+				map[string]configuration.Argument{
+					"hello": {
+						From: "test-2",
+					},
+				},
+				// test-2
+				map[string]configuration.Argument{
+					"hello": {
+						Schema: map[string]interface{}{
+							"type": "number",
+						},
+					},
+				},
+			),
+			args: args{
+				pth: "hello",
+			},
+			want:    nil,
+			wantErr: true,
+		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {