public void AddSpanAddsSpanToCurrentBlockBuilder()
{
// Arrange
var factory = SpanFactory.CreateCsHtml();
var 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());
}
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();
}
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!)
var previous = parent.Children.LastOrDefault() as Span;
if (previous == null || !CanRewrite(previous))
{
return span;
}
// Merge spans
parent.Children.Remove(previous);
var merged = new SpanBuilder();
FillSpan(merged, previous.Start, previous.Content + span.Content);
return merged.Build();
}
public void VisitCallsOnCompleteWhenAllNodesHaveBeenVisited()
{
// Arrange
var 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 VisitSendsDocumentToVisitor()
{
// Arrange
var 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 VisitSendsErrorsToVisitor()
{
// Arrange
var targetMock = new Mock<ParserVisitor>();
var root = new BlockBuilder() { Type = BlockType.Comment }.Build();
var errorSink = new ErrorSink();
var 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 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();
}
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);
var firstChild = builder.Children[0] as Span;
if (firstChild != null && firstChild.Symbols[0] is HtmlSymbol)
{
var htmlSymbol = firstChild.Symbols[firstChild.Symbols.Count - 1] as HtmlSymbol;
switch (htmlSymbol.Type)
{
// Treat NoQuotes and DoubleQuotes equivalently. We purposefully do not persist NoQuotes
// ValueStyles at code generation time to protect users from rendering dynamic content with spaces
// that can break attributes.
// Ex: <tag my-attribute=@value /> where @value results in the test "hello world".
// This way, the above code would render <tag my-attribute="hello world" />.
case HtmlSymbolType.Equals:
case HtmlSymbolType.DoubleQuote:
result.AttributeValueStyle = HtmlAttributeValueStyle.DoubleQuotes;
break;
case HtmlSymbolType.SingleQuote:
result.AttributeValueStyle = HtmlAttributeValueStyle.SingleQuotes;
break;
default:
result.AttributeValueStyle = HtmlAttributeValueStyle.Minimized;
break;
}
}
// 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 TrackBlock(BlockBuilder builder)
{
_currentBlock = builder;
_blockStack.Push(builder);
}
private void BuildCurrentlyTrackedBlock()
{
// Going to remove the current BlockBuilder from the stack because it's complete.
var currentBlock = _blockStack.Pop();
// If there are block stacks left it means we're not at the root.
if (_blockStack.Count > 0)
{
// Grab the next block in line so we can continue managing its children (it's not done).
var previousBlock = _blockStack.Peek();
// We've finished the currentBlock so build it and add it to its parent.
previousBlock.Children.Add(currentBlock.Build());
// Update the _currentBlock to point at the last tracked block because it's not complete.
_currentBlock = previousBlock;
}
else
{
_currentBlock = currentBlock;
}
}
protected virtual Block CreateSimpleBlockAndSpan(string spanContent, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters = AcceptedCharacters.Any)
{
var span = Factory.Span(spanType, spanContent, spanType == SpanKind.Markup).Accepts(acceptedCharacters);
var b = new BlockBuilder()
{
Type = blockType
};
return ConfigureAndAddSpanToBlock(b, span);
}
public void GetTagHelperDescriptors_ReturnsExpectedDirectiveDescriptors(
ChunkTree[] chunkTrees,
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, chunkTrees, 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);
}
}
public Block(BlockBuilder source)
: this(source.Type, source.Children, source.ChunkGenerator)
{
source.Reset();
}
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 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();
}
protected virtual SyntaxTreeNode RewriteBlock(BlockBuilder parent, Block block)
{
throw new NotImplementedException();
}
protected virtual void SingleSpanBlockTest(string document, string spanContent, BlockType blockType, SpanKind spanType, AcceptedCharacters acceptedCharacters, params RazorError[] expectedErrors)
{
var builder = new BlockBuilder();
builder.Type = blockType;
ParseBlockTest(
document,
ConfigureAndAddSpanToBlock(
builder,
Factory.Span(spanType, spanContent, spanType == SpanKind.Markup)
.Accepts(acceptedCharacters)),
expectedErrors ?? new RazorError[0]);
}
protected virtual SyntaxTreeNode RewriteSpan(BlockBuilder parent, Span span)
{
throw new NotImplementedException();
}
protected virtual Block ConfigureAndAddSpanToBlock(BlockBuilder block, SpanConstructor span)
{
switch (block.Type)
{
case BlockType.Markup:
span.With(new MarkupChunkGenerator());
break;
case BlockType.Statement:
span.With(new StatementChunkGenerator());
break;
case BlockType.Expression:
block.ChunkGenerator = new ExpressionChunkGenerator();
span.With(new ExpressionChunkGenerator());
break;
}
block.Children.Add(span);
return block.Build();
}
public Block(BlockBuilder source)
: this(source.Type, source.Children, source.ChunkGenerator)
{
source.Reset();
}
