fix(fmt): Preserve multiple newlines between elements (#374)

generator/generator.go

@@ -528,6 +528,8 @@ func (g *generator) writeNodes(indentLevel int, nodes []parser.Node, next parser
 }
 
 func (g *generator) writeNode(indentLevel int, current parser.Node, next parser.Node) (err error) {
+	maybeWhitespace := true
+
 	switch n := current.(type) {
 	case parser.DocType:
 		err = g.writeDocType(indentLevel, n)
@@ -540,14 +542,17 @@ func (g *generator) writeNode(indentLevel int, current parser.Node, next parser.
 	case parser.RawElement:
 		err = g.writeRawElement(indentLevel, n)
 	case parser.ForExpression:
+		maybeWhitespace = false
 		err = g.writeForExpression(indentLevel, n, next)
 	case parser.CallTemplateExpression:
 		err = g.writeCallTemplateExpression(indentLevel, n)
 	case parser.TemplElementExpression:
 		err = g.writeTemplElementExpression(indentLevel, n)
 	case parser.IfExpression:
+		maybeWhitespace = false
 		err = g.writeIfExpression(indentLevel, n, next)
 	case parser.SwitchExpression:
+		maybeWhitespace = false
 		err = g.writeSwitchExpression(indentLevel, n, next)
 	case parser.StringExpression:
 		err = g.writeStringExpression(indentLevel, n.Expression)
@@ -566,8 +571,9 @@ func (g *generator) writeNode(indentLevel int, current parser.Node, next parser.
 	// Write trailing whitespace, if there is a next node that might need the space.
 	// If the next node is inline or text, we might need it.
 	// If the current node is a block element, we don't need it.
-	needed := (isInlineOrText(current) && isInlineOrText(next))
-	if ws, ok := current.(parser.WhitespaceTrailer); ok && needed {
+	// If, switch and for as current node skip whitespace, but not always when next node.
+	neededWhitespace := maybeWhitespace && isInlineOrText(current) && isInlineOrText(next)
+	if ws, ok := current.(parser.WhitespaceTrailer); ok && neededWhitespace {
 		if err := g.writeWhitespaceTrailer(indentLevel, ws.Trailing()); err != nil {
 			return err
 		}
@@ -604,7 +610,7 @@ func (g *generator) writeWhitespaceTrailer(indentLevel int, n parser.TrailingSpa
 	}
 	// Normalize whitespace for minified output. In HTML, a single space is equivalent to
 	// any number of spaces, tabs, or newlines.
-	if n == parser.SpaceVertical {
+	if n == parser.SpaceVertical || n == parser.SpaceVerticalDouble {
 		n = parser.SpaceHorizontal
 	}
 	if _, err = g.w.WriteStringLiteral(indentLevel, string(n)); err != nil {

parser/v2/calltemplateparser.go

@@ -29,5 +29,11 @@ func (p callTemplateExpressionParser) Parse(pi *parse.Input) (n Node, ok bool, e
 		return
 	}
 
+	// Parse trailing whitespace.
+	r.TrailingSpace, err = parseTrailingSpace(pi, true, false)
+	if err != nil {
+		return r, false, err
+	}
+
 	return r, true, nil
 }

parser/v2/calltemplateparser_test.go

@@ -76,6 +76,28 @@ func TestCallTemplateExpressionParser(t *testing.T) {
 				},
 			},
 		},
+		{
+			name:  "call: can parse the initial expression and leave the text",
+			input: `{!Other(p.Test)} Home`,
+			expected: CallTemplateExpression{
+				Expression: Expression{
+					Value: "Other(p.Test)",
+					Range: Range{
+						From: Position{
+							Index: 2,
+							Line:  0,
+							Col:   2,
+						},
+						To: Position{
+							Index: 15,
+							Line:  0,
+							Col:   15,
+						},
+					},
+				},
+				TrailingSpace: SpaceHorizontal,
+			},
+		},
 	}
 	for _, tt := range tests {
 		tt := tt

parser/v2/elementparser.go

@@ -467,11 +467,7 @@ func addTrailingSpaceAndValidate(start parse.Position, e Element, pi *parse.Inpu
 		return e, false, err
 	}
 	// Add trailing space.
-	ws, _, err := parse.Whitespace.Parse(pi)
-	if err != nil {
-		return e, false, err
-	}
-	e.TrailingSpace, err = NewTrailingSpace(ws)
+	e.TrailingSpace, err = parseTrailingSpace(pi, true, false)
 	if err != nil {
 		return e, false, err
 	}

parser/v2/elementparser_test.go

@@ -1538,6 +1538,43 @@ func TestElementParser(t *testing.T) {
 				},
 			},
 		},
+		{
+			name: "element: with multiple newlines, should collapse to two",
+			input: `<div>
+	<span></span>
+
+
+
+	<span></span>
+</div>`,
+			expected: Element{
+				Name: "div",
+				NameRange: Range{
+					From: Position{Index: 1, Line: 0, Col: 1},
+					To:   Position{Index: 4, Line: 0, Col: 4},
+				},
+				IndentChildren: true,
+				Children: []Node{
+					Whitespace{Value: "\n\t"},
+					Element{
+						Name: "span",
+						NameRange: Range{
+							From: Position{Index: 8, Line: 1, Col: 2},
+							To:   Position{Index: 12, Line: 1, Col: 6},
+						},
+						TrailingSpace: SpaceVerticalDouble,
+					},
+					Element{
+						Name: "span",
+						NameRange: Range{
+							From: Position{Index: 26, Line: 5, Col: 2},
+							To:   Position{Index: 30, Line: 5, Col: 6},
+						},
+						TrailingSpace: SpaceVertical,
+					},
+				},
+			},
+		},
 		{
 			name: "element: can contain text that starts with for",
 			input: `<div>for which any 

parser/v2/forexpressionparser.go

@@ -10,7 +10,10 @@ var forExpression parse.Parser[Node] = forExpressionParser{}
 type forExpressionParser struct{}
 
 func (forExpressionParser) Parse(pi *parse.Input) (n Node, ok bool, err error) {
-	var r ForExpression
+	r := ForExpression{
+		// Default behavior is always a trailing space
+		TrailingSpace: SpaceVertical,
+	}
 	start := pi.Index()
 
 	// Strip leading whitespace and look for `for `.
@@ -48,5 +51,11 @@ func (forExpressionParser) Parse(pi *parse.Input) (n Node, ok bool, err error) {
 		return
 	}
 
+	// Parse trailing whitespace.
+	r.TrailingSpace, err = parseTrailingSpace(pi, true, true)
+	if err != nil {
+		return r, false, err
+	}
+
 	return r, true, nil
 }

parser/v2/forexpressionparser_test.go

@@ -64,6 +64,7 @@ func TestForExpressionParser(t *testing.T) {
 						TrailingSpace: SpaceVertical,
 					},
 				},
+				TrailingSpace: SpaceVertical,
 			},
 		},
 		{
@@ -117,6 +118,7 @@ func TestForExpressionParser(t *testing.T) {
 						TrailingSpace: SpaceVertical,
 					},
 				},
+				TrailingSpace: SpaceVertical,
 			},
 		},
 	}

parser/v2/formattestdata/calltemplate_newline_is_preserved.txt

@@ -0,0 +1,34 @@
+-- in --
+package main
+
+templ test() {
+	<span></span>
+
+
+	{! Other(p.Test) }
+	{!Other(p.Test)} Home
+
+	<div>Some standard templ</div>
+
+{!Other(p.Test) }
+
+
+
+	<span></span>
+
+}
+-- out --
+package main
+
+templ test() {
+	<span></span>
+
+	@Other(p.Test)
+	@Other(p.Test) Home
+	<div>Some standard templ</div>
+
+	@Other(p.Test)
+
+	<span></span>
+
+}

parser/v2/formattestdata/comments_newline_is_preserved.txt

@@ -0,0 +1,31 @@
+-- in --
+package main
+
+templ test() {
+	<!-- This is a comment -->
+
+	// This is not included in the output.
+	<div>Some standard templ</div>
+
+
+	/* This is not included in the output too. */
+	/*
+		Leave this alone.
+	*/
+
+
+}
+-- out --
+package main
+
+templ test() {
+	<!-- This is a comment -->
+
+	// This is not included in the output.
+	<div>Some standard templ</div>
+
+	/* This is not included in the output too. */
+	/*
+		Leave this alone.
+	*/
+}

parser/v2/formattestdata/element_double_newline_after_component.txt

@@ -0,0 +1,29 @@
+-- in --
+package main
+
+templ x() {
+	<div>
+		@Hero()
+		<span></span>
+
+
+		@Hero()
+
+
+
+		<span></span>
+	</div>
+}
+-- out --
+package main
+
+templ x() {
+	<div>
+		@Hero()
+		<span></span>
+
+		@Hero()
+
+		<span></span>
+	</div>
+}

parser/v2/formattestdata/element_double_newline_indent_issue.txt

@@ -0,0 +1,25 @@
+-- in --
+package main
+
+templ x() {
+	<div>
+		<a></a><span></span>
+
+		// This line is indented incorrectly
+<a></a>
+
+	</div>
+}
+
+-- out --
+package main
+
+templ x() {
+	<div>
+		<a></a><span></span>
+
+		// This line is indented incorrectly
+		<a></a>
+
+	</div>
+}

parser/v2/formattestdata/element_double_newline_is_preserved.txt

@@ -0,0 +1,28 @@
+-- in --
+package main
+
+templ x() {
+  <div>
+    <span>Hello
+
+    World
+    </span>
+
+
+
+    <span>Foo Bar </span>
+  </div>
+}
+-- out --
+package main
+
+templ x() {
+	<div>
+		<span>
+			Hello
+			World
+		</span>
+
+		<span>Foo Bar </span>
+	</div>
+}

parser/v2/formattestdata/element_double_newline_string_literal_termination_issue.txt

@@ -0,0 +1,25 @@
+-- in --
+package main
+
+// The below template caused the generated code to not strip newlines, causing error
+templ x() {
+	<div>
+		<a></a>
+
+
+
+		<a>
+		</a>
+	</div>
+}
+-- out --
+package main
+
+// The below template caused the generated code to not strip newlines, causing error
+templ x() {
+	<div>
+		<a></a>
+
+		<a></a>
+	</div>
+}