public override void VisitBlock(Block block) { if (CanRewrite(block)) { SyntaxTreeNode newNode = RewriteBlock(_blocks.Peek(), block); if (newNode != null) { _blocks.Peek().Children.Add(newNode); } } else { // Not rewritable. BlockBuilder 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) { var b = new BlockBuilder (block); var abGen = block.CodeGenerator as AttributeBlockCodeGenerator; if (abGen != null) { b.CodeGenerator = new PreprocessedAttributeBlockCodeGenerator (abGen); } else { b.CodeGenerator = new PreprocessedDynamicAttributeBlockCodeGenerator ((DynamicAttributeBlockCodeGenerator)b.CodeGenerator); } return b.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 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 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 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 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) { BlockBuilder newBlock = new BlockBuilder(block); newBlock.Children.Clear(); Span ws = block.Children.FirstOrDefault() as Span; IEnumerable<SyntaxTreeNode> newNodes = block.Children; if (ws.Content.All(Char.IsWhiteSpace)) { // Add this node to the parent SpanBuilder 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(); }
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)); }
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(); }
public void AddSpanAddsSpanToCurrentBlockBuilder() { // Arrange var factory = SpanFactory.CreateCsHtml(); Mock<ParserVisitor> mockListener = new Mock<ParserVisitor>(); ParserContext context = SetupTestContext("phoo"); SpanBuilder builder = new SpanBuilder() { Kind = SpanKind.Code }; builder.Accept(new CSharpSymbol(1, 0, 1, "foo", CSharpSymbolType.Identifier)); Span added = builder.Build(); using (context.StartBlock(BlockType.Functions)) { context.AddSpan(added); } BlockBuilder expected = new BlockBuilder() { Type = BlockType.Functions, }; expected.Children.Add(added); // Assert ParserTestBase.EvaluateResults(context.CompleteParse(), expected.Build()); }