public CompilationResult Compile(List <string> fileContents)
{
var references = GetReferences();
var roslynCompilationService = new RoslynCompilationService();
return(roslynCompilationService.Compile(fileContents, references));
}
public void EnsureOptions_ConfiguresCompilationOptions()
{
// Arrange
var compiler = new RoslynCompilationService(new DefaultMetadataReferenceManager(), Assembly.GetEntryAssembly());
// Act & Assert
var compilationOptions = compiler.CSharpCompilationOptions;
Assert.True(compilationOptions.AllowUnsafe);
Assert.Equal(ReportDiagnostic.Default, compilationOptions.GeneralDiagnosticOption);
Assert.Equal(OptimizationLevel.Debug, compilationOptions.OptimizationLevel);
Assert.Collection(compilationOptions.SpecificDiagnosticOptions.OrderBy(d => d.Key),
item =>
{
Assert.Equal("CS1701", item.Key);
Assert.Equal(ReportDiagnostic.Suppress, item.Value);
},
item =>
{
Assert.Equal("CS1702", item.Key);
Assert.Equal(ReportDiagnostic.Suppress, item.Value);
},
item =>
{
Assert.Equal("CS1705", item.Key);
Assert.Equal(ReportDiagnostic.Suppress, item.Value);
});
}
public virtual RazorLightEngine Build()
{
var options = new RazorLightOptions();
if (namespaces != null)
{
options.Namespaces = namespaces;
}
if (dynamicTemplates != null)
{
options.DynamicTemplates = dynamicTemplates;
}
if (metadataReferences != null)
{
options.AdditionalMetadataReferences = metadataReferences;
}
if (prerenderCallbacks != null)
{
options.PreRenderCallbacks = prerenderCallbacks;
}
var sourceGenerator = new RazorSourceGenerator(DefaultRazorEngine.Instance, project, options.Namespaces);
var metadataReferenceManager = new DefaultMetadataReferenceManager(options.AdditionalMetadataReferences);
var assembly = operatingAssembly ?? Assembly.GetEntryAssembly();
var compiler = new RoslynCompilationService(metadataReferenceManager, assembly);
var templateFactoryProvider = new TemplateFactoryProvider(sourceGenerator, compiler, options);
return(new RazorLightEngine(options, templateFactoryProvider, cachingProvider));
}
public TestRazorTemplateCompiler(
RazorSourceGenerator sourceGenerator,
RoslynCompilationService roslynCompilationService,
RazorLightProject razorLightProject,
RazorLightOptions razorLightOptions) : base(sourceGenerator, roslynCompilationService, razorLightProject, razorLightOptions)
{
}
public void Throw_OnNullRazorTemplate_OnCompile()
{
var compiler = new RoslynCompilationService(new DefaultMetadataReferenceManager(), Assembly.GetEntryAssembly());
Func <Task> action = () => compiler.CompileAsync(null);
Assert.ThrowsAsync <ArgumentNullException>(action);
}
public void Constructor_SetsCompilationOptionsFromDependencyContext()
{
var compiler = new RoslynCompilationService(new DefaultMetadataReferenceManager(), Assembly.GetEntryAssembly());
// Act & Assert
var parseOptions = compiler.ParseOptions;
Assert.Contains("SOME_TEST_DEFINE", parseOptions.PreprocessorSymbolNames);
}
private TemplateFactoryProvider GetProvider()
{
var sourceGenerator = new RazorSourceGenerator(DefaultRazorEngine.Instance, project);
var metadataReferences = new DefaultMetadataReferenceManager();
var compiler = new RoslynCompilationService(metadataReferences, Assembly.GetEntryAssembly());
var provider = new TemplateFactoryProvider(sourceGenerator, compiler, new RazorLightOptions());
return(provider);
}
public static CSharpCompilation AddAssemblyMetadata(
RoslynCompilationService compiler,
CSharpCompilation compilation,
CompilationOptions compilationOptions)
{
var applicationAssemblyName = Assembly.Load(new AssemblyName(compilationOptions.ApplicationName)).GetName();
var assemblyVersionContent = $"[assembly:{typeof(AssemblyVersionAttribute).FullName}(\"{applicationAssemblyName.Version}\")]";
var syntaxTree = compiler.CreateSyntaxTree(SourceText.From(assemblyVersionContent));
return(compilation.AddSyntaxTrees(syntaxTree));
}
public static TestRazorTemplateCompiler Create(RazorLightOptions options = null, RazorLightProject project = null)
{
var razorOptions = options ?? new RazorLightOptions();
var metatadaManager = new DefaultMetadataReferenceManager();
var assembly = Assembly.GetCallingAssembly();
var razorProject = project ?? new EmbeddedRazorProject(assembly);
var compilerService = new RoslynCompilationService(metatadaManager, assembly);
var generator = new RazorSourceGenerator(DefaultRazorEngine.Instance, razorProject);
return(new TestRazorTemplateCompiler(generator, compilerService, razorProject, razorOptions));
}
private int Execute()
{
if (!ParseArguments())
{
return(1);
}
var engine = new EngineFactory().ForFileSystem(Options.ContentRootOption.Value());
factoryProvider = (TemplateFactoryProvider)engine.TemplateFactoryProvider;
compiler = factoryProvider.Compiler;
ViewCompilationInfo[] results = GenerateCode();
bool success = true;
foreach (var result in results)
{
if (result.CSharpDocument.Diagnostics.Count > 0)
{
success = false;
foreach (var error in result.CSharpDocument.Diagnostics)
{
Application.Error.WriteLine($"{result.TemplateFileInfo.FullPath} ({error.Span.LineIndex}): {error.GetMessage()}");
}
}
}
if (!success)
{
return(1);
}
string precompileAssemblyName = $"{Options.ApplicationName}_Precompiled";
CSharpCompilation compilation = CompileViews(results, precompileAssemblyName);
string assemblyPath = Path.Combine(Options.OutputPath, precompileAssemblyName + ".dll");
EmitResult emitResult = EmitAssembly(
compilation,
compiler.EmitOptions,
assemblyPath);
if (!emitResult.Success)
{
foreach (var diagnostic in emitResult.Diagnostics)
{
Application.Error.WriteLine(CSharpDiagnosticFormatter.Instance.Format(diagnostic));
}
return(1);
}
return(0);
}
/// <summary>
///Creates RazorLightEngine with a custom RazorLightProject
/// </summary>
/// <param name="project">The project</param>
/// <returns>Instance of RazorLightEngine</returns>
public virtual RazorLightEngine Create(RazorLightProject project, RazorLightOptions options = null)
{
var razorOptions = options ?? new RazorLightOptions();
var sourceGenerator = new RazorSourceGenerator(DefaultRazorEngine.Instance, project, razorOptions.Namespaces);
var metadataReferenceManager = new DefaultMetadataReferenceManager(razorOptions.AdditionalMetadataReferences);
var compiler = new RoslynCompilationService(metadataReferenceManager, Assembly.GetEntryAssembly());
var templateFactoryProvider = new TemplateFactoryProvider(sourceGenerator, compiler, razorOptions);
ICachingProvider cacheProvider = new MemoryCachingProvider();
return(new RazorLightEngine(razorOptions, templateFactoryProvider, cacheProvider));
}
private EntityFrameworkServices GetEfServices(string path, string applicationName, bool useSqlite)
{
_appInfo = new ApplicationInfo(applicationName, Path.GetDirectoryName(path), "Debug");
_logger = new ConsoleLogger();
_packageInstaller = new Mock <IPackageInstaller>();
_serviceProvider = new Mock <IServiceProvider>();
_projectContext = GetProjectInformation(path);
_workspace = new RoslynWorkspace(_projectContext);
_loader = new TestAssemblyLoadContext(_projectContext);
_modelTypesLocator = new ModelTypesLocator(_workspace);
var dbContextMock = new Mock <IDbContextEditorServices>();
var editSyntaxTreeResult = new EditSyntaxTreeResult()
{
Edited = true
};
dbContextMock.Setup(db => db.EditStartupForNewContext(It.IsAny <ModelType>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
useSqlite))
.Returns(editSyntaxTreeResult);
var connectionStringsWriter = new Mock <IConnectionStringsWriter>();
connectionStringsWriter.Setup(c => c.AddConnectionString(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>()));
var filesLocator = new FilesLocator();
var compilationService = new RoslynCompilationService(_appInfo, _loader, _projectContext);
var templatingService = new Templating.RazorTemplating(compilationService);
_dbContextEditorServices = new DbContextEditorServices(_projectContext, _appInfo, filesLocator, templatingService, connectionStringsWriter.Object);
return(new EntityFrameworkServices(
_projectContext,
_appInfo,
_loader,
_modelTypesLocator,
_dbContextEditorServices,
_packageInstaller.Object,
_serviceProvider.Object,
_workspace,
DefaultFileSystem.Instance,
_logger));
}
private ServiceProvider SetupServiceProvider()
{
#if DNX451 || DNXCORE50
// provides ILibraryManager etc services
var serviceProvider = new ServiceProvider(
CallContextServiceLocator.Locator.ServiceProvider);
#else
var serviceProvider = new ServiceProvider(null);
#endif
serviceProvider.AddService(typeof(CSharpCodeGeneratorHelper), new CSharpCodeGeneratorHelper());
serviceProvider.AddService(typeof(ModelUtilities), new ModelUtilities());
var metadataReferencesProvider = new MetadataReferencesProvider(serviceProvider);
serviceProvider.AddService(typeof(MetadataReferencesProvider), metadataReferencesProvider);
var compilationService = new RoslynCompilationService();
serviceProvider.AddService(typeof(ITemplating), new RazorTemplating(compilationService, metadataReferencesProvider));
return(serviceProvider);
}
public void Ensure_Throws_OnNull_Constructor_Dependencies()
{
var options = new RazorLightOptions();
var metadataManager = new DefaultMetadataReferenceManager();
var assembly = Assembly.GetCallingAssembly();
var project = new EmbeddedRazorProject(assembly);
var compilerService = new RoslynCompilationService(metadataManager, assembly);
var generator = new RazorSourceGenerator(DefaultRazorEngine.Instance, project);
Action p1 = new Action(() => { new RazorTemplateCompiler(null, compilerService, project, options); });
Action p2 = new Action(() => { new RazorTemplateCompiler(generator, null, project, options); });
Action p3 = new Action(() => { new RazorTemplateCompiler(generator, compilerService, null, options); });
Action p4 = new Action(() => { new RazorTemplateCompiler(generator, compilerService, project, null); });
Assert.Throws <ArgumentNullException>(p1);
Assert.Throws <ArgumentNullException>(p2);
Assert.Throws <ArgumentNullException>(p3);
Assert.Throws <ArgumentNullException>(p4);
}
public DatabaseTool(
[CanBeNull] IServiceProvider serviceProvider,
[NotNull] ILoggerProvider loggerProvider)
{
Check.NotNull(loggerProvider, nameof(loggerProvider));
_serviceProvider = new ServiceProvider(serviceProvider);
var loggerFactory = new LoggerFactory();
loggerFactory.AddProvider(loggerProvider);
_logger = new LazyRef <ILogger>(() => loggerFactory.CreateLogger <DatabaseTool>());
_serviceProvider.AddService(typeof(ILogger), _logger.Value);
_serviceProvider.AddService(typeof(IFileService), new FileSystemFileService());
_serviceProvider.AddService(typeof(CSharpCodeGeneratorHelper), new CSharpCodeGeneratorHelper());
_serviceProvider.AddService(typeof(ModelUtilities), new ModelUtilities());
var metadataReferencesProvider = new MetadataReferencesProvider(_serviceProvider);
_serviceProvider.AddService(typeof(MetadataReferencesProvider), metadataReferencesProvider);
var compilationService = new RoslynCompilationService();
_serviceProvider.AddService(typeof(ITemplating), new RazorTemplating(compilationService, metadataReferencesProvider));
}
public async Task Throw_With_CompilationErrors_On_Failed_BuildAsync()
{
var compiler = new RoslynCompilationService(new DefaultMetadataReferenceManager(), Assembly.GetEntryAssembly());
var template = new TestGeneratedRazorTemplate("key", "public class Test { error }");
TemplateCompilationException ex = null;
try
{
await compiler.CompileAsync(template);
}
catch (TemplateCompilationException e)
{
ex = e;
}
Assert.NotNull(ex);
Assert.NotEmpty(ex.CompilationErrors);
Assert.Equal(1, ex.CompilationErrors.Count);
}
public void E2ETest()
{
SetCurrentCulture();
var serviceCollection = SetupInitialServices();
var logger = new InMemoryCommandLogger("E2ETest");
serviceCollection.AddScoped(typeof(ILogger), sp => logger);
var fileService = new InMemoryFileService();
serviceCollection.AddScoped(typeof(IFileService), sp => fileService);
var provider = GetMetadataModelProvider(serviceCollection);
var configuration = new ReverseEngineeringConfiguration
{
Provider = provider,
ConnectionString = E2EConnectionString,
Namespace = TestNamespace,
CustomTemplatePath = null, // not used for this test
OutputPath = TestOutputDir
};
var expectedFileContents = InitializeE2EExpectedFileContents();
var serviceProvider = serviceCollection.BuildServiceProvider();
var generator = serviceProvider.GetRequiredService <ReverseEngineeringGenerator>();
var filePaths = generator.GenerateAsync(configuration).Result;
Assert.Equal(_E2ETestExpectedWarnings.Count, logger.WarningMessages.Count);
// loop over warnings instead of using the collection form of Assert.Equal()
// to give better error messages if it does fail. Similarly for file paths below.
var i = 0;
foreach (var expectedWarning in _E2ETestExpectedWarnings)
{
Assert.Equal(expectedWarning, logger.WarningMessages[i++]);
}
Assert.Equal(0, logger.InformationMessages.Count);
Assert.Equal(0, logger.VerboseMessages.Count);
var expectedFilePaths = _E2ETestExpectedFileNames.Select(name => Path.Combine(TestOutputDir, name));
Assert.Equal(expectedFilePaths.Count(), filePaths.Count);
i = 0;
foreach (var expectedFilePath in expectedFilePaths)
{
Assert.Equal(expectedFilePath, filePaths[i++]);
}
var listOfFileContents = new List <string>();
foreach (var fileName in _E2ETestExpectedFileNames)
{
var fileContents = fileService.RetrieveFileContents(TestOutputDir, fileName);
Assert.Equal(expectedFileContents[fileName], fileContents);
listOfFileContents.Add(fileContents);
}
// compile generated code
var metadataReferencesProvider =
(MetadataReferencesProvider)serviceProvider.GetService(typeof(MetadataReferencesProvider));
var metadataReferences = SetupMetadataReferencesForCompilationOfGeneratedCode(metadataReferencesProvider);
var roslynCompilationService = new RoslynCompilationService();
var compilationResult =
roslynCompilationService.Compile(listOfFileContents, metadataReferences);
if (compilationResult.Messages.Any())
{
_output.WriteLine("Compilation Errors from compiling generated code");
_output.WriteLine("================================================");
foreach (var message in compilationResult.Messages)
{
_output.WriteLine(message);
}
_output.WriteLine("================================================");
Assert.Equal(string.Empty, "See Compilation Errors in Output.");
}
}
public virtual RazorLightEngine Build()
{
options = options ?? new RazorLightOptions();
project = project ?? new NoRazorProject();
if (namespaces != null)
{
if (namespaces.Count > 0 && options.Namespaces.Count > 0)
{
ThrowIfHasBeenSetExplicitly(nameof(namespaces));
}
options.Namespaces = namespaces;
}
if (dynamicTemplates != null)
{
if (dynamicTemplates.Count > 0 && options.DynamicTemplates.Count > 0)
{
ThrowIfHasBeenSetExplicitly(nameof(dynamicTemplates));
}
options.DynamicTemplates = dynamicTemplates;
}
if (metadataReferences != null)
{
if (metadataReferences.Count > 0 && options.AdditionalMetadataReferences.Count > 0)
{
ThrowIfHasBeenSetExplicitly(nameof(metadataReferences));
}
options.AdditionalMetadataReferences = metadataReferences;
}
if (excludedAssemblies != null)
{
if (excludedAssemblies.Count > 0 && options.ExcludedAssemblies.Count > 0)
{
ThrowIfHasBeenSetExplicitly(nameof(excludedAssemblies));
}
options.ExcludedAssemblies = excludedAssemblies;
}
if (prerenderCallbacks != null)
{
if (prerenderCallbacks.Count > 0 && options.PreRenderCallbacks.Count > 0)
{
ThrowIfHasBeenSetExplicitly(nameof(prerenderCallbacks));
}
options.PreRenderCallbacks = prerenderCallbacks;
}
if (cachingProvider != null)
{
if (options.CachingProvider != null)
{
ThrowIfHasBeenSetExplicitly(nameof(cachingProvider));
}
options.CachingProvider = cachingProvider;
}
if (disableEncoding.HasValue)
{
if (options.DisableEncoding != null)
{
ThrowIfHasBeenSetExplicitly(nameof(disableEncoding));
}
options.DisableEncoding = options.DisableEncoding ?? disableEncoding ?? false;
}
else
{
if (!options.DisableEncoding.HasValue)
{
options.DisableEncoding = false;
}
}
if (enableDebugMode.HasValue && options.EnableDebugMode.HasValue)
{
ThrowIfHasBeenSetExplicitly(nameof(enableDebugMode));
}
else
{
options.EnableDebugMode = options.EnableDebugMode ?? enableDebugMode ?? false;
}
var metadataReferenceManager = new DefaultMetadataReferenceManager(options.AdditionalMetadataReferences, options.ExcludedAssemblies);
var assembly = operatingAssembly ?? Assembly.GetEntryAssembly();
var compiler = new RoslynCompilationService(metadataReferenceManager, assembly);
var sourceGenerator = new RazorSourceGenerator(DefaultRazorEngine.Instance, project, options.Namespaces);
var templateCompiler = new RazorTemplateCompiler(sourceGenerator, compiler, project, options);
var templateFactoryProvider = new TemplateFactoryProvider();
var engineHandler = new EngineHandler(options, templateCompiler, templateFactoryProvider, cachingProvider);
return(new RazorLightEngine(engineHandler));
}
