public override void VisitBlock(Block block) { if (CanRewrite(block)) { var newNode = RewriteBlock(_blocks.Peek(), block); if (newNode != null) { _blocks.Peek().Children.Add(newNode); } } else { // Not rewritable. var builder = new BlockBuilder(block); builder.Children.Clear(); _blocks.Push(builder); base.VisitBlock(block); Debug.Assert(ReferenceEquals(builder, _blocks.Peek())); if (_blocks.Count > 1) { _blocks.Pop(); _blocks.Peek().Children.Add(builder.Build()); } } }
protected override SyntaxTreeNode RewriteBlock(BlockBuilder parent, Block block) { // Collect the content of this node var content = string.Concat(block.Children.Cast<Span>().Select(s => s.Content)); // Create a new span containing this content var span = new SpanBuilder(); span.EditHandler = new SpanEditHandler(HtmlTokenizer.Tokenize); FillSpan(span, block.Children.Cast<Span>().First().Start, content); return span.Build(); }
public void ConstructorWithBlockBuilderSetsParent() { // Arrange BlockBuilder builder = new BlockBuilder() { Type = BlockType.Comment }; Span span = new SpanBuilder() { Kind = SpanKind.Code }.Build(); builder.Children.Add(span); // Act Block block = builder.Build(); // Assert Assert.Same(block, span.Parent); }
public void VisitSendsDocumentToVisitor() { // Arrange Mock<ParserVisitor> targetMock = new Mock<ParserVisitor>(); Block root = new BlockBuilder() { Type = BlockType.Comment }.Build(); ParserResults results = new ParserResults(root, new List<RazorError>()); // Act targetMock.Object.Visit(results); // Assert targetMock.Verify(v => v.VisitBlock(root)); }
protected override SyntaxTreeNode RewriteSpan(BlockBuilder parent, Span span) { // Only rewrite if we have a previous that is also markup (CanRewrite does this check for us!) Span previous = parent.Children.LastOrDefault() as Span; if (previous == null || !CanRewrite(previous)) { return span; } // Merge spans parent.Children.Remove(previous); SpanBuilder merged = new SpanBuilder(); FillSpan(merged, previous.Start, previous.Content + span.Content); return merged.Build(); }
public void VisitSendsDocumentToVisitor() { // Arrange Mock<ParserVisitor> targetMock = new Mock<ParserVisitor>(); var root = new BlockBuilder() { Type = BlockType.Comment }.Build(); var errorSink = new ErrorSink(); var results = new ParserResults(root, Enumerable.Empty<TagHelperDescriptor>(), errorSink); // Act targetMock.Object.Visit(results); // Assert targetMock.Verify(v => v.VisitBlock(root)); }
public void VisitCallsOnCompleteWhenAllNodesHaveBeenVisited() { // Arrange Mock<ParserVisitor> targetMock = new Mock<ParserVisitor>(); var root = new BlockBuilder() { Type = BlockType.Comment }.Build(); var errorSink = new ErrorSink(); errorSink.OnError(new RazorError("Foo", new SourceLocation(1, 0, 1), length: 3)); errorSink.OnError(new RazorError("Bar", new SourceLocation(2, 0, 2), length: 3)); var results = new ParserResults(root, Enumerable.Empty<TagHelperDescriptor>(), errorSink); // Act targetMock.Object.Visit(results); // Assert targetMock.Verify(v => v.OnComplete()); }
public void ConstructorCopiesBasicValuesFromBlockBuilder() { // Arrange BlockBuilder builder = new BlockBuilder() { Name = "Foo", Type = BlockType.Helper }; // Act Block actual = builder.Build(); // Assert Assert.Equal("Foo", actual.Name); Assert.Equal(BlockType.Helper, actual.Type); }
public void ConstructorTransfersInstanceOfCodeGeneratorFromBlockBuilder() { // Arrange IBlockCodeGenerator expected = new ExpressionCodeGenerator(); BlockBuilder builder = new BlockBuilder() { Type = BlockType.Helper, CodeGenerator = expected }; // Act Block actual = builder.Build(); // Assert Assert.Same(expected, actual.CodeGenerator); }
public void ConstructorTransfersChildrenFromBlockBuilder() { // Arrange Span expected = new SpanBuilder() { Kind = SpanKind.Code }.Build(); BlockBuilder builder = new BlockBuilder() { Type = BlockType.Functions }; builder.Children.Add(expected); // Act Block block = builder.Build(); // Assert Assert.Same(expected, block.Children.Single()); }
public void VisitCallsOnCompleteWhenAllNodesHaveBeenVisited() { // Arrange Mock<ParserVisitor> targetMock = new Mock<ParserVisitor>(); Block root = new BlockBuilder() { Type = BlockType.Comment }.Build(); List<RazorError> errors = new List<RazorError>() { new RazorError("Foo", 1, 0, 1), new RazorError("Bar", 2, 0, 2) }; ParserResults results = new ParserResults(root, errors); // Act targetMock.Object.Visit(results); // Assert targetMock.Verify(v => v.OnComplete()); }
public Block(BlockBuilder source) { if (source.Type == null) { throw new InvalidOperationException(RazorResources.Block_Type_Not_Specified); } Type = source.Type.Value; Children = source.Children; Name = source.Name; CodeGenerator = source.CodeGenerator; source.Reset(); foreach (SyntaxTreeNode node in Children) { node.Parent = this; } }
public void VisitSendsErrorsToVisitor() { // Arrange Mock<ParserVisitor> targetMock = new Mock<ParserVisitor>(); Block root = new BlockBuilder() { Type = BlockType.Comment }.Build(); List<RazorError> errors = new List<RazorError>() { new RazorError("Foo", 1, 0, 1), new RazorError("Bar", 2, 0, 2) }; ParserResults results = new ParserResults(root, errors); // Act targetMock.Object.Visit(results); // Assert targetMock.Verify(v => v.VisitError(errors[0])); targetMock.Verify(v => v.VisitError(errors[1])); }
//public override void VisitBlock(Block block) //{ // BlockBuilder parent = null; // if (_blocks.Count > 0) // { // parent = _blocks.Peek(); // } // BlockBuilder newBlock = new BlockBuilder(block); // newBlock.Children.Clear(); // _blocks.Push(newBlock); // if (block.Type == BlockType.Expression && parent != null) // { // VisitExpressionBlock(block, parent); // } // else // { // base.VisitBlock(block); // } // if (_blocks.Count > 1) // { // parent.Children.Add(_blocks.Pop().Build()); // } //} //public override void VisitSpan(Span span) //{ // Debug.Assert(_blocks.Count > 0); // _blocks.Peek().Children.Add(span); //} protected override SyntaxTreeNode RewriteBlock(BlockBuilder parent, Block block) { var newBlock = new BlockBuilder(block); newBlock.Children.Clear(); var ws = block.Children.FirstOrDefault() as Span; IEnumerable<SyntaxTreeNode> newNodes = block.Children; if (ws.Content.All(Char.IsWhiteSpace)) { // Add this node to the parent var builder = new SpanBuilder(ws); builder.ClearSymbols(); FillSpan(builder, ws.Start, ws.Content); parent.Children.Add(builder.Build()); // Remove the old whitespace node newNodes = block.Children.Skip(1); } foreach (SyntaxTreeNode node in newNodes) { newBlock.Children.Add(node); } return newBlock.Build(); }
public void VisitSendsErrorsToVisitor() { // Arrange Mock<ParserVisitor> targetMock = new Mock<ParserVisitor>(); var root = new BlockBuilder() { Type = BlockType.Comment }.Build(); var errorSink = new ErrorSink(); List<RazorError> errors = new List<RazorError> { new RazorError("Foo", new SourceLocation(1, 0, 1), length: 3), new RazorError("Bar", new SourceLocation(2, 0, 2), length: 3), }; foreach (var error in errors) { errorSink.OnError(error); } var results = new ParserResults(root, Enumerable.Empty<TagHelperDescriptor>(), errorSink); // Act targetMock.Object.Visit(results); // Assert targetMock.Verify(v => v.VisitError(errors[0])); targetMock.Verify(v => v.VisitError(errors[1])); }
protected virtual SyntaxTreeNode RewriteSpan(BlockBuilder parent, Span span) { throw new NotImplementedException(); }
public void AddSpanAddsSpanToCurrentBlockBuilder() { // Arrange var factory = SpanFactory.CreateCsHtml(); Mock<ParserVisitor> mockListener = new Mock<ParserVisitor>(); var context = SetupTestContext("phoo"); var builder = new SpanBuilder() { Kind = SpanKind.Code }; builder.Accept(new CSharpSymbol(1, 0, 1, "foo", CSharpSymbolType.Identifier)); var added = builder.Build(); using (context.StartBlock(BlockType.Functions)) { context.AddSpan(added); } var expected = new BlockBuilder() { Type = BlockType.Functions, }; expected.Children.Add(added); // Assert ParserTestBase.EvaluateResults(context.CompleteParse(), expected.Build()); }
private static TryParseResult TryParseBlock( string tagName, Block block, IEnumerable<TagHelperDescriptor> descriptors, ErrorSink errorSink) { // TODO: Accept more than just spans: https://github.com/aspnet/Razor/issues/96. // The first child will only ever NOT be a Span if a user is doing something like: // <input @checked /> var childSpan = block.Children.First() as Span; if (childSpan == null || childSpan.Kind != SpanKind.Markup) { errorSink.OnError(block.Children.First().Start, RazorResources.FormatTagHelpers_CannotHaveCSharpInTagDeclaration(tagName)); return null; } var builder = new BlockBuilder(block); // If there's only 1 child it means that it's plain text inside of the attribute. // i.e. <div class="plain text in attribute"> if (builder.Children.Count == 1) { return TryParseSpan(childSpan, descriptors, errorSink); } var textSymbol = childSpan.Symbols.FirstHtmlSymbolAs(HtmlSymbolType.Text); var name = textSymbol != null ? textSymbol.Content : null; if (name == null) { errorSink.OnError(childSpan.Start, RazorResources.FormatTagHelpers_AttributesMustHaveAName(tagName)); return null; } // Have a name now. Able to determine correct isBoundNonStringAttribute value. var result = CreateTryParseResult(name, descriptors); // Remove first child i.e. foo=" builder.Children.RemoveAt(0); // Grabbing last child to check if the attribute value is quoted. var endNode = block.Children.Last(); if (!endNode.IsBlock) { var endSpan = (Span)endNode; // In some malformed cases e.g. <p bar="false', the last Span (false' in the ex.) may contain more // than a single HTML symbol. Do not ignore those other symbols. var symbolCount = endSpan.Symbols.Count(); var endSymbol = symbolCount == 1 ? (HtmlSymbol)endSpan.Symbols.First() : null; // Checking to see if it's a quoted attribute, if so we should remove end quote if (endSymbol != null && IsQuote(endSymbol)) { builder.Children.RemoveAt(builder.Children.Count - 1); } } // We need to rebuild the chunk generators of the builder and its children (this is needed to // ensure we don't do special attribute chunk generation since this is a tag helper). block = RebuildChunkGenerators(builder.Build()); // If there's only 1 child at this point its value could be a simple markup span (treated differently than // block level elements for attributes). if (block.Children.Count() == 1) { var child = block.Children.First() as Span; if (child != null) { // After pulling apart the block we just have a value span. var spanBuilder = new SpanBuilder(child); result.AttributeValueNode = CreateMarkupAttribute(spanBuilder, result.IsBoundNonStringAttribute); return result; } } result.AttributeValueNode = ConvertToMarkupAttributeBlock(block, result.IsBoundNonStringAttribute); return result; }
private static Block ConvertToMarkupAttributeBlock(Block block, bool isBoundNonStringAttribute) { var blockBuilder = new BlockBuilder { ChunkGenerator = block.ChunkGenerator, Type = block.Type }; foreach (var child in block.Children) { SyntaxTreeNode markupAttributeChild; if (child.IsBlock) { markupAttributeChild = ConvertToMarkupAttributeBlock((Block)child, isBoundNonStringAttribute); } else { var spanBuilder = new SpanBuilder((Span)child); markupAttributeChild = CreateMarkupAttribute(spanBuilder, isBoundNonStringAttribute); } blockBuilder.Children.Add(markupAttributeChild); } return blockBuilder.Build(); }
private static Block RebuildChunkGenerators(Block block, bool isBound) { var builder = new BlockBuilder(block); // Don't want to rebuild unbound dynamic attributes. They need to run through the conditional attribute // removal system at runtime. A conditional attribute at the parse tree rewriting level is defined by // having at least 1 child with a DynamicAttributeBlockChunkGenerator. if (!isBound && block.Children.Any( child => child.IsBlock && ((Block)child).ChunkGenerator is DynamicAttributeBlockChunkGenerator)) { // The parent chunk generator must be removed because it's normally responsible for conditionally // generating the attribute prefix (class=") and suffix ("). The prefix and suffix concepts aren't // applicable for the TagHelper use case since the attributes are put into a dictionary like object as // name value pairs. builder.ChunkGenerator = ParentChunkGenerator.Null; return builder.Build(); } var isDynamic = builder.ChunkGenerator is DynamicAttributeBlockChunkGenerator; // We don't want any attribute specific logic here, null out the block chunk generator. if (isDynamic || builder.ChunkGenerator is AttributeBlockChunkGenerator) { builder.ChunkGenerator = ParentChunkGenerator.Null; } for (var i = 0; i < builder.Children.Count; i++) { var child = builder.Children[i]; if (child.IsBlock) { // The child is a block, recurse down into the block to rebuild its children builder.Children[i] = RebuildChunkGenerators((Block)child, isBound); } else { var childSpan = (Span)child; ISpanChunkGenerator newChunkGenerator = null; var literalGenerator = childSpan.ChunkGenerator as LiteralAttributeChunkGenerator; if (literalGenerator != null) { if (literalGenerator.ValueGenerator == null || literalGenerator.ValueGenerator.Value == null) { newChunkGenerator = new MarkupChunkGenerator(); } else { newChunkGenerator = literalGenerator.ValueGenerator.Value; } } else if (isDynamic && childSpan.ChunkGenerator == SpanChunkGenerator.Null) { // Usually the dynamic chunk generator handles creating the null chunk generators underneath // it. This doesn't make sense in terms of tag helpers though, we need to change null code // generators to markup chunk generators. newChunkGenerator = new MarkupChunkGenerator(); } // If we have a new chunk generator we'll need to re-build the child if (newChunkGenerator != null) { var childSpanBuilder = new SpanBuilder(childSpan) { ChunkGenerator = newChunkGenerator }; builder.Children[i] = childSpanBuilder.Build(); } } } return builder.Build(); }
private static Block ConvertToMarkupAttributeBlock( Block block, Func<Block, Span, Span> createMarkupAttribute) { var blockBuilder = new BlockBuilder { ChunkGenerator = block.ChunkGenerator, Type = block.Type }; foreach (var child in block.Children) { SyntaxTreeNode markupAttributeChild; if (child.IsBlock) { markupAttributeChild = ConvertToMarkupAttributeBlock((Block)child, createMarkupAttribute); } else { markupAttributeChild = createMarkupAttribute(block, (Span)child); } blockBuilder.Children.Add(markupAttributeChild); } return blockBuilder.Build(); }
private static TryParseResult TryParseBlock( string tagName, Block block, IEnumerable<TagHelperDescriptor> descriptors, ErrorSink errorSink) { // TODO: Accept more than just spans: https://github.com/aspnet/Razor/issues/96. // The first child will only ever NOT be a Span if a user is doing something like: // <input @checked /> var childSpan = block.Children.First() as Span; if (childSpan == null || childSpan.Kind != SpanKind.Markup) { errorSink.OnError( block.Start, RazorResources.FormatTagHelpers_CannotHaveCSharpInTagDeclaration(tagName), block.Length); return null; } var builder = new BlockBuilder(block); // If there's only 1 child it means that it's plain text inside of the attribute. // i.e. <div class="plain text in attribute"> if (builder.Children.Count == 1) { return TryParseSpan(childSpan, descriptors, errorSink); } var nameSymbols = childSpan .Symbols .OfType<HtmlSymbol>() .SkipWhile(symbol => !HtmlMarkupParser.IsValidAttributeNameSymbol(symbol)) // Skip prefix .TakeWhile(nameSymbol => HtmlMarkupParser.IsValidAttributeNameSymbol(nameSymbol)) .Select(nameSymbol => nameSymbol.Content); var name = string.Concat(nameSymbols); if (string.IsNullOrEmpty(name)) { errorSink.OnError( childSpan.Start, RazorResources.FormatTagHelpers_AttributesMustHaveAName(tagName), childSpan.Length); return null; } // Have a name now. Able to determine correct isBoundNonStringAttribute value. var result = CreateTryParseResult(name, descriptors); // Remove first child i.e. foo=" builder.Children.RemoveAt(0); // Grabbing last child to check if the attribute value is quoted. var endNode = block.Children.Last(); if (!endNode.IsBlock) { var endSpan = (Span)endNode; // In some malformed cases e.g. <p bar="false', the last Span (false' in the ex.) may contain more // than a single HTML symbol. Do not ignore those other symbols. var symbolCount = endSpan.Symbols.Count(); var endSymbol = symbolCount == 1 ? (HtmlSymbol)endSpan.Symbols.First() : null; // Checking to see if it's a quoted attribute, if so we should remove end quote if (endSymbol != null && IsQuote(endSymbol)) { builder.Children.RemoveAt(builder.Children.Count - 1); } } // We need to rebuild the chunk generators of the builder and its children (this is needed to // ensure we don't do special attribute chunk generation since this is a tag helper). block = RebuildChunkGenerators(builder.Build(), result.IsBoundAttribute); // If there's only 1 child at this point its value could be a simple markup span (treated differently than // block level elements for attributes). if (block.Children.Count() == 1) { var child = block.Children.First() as Span; if (child != null) { // After pulling apart the block we just have a value span. var spanBuilder = new SpanBuilder(child); result.AttributeValueNode = CreateMarkupAttribute(spanBuilder, result.IsBoundNonStringAttribute); return result; } } var isFirstSpan = true; result.AttributeValueNode = ConvertToMarkupAttributeBlock( block, (parentBlock, span) => { // If the attribute was requested by a tag helper but the corresponding property was not a // string, then treat its value as code. A non-string value can be any C# value so we need // to ensure the SyntaxTreeNode reflects that. if (result.IsBoundNonStringAttribute) { // For bound non-string attributes, we'll only allow a transition span to appear at the very // beginning of the attribute expression. All later transitions would appear as code so that // they are part of the generated output. E.g. // key="@value" -> MyTagHelper.key = value // key=" @value" -> MyTagHelper.key = @value // key="1 + @case" -> MyTagHelper.key = 1 + @case // key="@int + @case" -> MyTagHelper.key = int + @case // key="@(a + b) -> MyTagHelper.key = a + b // key="4 + @(a + b)" -> MyTagHelper.key = 4 + @(a + b) if (isFirstSpan && span.Kind == SpanKind.Transition) { // do nothing. } else { var spanBuilder = new SpanBuilder(span); if (parentBlock.Type == BlockType.Expression && (spanBuilder.Kind == SpanKind.Transition || spanBuilder.Kind == SpanKind.MetaCode)) { // Change to a MarkupChunkGenerator so that the '@' \ parenthesis is generated as part of the output. spanBuilder.ChunkGenerator = new MarkupChunkGenerator(); } spanBuilder.Kind = SpanKind.Code; span = spanBuilder.Build(); } } isFirstSpan = false; return span; }); return result; }
private void EofBlockCore(string keyword, string expectedTerminator, bool autoComplete, BlockType blockType, bool keywordIsMetaCode, Func<UnclassifiedCodeSpanConstructor, SpanConstructor> classifier) { BlockBuilder expected = new BlockBuilder(); expected.Type = blockType; if (keywordIsMetaCode) { expected.Children.Add(Factory.MetaCode(keyword).Accepts(AcceptedCharacters.None)); expected.Children.Add( classifier(Factory.EmptyVB()) .With((SpanEditHandler)( autoComplete ? new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString) { AutoCompleteString = expectedTerminator } : SpanEditHandler.CreateDefault()))); } else { expected.Children.Add( classifier(Factory.Code(keyword)) .With((SpanEditHandler)( autoComplete ? new AutoCompleteEditHandler(CSharpLanguageCharacteristics.Instance.TokenizeString) { AutoCompleteString = expectedTerminator } : SpanEditHandler.CreateDefault()))); } ParseBlockTest(keyword, expected.Build(), new RazorError( String.Format(RazorResources.ParseError_BlockNotTerminated, keyword, expectedTerminator), SourceLocation.Zero)); }
protected virtual Block CreateSimpleBlockAndSpan(string spanContent, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters = AcceptedCharacters.Any) { SpanConstructor span = Factory.Span(spanType, spanContent, spanType == SpanKind.Markup).Accepts(acceptedCharacters); BlockBuilder b = new BlockBuilder() { Type = blockType }; return ConfigureAndAddSpanToBlock(b, span); }
public Block(BlockBuilder source) : this(source.Type, source.Children, source.CodeGenerator) { source.Reset(); }
private static Block RebuildChunkGenerators(Block block) { var builder = new BlockBuilder(block); var isDynamic = builder.ChunkGenerator is DynamicAttributeBlockChunkGenerator; // We don't want any attribute specific logic here, null out the block chunk generator. if (isDynamic || builder.ChunkGenerator is AttributeBlockChunkGenerator) { builder.ChunkGenerator = ParentChunkGenerator.Null; } for (var i = 0; i < builder.Children.Count; i++) { var child = builder.Children[i]; if (child.IsBlock) { // The child is a block, recurse down into the block to rebuild its children builder.Children[i] = RebuildChunkGenerators((Block)child); } else { var childSpan = (Span)child; ISpanChunkGenerator newChunkGenerator = null; var literalGenerator = childSpan.ChunkGenerator as LiteralAttributeChunkGenerator; if (literalGenerator != null) { if (literalGenerator.ValueGenerator == null || literalGenerator.ValueGenerator.Value == null) { newChunkGenerator = new MarkupChunkGenerator(); } else { newChunkGenerator = literalGenerator.ValueGenerator.Value; } } else if (isDynamic && childSpan.ChunkGenerator == SpanChunkGenerator.Null) { // Usually the dynamic chunk generator handles creating the null chunk generators underneath // it. This doesn't make sense in terms of tag helpers though, we need to change null code // generators to markup chunk generators. newChunkGenerator = new MarkupChunkGenerator(); } // If we have a new chunk generator we'll need to re-build the child if (newChunkGenerator != null) { var childSpanBuilder = new SpanBuilder(childSpan) { ChunkGenerator = newChunkGenerator }; builder.Children[i] = childSpanBuilder.Build(); } } } return builder.Build(); }
public void GetTagHelperDescriptors_ReturnsExpectedDirectiveDescriptors( CodeTree[] codeTrees, TagHelperDirectiveDescriptor[] expectedDirectiveDescriptors) { // Arrange var builder = new BlockBuilder { Type = BlockType.Comment }; var block = new Block(builder); IList<TagHelperDirectiveDescriptor> descriptors = null; var resolver = new Mock<ITagHelperDescriptorResolver>(); resolver.Setup(r => r.Resolve(It.IsAny<TagHelperDescriptorResolutionContext>())) .Callback((TagHelperDescriptorResolutionContext context) => { descriptors = context.DirectiveDescriptors; }) .Returns(Enumerable.Empty<TagHelperDescriptor>()) .Verifiable(); var baseParser = new RazorParser( new CSharpCodeParser(), new HtmlMarkupParser(), tagHelperDescriptorResolver: resolver.Object); var parser = new TestableMvcRazorParser(baseParser, codeTrees, defaultInheritedChunks: new Chunk[0]); // Act parser.GetTagHelperDescriptorsPublic(block, errorSink: new ErrorSink()).ToArray(); // Assert Assert.NotNull(descriptors); Assert.Equal(expectedDirectiveDescriptors.Length, descriptors.Count); for (var i = 0; i < expectedDirectiveDescriptors.Length; i++) { var expected = expectedDirectiveDescriptors[i]; var actual = descriptors[i]; Assert.Equal(expected.DirectiveText, actual.DirectiveText, StringComparer.Ordinal); Assert.Equal(SourceLocation.Zero, actual.Location); Assert.Equal(expected.DirectiveType, actual.DirectiveType); } }
protected virtual void SingleSpanBlockTest(string document, string spanContent, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters, params RazorError[] expectedErrors) { BlockBuilder builder = new BlockBuilder(); builder.Type = blockType; ParseBlockTest( document, ConfigureAndAddSpanToBlock( builder, Factory.Span(spanType, spanContent, spanType == SpanKind.Markup) .Accepts(acceptedCharacters)), expectedErrors ?? new RazorError[0]); }
private void UnterminatedBlockCore(string keyword, string expectedTerminator, BlockType blockType, bool keywordIsMetaCode, Func<UnclassifiedCodeSpanConstructor, SpanConstructor> classifier) { const string blockBody = @" ' This block is not correctly terminated!"; BlockBuilder expected = new BlockBuilder(); expected.Type = blockType; if (keywordIsMetaCode) { expected.Children.Add(Factory.MetaCode(keyword).Accepts(AcceptedCharacters.None)); expected.Children.Add(classifier(Factory.Code(blockBody))); } else { expected.Children.Add(classifier(Factory.Code(keyword + blockBody))); } ParseBlockTest(keyword + blockBody, expected.Build(), new RazorError( String.Format(RazorResources.ParseError_BlockNotTerminated, keyword, expectedTerminator), SourceLocation.Zero)); }
protected virtual Block ConfigureAndAddSpanToBlock(BlockBuilder block, SpanConstructor span) { switch (block.Type) { case BlockType.Markup: span.With(new MarkupCodeGenerator()); break; case BlockType.Statement: span.With(new StatementCodeGenerator()); break; case BlockType.Expression: block.CodeGenerator = new ExpressionCodeGenerator(); span.With(new ExpressionCodeGenerator()); break; } block.Children.Add(span); return block.Build(); }