Parse a body file expression (#88)

Author: FollowTheProcess

internal/syntax/ast/ast_test.go

@@ -70,6 +70,23 @@ func TestNode(t *testing.T) {
 			end:   token.Token{Kind: token.Text, Start: 12, End: 8},
 			kind:  ast.KindVarStatement,
 		},
+		{
+			name: "var statement no value",
+			// @variable
+			node: ast.VarStatement{
+				Value: nil,
+				Ident: ast.Ident{
+					Name:  "variable",
+					Token: token.Token{Kind: token.Ident, Start: 1, End: 9},
+					Type:  ast.KindIdent,
+				},
+				At:   token.Token{Kind: token.At, Start: 0, End: 1},
+				Type: ast.KindVarStatement,
+			},
+			start: token.Token{Kind: token.At, Start: 0, End: 1},
+			end:   token.Token{Kind: token.Ident, Start: 1, End: 9},
+			kind:  ast.KindVarStatement,
+		},
 		{
 			name: "interp only",
 			// {{ hello }}
@@ -209,6 +226,10 @@ func TestNode(t *testing.T) {
 		{
 			name: "request",
 			node: ast.Request{
+				Body: ast.Body{
+					Token: token.Token{Kind: token.Body, Start: 30, End: 110},
+					Type:  ast.KindBody,
+				},
 				URL: ast.TextLiteral{
 					Value: "https://example.com",
 					Token: token.Token{Kind: token.URL, Start: 9, End: 28},
@@ -222,9 +243,25 @@ func TestNode(t *testing.T) {
 				Type: ast.KindRequest,
 			},
 			start: token.Token{Kind: token.Separator, Start: 0, End: 3},
-			end:   token.Token{Kind: token.URL, Start: 9, End: 28},
+			end:   token.Token{Kind: token.Body, Start: 30, End: 110},
 			kind:  ast.KindRequest,
 		},
+		{
+			name: "inner interp",
+			node: ast.Interp{
+				Expr: ast.Ident{
+					Name:  "id",
+					Token: token.Token{Kind: token.Ident, Start: 3, End: 5},
+					Type:  ast.KindIdent,
+				},
+				Open:  token.Token{Kind: token.OpenInterp, Start: 0, End: 2},
+				Close: token.Token{Kind: token.CloseInterp, Start: 6, End: 8},
+				Type:  ast.KindInterp,
+			},
+			start: token.Token{Kind: token.OpenInterp, Start: 0, End: 2},
+			end:   token.Token{Kind: token.CloseInterp, Start: 6, End: 8},
+			kind:  ast.KindInterp,
+		},
 		{
 			// https://example/com/{{ version }}/items/123
 			// |------ left ------|-- interp --|- right -|
@@ -343,6 +380,32 @@ func TestNode(t *testing.T) {
 			end:   token.Token{Kind: token.Body, Start: 12, End: 136},
 			kind:  ast.KindBody,
 		},
+		{
+			name: "body file",
+			node: ast.BodyFile{
+				Token: token.Token{Kind: token.LeftAngle, Start: 31, End: 32},
+				Value: ast.TextLiteral{
+					Value: "./body.json",
+					Token: token.Token{Kind: token.Text, Start: 33, End: 44},
+					Type:  ast.KindTextLiteral,
+				},
+				Type: ast.KindBodyFile,
+			},
+			start: token.Token{Kind: token.LeftAngle, Start: 31, End: 32},
+			end:   token.Token{Kind: token.Text, Start: 33, End: 44},
+			kind:  ast.KindBodyFile,
+		},
+		{
+			name: "body file no value",
+			node: ast.BodyFile{
+				Token: token.Token{Kind: token.LeftAngle, Start: 31, End: 32},
+				Value: nil,
+				Type:  ast.KindBodyFile,
+			},
+			start: token.Token{Kind: token.LeftAngle, Start: 31, End: 32},
+			end:   token.Token{Kind: token.LeftAngle, Start: 31, End: 32},
+			kind:  ast.KindBodyFile,
+		},
 		{
 			name:  "empty file",
 			node:  ast.File{Type: ast.KindFile},

internal/syntax/ast/expression.go

@@ -223,3 +223,39 @@ func (b Body) Kind() Kind {
 
 // expressionNode marks a [Body] as an [Expression].
 func (b Body) expressionNode() {}
+
+// BodyFile is a http body from a filepath.
+type BodyFile struct {
+	// Value is the expression of the filepath.
+	Value Expression
+
+	// Token is the [token.LeftAngle] token.
+	Token token.Token
+
+	// Type is [KindBodyFile].
+	Type Kind
+}
+
+// Start returns the first token associated with the BodyFile, which
+// is the [token.LeftAngle].
+func (b BodyFile) Start() token.Token {
+	return b.Token
+}
+
+// End returns the last token associated with the BodyFile, which is
+// the final token in the filepath expression.
+func (b BodyFile) End() token.Token {
+	if b.Value != nil {
+		return b.Value.End()
+	}
+
+	return b.Token
+}
+
+// Kind returns [KindBodyFile].
+func (b BodyFile) Kind() Kind {
+	return b.Type
+}
+
+// expressionNode marks a [BodyFile] as an [Expression].
+func (b BodyFile) expressionNode() {}

internal/syntax/ast/kind.go

@@ -21,6 +21,7 @@ const (
 	KindHeader                             // Header
 	KindInterpolatedExpression             // InterpolatedExpression
 	KindBody                               // Body
+	KindBodyFile                           // BodyFile
 )
 
 // MarshalText implements [encoding.TextMarshaler] for [Kind].

internal/syntax/ast/kind_string.go

@@ -189,9 +189,9 @@ func (r Request) Start() token.Token {
 
 // End returns the last token associated with the [Request].
 func (r Request) End() token.Token {
-	// TODO(@FollowTheProcess): There's more that can come after this like body, response ref etc.
-	if r.URL != nil {
-		return r.URL.End()
+	// TODO(@FollowTheProcess): The response file redirect or response ref should be last
+	if r.Body != nil {
+		return r.Body.End()
 	}
 
 	return r.Method.End()

internal/syntax/ast/statement.go

@@ -464,7 +464,9 @@ func (p *Parser) parseRequest() (ast.Request, error) {
 		result.Headers = append(result.Headers, header)
 	}
 
-	if p.next.Is(token.Body) {
+	// Body or < <body file>
+	switch p.next.Kind {
+	case token.Body:
 		p.advance()
 
 		body, err := p.parseExpression(token.LowestPrecedence)
@@ -473,6 +475,17 @@ func (p *Parser) parseRequest() (ast.Request, error) {
 		}
 
 		result.Body = body
+	case token.LeftAngle:
+		p.advance()
+
+		bodyFile, err := p.parseBodyFile()
+		if err != nil {
+			return result, err
+		}
+
+		result.Body = bodyFile
+	default:
+		// Nothing, not all requests have a body
 	}
 
 	return result, nil
@@ -542,21 +555,13 @@ func (p *Parser) parseExpression(precedence int) (ast.Expression, error) {
 	//
 	// In our case the Interp is the operator and carries the highest precedence.
 
-	for p.next.Is(token.Text, token.OpenInterp, token.Ident, token.URL, token.Body) && precedence < p.next.Precedence() {
+	for p.next.Is(token.OpenInterp) && precedence < p.next.Precedence() {
 		p.advance()
 
 		switch p.current.Kind {
 		case token.OpenInterp:
 			// It's an interpolated expression where we already know the left hand side
 			expr, err = p.parseInterpolatedExpression(expr)
-		case token.Text:
-			expr, err = p.parseTextLiteral()
-		case token.Ident:
-			expr, err = p.parseIdent()
-		case token.URL:
-			expr, err = p.parseURL()
-		case token.Body:
-			expr, err = p.parseBody()
 		default:
 			p.errorf("parseExpression: unexpected token: %s", p.current.Kind)
 		}
@@ -696,3 +701,24 @@ func (p *Parser) parseBody() (ast.Body, error) {
 
 	return body, nil
 }
+
+// parseBodyFile parses a body file expression.
+func (p *Parser) parseBodyFile() (ast.BodyFile, error) {
+	bodyFile := ast.BodyFile{
+		Token: p.current,
+		Type:  ast.KindBodyFile,
+	}
+
+	if err := p.expect(token.Text, token.OpenInterp); err != nil {
+		return bodyFile, err
+	}
+
+	value, err := p.parseExpression(token.LowestPrecedence)
+	if err != nil {
+		return bodyFile, err
+	}
+
+	bodyFile.Value = value
+
+	return bodyFile, nil
+}

internal/syntax/parser/v2/parser.go

@@ -4,5 +4,5 @@ GET https://blowup.com
 
 < £$%^&
 -- want.txt --
-bad-body-file.txtar:4:1-2: parseStatement: unrecognised token: LeftAngle
+bad-body-file.txtar:4:1-2: Error token from scanner
 bad-body-file.txtar:4:5: unrecognised character: '£'

internal/syntax/parser/v2/testdata/invalid/bad-body-file.txtar

@@ -0,0 +1,60 @@
+source: parser_test.go
+expression: parsed
+---
+name: body-file.http
+statements:
+  - url:
+      value: https://api.somewhere.com/items/1
+      token:
+        kind: URL
+        start: 41
+        end: 74
+      type: URL
+    body:
+      value:
+        value: input.json
+        token:
+          kind: Text
+          start: 109
+          end: 119
+        type: TextLiteral
+      token:
+        kind: LeftAngle
+        start: 107
+        end: 108
+      type: BodyFile
+    vars: []
+    prompts: []
+    headers:
+      - value:
+          value: application/json
+          token:
+            kind: Text
+            start: 89
+            end: 105
+          type: TextLiteral
+        key: Content-Type
+        token:
+          kind: Header
+          start: 75
+          end: 87
+        type: Header
+    comment:
+      text: Read the body from ./input.json
+      token:
+        kind: Comment
+        start: 4
+        end: 35
+      type: Comment
+    method:
+      token:
+        kind: MethodPost
+        start: 36
+        end: 40
+      type: Method
+    sep:
+      kind: Separator
+      start: 0
+      end: 3
+    type: Request
+type: File

internal/syntax/parser/v2/testdata/snapshots/TestParse/body-file.http.snap

@@ -0,0 +1,5 @@
+### Read the body from ./input.json
+POST https://api.somewhere.com/items/1
+Content-Type: application/json
+
+< input.json

internal/syntax/parser/v2/testdata/valid/body-file.http

@@ -36,6 +36,8 @@ const (
 	bufferSize = 32       // benchmarks suggest this is the optimum token channel buffer size
 )
 
+// TODO(@FollowTheProcess): Allow interp in body file, so < {{ ident }}
+
 // scanFn represents the state of the scanner as a function that does the work
 // associated with the current state, then returns the next state.
 type scanFn func(*Scanner) scanFn