Using a flag to consume whitespace and newline at the end of a verbatim block

ajaybhargavb · ajaybhargavb · commit 743df7af5239 · 2015-09-08T15:24:36.000-07:00
diff --git a/src/Microsoft.AspNet.Razor/Parser/CSharpCodeParser.cs b/src/Microsoft.AspNet.Razor/Parser/CSharpCodeParser.cs
@@ -316,13 +316,17 @@ private void VerbatimBlock()
                 Span.ChunkGenerator = SpanChunkGenerator.Null;
             }
 
-            if (!At(CSharpSymbolType.WhiteSpace) && !At(CSharpSymbolType.NewLine))
+            Output(SpanKind.MetaCode);
+
+            if (IsNested)
             {
-                PutCurrentBack();
+                CompleteBlock(insertMarkerIfNecessary: false, captureWhitespaceToEndOfLine: true);
+                Output(SpanKind.Code);
+            }
+            else if (At(CSharpSymbolType.WhiteSpace) || At(CSharpSymbolType.NewLine))
+            {
+                Context.NullGenerateWhitespaceAndNewLine = true;
             }
-
-            CompleteBlock(insertMarkerIfNecessary: false, captureWhitespaceToEndOfLine: true);
-            Output(SpanKind.MetaCode);
         }
 
         private void ImplicitExpression()
diff --git a/src/Microsoft.AspNet.Razor/Parser/HtmlMarkupParser.cs b/src/Microsoft.AspNet.Razor/Parser/HtmlMarkupParser.cs
@@ -71,7 +71,19 @@ protected void SkipToAndParseCode(Func<HtmlSymbol, bool> condition)
             var startOfLine = false;
             while (!EndOfFile && !condition(CurrentSymbol))
             {
-                if (At(HtmlSymbolType.NewLine))
+                if (Context.NullGenerateWhitespaceAndNewLine)
+                {
+                    Context.NullGenerateWhitespaceAndNewLine = false;
+                    Span.ChunkGenerator = SpanChunkGenerator.Null;
+                    AcceptWhile(symbol => symbol.Type == HtmlSymbolType.WhiteSpace);
+                    if (At(HtmlSymbolType.NewLine))
+                    {
+                        AcceptAndMoveNext();
+                    }
+
+                    Output(SpanKind.Markup);
+                }
+                else if (At(HtmlSymbolType.NewLine))
                 {
                     if (last != null)
                     {
diff --git a/src/Microsoft.AspNet.Razor/Parser/ParserContext.cs b/src/Microsoft.AspNet.Razor/Parser/ParserContext.cs
@@ -67,6 +67,8 @@ public BlockBuilder CurrentBlock
         public Span LastSpan { get; private set; }
         public bool WhiteSpaceIsSignificantToAncestorBlock { get; set; }
 
+        public bool NullGenerateWhitespaceAndNewLine { get; set; }
+
         public AcceptedCharacters LastAcceptedCharacters
         {
             get
diff --git a/test/Microsoft.AspNet.Razor.Test/Parser/Html/HtmlDocumentTest.cs b/test/Microsoft.AspNet.Razor.Test/Parser/Html/HtmlDocumentTest.cs
@@ -291,7 +291,7 @@ public void ParseDocumentIgnoresTagsInContentsOfScriptTag()
         }
 
         [Fact]
-        public void ParseDocumentDoesNotRenderExtraNewLine()
+        public void ParseDocumentDoesNotRenderExtraNewLineAtTheEndOfVerbatimBlock()
         {
             ParseDocumentTest("@{\r\n}\r\n<html>",
                 new MarkupBlock(
@@ -300,10 +300,27 @@ public void ParseDocumentDoesNotRenderExtraNewLine()
                         Factory.CodeTransition(),
                         Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
                         Factory.Code("\r\n").AsStatement().AutoCompleteWith(null, false),
-                        Factory.MetaCode("}\r\n").Accepts(AcceptedCharacters.None)),
+                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
+                    Factory.Markup("\r\n").With(SpanChunkGenerator.Null),
                     BlockFactory.MarkupTagBlock("<html>")));
         }
 
+        [Fact]
+        public void ParseDocumentDoesNotIgnoreNewLineAtTheEndOfMarkupBlock()
+        {
+            ParseDocumentTest("@{\r\n}\r\n<html>\r\n",
+                new MarkupBlock(
+                    Factory.EmptyHtml(),
+                    new StatementBlock(
+                        Factory.CodeTransition(),
+                        Factory.MetaCode("{").Accepts(AcceptedCharacters.None),
+                        Factory.Code("\r\n").AsStatement().AutoCompleteWith(null, false),
+                        Factory.MetaCode("}").Accepts(AcceptedCharacters.None)),
+                    Factory.Markup("\r\n").With(SpanChunkGenerator.Null),
+                    BlockFactory.MarkupTagBlock("<html>"),
+                    Factory.Markup("\r\n")));
+        }
+
         [Fact]
         public void ParseSectionIgnoresTagsInContentsOfScriptTag()
         {

Original file line number	Diff line number	Diff line change
`@@ -316,13 +316,17 @@ private void VerbatimBlock()`
`316`	`316`	`Span.ChunkGenerator = SpanChunkGenerator.Null;`
`317`	`317`	`}`
`318`	`318`
`319`		`- if (!At(CSharpSymbolType.WhiteSpace) && !At(CSharpSymbolType.NewLine))`
	`319`	`+ Output(SpanKind.MetaCode);`
	`320`	`+`
	`321`	`+ if (IsNested)`
`320`	`322`	`{`
`321`		`- PutCurrentBack();`
	`323`	`+ CompleteBlock(insertMarkerIfNecessary: false, captureWhitespaceToEndOfLine: true);`
	`324`	`+ Output(SpanKind.Code);`
	`325`	`+ }`
	`326`	`+ else if (At(CSharpSymbolType.WhiteSpace) \|\| At(CSharpSymbolType.NewLine))`
	`327`	`+ {`
	`328`	`+ Context.NullGenerateWhitespaceAndNewLine = true;`
`322`	`329`	`}`
`323`		`-`
`324`		`- CompleteBlock(insertMarkerIfNecessary: false, captureWhitespaceToEndOfLine: true);`
`325`		`- Output(SpanKind.MetaCode);`
`326`	`330`	`}`
`327`	`331`
`328`	`332`	`private void ImplicitExpression()`
Original file line number	Diff line number	Diff line change
`@@ -67,6 +67,8 @@ public BlockBuilder CurrentBlock`
`67`	`67`	`public Span LastSpan { get; private set; }`
`68`	`68`	`public bool WhiteSpaceIsSignificantToAncestorBlock { get; set; }`
`69`	`69`
	`70`	`+ public bool NullGenerateWhitespaceAndNewLine { get; set; }`
	`71`	`+`
`70`	`72`	`public AcceptedCharacters LastAcceptedCharacters`
`71`	`73`	`{`
`72`	`74`	`get`