public void DocumentProcessed_DoesNothingIfAlreadySynchronized()
{
// Arrange
var router = new TestRouter();
var documentVersion = VersionStamp.Default.GetNewerVersion();
var document = TestDocumentSnapshot.Create("C:/path/file.cshtml", documentVersion);
var cache = new TestDocumentVersionCache(new Dictionary <DocumentSnapshot, long>()
{
[document] = 1337,
});
var csharpDocument = RazorCSharpDocument.Create("Anything", RazorCodeGenerationOptions.CreateDefault(), Enumerable.Empty <RazorDiagnostic>());
// Force the state to already be up-to-date
document.State.HostDocument.GeneratedCodeContainer.SetOutput(document, csharpDocument, documentVersion.GetNewerVersion(), VersionStamp.Default);
var listener = new UnsynchronizableContentDocumentProcessedListener(Dispatcher, cache, router);
listener.Initialize(ProjectSnapshotManager);
// Act
listener.DocumentProcessed(document);
// Assert
Assert.Empty(router.SynchronizedDocuments);
}
public void DocumentProcessed_SynchronizesIfSourceVersionsAreIdenticalButSyncVersionNewer()
{
// Arrange
var router = new TestRouter();
var lastVersion = VersionStamp.Default.GetNewerVersion();
var lastDocument = TestDocumentSnapshot.Create("C:/path/old.cshtml", lastVersion);
var document = TestDocumentSnapshot.Create("C:/path/file.cshtml", lastVersion);
var cache = new TestDocumentVersionCache(new Dictionary <DocumentSnapshot, long>()
{
[document] = 1338,
[lastDocument] = 1337,
});
var csharpDocument = RazorCSharpDocument.Create("Anything", RazorCodeGenerationOptions.CreateDefault(), Enumerable.Empty <RazorDiagnostic>());
// Force the state to already be up-to-date
document.State.HostDocument.GeneratedCodeContainer.SetOutput(lastDocument, csharpDocument, lastVersion, VersionStamp.Default);
var listener = new UnsynchronizableContentDocumentProcessedListener(Dispatcher, cache, router);
listener.Initialize(ProjectSnapshotManager);
// Act
listener.DocumentProcessed(document);
// Assert
var filePath = Assert.Single(router.SynchronizedDocuments);
Assert.Equal(document.FilePath, filePath);
}
private static RazorCodeActionContext CreateRazorCodeActionContext(RazorCodeActionParams request, SourceLocation location, string filePath, string text, SourceSpan componentSourceSpan, bool supportsFileCreation = true)
{
var shortComponent = TagHelperDescriptorBuilder.Create(ComponentMetadata.Component.TagHelperKind, "Fully.Qualified.Component", "TestAssembly");
shortComponent.TagMatchingRule(rule => rule.TagName = "Component");
var fullyQualifiedComponent = TagHelperDescriptorBuilder.Create(ComponentMetadata.Component.TagHelperKind, "Fully.Qualified.Component", "TestAssembly");
fullyQualifiedComponent.TagMatchingRule(rule => rule.TagName = "Fully.Qualified.Component");
var tagHelpers = new[] { shortComponent.Build(), fullyQualifiedComponent.Build() };
var sourceDocument = TestRazorSourceDocument.Create(text, filePath: filePath, relativePath: filePath);
var projectEngine = RazorProjectEngine.Create(builder => {
builder.AddTagHelpers(tagHelpers);
});
var codeDocument = projectEngine.ProcessDesignTime(sourceDocument, FileKinds.Component, Array.Empty <RazorSourceDocument>(), tagHelpers);
var cSharpDocument = codeDocument.GetCSharpDocument();
var diagnosticDescriptor = new RazorDiagnosticDescriptor("RZ10012", () => "", RazorDiagnosticSeverity.Error);
var diagnostic = RazorDiagnostic.Create(diagnosticDescriptor, componentSourceSpan);
var cSharpDocumentWithDiagnostic = RazorCSharpDocument.Create(cSharpDocument.GeneratedCode, cSharpDocument.Options, new[] { diagnostic });
codeDocument.SetCSharpDocument(cSharpDocumentWithDiagnostic);
var documentSnapshot = Mock.Of <DocumentSnapshot>(document =>
document.GetGeneratedOutputAsync() == Task.FromResult(codeDocument) &&
document.GetTextAsync() == Task.FromResult(codeDocument.GetSourceText()) &&
document.Project.TagHelpers == tagHelpers);
var sourceText = SourceText.From(text);
var context = new RazorCodeActionContext(request, documentSnapshot, codeDocument, location, sourceText, supportsFileCreation);
return(context);
}
public OutputItem(
SourceItem inputItem,
RazorCSharpDocument cSharpDocument)
{
InputItem = inputItem;
CSharpDocument = cSharpDocument;
}
public ViewCompilationInfo(
ViewFileInfo viewFileInfo,
RazorCSharpDocument cSharpDocument)
{
ViewFileInfo = viewFileInfo;
CSharpDocument = cSharpDocument;
}
public void ReportUnsynchronizableContent_DoesNothingForOlderDocuments()
{
// Arrange
var router = new TestRouter();
var lastVersion = VersionStamp.Default.GetNewerVersion();
var lastDocument = TestDocumentSnapshot.Create("C:/path/old.cshtml", lastVersion);
var oldDocument = TestDocumentSnapshot.Create("C:/path/file.cshtml", VersionStamp.Default);
var cache = new TestDocumentVersionCache(new Dictionary <DocumentSnapshot, long>()
{
[oldDocument] = 1337,
[lastDocument] = 1338,
});
var csharpDocument = RazorCSharpDocument.Create("Anything", RazorCodeGenerationOptions.CreateDefault(), Enumerable.Empty <RazorDiagnostic>());
// Force the state to already be up-to-date
oldDocument.State.HostDocument.GeneratedCodeContainer.SetOutput(lastDocument, csharpDocument, lastVersion, VersionStamp.Default);
var backgroundGenerator = new BackgroundDocumentGenerator(Dispatcher, cache, Listeners, router, LoggerFactory);
var work = new[] { new KeyValuePair <string, DocumentSnapshot>(oldDocument.FilePath, oldDocument) };
// Act
backgroundGenerator.ReportUnsynchronizableContent(work);
// Assert
Assert.Empty(router.SynchronizedDocuments);
}
public void DocumentProcessed_SynchronizesIfSourceVersionsAreIdenticalButSyncVersionNewer()
{
// Arrange
var lastVersion = VersionStamp.Default.GetNewerVersion();
var lastDocument = TestDocumentSnapshot.Create("C:/path/old.cshtml", lastVersion);
var document = TestDocumentSnapshot.Create("C:/path/file.cshtml", lastVersion);
var csharpPublisher = new Mock <CSharpPublisher>();
csharpPublisher.Setup(publisher => publisher.Publish(It.IsAny <string>(), It.IsAny <SourceText>(), It.IsAny <long>()))
.Callback <string, SourceText, long>((filePath, sourceText, hostDocumentVersion) =>
{
Assert.Equal(document.FilePath, filePath);
})
.Verifiable();
var cache = new TestDocumentVersionCache(new Dictionary <DocumentSnapshot, long>()
{
[document] = 1338,
[lastDocument] = 1337,
});
var csharpDocument = RazorCSharpDocument.Create("Anything", RazorCodeGenerationOptions.CreateDefault(), Enumerable.Empty <RazorDiagnostic>());
// Force the state to already be up-to-date
document.State.HostDocument.GeneratedCodeContainer.SetOutput(lastDocument, csharpDocument, lastVersion, VersionStamp.Default);
var listener = new UnsynchronizableContentDocumentProcessedListener(Dispatcher, cache, csharpPublisher.Object);
listener.Initialize(ProjectSnapshotManager);
// Act
listener.DocumentProcessed(document);
// Assert
csharpPublisher.VerifyAll();
}
public void SetOutput(SourceText source, RazorCodeDocument codeDocument)
{
Source = source;
Output = codeDocument.GetCSharpDocument();
_textContainer.SetText(SourceText.From(Output.GeneratedCode));
}
public void SetOutput_InvokesChangedEvent()
{
// Arrange
using var workspace = TestWorkspace.Create();
var services = workspace.Services;
var hostProject = new HostProject("C:/project.csproj", RazorConfiguration.Default, "project");
var projectState = ProjectState.Create(services, hostProject);
var project = new DefaultProjectSnapshot(projectState);
var text = SourceText.From("...");
var textAndVersion = TextAndVersion.Create(text, VersionStamp.Default);
var hostDocument = new HostDocument("C:/file.cshtml", "C:/file.cshtml");
var documentState = new DocumentState(services, hostDocument, text, VersionStamp.Default, () => Task.FromResult(textAndVersion));
var document = new DefaultDocumentSnapshot(project, documentState);
var csharpDocument = RazorCSharpDocument.Create("...", RazorCodeGenerationOptions.CreateDefault(), Enumerable.Empty <RazorDiagnostic>());
var htmlDocument = RazorHtmlDocument.Create("...", RazorCodeGenerationOptions.CreateDefault());
var version = VersionStamp.Create();
var container = new GeneratedDocumentContainer();
var csharpChanged = false;
var htmlChanged = false;
container.GeneratedCSharpChanged += (o, a) => { csharpChanged = true; };
container.GeneratedHtmlChanged += (o, a) => { htmlChanged = true; };
// Act
container.SetOutput(document, csharpDocument, htmlDocument, version, version, version);
// Assert
Assert.NotNull(container.LatestDocument);
Assert.True(csharpChanged);
Assert.True(htmlChanged);
}
public void SetOutput(
DefaultDocumentSnapshot document,
RazorCSharpDocument outputCSharp,
RazorHtmlDocument outputHtml,
VersionStamp inputVersion,
VersionStamp outputCSharpVersion,
VersionStamp outputHtmlVersion)
{
lock (_setOutputLock)
{
if (_inputVersion.HasValue &&
_inputVersion != inputVersion &&
_inputVersion == _inputVersion.Value.GetNewerVersion(inputVersion))
{
// Latest document is newer than the provided document.
return;
}
if (!document.TryGetText(out var source))
{
Debug.Fail("The text should have already been evaluated.");
return;
}
_source = source;
_inputVersion = inputVersion;
_outputCSharpVersion = outputCSharpVersion;
_outputHtmlVersion = outputHtmlVersion;
_outputCSharp = outputCSharp;
_outputHtml = outputHtml;
_latestDocument = document;
_csharpTextContainer.SetText(SourceText.From(_outputCSharp.GeneratedCode));
_htmlTextContainer.SetText(SourceText.From(_outputHtml.GeneratedHtml));
}
}
private static RazorCodeActionContext CreateRazorCodeActionContext(
CodeActionParams request,
SourceLocation location,
string filePath,
string text,
SourceSpan componentSourceSpan,
bool supportsFileCreation = true,
bool supportsCodeActionResolve = true)
{
var tagHelpers = Array.Empty <TagHelperDescriptor>();
var sourceDocument = TestRazorSourceDocument.Create(text, filePath: filePath, relativePath: filePath);
var projectEngine = RazorProjectEngine.Create(builder => builder.AddTagHelpers(tagHelpers));
var codeDocument = projectEngine.ProcessDesignTime(sourceDocument, FileKinds.Component, Array.Empty <RazorSourceDocument>(), tagHelpers);
var cSharpDocument = codeDocument.GetCSharpDocument();
var diagnosticDescriptor = new RazorDiagnosticDescriptor("RZ10012", () => "", RazorDiagnosticSeverity.Error);
var diagnostic = RazorDiagnostic.Create(diagnosticDescriptor, componentSourceSpan);
var cSharpDocumentWithDiagnostic = RazorCSharpDocument.Create(cSharpDocument.GeneratedCode, cSharpDocument.Options, new[] { diagnostic });
codeDocument.SetCSharpDocument(cSharpDocumentWithDiagnostic);
var documentSnapshot = Mock.Of <DocumentSnapshot>(document =>
document.GetGeneratedOutputAsync() == Task.FromResult(codeDocument) &&
document.GetTextAsync() == Task.FromResult(codeDocument.GetSourceText()) &&
document.Project.TagHelpers == tagHelpers, MockBehavior.Strict);
var sourceText = SourceText.From(text);
var context = new RazorCodeActionContext(request, documentSnapshot, codeDocument, location, sourceText, supportsFileCreation, supportsCodeActionResolve);
return(context);
}
public void SetOutput(RazorCSharpDocument csharpDocument, DefaultDocumentSnapshot document)
{
lock (_setOutputLock)
{
if (!document.TryGetTextVersion(out var version))
{
Debug.Fail("The text version should have already been evaluated.");
return;
}
if (_sourceVersion.HasValue && _sourceVersion == SourceVersion.GetNewerVersion(version))
{
// Latest document is newer than the provided document.
return;
}
if (!document.TryGetText(out var source))
{
Debug.Fail("The text should have already been evaluated.");
return;
}
_source = source;
_sourceVersion = version;
_output = csharpDocument;
_latestDocument = document;
_textContainer.SetText(SourceText.From(Output.GeneratedCode));
}
}
public OutputItem(
SourceItem viewFileInfo,
RazorCSharpDocument cSharpDocument)
{
ViewFileInfo = viewFileInfo;
CSharpDocument = cSharpDocument;
}
public void DocumentProcessed_DoesNothingForOlderDocuments()
{
// Arrange
var generatedDocumentPublisher = new Mock <GeneratedDocumentPublisher>(MockBehavior.Strict);
var lastVersion = VersionStamp.Default.GetNewerVersion();
var lastDocument = TestDocumentSnapshot.Create("C:/path/old.cshtml", lastVersion);
var oldDocument = TestDocumentSnapshot.Create("C:/path/file.cshtml", VersionStamp.Default);
var cache = new TestDocumentVersionCache(new Dictionary <DocumentSnapshot, int?>()
{
[oldDocument] = 1337,
[lastDocument] = 1338,
});
var csharpDocument = RazorCSharpDocument.Create("Anything", RazorCodeGenerationOptions.CreateDefault(), Enumerable.Empty <RazorDiagnostic>());
var htmlDocument = RazorHtmlDocument.Create("Anything", RazorCodeGenerationOptions.CreateDefault());
var codeDocument = CreateCodeDocument(csharpDocument, htmlDocument);
// Force the state to already be up-to-date
oldDocument.State.HostDocument.GeneratedDocumentContainer.SetOutput(lastDocument, codeDocument, lastVersion, VersionStamp.Default, VersionStamp.Default);
var listener = new UnsynchronizableContentDocumentProcessedListener(Dispatcher, cache, generatedDocumentPublisher.Object);
listener.Initialize(ProjectSnapshotManager);
// Act & Assert
listener.DocumentProcessed(oldDocument);
}
public async Task <IGeneratedRazorTemplate> GenerateCodeAsync(TkRazorProjectItem projectItem)
{
TkDebug.AssertArgumentNull(projectItem, nameof(projectItem), this);
if (!projectItem.Exists)
{
throw new ToolkitException($"Project can not find template with key {projectItem.Key}", this);
}
RazorCodeDocument codeDocument = await CreateCodeDocumentAsync(projectItem);
ProjectEngine.Process(codeDocument);
RazorCSharpDocument document = codeDocument.GetCSharpDocument();
if (document.Diagnostics.Count > 0)
{
var builder = new StringBuilder();
builder.AppendLine("Failed to generate Razor template. See \"Diagnostics\" property for more details");
foreach (RazorDiagnostic d in document.Diagnostics)
{
builder.AppendLine($"- {d.GetMessage()}");
}
throw new TemplateGenerationException(builder.ToString(), document.Diagnostics, this);
}
return(new GeneratedRazorTemplate(projectItem, document));
}
private CompilationResult GetCompilation(RazorProjectItem projectItem, RazorProjectFileSystem projectFileSystem)
{
using (IServiceScope scope = _serviceScopeFactory.CreateScope())
{
IServiceProvider serviceProvider = scope.ServiceProvider;
// See RazorViewCompiler.CompileAndEmit()
RazorProjectEngine projectEngine = serviceProvider.GetRequiredService <RazorProjectEngine>();
RazorCodeDocument codeDocument = projectEngine.Process(projectItem);
RazorCSharpDocument cSharpDocument = codeDocument.GetCSharpDocument();
if (cSharpDocument.Diagnostics.Count > 0)
{
throw (Exception)CreateCompilationFailedException.Invoke(
null,
new object[] { codeDocument, cSharpDocument.Diagnostics });
}
// Use the RazorViewCompiler to finish compiling the view for consistency with layouts
IViewCompilerProvider viewCompilerProvider = serviceProvider.GetRequiredService <IViewCompilerProvider>();
IViewCompiler viewCompiler = viewCompilerProvider.GetCompiler();
Assembly assembly = (Assembly)CompileAndEmitMethod.Invoke(
viewCompiler,
new object[] { codeDocument, cSharpDocument.GeneratedCode });
// Get the runtime item
RazorCompiledItemLoader compiledItemLoader = new RazorCompiledItemLoader();
RazorCompiledItem compiledItem = compiledItemLoader.LoadItems(assembly).SingleOrDefault();
return(new CompilationResult(compiledItem));
}
}
private static SyntaxTree GenerateSyntaxTree(RazorProjectItem razorProjectItem, RazorProjectEngine razorProjectEngine)
{
RazorCodeDocument razorCodeDocument = razorProjectEngine.Process(razorProjectItem);
RazorCSharpDocument razorCSharpDocument = razorCodeDocument.GetCSharpDocument();
return(CSharpSyntaxTree.ParseText(razorCSharpDocument.GeneratedCode));
}
public void SetOutput_AcceptsSameVersionedDocuments()
{
// Arrange
using var workspace = TestWorkspace.Create();
var services = workspace.Services;
var hostProject = new HostProject("C:/project.csproj", RazorConfiguration.Default, "project");
var projectState = ProjectState.Create(services, hostProject);
var project = new DefaultProjectSnapshot(projectState);
var text = SourceText.From("...");
var textAndVersion = TextAndVersion.Create(text, VersionStamp.Default);
var hostDocument = new HostDocument("C:/file.cshtml", "C:/file.cshtml");
var documentState = new DocumentState(services, hostDocument, text, VersionStamp.Default, () => Task.FromResult(textAndVersion));
var document = new DefaultDocumentSnapshot(project, documentState);
var newDocument = new DefaultDocumentSnapshot(project, documentState);
var csharpDocument = RazorCSharpDocument.Create("...", RazorCodeGenerationOptions.CreateDefault(), Enumerable.Empty <RazorDiagnostic>());
var htmlDocument = RazorHtmlDocument.Create("...", RazorCodeGenerationOptions.CreateDefault());
var version = VersionStamp.Create();
var container = new GeneratedDocumentContainer();
container.SetOutput(document, csharpDocument, htmlDocument, version, version, version);
// Act
container.SetOutput(newDocument, csharpDocument, htmlDocument, version, version, version);
// Assert
Assert.Same(newDocument, container.LatestDocument);
}
public static string Serialize(RazorCSharpDocument csharpDocument, RazorSourceDocument sourceDocument)
{
var builder = new StringBuilder();
var sourceFilePath = sourceDocument.FilePath;
var charBuffer = new char[sourceDocument.Length];
sourceDocument.CopyTo(0, charBuffer, 0, sourceDocument.Length);
var sourceContent = new string(charBuffer);
for (var i = 0; i < csharpDocument.SourceMappings.Count; i++)
{
var sourceMapping = csharpDocument.SourceMappings[i];
if (!string.Equals(sourceMapping.OriginalSpan.FilePath, sourceFilePath, StringComparison.Ordinal))
{
continue;
}
builder.Append("Source Location: ");
AppendMappingLocation(builder, sourceMapping.OriginalSpan, sourceContent);
builder.Append("Generated Location: ");
AppendMappingLocation(builder, sourceMapping.GeneratedSpan, csharpDocument.GeneratedCode);
builder.AppendLine();
}
return(builder.ToString());
}
public RazorCSharp(RazorCSharpDocument cSharp, CSharpCompilationOptions compilationOptions, IList <MetadataReference> references, EmitOptions emitOptions)
{
CSharp = cSharp;
_compilationOptions = compilationOptions;
_references = references;
_emitOptions = emitOptions;
}
public void ReportUnsynchronizableContent_SynchronizesIfSourceVersionsAreIdenticalButSyncVersionNewer()
{
// Arrange
var router = new TestRouter();
var lastVersion = VersionStamp.Default.GetNewerVersion();
var lastDocument = TestDocumentSnapshot.Create("C:/path/old.cshtml", lastVersion);
var document = TestDocumentSnapshot.Create("C:/path/file.cshtml", lastVersion);
var cache = new TestDocumentVersionCache(new Dictionary <DocumentSnapshot, long>()
{
[document] = 1338,
[lastDocument] = 1337,
});
var csharpDocument = RazorCSharpDocument.Create("Anything", RazorCodeGenerationOptions.CreateDefault(), Enumerable.Empty <RazorDiagnostic>());
// Force the state to already be up-to-date
document.State.HostDocument.GeneratedCodeContainer.SetOutput(csharpDocument, lastDocument);
var backgroundGenerator = new BackgroundDocumentGenerator(Dispatcher, cache, router, LoggerFactory);
var work = new[] { new KeyValuePair <string, DocumentSnapshot>(document.FilePath, document) };
// Act
backgroundGenerator.ReportUnsynchronizableContent(work);
// Assert
var filePath = Assert.Single(router.SynchronizedDocuments);
Assert.Equal(document.FilePath, filePath);
}
/// <summary>
/// Parses the template specified by <paramref name="projectItem"/>.
/// </summary>
/// <param name="projectItem">The <see cref="RazorLightProjectItem"/>.</param>
/// <returns>The <see cref="IGeneratedRazorTemplate"/>.</returns>
public async Task <IGeneratedRazorTemplate> GenerateCodeAsync(RazorLightProjectItem projectItem)
{
if (projectItem == null)
{
throw new ArgumentNullException(nameof(projectItem));
}
if (!projectItem.Exists)
{
throw new InvalidOperationException($"{nameof(RazorLightProjectItem)} of type " +
$"{projectItem.GetType().FullName} with key {projectItem.Key} does not exist.");
}
RazorCodeDocument codeDocument = await CreateCodeDocumentAsync(projectItem);
ProjectEngine.Process(codeDocument);
RazorCSharpDocument document = codeDocument.GetCSharpDocument();
if (document.Diagnostics.Count > 0)
{
var builder = new StringBuilder();
builder.AppendLine("Failed to generate Razor template. See \"Diagnostics\" property for more details");
foreach (RazorDiagnostic d in document.Diagnostics)
{
builder.AppendLine($"- {d.GetMessage()}");
}
throw new TemplateGenerationException(builder.ToString(), document.Diagnostics);
}
return(new GeneratedRazorTemplate(projectItem, document));
}
private MemoryStream CreateAndCompileToStream(string templateSource, RazorEngineCompilationOptions options)
{
templateSource = this.WriteDirectives(templateSource, options);
RazorProjectEngine engine = RazorProjectEngine.Create(
RazorConfiguration.Default,
RazorProjectFileSystem.Create(@"."),
(builder) =>
{
builder.SetNamespace(options.TemplateNamespace);
});
string fileName = Path.GetRandomFileName();
RazorSourceDocument document = RazorSourceDocument.Create(templateSource, fileName);
RazorCodeDocument codeDocument = engine.Process(
document,
null,
new List <RazorSourceDocument>(),
new List <TagHelperDescriptor>());
RazorCSharpDocument razorCSharpDocument = codeDocument.GetCSharpDocument();
SyntaxTree syntaxTree = CSharpSyntaxTree.ParseText(razorCSharpDocument.GeneratedCode);
CSharpCompilation compilation = CSharpCompilation.Create(
fileName,
new[]
{
syntaxTree
},
options.ReferencedAssemblies
.Select(ass => MetadataReference.CreateFromFile(ass.Location))
.Concat(options.MetadataReferences)
.ToList(),
new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
MemoryStream memoryStream = new MemoryStream();
EmitResult emitResult = compilation.Emit(memoryStream);
if (!emitResult.Success)
{
List <Diagnostic> errors = emitResult.Diagnostics.ToList();
RazorEngineCompilationException exception = new RazorEngineCompilationException($"Unable to compile template: {errors.FirstOrDefault()}")
{
Errors = errors,
GeneratedCode = razorCSharpDocument.GeneratedCode
};
throw exception;
}
memoryStream.Position = 0;
return(memoryStream);
}
public GeneratedRazorTemplate(TkRazorProjectItem projectItem, RazorCSharpDocument cSharpDocument)
{
TkDebug.AssertArgumentNull(projectItem, nameof(projectItem), null);
TkDebug.AssertArgumentNull(cSharpDocument, nameof(cSharpDocument), null);
ProjectItem = projectItem;
CSharpDocument = cSharpDocument;
}
private static RazorCodeDocument CreateCodeDocument(RazorCSharpDocument csharpDocument, RazorHtmlDocument htmlDocument)
{
var codeDocument = TestRazorCodeDocument.CreateEmpty();
codeDocument.SetCSharpDocument(csharpDocument);
codeDocument.Items[typeof(RazorHtmlDocument)] = htmlDocument;
return(codeDocument);
}
private static RazorCodeDocument CreateCodeDocument(params RazorDiagnostic[] diagnostics)
{
var codeDocument = TestRazorCodeDocument.CreateEmpty();
var razorCSharpDocument = RazorCSharpDocument.Create(string.Empty, RazorCodeGenerationOptions.CreateDefault(), diagnostics);
codeDocument.SetCSharpDocument(razorCSharpDocument);
return(codeDocument);
}
public static void SetCSharpDocument(this RazorCodeDocument document, RazorCSharpDocument csharp)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
document.Items[typeof(RazorCSharpDocument)] = csharp;
}
protected void AssertCSharpDocumentMatchesBaseline(RazorCSharpDocument cSharpDocument)
{
if (FileName == null)
{
var message = $"{nameof(AssertCSharpDocumentMatchesBaseline)} should only be called from an integration test ({nameof(FileName)} is null).";
throw new InvalidOperationException(message);
}
var baselineFileName = Path.ChangeExtension(FileName, ".codegen.cs");
var baselineDiagnosticsFileName = Path.ChangeExtension(FileName, ".diagnostics.txt");
if (GenerateBaselines)
{
var baselineFullPath = Path.Combine(TestProjectRoot, baselineFileName);
File.WriteAllText(baselineFullPath, cSharpDocument.GeneratedCode);
var baselineDiagnosticsFullPath = Path.Combine(TestProjectRoot, baselineDiagnosticsFileName);
var lines = cSharpDocument.Diagnostics.Select(RazorDiagnosticSerializer.Serialize).ToArray();
if (lines.Any())
{
File.WriteAllLines(baselineDiagnosticsFullPath, lines);
}
else if (File.Exists(baselineDiagnosticsFullPath))
{
File.Delete(baselineDiagnosticsFullPath);
}
return;
}
var codegenFile = TestFile.Create(baselineFileName, GetType().GetTypeInfo().Assembly);
if (!codegenFile.Exists())
{
throw new XunitException($"The resource {baselineFileName} was not found.");
}
var baseline = codegenFile.ReadAllText();
// Normalize newlines to match those in the baseline.
var actual = cSharpDocument.GeneratedCode.Replace("\r", "").Replace("\n", "\r\n");
Assert.Equal(baseline, actual);
var baselineDiagnostics = string.Empty;
var diagnosticsFile = TestFile.Create(baselineDiagnosticsFileName, GetType().GetTypeInfo().Assembly);
if (diagnosticsFile.Exists())
{
baselineDiagnostics = diagnosticsFile.ReadAllText();
}
var actualDiagnostics = string.Concat(cSharpDocument.Diagnostics.Select(d => RazorDiagnosticSerializer.Serialize(d) + "\r\n"));
Assert.Equal(baselineDiagnostics, actualDiagnostics);
}
public void Execute(RazorCodeDocument codeDocument)
{
if (Writer != null)
{
var intermediateNode = codeDocument.GetDocumentIntermediateNode();
RazorCSharpDocument csharp = Writer.WriteDocument(codeDocument, intermediateNode);
codeDocument.SetCSharpDocument(csharp);
}
else
{
_inner.Execute(codeDocument);
}
}
private static RazorCodeDocument CreateCodeDocumentWithCSharpProjection(string razorSource, string projectedCSharpSource, IEnumerable <SourceMapping> sourceMappings)
{
var codeDocument = CreateCodeDocument(razorSource, Array.Empty <TagHelperDescriptor>());
var csharpDocument = RazorCSharpDocument.Create(
projectedCSharpSource,
RazorCodeGenerationOptions.CreateDefault(),
Enumerable.Empty <RazorDiagnostic>(),
sourceMappings,
Enumerable.Empty <LinePragma>());
codeDocument.SetCSharpDocument(csharpDocument);
return(codeDocument);
}