internal virtual RazorSyntaxTree ParseDocument(RazorLanguageVersion version, string document, IEnumerable <DirectiveDescriptor> directives, bool designTime = false, RazorParserFeatureFlags featureFlags = null, string fileKind = null) { directives ??= Array.Empty <DirectiveDescriptor>(); var source = TestRazorSourceDocument.Create(document, filePath: null, relativePath: null, normalizeNewLines: true); var options = CreateParserOptions(version, directives, designTime, featureFlags, fileKind); var context = new ParserContext(source, options); var codeParser = new CSharpCodeParser(directives, context); var markupParser = new HtmlMarkupParser(context); codeParser.HtmlParser = markupParser; markupParser.CodeParser = codeParser; var root = markupParser.ParseDocument().CreateRed(); var diagnostics = context.ErrorSink.Errors; var codeDocument = RazorCodeDocument.Create(source); var syntaxTree = RazorSyntaxTree.Create(root, source, diagnostics, options); codeDocument.SetSyntaxTree(syntaxTree); var defaultDirectivePass = new DefaultDirectiveSyntaxTreePass(); syntaxTree = defaultDirectivePass.Execute(codeDocument, syntaxTree); return(syntaxTree); }
internal virtual RazorSyntaxTree ParseDocument(string document, IEnumerable <DirectiveDescriptor> directives, bool designTime = false) { directives = directives ?? Array.Empty <DirectiveDescriptor>(); var source = TestRazorSourceDocument.Create(document, fileName: null); var options = CreateParserOptions(directives, designTime); var context = new ParserContext(source, options); var codeParser = new CSharpCodeParser(directives, context); var markupParser = new HtmlMarkupParser(context); codeParser.HtmlParser = markupParser; markupParser.CodeParser = codeParser; markupParser.ParseDocument(); var root = context.Builder.Build(); var diagnostics = context.ErrorSink.Errors?.Select(error => RazorDiagnostic.Create(error)); var codeDocument = RazorCodeDocument.Create(source); var syntaxTree = RazorSyntaxTree.Create(root, source, diagnostics, options); codeDocument.SetSyntaxTree(syntaxTree); var defaultDirectivePass = new DefaultDirectiveSyntaxTreePass(); syntaxTree = defaultDirectivePass.Execute(codeDocument, syntaxTree); return(syntaxTree); }
internal virtual RazorSyntaxTree ParseCodeBlock( RazorLanguageVersion version, string document, IEnumerable <DirectiveDescriptor> directives, bool designTime) { directives = directives ?? Array.Empty <DirectiveDescriptor>(); var source = TestRazorSourceDocument.Create(document, filePath: null, relativePath: null, normalizeNewLines: true); var options = CreateParserOptions(version, directives, designTime); var context = new ParserContext(source, options); var codeParser = new CSharpCodeParser(directives, context); var markupParser = new HtmlMarkupParser(context); codeParser.HtmlParser = markupParser; markupParser.CodeParser = codeParser; var root = codeParser.ParseBlock().CreateRed(); var diagnostics = context.ErrorSink.Errors; var syntaxTree = RazorSyntaxTree.Create(root, source, diagnostics, options); return(syntaxTree); }
public virtual RazorSyntaxTree Parse(RazorSourceDocument source) { if (source == null) { throw new ArgumentNullException(nameof(source)); } var context = new ParserContext(source, Options); var codeParser = new CSharpCodeParser(Options.Directives, context); var markupParser = new HtmlMarkupParser(context); codeParser.HtmlParser = markupParser; markupParser.CodeParser = codeParser; var diagnostics = context.ErrorSink.Errors; var root = markupParser.ParseDocument().CreateRed(); return(RazorSyntaxTree.Create(root, source, diagnostics, Options)); }
internal virtual RazorSyntaxTree ParseHtmlBlock(string document, IEnumerable <DirectiveDescriptor> directives, bool designTime = false) { directives = directives ?? Array.Empty <DirectiveDescriptor>(); var source = TestRazorSourceDocument.Create(document, fileName: null); var options = CreateParserOptions(directives, designTime); var context = new ParserContext(source, options); var parser = new HtmlMarkupParser(context); parser.CodeParser = new CSharpCodeParser(directives, context) { HtmlParser = parser, }; parser.ParseBlock(); var root = context.Builder.Build(); var diagnostics = context.ErrorSink.Errors?.Select(error => RazorDiagnostic.Create(error)); return(RazorSyntaxTree.Create(root, source, diagnostics, options)); }
public virtual RazorSyntaxTree Parse(RazorSourceDocument source) { if (source == null) { throw new ArgumentNullException(nameof(source)); } var context = new ParserContext(source, Options); var codeParser = new CSharpCodeParser(Options.Directives, context); var markupParser = new HtmlMarkupParser(context); codeParser.HtmlParser = markupParser; markupParser.CodeParser = codeParser; markupParser.ParseDocument(); var root = context.Builder.Build(); // Temporary code while we're still using legacy diagnostics in the SyntaxTree. var diagnostics = context.ErrorSink.Errors.Select(error => RazorDiagnostic.Create(error)); return(RazorSyntaxTree.Create(root, source, diagnostics, Options)); }
private static TryParseResult TryParseBlock( string tagName, Block block, IEnumerable <TagHelperDescriptor> descriptors, ErrorSink errorSink, HashSet <string> processedBoundAttributeNames) { // 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 != SpanKindInternal.Markup) { errorSink.OnError( block.Start, LegacyResources.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, processedBoundAttributeNames)); } 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, LegacyResources.FormatTagHelpers_AttributesMustHaveAName(tagName), childSpan.Length); return(null); } // Have a name now. Able to determine correct isBoundNonStringAttribute value. var result = CreateTryParseResult(name, descriptors, processedBoundAttributeNames); 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) { case HtmlSymbolType.Equals: if (builder.Children.Count == 2 && builder.Children[1] is Span value && value.Kind == SpanKindInternal.Markup) { // Attribute value is a string literal. Eg: <tag my-attribute=foo />. result.AttributeStructure = AttributeStructure.NoQuotes; } else { // Could be an expression, 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" />. result.AttributeStructure = AttributeStructure.DoubleQuotes; } break;
// This method handles cases when the attribute is a simple span attribute such as // class="something moresomething". This does not handle complex attributes such as // class="@myclass". Therefore the span.Content is equivalent to the entire attribute. private static TryParseResult TryParseSpan( Span span, IEnumerable <TagHelperDescriptor> descriptors, ErrorSink errorSink, HashSet <string> processedBoundAttributeNames) { var afterEquals = false; var builder = new SpanBuilder(span.Start) { ChunkGenerator = span.ChunkGenerator, EditHandler = span.EditHandler, Kind = span.Kind }; // Will contain symbols that represent a single attribute value: <input| class="btn"| /> var htmlSymbols = span.Symbols.OfType <HtmlSymbol>().ToArray(); var capturedAttributeValueStart = false; var attributeValueStartLocation = span.Start; // Default to DoubleQuotes. We purposefully do not persist NoQuotes ValueStyle to stay consistent with the // TryParseBlock() variation of attribute parsing. var attributeValueStyle = AttributeStructure.DoubleQuotes; // The symbolOffset is initialized to 0 to expect worst case: "class=". If a quote is found later on for // the attribute value the symbolOffset is adjusted accordingly. var symbolOffset = 0; string name = null; // Iterate down through the symbols to find the name and the start of the value. // We subtract the symbolOffset so we don't accept an ending quote of a span. for (var i = 0; i < htmlSymbols.Length - symbolOffset; i++) { var symbol = htmlSymbols[i]; if (afterEquals) { // We've captured all leading whitespace, the attribute name, and an equals with an optional // quote/double quote. We're now at: " asp-for='|...'" or " asp-for=|..." // The goal here is to capture all symbols until the end of the attribute. Note this will not // consume an ending quote due to the symbolOffset. // When symbols are accepted into SpanBuilders, their locations get altered to be offset by the // parent which is why we need to mark our start location prior to adding the symbol. // This is needed to know the location of the attribute value start within the document. if (!capturedAttributeValueStart) { capturedAttributeValueStart = true; attributeValueStartLocation = symbol.Start; } builder.Accept(symbol); } else if (name == null && HtmlMarkupParser.IsValidAttributeNameSymbol(symbol)) { // We've captured all leading whitespace prior to the attribute name. // We're now at: " |asp-for='...'" or " |asp-for=..." // The goal here is to capture the attribute name. var nameBuilder = new StringBuilder(); // Move the indexer past the attribute name symbols. for (var j = i; j < htmlSymbols.Length; j++) { var nameSymbol = htmlSymbols[j]; if (!HtmlMarkupParser.IsValidAttributeNameSymbol(nameSymbol)) { break; } nameBuilder.Append(nameSymbol.Content); i++; } i--; name = nameBuilder.ToString(); attributeValueStartLocation = SourceLocationTracker.Advance(attributeValueStartLocation, name); } else if (symbol.Type == HtmlSymbolType.Equals) { // We've captured all leading whitespace and the attribute name. // We're now at: " asp-for|='...'" or " asp-for|=..." // The goal here is to consume the equal sign and the optional single/double-quote. // The coming symbols will either be a quote or value (in the case that the value is unquoted). SourceLocation symbolStartLocation; // Skip the whitespace preceding the start of the attribute value. do { i++; // Start from the symbol after '='. } while (i < htmlSymbols.Length && (htmlSymbols[i].Type == HtmlSymbolType.WhiteSpace || htmlSymbols[i].Type == HtmlSymbolType.NewLine)); // Check for attribute start values, aka single or double quote if (i < htmlSymbols.Length && IsQuote(htmlSymbols[i])) { if (htmlSymbols[i].Type == HtmlSymbolType.SingleQuote) { attributeValueStyle = AttributeStructure.SingleQuotes; } symbolStartLocation = htmlSymbols[i].Start; // If there's a start quote then there must be an end quote to be valid, skip it. symbolOffset = 1; } else { // We are at the symbol after equals. Go back to equals to ensure we don't skip past that symbol. i--; symbolStartLocation = symbol.Start; } attributeValueStartLocation = new SourceLocation( symbolStartLocation.FilePath, symbolStartLocation.AbsoluteIndex + 1, symbolStartLocation.LineIndex, symbolStartLocation.CharacterIndex + 1); afterEquals = true; } else if (symbol.Type == HtmlSymbolType.WhiteSpace) { // We're at the start of the attribute, this branch may be hit on the first iterations of // the loop since the parser separates attributes with their spaces included as symbols. // We're at: "| asp-for='...'" or "| asp-for=..." // Note: This will not be hit even for situations like asp-for ="..." because the core Razor // parser currently does not know how to handle attributes in that format. This will be addressed // by https://github.com/aspnet/Razor/issues/123. attributeValueStartLocation = SourceLocationTracker.Advance(attributeValueStartLocation, symbol.Content); } } // After all symbols have been added we need to set the builders start position so we do not indirectly // modify the span's start location. builder.Start = attributeValueStartLocation; if (name == null) { // We couldn't find a name, if the original span content was whitespace it ultimately means the tag // that owns this "attribute" is malformed and is expecting a user to type a new attribute. // ex: <myTH class="btn"| | if (!string.IsNullOrWhiteSpace(span.Content)) { errorSink.OnError( span.Start, LegacyResources.TagHelperBlockRewriter_TagHelperAttributeListMustBeWellFormed, span.Content.Length); } return(null); } var result = CreateTryParseResult(name, descriptors, processedBoundAttributeNames); // If we're not after an equal then we should treat the value as if it were a minimized attribute. Span attributeValue = null; if (afterEquals) { attributeValue = CreateMarkupAttribute(builder, result); } else { attributeValueStyle = AttributeStructure.Minimized; } result.AttributeValueNode = attributeValue; result.AttributeStructure = attributeValueStyle; return(result); }