public void Process_SetsNullTagHelpersOnCodeDocument()
{
// Arrange
var projectItem = new TestRazorProjectItem("Index.cshtml");
var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, TestRazorProjectFileSystem.Empty);
// Act
var codeDocument = projectEngine.Process(projectItem);
// Assert
var tagHelpers = codeDocument.GetTagHelpers();
Assert.Null(tagHelpers);
}
public void Process_SetsInferredFileKindOnCodeDocument_Component()
{
// Arrange
var projectItem = new TestRazorProjectItem("Index.razor");
var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, TestRazorProjectFileSystem.Empty);
// Act
var codeDocument = projectEngine.Process(projectItem);
// Assert
var actual = codeDocument.GetFileKind();
Assert.Same(FileKinds.Component, actual);
}
public void Process_GeneratesCodeDocumentWithValidCSharpDocument()
{
// Arrange
var projectItem = new TestRazorProjectItem("Index.cshtml");
var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, TestRazorProjectFileSystem.Empty);
// Act
var codeDocument = projectEngine.Process(projectItem);
// Assert
var csharpDocument = codeDocument.GetCSharpDocument();
Assert.NotNull(csharpDocument);
Assert.Empty(csharpDocument.Diagnostics);
}
public void Process_WithNullTagHelpers_SetsOnCodeDocument()
{
// Arrange
var projectItem = new TestRazorProjectItem("Index.cshtml");
var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, TestRazorProjectFileSystem.Empty);
// Act
var codeDocument = projectEngine.Process(RazorSourceDocument.ReadFrom(projectItem), "test", Array.Empty <RazorSourceDocument>(), tagHelpers: null);
// Assert
var tagHelpers = codeDocument.GetTagHelpers();
Assert.Null(tagHelpers);
}
private static RazorCodeDocument CreateCodeDocument(string text)
{
var projectItem = new TestRazorProjectItem("c:/Test.razor", "c:/Test.razor", "Test.razor")
{
Content = text
};
var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, TestRazorProjectFileSystem.Empty, (builder) =>
{
PageDirective.Register(builder);
});
var codeDocument = projectEngine.Process(projectItem);
codeDocument.SetFileKind(FileKinds.Component);
return(codeDocument);
}
internal RazorProjectEngine CreateProjectEngine(RazorConfiguration configuration, MetadataReference[] references)
{
return(RazorProjectEngine.Create(configuration, FileSystem, b =>
{
// Turn off checksums, we're testing code generation.
b.Features.Add(new SuppressChecksum());
BlazorExtensionInitializer.Register(b);
b.Features.Add(new CompilationTagHelperFeature());
b.Features.Add(new DefaultMetadataReferenceFeature()
{
References = references,
});
}));
}
public RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure)
{
// Rewrite the assembly name into a full name just like this one, but with the name of the MVC design time assembly.
var assemblyName = new AssemblyName(typeof(RazorProjectEngine).Assembly.FullName);
assemblyName.Name = AssemblyName;
var extension = new AssemblyExtension(configuration.ConfigurationName, Assembly.Load(assemblyName));
var initializer = extension.CreateInitializer();
return(RazorProjectEngine.Create(configuration, fileSystem, b =>
{
initializer.Initialize(b);
configure?.Invoke(b);
}));
}
private static RazorProjectFileSystem InitialiseTemplateProject(string dynamicAssemblyNamespace, out RazorProjectEngine razorProjectEngine)
{
// points to the local path
RazorProjectFileSystem razorProjectFileSystem = RazorProjectFileSystem.Create(".");
// customize the default engine a little bit
razorProjectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, razorProjectFileSystem, (builder) =>
{
// InheritsDirective.Register(builder);
// define a namespace for the Template class
builder.SetNamespace(dynamicAssemblyNamespace);
});
return(razorProjectFileSystem);
}
public void GenerateCodeWithDefaults()
{
// Arrange
var fileSystem = new DefaultRazorProjectFileSystem(TestProjectRoot);
var razorEngine = RazorProjectEngine.Create(engine =>
{
engine.Features.Add(new SuppressChecksumOptionsFeature());
}).Engine;
var templateEngine = new RazorTemplateEngine(razorEngine, fileSystem);
// Act
var cSharpDocument = templateEngine.GenerateCode($"{FileName}.cshtml");
// Assert
AssertCSharpDocumentMatchesBaseline(cSharpDocument);
}
public RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure)
{
return(RazorProjectEngine.Create(configuration, fileSystem, b =>
{
CompilerFeatures.Register(b);
configure?.Invoke(b);
// See comments on MangleClassNames
var componentDocumentClassifier = b.Features.OfType <ComponentDocumentClassifierPass>().FirstOrDefault();
if (componentDocumentClassifier != null)
{
componentDocumentClassifier.MangleClassNames = true;
}
}));
}
public CodeGenerationBenchmark()
{
var current = new DirectoryInfo(AppContext.BaseDirectory);
while (current != null && !File.Exists(Path.Combine(current.FullName, "MSN.cshtml")))
{
current = current.Parent;
}
var root = current;
var fileSystem = RazorProjectFileSystem.Create(root.FullName);
ProjectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, b => RazorExtensions.Register(b));;
MSN = fileSystem.GetItem(Path.Combine(root.FullName, "MSN.cshtml"), FileKinds.Legacy);
}
private int ExecuteCore(
RazorConfiguration configuration,
string projectDirectory,
string tagHelperManifest,
List <string> sources,
List <string> outputs,
List <string> relativePaths)
{
tagHelperManifest = Path.Combine(projectDirectory, tagHelperManifest);
var tagHelpers = GetTagHelpers(tagHelperManifest);
var inputItems = GetInputItems(projectDirectory, sources, outputs, relativePaths);
var compositeFileSystem = new CompositeRazorProjectFileSystem(new[]
{
GetVirtualRazorProjectSystem(inputItems),
RazorProjectFileSystem.Create(projectDirectory),
});
var engine = RazorProjectEngine.Create(configuration, compositeFileSystem, b =>
{
b.Features.Add(new StaticTagHelperFeature()
{
TagHelpers = tagHelpers,
});
});
var results = GenerateCode(engine, inputItems);
var success = true;
foreach (var result in results)
{
if (result.CSharpDocument.Diagnostics.Count > 0)
{
success = false;
foreach (var error in result.CSharpDocument.Diagnostics)
{
Console.Error.WriteLine(error.ToString());
}
}
var outputFilePath = result.InputItem.OutputPath;
File.WriteAllText(outputFilePath, result.CSharpDocument.GeneratedCode);
}
return(success ? 0 : -1);
}
public async Task <Type> CompileBlazor(string code)
{
CompileLog.Add("Create fileSystem");
var fileSystem = new EmptyRazorProjectFileSystem();
CompileLog.Add("Create engine");
// Microsoft.AspNetCore.Blazor.Build.
var engine = RazorProjectEngine.Create(RazorConfiguration.Create(RazorLanguageVersion.Version_3_0, "Blazor", new RazorExtension[0]), fileSystem, b =>
{
//BlazorExtensionInitializer.Register(b);
});
CompileLog.Add("Create file");
var file = new MemoryRazorProjectItem(code, true, "/App", "/App/App.razor");
CompileLog.Add("File process and GetCSharpDocument");
var doc = engine.Process(file).GetCSharpDocument();
CompileLog.Add("Get GeneratedCode");
var csCode = doc.GeneratedCode;
CompileLog.Add("Read Diagnostics");
foreach (var diagnostic in doc.Diagnostics)
{
CompileLog.Add(diagnostic.ToString());
}
if (doc.Diagnostics.Any(i => i.Severity == RazorDiagnosticSeverity.Error))
{
return(null);
}
CompileLog.Add(csCode);
CompileLog.Add("Compile assembly");
var assembly = await Compile(csCode);
if (assembly != null)
{
CompileLog.Add("Search Blazor component");
return(assembly.GetExportedTypes().FirstOrDefault(i => i.IsSubclassOf(typeof(ComponentBase))));
}
return(null);
}
private int ExecuteCore(RazorConfiguration configuration, string projectDirectory, string outputFilePath, string[] assemblies)
{
outputFilePath = Path.Combine(projectDirectory, outputFilePath);
var metadataReferences = new MetadataReference[assemblies.Length];
for (var i = 0; i < assemblies.Length; i++)
{
metadataReferences[i] = Parent.AssemblyReferenceProvider(assemblies[i], default(MetadataReferenceProperties));
}
var engine = RazorProjectEngine.Create(configuration, RazorProjectFileSystem.Empty, b =>
{
b.Features.Add(new DefaultMetadataReferenceFeature()
{
References = metadataReferences
});
b.Features.Add(new CompilationTagHelperFeature());
b.Features.Add(new DefaultTagHelperDescriptorProvider());
CompilerFeatures.Register(b);
});
var feature = engine.Engine.Features.OfType <ITagHelperFeature>().Single();
var tagHelpers = feature.GetDescriptors();
using (var stream = new MemoryStream())
{
Serialize(stream, tagHelpers);
stream.Position = 0;
var newHash = Hash(stream);
var existingHash = Hash(outputFilePath);
if (!HashesEqual(newHash, existingHash))
{
stream.Position = 0;
using (var output = File.Open(outputFilePath, FileMode.Create))
{
stream.CopyTo(output);
}
}
}
return(ExitCodeSuccess);
}
public void GetDefaultImports_IncludesDefaultTagHelpers()
{
// Arrange
var mvcRazorTemplateEngine = new MvcRazorTemplateEngine(
RazorProjectEngine.Create().Engine,
new TestRazorProjectFileSystem());
// Act
var imports = mvcRazorTemplateEngine.Options.DefaultImports;
// Assert
var importContent = GetContent(imports)
.Split(new[] { Environment.NewLine }, StringSplitOptions.None)
.Where(line => line.StartsWith("@addTagHelper"));
Assert.Contains("@addTagHelper Microsoft.AspNetCore.Mvc.Razor.TagHelpers.UrlResolutionTagHelper, Microsoft.AspNetCore.Mvc.Razor", importContent);
}
public RazorProjectEngine CreateRazorProjectEngine(IReadOnlyList <MetadataReference> references)
{
Console.WriteLine("CreateRazorProjectEngine");
return(RazorProjectEngine.Create(_config, _fileSystem, builder =>
{
builder.SetRootNamespace(DefaultRootNamespace);
builder.AddDefaultImports(RazorConstants.DefaultUsings);
// Features that use Roslyn are mandatory for components
CompilerFeatures.Register(builder);
builder.Features.Add(new CompilationTagHelperFeature());
builder.Features.Add(new DefaultMetadataReferenceFeature {
References = references
});
}));
}
public void GetIdentifier_SanitizesRelativePath(string relativePath, string expected)
{
// Arrange
var sourceDocument = RazorSourceDocument.Create("content", new RazorSourceDocumentProperties("Test.cshtml", relativePath));
var codeDocument = RazorCodeDocument.Create(sourceDocument);
var feature = new DefaultMetadataIdentifierFeature()
{
Engine = RazorProjectEngine.Create().Engine,
};
// Act
var result = feature.GetIdentifier(codeDocument, sourceDocument);
// Assert
Assert.Equal(expected, result);
}
public void Execute_NoOps_ForDesignTime()
{
// Arrange
var irDocument = new DocumentIntermediateNode
{
DocumentKind = MvcViewDocumentClassifierPass.MvcViewDocumentKind,
Options = RazorCodeGenerationOptions.CreateDesignTimeDefault(),
};
var builder = IntermediateNodeBuilder.Create(irDocument);
var @namespace = new NamespaceDeclarationIntermediateNode
{
Content = "SomeNamespace",
Annotations =
{
[CommonAnnotations.PrimaryNamespace] = CommonAnnotations.PrimaryNamespace
},
};
builder.Push(@namespace);
var @class = new ClassDeclarationIntermediateNode
{
ClassName = "SomeName",
Annotations =
{
[CommonAnnotations.PrimaryClass] = CommonAnnotations.PrimaryClass,
},
};
builder.Add(@class);
var pass = new AssemblyAttributeInjectionPass
{
Engine = RazorProjectEngine.Create().Engine,
};
var source = TestRazorSourceDocument.Create("test", new RazorSourceDocumentProperties(filePath: null, relativePath: "/Views/Index.cshtml"));
var document = RazorCodeDocument.Create(source);
// Act
pass.Execute(document, irDocument);
// Assert
Assert.Collection(
irDocument.Children,
node => Assert.Same(@namespace, node));
}
public static IServiceCollection AddRazorTemlpate <TConfig, TFile, TCompilation>(this IServiceCollection services, Action <RazorProjectEngineBuilder> builder)
where TConfig : RazorConfiguration
where TFile : RazorProjectFileSystem
where TCompilation : class, ICompilationService
{
services.AddOptions();
services.AddLogging(b => b.AddConsole().SetMinimumLevel(LogLevel.Trace));
services.TryAddSingleton <ICompilationService, TCompilation>();
services.TryAddSingleton <ICodeGenAssemblyLoadContext, DefaultAssemblyLoadContext>();
services.TryAddSingleton(p => RazorProjectEngine.Create(
p.GetService <TConfig>() ?? RazorConfiguration.Default,
p.GetService <TFile>() ?? RazorProjectFileSystem.Create(Directory.GetCurrentDirectory()),
x => { TemplatingHelper.Register(x); builder(x); })
);
services.TryAddSingleton <ITemplateFactory, TemplateFactory>();
return(services);
}
public ComponentDuplicateAttributeDiagnosticPassTest()
{
Pass = new ComponentMarkupDiagnosticPass();
ProjectEngine = (DefaultRazorProjectEngine)RazorProjectEngine.Create(
RazorConfiguration.Default,
RazorProjectFileSystem.Create(Environment.CurrentDirectory),
b =>
{
// Don't run the markup mutating passes.
b.Features.Remove(b.Features.OfType <ComponentMarkupDiagnosticPass>().Single());
b.Features.Remove(b.Features.OfType <ComponentMarkupBlockPass>().Single());
b.Features.Remove(b.Features.OfType <ComponentMarkupEncodingPass>().Single());
});
Engine = ProjectEngine.Engine;
Pass.Engine = Engine;
}
static RazorProjectEngine CreateProjectEngine(string rootNamespace, string projectDirectory)
{
var fileSystem = RazorProjectFileSystem.Create(projectDirectory);
var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, builder => {
builder
.SetNamespace(rootNamespace)
.ConfigureClass((document, @class) => {
@class.ClassName = Path.GetFileNameWithoutExtension(document.Source.FilePath);
});
FunctionsDirective.Register(builder);
InheritsDirective.Register(builder);
SectionDirective.Register(builder);
});
return(projectEngine);
}
public void SetCSharpLanguageVersion_ResolvesNonNumericCSharpLangVersions()
{
// Arrange
var csharpLanguageVersion = CSharp.LanguageVersion.Latest;
// Act
var projectEngine = RazorProjectEngine.Create(builder =>
{
builder.SetCSharpLanguageVersion(csharpLanguageVersion);
});
// Assert
var feature = projectEngine.EngineFeatures.OfType <ConfigureParserForCSharpVersionFeature>().FirstOrDefault();
Assert.NotNull(feature);
Assert.NotEqual(csharpLanguageVersion, feature.CSharpLanguageVersion);
}
private static RazorCodeDocument GetCodeDocument(string source)
{
var taghelper = TagHelperDescriptorBuilder.Create("TestTagHelper", "TestAssembly")
.BoundAttributeDescriptor(attr => attr.Name("show").TypeName("System.Boolean"))
.BoundAttributeDescriptor(attr => attr.Name("id").TypeName("System.Int32"))
.TagMatchingRuleDescriptor(rule => rule.RequireTagName("taghelper"))
.TypeName("TestTagHelper")
.Build();
var engine = RazorProjectEngine.Create();
var sourceDocument = TestRazorSourceDocument.Create(source, normalizeNewLines: true);
var importDocument = TestRazorSourceDocument.Create("@addTagHelper *, TestAssembly", filePath: "import.cshtml", relativePath: "import.cshtml");
var codeDocument = engine.ProcessDesignTime(sourceDocument, importSources: new [] { importDocument }, new [] { taghelper });
return(codeDocument);
}
public ComponentWhitespacePassTest()
{
Pass = new ComponentWhitespacePass();
ProjectEngine = (DefaultRazorProjectEngine)RazorProjectEngine.Create(
RazorConfiguration.Default,
RazorProjectFileSystem.Create(Environment.CurrentDirectory),
b =>
{
if (b.Features.OfType <ComponentWhitespacePass>().Any())
{
b.Features.Remove(b.Features.OfType <ComponentWhitespacePass>().Single());
}
});
Engine = ProjectEngine.Engine;
Pass.Engine = Engine;
}
public void GetIdentifier_ReturnsNull_ForEmptyRelativePath()
{
// Arrange
var sourceDocument = RazorSourceDocument.Create("content", new RazorSourceDocumentProperties("Test.cshtml", string.Empty));
var codeDocument = RazorCodeDocument.Create(sourceDocument);
var feature = new DefaultMetadataIdentifierFeature()
{
Engine = RazorProjectEngine.Create().Engine,
};
// Act
var result = feature.GetIdentifier(codeDocument, sourceDocument);
// Assert
Assert.Null(result);
}
public async Task Handle_AddOneUsingToPageDirective()
{
// Arrange
var documentPath = "c:/Test.cshtml";
var documentUri = new Uri(documentPath);
var contents = $"@page{Environment.NewLine}@model IndexModel";
var projectItem = new TestRazorProjectItem("c:/Test.cshtml", "c:/Test.cshtml", "Test.cshtml")
{
Content = contents
};
var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, TestRazorProjectFileSystem.Empty, (builder) =>
{
PageDirective.Register(builder);
ModelDirective.Register(builder);
});
var codeDocument = projectEngine.Process(projectItem);
codeDocument.SetFileKind(FileKinds.Legacy);
var resolver = new AddUsingsCodeActionResolver(LegacyDispatcher, CreateDocumentResolver(documentPath, codeDocument));
var actionParams = new AddUsingsCodeActionParams
{
Uri = documentUri,
Namespace = "System"
};
var data = JObject.FromObject(actionParams);
// Act
var workspaceEdit = await resolver.ResolveAsync(data, default);
// Assert
Assert.NotNull(workspaceEdit);
Assert.NotNull(workspaceEdit.DocumentChanges);
Assert.Single(workspaceEdit.DocumentChanges);
var documentChanges = workspaceEdit.DocumentChanges.ToArray();
var addUsingsChange = documentChanges[0];
Assert.True(addUsingsChange.IsTextDocumentEdit);
var firstEdit = Assert.Single(addUsingsChange.TextDocumentEdit.Edits);
Assert.Equal(1, firstEdit.Range.Start.Line);
Assert.Equal($"@using System{Environment.NewLine}", firstEdit.NewText);
}
public CSharpScriptRazorGenerator(string directoryRoot)
{
var fileSystem = RazorProjectFileSystem.Create(directoryRoot);
var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, builder =>
{
// Register directives.
SectionDirective.Register(builder);
// We replace the default document classifier, because we can't have namespace declaration ins script.
var defaultDocumentClassifier = builder.Features
.OfType <IRazorDocumentClassifierPass>()
.FirstOrDefault(x => x.Order == 1000);
builder.Features.Remove(defaultDocumentClassifier);
builder.Features.Add(new CSharpScriptDocumentClassifierPass());
});
_projectEngine = projectEngine;
}
private static RazorProjectEngine GetDiscoveryProjectEngine(
IReadOnlyList <MetadataReference> references,
StaticCompilationTagHelperFeature tagHelperFeature)
{
var discoveryProjectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, new VirtualRazorProjectFileSystem(), b =>
{
b.Features.Add(new DefaultMetadataReferenceFeature {
References = references
});
b.Features.Add(tagHelperFeature);
b.Features.Add(new DefaultTagHelperDescriptorProvider());
CompilerFeatures.Register(b);
RazorExtensions.Register(b);
});
return(discoveryProjectEngine);
}
private static (RazorCodeDocument, DocumentSnapshot) CreateCodeDocumentAndSnapshot(SourceText text, string path, IReadOnlyList <TagHelperDescriptor> tagHelpers = null, string fileKind = default)
{
fileKind ??= FileKinds.Component;
tagHelpers ??= Array.Empty <TagHelperDescriptor>();
var sourceDocument = text.GetRazorSourceDocument(path, path);
var projectEngine = RazorProjectEngine.Create(builder => { builder.SetRootNamespace("Test"); });
var codeDocument = projectEngine.ProcessDesignTime(sourceDocument, fileKind, Array.Empty <RazorSourceDocument>(), tagHelpers);
var documentSnapshot = new Mock <DocumentSnapshot>();
documentSnapshot.Setup(d => d.GetGeneratedOutputAsync()).Returns(Task.FromResult(codeDocument));
documentSnapshot.Setup(d => d.Project.GetProjectEngine()).Returns(projectEngine);
documentSnapshot.Setup(d => d.TargetPath).Returns(path);
documentSnapshot.Setup(d => d.Project.TagHelpers).Returns(tagHelpers);
documentSnapshot.Setup(d => d.FileKind).Returns(fileKind);
return(codeDocument, documentSnapshot.Object);
}
private static RazorProjectEngine CreateProjectEngine(
IEnumerable <TagHelperDescriptor> tagHelpers = null)
{
var fileSystem = new TestRazorProjectFileSystem();
var projectEngine = RazorProjectEngine.Create(RazorConfiguration.Default, fileSystem, builder =>
{
RazorExtensions.Register(builder);
builder.AddDefaultImports("@addTagHelper *, Test");
if (tagHelpers != null)
{
builder.AddTagHelpers(tagHelpers);
}
});
return(projectEngine);
}
