Implement the uuid builtin and mock for tests

Author: FollowTheProcess

go.mod

@@ -5,6 +5,7 @@ go 1.25.5
 require (
 	github.com/BurntSushi/toml v1.5.0
 	github.com/charmbracelet/huh v0.8.0
+	github.com/google/uuid v1.6.0
 	github.com/rogpeppe/go-internal v1.14.1
 	go.followtheprocess.codes/cli v0.18.2
 	go.followtheprocess.codes/hue v1.0.0

go.sum

@@ -52,6 +52,8 @@ github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkp
 github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f h1:Y/CXytFA4m6baUTXGLOoWe4PQhGxaX0KpnayAqC48p4=
 github.com/erikgeiser/coninput v0.0.0-20211004153227-1c3628e74d0f/go.mod h1:vw97MGsxSvLiUE2X8qFplwetxpGLQrlU1Q9AUEIzCaM=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
 github.com/lucasb-eyer/go-colorful v1.3.0 h1:2/yBRLdWBZKrf7gB40FoiKfAWYQ0lqNcbuQwVHXptag=
 github.com/lucasb-eyer/go-colorful v1.3.0/go.mod h1:R4dSotOR9KMtayYi1e77YzuveK+i7ruzyGqttikkLy0=
 github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWEY=

internal/syntax/ast/expression.go

@@ -48,7 +48,7 @@ func (i Ident) expressionNode() {}
 // The Builtin AST node is functionality identical to an [Ident], but must
 // be separate to allow differentiating builtins from regular idents.
 type Builtin struct {
-	// Name is the ident's name.
+	// Name is the name of the builtin ident.
 	Name string `yaml:"name"`
 
 	// Dollar is the [token.Dollar] token marking

internal/syntax/resolver/builtins/builtins.go

@@ -0,0 +1,56 @@
+// Package builtins provides the implementation of various builtin identifiers and functions
+// to the resolver.
+package builtins
+
+import (
+	"fmt"
+
+	"github.com/google/uuid"
+)
+
+// Builtin is an implementation of a zap builtin.
+type Builtin func() (string, error)
+
+// Library is a library of builtins.
+type Library interface {
+	// Get looks up a builtin from the library by name, returning it (or nil)
+	// and a boolean indicating its existence.
+	Get(name string) (Builtin, bool)
+}
+
+// Builtins is a [Library] containing the builtin implementations.
+type Builtins struct {
+	library map[string]Builtin
+}
+
+// NewLibrary returns the zap builtins library.
+func NewLibrary() Builtins {
+	library := map[string]Builtin{
+		"uuid": builtinUUID,
+	}
+
+	return Builtins{
+		library: library,
+	}
+}
+
+// Get looks up a builtin by name, returning the builtin and a boolean
+// indicating its existence.
+func (b Builtins) Get(name string) (Builtin, bool) {
+	fn, ok := b.library[name]
+	if !ok {
+		return nil, false
+	}
+
+	return fn, true
+}
+
+// builtinUUID is the implementation of the '$uuid' builtin.
+func builtinUUID() (string, error) {
+	uid, err := uuid.NewRandom()
+	if err != nil {
+		return "", fmt.Errorf("failed to generate a new uuid: %w", err)
+	}
+
+	return uid.String(), nil
+}

internal/syntax/resolver/resolver.go

@@ -16,6 +16,7 @@ import (
 	"go.followtheprocess.codes/zap/internal/spec"
 	"go.followtheprocess.codes/zap/internal/syntax"
 	"go.followtheprocess.codes/zap/internal/syntax/ast"
+	"go.followtheprocess.codes/zap/internal/syntax/resolver/builtins"
 	"go.followtheprocess.codes/zap/internal/syntax/token"
 )
 
@@ -43,17 +44,19 @@ var ErrResolve = errors.New("resolve error")
 // parsing URLs and durations, and otherwise validating and checking the parse tree
 // along the way.
 type Resolver struct {
+	library     builtins.Library    // Library of builtins to draw from.
 	name        string              // The name of the file being resolved.
 	src         []byte              // Raw source
 	diagnostics []syntax.Diagnostic // Diagnostics collected during resolving.
 	hadErrors   bool                // Whether we encountered resolver errors.
 }
 
 // New returns a new [Resolver].
-func New(name string, src []byte) *Resolver {
+func New(name string, src []byte, library builtins.Library) *Resolver {
 	return &Resolver{
-		name: name,
-		src:  src,
+		name:    name,
+		src:     src,
+		library: library,
 	}
 }
 
@@ -432,6 +435,8 @@ func (r *Resolver) resolveExpression(env *environment, expression ast.Expression
 		return expr.Value, nil
 	case ast.Ident:
 		return r.resolveIdent(env, expr)
+	case ast.Builtin:
+		return r.resolveBuiltin(expr)
 	case ast.InterpolatedExpression:
 		return r.resolveInterpolatedExpression(env, expr)
 	case ast.Interp:
@@ -651,3 +656,16 @@ func (r *Resolver) resolveIdent(env *environment, ident ast.Ident) (string, erro
 
 	return env.get(ident.Name)
 }
+
+// resolveBuiltin resolves an [ast.Builtin] into the concrete value it
+// refers to.
+//
+// Note: no environment here as builtins are well... built in.
+func (r *Resolver) resolveBuiltin(b ast.Builtin) (string, error) {
+	fn, ok := r.library.Get(b.Name)
+	if !ok {
+		return "", fmt.Errorf("no such builtin: %q", b.Name)
+	}
+
+	return fn()
+}

internal/syntax/resolver/resolver_test.go

@@ -15,6 +15,7 @@ import (
 	"go.followtheprocess.codes/zap/internal/spec"
 	"go.followtheprocess.codes/zap/internal/syntax/parser"
 	"go.followtheprocess.codes/zap/internal/syntax/resolver"
+	"go.followtheprocess.codes/zap/internal/syntax/syntaxtest"
 	"go.uber.org/goleak"
 	"go.yaml.in/yaml/v4"
 )
@@ -49,7 +50,7 @@ func TestValid(t *testing.T) {
 			t.Logf("Diagnostics: %+v\n", p.Diagnostics())
 			test.Ok(t, err, test.Context("unexpected parser error"))
 
-			res := resolver.New(name, []byte(src))
+			res := resolver.New(name, []byte(src), syntaxtest.NewTestLibrary())
 
 			resolved, err := res.Resolve(parsed)
 			if err != nil {
@@ -111,7 +112,7 @@ func TestInvalid(t *testing.T) {
 			parsed, err := p.Parse()
 			test.Ok(t, err, test.Context("unexpected parser error"))
 
-			res := resolver.New(name, []byte(src))
+			res := resolver.New(name, []byte(src), syntaxtest.NewTestLibrary())
 
 			_, err = res.Resolve(parsed)
 			test.Err(t, err, test.Context("resolved did not return an error but should have"))
@@ -153,7 +154,7 @@ func BenchmarkResolver(b *testing.B) {
 	test.Ok(b, err)
 
 	for b.Loop() {
-		res := resolver.New(file, []byte(src))
+		res := resolver.New(file, []byte(src), syntaxtest.NewTestLibrary())
 		_, err = res.Resolve(parsed)
 		test.Ok(b, err)
 	}
@@ -196,7 +197,7 @@ func FuzzResolver(f *testing.F) {
 
 		parsed, _ := parser.Parse() //nolint:errcheck // Just checking for panics and infinite loops
 
-		res := resolver.New(parsed.Name, []byte(src))
+		res := resolver.New(parsed.Name, []byte(src), syntaxtest.NewTestLibrary())
 
 		resolved, err := res.Resolve(parsed)
 		// Property: If there is an error, the file should be the zero spec.File{}

internal/syntax/resolver/testdata/valid/interpolation-builtin-body.txtar

@@ -0,0 +1,21 @@
+-- src.http --
+###
+POST https://example.com/123
+Content-Type: application/json
+
+{
+  "id": "{{ $uuid }}"
+}
+-- want.yaml --
+name: interpolation-builtin-body.txtar
+requests:
+  - headers:
+      Content-Type:
+        - application/json
+    name: '#1'
+    method: POST
+    url: https://example.com/123
+    body: |-
+      {
+        "id": "d0a43b68-b9a1-4e89-bd21-b06fc59fefb5"
+      }

internal/syntax/resolver/testdata/valid/interpolation-builtin-global.txtar

@@ -0,0 +1,14 @@
+-- src.http --
+@id = {{ $uuid }}
+
+### Test
+GET https://example.com/{{ id }}
+-- want.yaml --
+name: interpolation-builtin-global.txtar
+vars:
+  id: d0a43b68-b9a1-4e89-bd21-b06fc59fefb5
+requests:
+  - name: '#1'
+    comment: Test
+    method: GET
+    url: https://example.com/d0a43b68-b9a1-4e89-bd21-b06fc59fefb5

internal/syntax/resolver/testdata/valid/interpolation-builtin-inline.txtar

@@ -0,0 +1,10 @@
+-- src.http --
+### Test
+GET https://example.com/{{ $uuid }}
+-- want.yaml --
+name: interpolation-builtin-inline.txtar
+requests:
+  - name: '#1'
+    comment: Test
+    method: GET
+    url: https://example.com/d0a43b68-b9a1-4e89-bd21-b06fc59fefb5

internal/syntax/syntax_test.go

@@ -10,6 +10,7 @@ import (
 	"go.followtheprocess.codes/zap/internal/syntax"
 	"go.followtheprocess.codes/zap/internal/syntax/parser"
 	"go.followtheprocess.codes/zap/internal/syntax/resolver"
+	"go.followtheprocess.codes/zap/internal/syntax/syntaxtest"
 )
 
 func TestPositionString(t *testing.T) {
@@ -306,7 +307,7 @@ func BenchmarkEntireParse(b *testing.B) {
 		parsed, err := p.Parse()
 		test.Ok(b, err)
 
-		res := resolver.New(file, src)
+		res := resolver.New(file, src, syntaxtest.NewTestLibrary())
 		_, err = res.Resolve(parsed)
 		test.Ok(b, err)
 	}