protected override SyntaxTreeNode RewriteSpan (BlockBuilder parent, Span span)
{
var b = new SpanBuilder (span);
var old = (LiteralAttributeCodeGenerator)span.CodeGenerator;
b.CodeGenerator = old.ValueGenerator != null
? new PreprocessedLiteralAttributeCodeGenerator (old.Prefix, old.ValueGenerator)
: new PreprocessedLiteralAttributeCodeGenerator (old.Prefix, old.Value);
return b.Build ();
}
protected override SyntaxTreeNode RewriteBlock(BlockBuilder parent, Block block)
{
// Collect the content of this node
string content = String.Concat(block.Children.Cast<Span>().Select(s => s.Content));
// Create a new span containing this content
SpanBuilder span = new SpanBuilder();
FillSpan(span, block.Children.Cast<Span>().First().Start, content);
return span.Build();
}
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 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();
}
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());
}
