private static Lazy <RazorCodeDocumentProvider> CreateCodeDocumentProvider(string text, IEnumerable <DirectiveDescriptor> directives)
{
var codeDocumentProvider = new Mock <RazorCodeDocumentProvider>();
var codeDocument = TestRazorCodeDocument.CreateEmpty();
var sourceDocument = TestRazorSourceDocument.Create(text);
var options = RazorParserOptions.Create(builder =>
{
foreach (var directive in directives)
{
builder.Directives.Add(directive);
}
});
var syntaxTree = RazorSyntaxTree.Parse(sourceDocument, options);
codeDocument.SetSyntaxTree(syntaxTree);
codeDocumentProvider.Setup(provider => provider.TryGetFromDocument(It.IsAny <TextDocument>(), out codeDocument))
.Returns(true);
return(new Lazy <RazorCodeDocumentProvider>(() => codeDocumentProvider.Object));
}
public IActionResult ParseIR([FromBody] Source source)
{
var document = RazorSourceDocument.Create(source.Content, fileName: null);
var options = RazorParserOptions.Create(builder => {
foreach (var directive in GetDirectives())
{
builder.Directives.Add(directive);
}
});
var sourceDocument = CreateSourceDocument(source.Content);
var engine = RazorProjectEngine.Create();
var codeDocument = engine.Process(sourceDocument, null, null);
var irDocument = codeDocument.GetDocumentIntermediateNode();
var output = SerializeIR(irDocument);
//output = NormalizeNewLines(output, replaceWith: "LF");
return(Json(output));
}
public ParserContext(RazorSourceDocument source, RazorParserOptions options)
{
if (source == null)
{
throw new ArgumentNullException(nameof(source));
}
SourceDocument = source;
var chars = new char[source.Length];
source.CopyTo(0, chars, 0, source.Length);
Source = new SeekableTextReader(chars, source.FilePath);
DesignTimeMode = options.DesignTime;
FeatureFlags = options.FeatureFlags;
ParseLeadingDirectives = options.ParseLeadingDirectives;
Builder = new SyntaxTreeBuilder();
ErrorSink = new ErrorSink();
SeenDirectives = new HashSet <string>(StringComparer.Ordinal);
}
public void ValidateTagHelperPrefix_ValidatesPrefix(
string directiveText,
SourceLocation directiveLocation,
object expectedErrors)
{
// Arrange
var expectedDiagnostics = (IEnumerable <RazorDiagnostic>)expectedErrors;
var source = TestRazorSourceDocument.Create();
var options = RazorParserOptions.CreateDefault();
var context = new ParserContext(source, options);
var parser = new CSharpCodeParser(context);
var diagnostics = new List <RazorDiagnostic>();
// Act
parser.ValidateTagHelperPrefix(directiveText, directiveLocation, diagnostics);
// Assert
Assert.Equal(expectedDiagnostics, diagnostics);
}
public IActionResult NewParse([FromBody] Source source)
{
var document = RazorSourceDocument.Create(source.Content, fileName: null);
var options = RazorParserOptions.Create(builder => {
foreach (var directive in GetDirectives())
{
builder.Directives.Add(directive);
}
});
var context = new ParserContext(document, options);
var codeParser = new CSharpCodeParser(GetDirectives(), context);
var markupParser = new HtmlMarkupParser(context);
codeParser.HtmlParser = markupParser;
markupParser.CodeParser = codeParser;
var root = markupParser.ParseDocument().CreateRed();
var result = NewTreeSerializer.Serialize(root);
return(Content(result));
}
private static RazorCodeActionContext CreateRazorCodeActionContext(CodeActionParams request, SourceLocation location, string filePath, string text)
{
var codeDocument = TestRazorCodeDocument.CreateEmpty();
codeDocument.SetFileKind(FileKinds.Component);
var sourceDocument = TestRazorSourceDocument.Create(text, filePath: filePath, relativePath: filePath);
var options = RazorParserOptions.Create(o =>
{
o.Directives.Add(ComponentCodeDirective.Directive);
o.Directives.Add(FunctionsDirective.Directive);
});
var syntaxTree = RazorSyntaxTree.Parse(sourceDocument, options);
codeDocument.SetSyntaxTree(syntaxTree);
var documentSnapshot = Mock.Of <DocumentSnapshot>(document =>
document.GetGeneratedOutputAsync() == Task.FromResult(codeDocument) &&
document.GetTextAsync() == Task.FromResult(codeDocument.GetSourceText()));
return(new RazorCodeActionContext(request, documentSnapshot, codeDocument, location));
}
public void Execute_AutomaticallyOverridesImportedSingleLineSinglyOccurringDirective_MultipleImports()
{
// Arrange
var directive = DirectiveDescriptor.CreateSingleLineDirective(
"custom",
builder =>
{
builder.AddStringToken();
builder.Usage = DirectiveUsage.FileScopedSinglyOccurring;
});
var phase = new DefaultRazorIntermediateNodeLoweringPhase();
var engine = RazorProjectEngine.CreateEmpty(b =>
{
b.Phases.Add(phase);
b.Features.Add(new DefaultRazorCodeGenerationOptionsFeature(designTime: false));
b.AddDirective(directive);
});
var options = RazorParserOptions.Create(builder => builder.Directives.Add(directive));
var importSource1 = TestRazorSourceDocument.Create("@custom \"hello\"", filePath: "import1.cshtml");
var importSource2 = TestRazorSourceDocument.Create("@custom \"world\"", filePath: "import2.cshtml");
var codeDocument = TestRazorCodeDocument.Create("<p>NonDirective</p>");
codeDocument.SetSyntaxTree(RazorSyntaxTree.Parse(codeDocument.Source, options));
codeDocument.SetImportSyntaxTrees(new[] { RazorSyntaxTree.Parse(importSource1, options), RazorSyntaxTree.Parse(importSource2, options) });
// Act
phase.Execute(codeDocument);
// Assert
var documentNode = codeDocument.GetDocumentIntermediateNode();
var customDirectives = documentNode.FindDirectiveReferences(directive);
var customDirective = (DirectiveIntermediateNode)Assert.Single(customDirectives).Node;
var stringToken = Assert.Single(customDirective.Tokens);
Assert.Equal("\"world\"", stringToken.Content);
}
public void Execute_DoesNotImportNonFileScopedSinglyOccurringDirectives_Block()
{
// Arrange
var codeBlockDirective = DirectiveDescriptor.CreateCodeBlockDirective("code", b => b.AddStringToken());
var razorBlockDirective = DirectiveDescriptor.CreateRazorBlockDirective("razor", b => b.AddStringToken());
var phase = new DefaultRazorIntermediateNodeLoweringPhase();
var engine = RazorProjectEngine.CreateEmpty(b =>
{
b.Phases.Add(phase);
b.Features.Add(new DefaultRazorCodeGenerationOptionsFeature(designTime: false));
b.AddDirective(codeBlockDirective);
b.AddDirective(razorBlockDirective);
});
var options = RazorParserOptions.Create(builder =>
{
builder.Directives.Add(codeBlockDirective);
builder.Directives.Add(razorBlockDirective);
});
var importSource = TestRazorSourceDocument.Create(
@"@code ""code block"" { }
@razor ""razor block"" { }",
filePath: "testImports.cshtml");
var codeDocument = TestRazorCodeDocument.Create("<p>NonDirective</p>");
codeDocument.SetSyntaxTree(RazorSyntaxTree.Parse(codeDocument.Source, options));
codeDocument.SetImportSyntaxTrees(new[] { RazorSyntaxTree.Parse(importSource, options) });
// Act
phase.Execute(codeDocument);
// Assert
var documentNode = codeDocument.GetDocumentIntermediateNode();
var directives = documentNode.Children.OfType <DirectiveIntermediateNode>();
Assert.Empty(directives);
}
public RazorParser()
: this(RazorParserOptions.CreateDefault())
{
}
