public override void VisitBlock(Block block)
{
if (CanRewrite(block))
{
var newNode = RewriteBlock(Parent, block);
if (newNode != null)
{
Parent.Children.Add(newNode);
}
}
else
{
// Not rewritable.
var builder = new BlockBuilder(block);
builder.Children.Clear();
_blocks.Push(builder);
base.VisitBlock(block);
Debug.Assert(ReferenceEquals(builder, Parent));
if (_blocks.Count > 1)
{
_blocks.Pop();
Parent.Children.Add(builder.Build());
}
}
}
public void ReplaceWith_NotifiesParentChildHasChanged()
{
// Arrange
var spanBuilder = new SpanBuilder(SourceLocation.Zero);
spanBuilder.Accept(SyntaxFactory.Token(SyntaxKind.HtmlTextLiteral, "hello"));
var span = spanBuilder.Build();
var blockBuilder = new BlockBuilder()
{
Type = BlockKindInternal.Markup,
};
blockBuilder.Children.Add(span);
var block = blockBuilder.Build();
span.Parent = block;
var originalBlockLength = block.Length;
var newSpanBuilder = new SpanBuilder(SourceLocation.Zero);
newSpanBuilder.Accept(SyntaxFactory.Token(SyntaxKind.HtmlTextLiteral, "hi"));
// Act
span.ReplaceWith(newSpanBuilder);
// Assert
Assert.Equal(5, originalBlockLength);
Assert.Equal(2, block.Length);
}
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 override SyntaxTreeNode Clone()
{
var blockBuilder = new BlockBuilder(this);
blockBuilder.Children.Clear();
for (var i = 0; i < Children.Count; i++)
{
var clonedChild = Children[i].Clone();
blockBuilder.Children.Add(clonedChild);
}
return(blockBuilder.Build());
}
public void ConstructorTransfersInstanceOfChunkGeneratorFromBlockBuilder()
{
// Arrange
var expected = new ExpressionChunkGenerator();
var builder = new BlockBuilder()
{
Type = BlockKindInternal.Statement,
ChunkGenerator = expected
};
// Act
var actual = builder.Build();
// Assert
Assert.Same(expected, actual.ChunkGenerator);
}
public void Clone_ClonesBlock()
{
// Arrange
var blockBuilder = new BlockBuilder()
{
ChunkGenerator = new DynamicAttributeBlockChunkGenerator(new LocationTagged <string>("class=\"", SourceLocation.Zero), 0, 0, 0),
Type = BlockKindInternal.Expression,
};
blockBuilder.Children.Add(new SpanBuilder(new SourceLocation(1, 2, 3)).Build());
var block = blockBuilder.Build();
// Act
var copy = (Block)block.Clone();
// Assert
ParserTestBase.EvaluateParseTree(copy, block);
Assert.NotSame(block, copy);
}
public void ConstructorTransfersChildrenFromBlockBuilder()
{
// Arrange
var expected = new SpanBuilder(SourceLocation.Undefined)
{
Kind = SpanKindInternal.Code
}.Build();
var builder = new BlockBuilder()
{
Type = BlockKindInternal.Statement
};
builder.Children.Add(expected);
// Act
var block = builder.Build();
// Assert
Assert.Same(expected, block.Children.Single());
}
public void ConstructorWithBlockBuilderSetsParent()
{
// Arrange
var builder = new BlockBuilder()
{
Type = BlockKindInternal.Comment
};
var span = new SpanBuilder(SourceLocation.Undefined)
{
Kind = SpanKindInternal.Code
}.Build();
builder.Children.Add(span);
// Act
var block = builder.Build();
// Assert
Assert.Same(block, span.Parent);
}
internal virtual Block ConfigureAndAddSpanToBlock(BlockBuilder block, SpanConstructor span)
{
switch (block.Type)
{
case BlockKindInternal.Markup:
span.With(new MarkupChunkGenerator());
break;
case BlockKindInternal.Statement:
span.With(new StatementChunkGenerator());
break;
case BlockKindInternal.Expression:
block.ChunkGenerator = new ExpressionChunkGenerator();
span.With(new ExpressionChunkGenerator());
break;
}
block.Children.Add(span);
return(block.Build());
}
public void ChildChanged_NotifiesParent()
{
// Arrange
var spanBuilder = new SpanBuilder(SourceLocation.Zero);
spanBuilder.Accept(new HtmlSymbol("hello", HtmlSymbolType.Text));
var span = spanBuilder.Build();
var blockBuilder = new BlockBuilder()
{
Type = BlockKindInternal.Markup,
};
blockBuilder.Children.Add(span);
var childBlock = blockBuilder.Build();
blockBuilder = new BlockBuilder()
{
Type = BlockKindInternal.Markup,
};
blockBuilder.Children.Add(childBlock);
var parentBlock = blockBuilder.Build();
var originalBlockLength = parentBlock.Length;
spanBuilder = new SpanBuilder(SourceLocation.Zero);
spanBuilder.Accept(new HtmlSymbol("hi", HtmlSymbolType.Text));
span.ReplaceWith(spanBuilder);
// Wire up parents now so we can re-trigger ChildChanged to cause cache refresh.
span.Parent = childBlock;
childBlock.Parent = parentBlock;
// Act
childBlock.ChildChanged();
// Assert
Assert.Equal(5, originalBlockLength);
Assert.Equal(2, parentBlock.Length);
}
