/// <summary>
/// Initializes a new instance of <see cref="MvcRazorParser"/>.
/// </summary>
/// <param name="parser">The <see cref="RazorParser"/> to copy properties from.</param>
/// <param name="inheritedChunkTrees">The <see cref="IReadOnlyList{ChunkTree}"/>s that are inherited
/// from parsed pages from _ViewImports files.</param>
/// <param name="defaultInheritedChunks">The <see cref="IReadOnlyList{Chunk}"/> inherited by
/// default by all Razor pages in the application.</param>
/// <param name="modelExpressionTypeName">The full name of the model expression <see cref="Type"/>.</param>
public MvcRazorParser(
RazorParser parser,
IReadOnlyList<ChunkTree> inheritedChunkTrees,
IReadOnlyList<Chunk> defaultInheritedChunks,
string modelExpressionTypeName)
: base(parser)
{
if (parser == null)
{
throw new ArgumentNullException(nameof(parser));
}
if (inheritedChunkTrees == null)
{
throw new ArgumentNullException(nameof(inheritedChunkTrees));
}
if (defaultInheritedChunks == null)
{
throw new ArgumentNullException(nameof(defaultInheritedChunks));
}
if (modelExpressionTypeName == null)
{
throw new ArgumentNullException(nameof(modelExpressionTypeName));
}
// Construct tag helper descriptors from @addTagHelper, @removeTagHelper and @tagHelperPrefix chunks
_viewImportsDirectiveDescriptors = GetTagHelperDirectiveDescriptors(
inheritedChunkTrees,
defaultInheritedChunks);
_modelExpressionTypeName = modelExpressionTypeName;
}
public void DecorateRazorParser_DesignTimeRazorPathNormalizer_NormalizesChunkInheritanceUtilityPaths(
string rootPrefix)
{
// Arrange
var rootedAppPath = $"{rootPrefix}SomeComputer/Location/Project/";
var rootedFilePath = $"{rootPrefix}SomeComputer/Location/Project/src/file.cshtml";
var chunkTreeCache = new DefaultChunkTreeCache(new TestFileProvider());
using (var host = new MvcRazorHost(
chunkTreeCache,
pathNormalizer: new DesignTimeRazorPathNormalizer(rootedAppPath)))
{
var parser = new RazorParser(
host.CodeLanguage.CreateCodeParser(),
host.CreateMarkupParser(),
tagHelperDescriptorResolver: null);
var chunkInheritanceUtility = new PathValidatingChunkInheritanceUtility(host, chunkTreeCache);
host.ChunkInheritanceUtility = chunkInheritanceUtility;
// Act
host.DecorateRazorParser(parser, rootedFilePath);
// Assert
Assert.Equal("src/file.cshtml", chunkInheritanceUtility.InheritedChunkTreePagePath, StringComparer.Ordinal);
}
}
/// <summary>
/// Initializes a new instance of <see cref="RazorParser"/> from the specified <paramref name="parser" />.
/// </summary>
/// <param name="parser">The <see cref="RazorParser"/> to copy values from.</param>
public RazorParser(RazorParser parser)
: this(parser.CodeParser, parser.MarkupParser, parser.TagHelperDescriptorResolver, parser.Optimizers)
{
if (parser == null)
{
throw new ArgumentNullException(nameof(parser));
}
DesignTimeMode = parser.DesignTimeMode;
}
public void ParseMethodCallsParseDocumentOnMarkupParserAndReturnsResults()
{
var factory = SpanFactory.CreateCsHtml();
// Arrange
var parser = new RazorParser(new CSharpCodeParser(),
new HtmlMarkupParser(),
tagHelperDescriptorResolver: null);
// Act/Assert
ParserTestBase.EvaluateResults(parser.Parse(new StringReader("foo @bar baz")),
new MarkupBlock(
factory.Markup("foo "),
new ExpressionBlock(
factory.CodeTransition(),
factory.Code("bar")
.AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
.Accepts(AcceptedCharacters.NonWhiteSpace)),
factory.Markup(" baz")));
}
public static RazorSyntaxTree Parse(RazorSourceDocument document)
{
if (document == null)
{
throw new ArgumentException(nameof(document));
}
var codeParser = new PageCodeParser();
var markupParser = new HtmlMarkupParser();
var parser = new OldParser.RazorParser(codeParser, markupParser, new NullTagHelperDescriptorResolver());
ParserResults result;
using (var reader = document.CreateReader())
{
result = parser.Parse(reader);
}
return(RazorSyntaxTree.Create(result.Document, result.ParserErrors));
}
public void ParseMethodUsesProvidedParserListenerIfSpecified()
{
var factory = SpanFactory.CreateCsHtml();
// Arrange
var parser = new RazorParser(new CSharpCodeParser(),
new HtmlMarkupParser(),
tagHelperDescriptorResolver: null);
// Act
var results = parser.Parse(new StringReader("foo @bar baz"));
// Assert
ParserTestBase.EvaluateResults(results,
new MarkupBlock(
factory.Markup("foo "),
new ExpressionBlock(
factory.CodeTransition(),
factory.Code("bar")
.AsImplicitExpression(CSharpCodeParser.DefaultKeywords)
.Accepts(AcceptedCharacters.NonWhiteSpace)),
factory.Markup(" baz")));
}
protected internal virtual RazorParser CreateParser(string sourceFileName)
{
var codeParser = Host.CodeLanguage.CreateCodeParser();
var markupParser = Host.CreateMarkupParser();
var parser = new RazorParser(
Host.DecorateCodeParser(codeParser),
Host.DecorateMarkupParser(markupParser),
Host.TagHelperDescriptorResolver)
{
DesignTimeMode = Host.DesignTimeMode
};
return Host.DecorateRazorParser(parser, sourceFileName);
}
private static void RunParseWithListenerTest(Action<RazorParser, TextReader> parserAction)
{
// Arrange
var markupParser = new MockMarkupParser();
var codeParser = new CSharpCodeParser();
var parser = new RazorParser(codeParser, markupParser, tagHelperDescriptorResolver: null);
var expectedReader = new StringReader("foo");
// Act
parserAction(parser, expectedReader);
// Assert
var actualContext = markupParser.Context;
Assert.NotNull(actualContext);
Assert.Same(markupParser, actualContext.MarkupParser);
Assert.Same(markupParser, actualContext.ActiveParser);
Assert.Same(codeParser, actualContext.CodeParser);
}
public TestableMvcRazorParser(
RazorParser parser,
IReadOnlyList<ChunkTree> chunkTrees,
IReadOnlyList<Chunk> defaultInheritedChunks)
: base(parser, chunkTrees, defaultInheritedChunks, typeof(ModelExpression).FullName)
{
}
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);
}
}
/// <summary>
/// Provides an opportunity for derived types to modify the instance of <see cref="RazorParser"/>
/// used by the <see cref="RazorTemplateEngine"/> to parse the Razor tree.
/// </summary>
/// <param name="incomingRazorParser">The <see cref="RazorParser"/></param>
/// <param name="sourceFileName">The file name of the Razor file being parsed.</param>
/// <returns>Either the same code parser, after modifications, or a different code parser.</returns>
public virtual RazorParser DecorateRazorParser(
RazorParser incomingRazorParser,
string sourceFileName)
{
if (incomingRazorParser == null)
{
throw new ArgumentNullException(nameof(incomingRazorParser));
}
return incomingRazorParser;
}
private static Span[] GenerateSpans(string text, SpanKind spanKind, int spanIndex, string spanText)
{
Assert.True(spanIndex > 0);
var parser = new RazorParser(new CSharpCodeParser(),
new HtmlMarkupParser(),
tagHelperDescriptorResolver: null);
Span[] spans;
using (var reader = new StringReader(text))
{
var results = parser.Parse(reader);
spans = results.Document.Flatten().ToArray();
}
Assert.True(spans.Length > spanIndex);
Assert.Equal(spanKind, spans[spanIndex].Kind);
Assert.Equal(spanText, spans[spanIndex].Content);
return spans;
}
/// <inheritdoc />
public override RazorParser DecorateRazorParser(RazorParser razorParser, string sourceFileName)
{
if (razorParser == null)
{
throw new ArgumentNullException(nameof(razorParser));
}
var inheritedChunkTrees = GetInheritedChunkTrees(sourceFileName);
return new MvcRazorParser(razorParser, inheritedChunkTrees, DefaultInheritedChunks, ModelExpressionType);
}