public void UpdateGuestProjectManager_ProjectChanged_ConfigurationChange() { // Arrange var oldHandle = new ProjectSnapshotHandleProxy( new Uri("vsls:/path/project.csproj"), RazorConfiguration.Default, "project", projectWorkspaceState: null); var newConfiguration = RazorConfiguration.Create(RazorLanguageVersion.Version_1_0, "Custom-1.0", Enumerable.Empty <RazorExtension>()); var newHandle = new ProjectSnapshotHandleProxy( oldHandle.FilePath, newConfiguration, oldHandle.RootNamespace, oldHandle.ProjectWorkspaceState); var synchronizationService = new ProjectSnapshotSynchronizationService( JoinableTaskFactory, SessionContext, Mock.Of <IProjectSnapshotManagerProxy>(), ProjectSnapshotManager); var hostProject = new HostProject("/guest/path/project.csproj", RazorConfiguration.Default, "project"); ProjectSnapshotManager.ProjectAdded(hostProject); ProjectSnapshotManager.ProjectConfigurationChanged(hostProject); var args = new ProjectChangeEventProxyArgs(oldHandle, newHandle, ProjectProxyChangeKind.ProjectChanged); // Act synchronizationService.UpdateGuestProjectManager(args); // Assert var project = Assert.Single(ProjectSnapshotManager.Projects); Assert.Equal("/guest/path/project.csproj", project.FilePath); Assert.Same(newConfiguration, project.Configuration); Assert.Empty(project.TagHelpers); }
public override RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure) { if (fileSystem is null) { throw new ArgumentNullException(nameof(fileSystem)); } // When we're running in the editor, the editor provides a configure delegate that will include // the editor settings and tag helpers. // // This service is only used in process in Visual Studio, and any other callers should provide these // things also. configure ??= ((b) => { }); // The default configuration currently matches the newest MVC configuration. // // We typically want this because the language adds features over time - we don't want to a bunch of errors // to show up when a document is first opened, and then go away when the configuration loads, we'd prefer the opposite. configuration ??= s_defaultConfiguration; // If there's no factory to handle the configuration then fall back to a very basic configuration. // // This will stop a crash from happening in this case (misconfigured project), but will still make // it obvious to the user that something is wrong. var factory = SelectFactory(configuration) ?? _fallback; return(factory.Create(configuration, fileSystem, configure)); }
public override RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure) { return(RazorProjectEngine.Create(configuration, fileSystem, b => { RazorExtensions.Register(b); })); }
private RazorProjectEngine CreateProjectEngine(RazorConfiguration configuration, MetadataReference[] references, Action <RazorProjectEngineBuilder>?configure) { return(RazorProjectEngine.Create(configuration, FileSystem, b => { b.Phases.Insert(0, new ConfigureCodeRenderingPhase(LineEnding)); configure?.Invoke(b); // Allow the test to do custom things with tag helpers, but do the default thing most of the time. if (!b.Features.OfType <ITagHelperFeature>().Any()) { b.Features.Add(new CompilationTagHelperFeature()); b.Features.Add(new DefaultMetadataReferenceFeature() { References = references, }); } b.Features.Add(new DefaultTypeNameFeature()); b.SetCSharpLanguageVersion(CSharpParseOptions.LanguageVersion); // Decorate each import feature so we can normalize line endings. foreach (var feature in b.Features.OfType <IImportProjectFeature>().ToArray()) { b.Features.Remove(feature); b.Features.Add(new NormalizedDefaultImportFeature(feature, LineEnding)); } })); }
public void Equals_ReturnsTrue_IfRazorConfigurationAreDifferentInstancesButEqualValues() { // Arrange var options1 = new RazorSourceGenerationOptions { CSharpLanguageVersion = LanguageVersion.Latest, Configuration = RazorConfiguration.Create(RazorLanguageVersion.Parse("6.0"), "Default", Enumerable.Empty <RazorExtension>(), useConsolidatedMvcViews: true), GenerateMetadataSourceChecksumAttributes = true, RootNamespace = "Asp", SupportLocalizedComponentNames = true, SuppressRazorSourceGenerator = true, }; var options2 = new RazorSourceGenerationOptions { Configuration = RazorConfiguration.Create(RazorLanguageVersion.Parse("6.0"), "Default", Enumerable.Empty <RazorExtension>(), useConsolidatedMvcViews: true), CSharpLanguageVersion = LanguageVersion.Latest, GenerateMetadataSourceChecksumAttributes = true, RootNamespace = "Asp", SupportLocalizedComponentNames = true, SuppressRazorSourceGenerator = true, }; // Act var equals = options1.Equals(options2); // Assert Assert.True(equals); }
protected override Task <int> ExecuteCoreAsync() { if (!Parent.Checker.Check(ExtensionFilePaths.Values)) { Error.WriteLine($"Extenions could not be loaded. See output for details."); return(Task.FromResult(ExitCodeFailure)); } // Loading all of the extensions should succeed as the dependency checker will have already // loaded them. var extensions = new RazorExtension[ExtensionNames.Values.Count]; for (var i = 0; i < ExtensionNames.Values.Count; i++) { extensions[i] = new AssemblyExtension(ExtensionNames.Values[i], Parent.Loader.LoadFromPath(ExtensionFilePaths.Values[i])); } var version = RazorLanguageVersion.Parse(Version.Value()); var configuration = RazorConfiguration.Create(version, Configuration.Value(), extensions); var result = ExecuteCore( configuration: configuration, projectDirectory: ProjectDirectory.Value(), outputFilePath: TagHelperManifest.Value(), assemblies: Assemblies.Values.ToArray()); return(Task.FromResult(result)); }
// intentionally private - we don't want individual tests messing with the project engine private RazorProjectEngine CreateProjectEngine(RazorConfiguration configuration, MetadataReference[] references) { return(RazorProjectEngine.Create(configuration, FileSystem, b => { b.SetRootNamespace(DefaultRootNamespace); // Turn off checksums, we're testing code generation. b.Features.Add(new SuppressChecksum()); b.Features.Add(new TestImportProjectFeature(ImportItems)); if (LineEnding != null) { b.Phases.Insert(0, new ForceLineEndingPhase(LineEnding)); } b.Features.Add(new CompilationTagHelperFeature()); b.Features.Add(new DefaultMetadataReferenceFeature() { References = references, }); b.SetCSharpLanguageVersion(CSharpParseOptions.LanguageVersion); CompilerFeatures.Register(b); })); }
public MSBuildProjectManagerTest() { CustomConfiguration = RazorConfiguration.Create( RazorLanguageVersion.Experimental, "Custom", Enumerable.Empty <RazorExtension>()); }
// Internal for testing internal static bool TryGetConfiguration( IImmutableDictionary <string, IProjectRuleSnapshot> state, out RazorConfiguration configuration) { if (!TryGetDefaultConfiguration(state, out var defaultConfiguration)) { configuration = null; return(false); } if (!TryGetLanguageVersion(state, out var languageVersion)) { configuration = null; return(false); } if (!TryGetConfigurationItem(defaultConfiguration, state, out var configurationItem)) { configuration = null; return(false); } var extensionNames = GetExtensionNames(configurationItem); if (!TryGetExtensions(extensionNames, state, out var extensions)) { configuration = null; return(false); } configuration = new ProjectSystemRazorConfiguration(languageVersion, configurationItem.Key, extensions); return(true); }
// Internal for testing internal static bool TryGetConfiguration( IMSBuildEvaluatedPropertyCollection projectProperties, IEnumerable <IMSBuildItemEvaluated> projectItems, out RazorConfiguration configuration) { if (!TryGetDefaultConfiguration(projectProperties, out var defaultConfiguration)) { configuration = null; return(false); } if (!TryGetLanguageVersion(projectProperties, out var languageVersion)) { configuration = null; return(false); } if (!TryGetConfigurationItem(defaultConfiguration, projectItems, out var configurationItem)) { configuration = null; return(false); } var extensionNames = GetExtensionNames(configurationItem); var extensions = GetExtensions(extensionNames, projectItems); configuration = new ProjectSystemRazorConfiguration(languageVersion, configurationItem.Include, extensions); return(true); }
public async Task ProjectWorkspaceStateChange_WithProjectWorkspaceState_CSharpLanguageVersionChange_DoesNotCacheOutput() { // Arrange var csharp8ValidConfiguration = RazorConfiguration.Create(RazorLanguageVersion.Version_3_0, HostProject.Configuration.ConfigurationName, HostProject.Configuration.Extensions); var hostProject = new HostProject(TestProjectData.SomeProject.FilePath, csharp8ValidConfiguration, TestProjectData.SomeProject.RootNamespace); var originalWorkspaceState = new ProjectWorkspaceState(SomeTagHelpers, LanguageVersion.CSharp7); var original = ProjectState.Create(Workspace.Services, hostProject, originalWorkspaceState) .WithAddedHostDocument(HostDocument, () => Task.FromResult(TextAndVersion.Create(SourceText.From("@DateTime.Now"), VersionStamp.Default))); var changedWorkspaceState = new ProjectWorkspaceState(SomeTagHelpers, LanguageVersion.CSharp8); var(originalOutput, originalInputVersion, originalCSharpOutputVersion, originalHtmlOutputVersion) = await GetOutputAsync(original, HostDocument); // Act var state = original.WithProjectWorkspaceState(changedWorkspaceState); // Assert var(actualOutput, actualInputVersion, actualCSharpOutputVersion, actualHtmlOutputVersion) = await GetOutputAsync(state, HostDocument); Assert.NotSame(originalOutput, actualOutput); Assert.NotEqual(originalInputVersion, actualInputVersion); Assert.NotEqual(originalCSharpOutputVersion, actualCSharpOutputVersion); Assert.Equal(originalHtmlOutputVersion, actualHtmlOutputVersion); Assert.Equal(state.ProjectWorkspaceStateVersion, actualInputVersion); }
static BlazorExtensionInitializer() { // RazorConfiguration is changing between 15.7 and preview2 builds of Razor, this is a reflection-based // workaround. DeclarationConfiguration = Create("BlazorDeclaration-0.1"); DefaultConfiguration = Create("Blazor-0.1"); RazorConfiguration Create(string configurationName) { var args = new object[] { RazorLanguageVersion.Version_2_1, configurationName, Array.Empty <RazorExtension>(), }; MethodInfo method; ConstructorInfo constructor; if ((method = typeof(RazorConfiguration).GetMethod("Create", BindingFlags.Public | BindingFlags.Static)) != null) { return((RazorConfiguration)method.Invoke(null, args)); } else if ((constructor = typeof(RazorConfiguration).GetConstructors().FirstOrDefault()) != null) { return((RazorConfiguration)constructor.Invoke(args)); } else { throw new InvalidOperationException("Can't create a configuration. This is bad."); } } }
public SerializedProjectSnapshot(string filePath, RazorConfiguration configuration) { FilePath = filePath; Configuration = configuration; Version = VersionStamp.Default; }
public SerializedProjectSnapshot(string filePath, RazorConfiguration configuration, string rootNamespace) { FilePath = filePath; Configuration = configuration; RootNamespace = rootNamespace; Version = VersionStamp.Default; }
public CodeGenerationIntegrationTest() : base(generateBaselines: null) { Configuration = RazorConfiguration.Create( RazorLanguageVersion.Version_2_0, "MVC-2.1", new[] { new AssemblyExtension("MVC-2.1", typeof(ExtensionInitializer).Assembly) }); }
public RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure) { return(RazorProjectEngine.Create(configuration, fileSystem, builder => { var csharpLoweringIndex = builder.Phases.IndexOf(builder.Phases.OfType <IRazorCSharpLoweringPhase>().Single()); builder.Phases[csharpLoweringIndex] = new UnsupportedCSharpLoweringPhase(); })); }
public CodeGenerationIntegrationTest() : base(generateBaselines: null, projectDirectoryHint: "Microsoft.AspNetCore.Mvc.Razor.Extensions.Version2_X") { Configuration = RazorConfiguration.Create( RazorLanguageVersion.Version_2_0, "MVC-2.1", new[] { new AssemblyExtension("MVC-2.1", typeof(ExtensionInitializer).Assembly) }); }
public override RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure) { return(Engine ?? RazorProjectEngine.Create(configuration, fileSystem, b => { configure(b); Configure(b); })); }
public RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure) { return(RazorProjectEngine.Create(configuration, fileSystem, b => { CompilerFeatures.Register(b); configure?.Invoke(b); })); }
public override void UpdateProject( string filePath, RazorConfiguration configuration, string rootNamespace, ProjectWorkspaceState projectWorkspaceState, IReadOnlyList <DocumentSnapshotHandle> documents) { _foregroundDispatcher.AssertForegroundThread(); var normalizedPath = _filePathNormalizer.Normalize(filePath); var project = (DefaultProjectSnapshot)_projectSnapshotManagerAccessor.Instance.GetLoadedProject(normalizedPath); if (project == null) { // Never tracked the project to begin with, noop. _logger.LogInformation($"Failed to update untracked project '{filePath}'."); return; } UpdateProjectDocuments(documents, project.FilePath); if (!projectWorkspaceState.Equals(ProjectWorkspaceState.Default)) { _logger.LogInformation($"Updating project '{filePath}' TagHelpers ({projectWorkspaceState.TagHelpers.Count}) and C# Language Version ({projectWorkspaceState.CSharpLanguageVersion})."); } _projectSnapshotManagerAccessor.Instance.ProjectWorkspaceStateChanged(project.FilePath, projectWorkspaceState); var currentHostProject = project.HostProject; var currentConfiguration = currentHostProject.Configuration; if (currentConfiguration.ConfigurationName == configuration?.ConfigurationName && currentHostProject.RootNamespace == rootNamespace) { _logger.LogTrace($"Updating project '{filePath}'. The project is already using configuration '{configuration.ConfigurationName}' and root namespace '{rootNamespace}'."); return; } if (configuration == null) { configuration = RazorDefaults.Configuration; _logger.LogInformation($"Updating project '{filePath}' to use Razor's default configuration ('{configuration.ConfigurationName}')'."); } else if (currentConfiguration.ConfigurationName != configuration.ConfigurationName) { _logger.LogInformation($"Updating project '{filePath}' to Razor configuration '{configuration.ConfigurationName}' with language version '{configuration.LanguageVersion}'."); } if (currentHostProject.RootNamespace != rootNamespace) { _logger.LogInformation($"Updating project '{filePath}''s root namespace to '{rootNamespace}'."); } var hostProject = new HostProject(project.FilePath, configuration, rootNamespace); _projectSnapshotManagerAccessor.Instance.ProjectConfigurationChanged(hostProject); }
private IProjectEngineFactory CreateFactory(RazorConfiguration configuration, string factoryTypeName) { if (factoryTypeName == null) { return(null); } return((IProjectEngineFactory)Activator.CreateInstance(Type.GetType(factoryTypeName, throwOnError: true))); }
public SerializedProjectSnapshot(string filePath, RazorConfiguration configuration, Project workspaceProject) { FilePath = filePath; Configuration = configuration; WorkspaceProject = workspaceProject; IsInitialized = true; Version = VersionStamp.Default; }
public DefaultRazorCodeGenerationOptionsBuilder(RazorConfiguration configuration, string fileKind) { if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } Configuration = configuration; FileKind = fileKind; }
protected RazorProjectEngine CreateProjectEngine(Action <RazorProjectEngineBuilder> configure) { var configuration = RazorConfiguration.Create(Version, "test", Array.Empty <RazorExtension>()); return(RazorProjectEngine.Create(configuration, RazorProjectFileSystem.Empty, b => { ConfigureProjectEngine(b); configure?.Invoke(b); })); }
public static RazorSourceGenerationContext Create(GeneratorExecutionContext context) { var globalOptions = context.AnalyzerConfigOptions.GlobalOptions; if (!globalOptions.TryGetValue("build_property.RootNamespace", out var rootNamespace)) { rootNamespace = "ASP"; } globalOptions.TryGetValue("build_property.DesignTimeBuild", out var designTimeBuild); if (!globalOptions.TryGetValue("build_property._RazorReferenceAssemblyTagHelpersOutputPath", out var refsTagHelperOutputCachePath)) { throw new InvalidOperationException("_RazorReferenceAssemblyTagHelpersOutputPath is not specified."); } if (!globalOptions.TryGetValue("build_property.RazorLangVersion", out var razorLanguageVersionString) || !RazorLanguageVersion.TryParse(razorLanguageVersionString, out var razorLanguageVersion)) { context.ReportDiagnostic(Diagnostic.Create( RazorDiagnostics.InvalidRazorLangVersionDescriptor, Location.None, razorLanguageVersionString)); return(null); } if (!globalOptions.TryGetValue("build_property.RazorConfiguration", out var configurationName)) { configurationName = "default"; } globalOptions.TryGetValue("build_property._RazorSourceGeneratorDebug", out var waitForDebugger); globalOptions.TryGetValue("build_property._RazorSourceGeneratorWriteGeneratedOutput", out var writeOutput); globalOptions.TryGetValue("build_property._RazorSourceGeneratorLog", out var enableLogging); var razorConfiguration = RazorConfiguration.Create(razorLanguageVersion, configurationName, Enumerable.Empty <RazorExtension>()); var(razorFiles, cshtmlFiles) = GetRazorInputs(context); var fileSystem = GetVirtualFileSystem(razorFiles, cshtmlFiles); return(new RazorSourceGenerationContext { RootNamespace = rootNamespace, Configuration = razorConfiguration, FileSystem = fileSystem, RazorFiles = razorFiles, CshtmlFiles = cshtmlFiles, DesignTimeBuild = designTimeBuild == "true", RefsTagHelperOutputCachePath = refsTagHelperOutputCachePath, WaitForDebugger = waitForDebugger == "true", WriteGeneratedContent = writeOutput == "true", EnableLogging = enableLogging == "true" }); }
public MSBuildProjectManagerTest() { var projectInstanceEvaluator = new Mock<ProjectInstanceEvaluator>(); projectInstanceEvaluator.Setup(instance => instance.Evaluate(It.IsAny<ProjectInstance>())) .Returns<ProjectInstance>(pi => pi); ProjectInstanceEvaluator = projectInstanceEvaluator.Object; CustomConfiguration = RazorConfiguration.Create( RazorLanguageVersion.Experimental, "Custom", Enumerable.Empty<RazorExtension>()); }
public RazorProjectEngine Create(RazorConfiguration configuration, RazorProjectFileSystem fileSystem, Action <RazorProjectEngineBuilder> configure) { return(RazorProjectEngine.Create(configuration, fileSystem, b => { configure?.Invoke(b); new BlazorExtensionInitializer().Initialize(b); var classifier = b.Features.OfType <ComponentDocumentClassifierPass>().Single(); classifier.MangleClassNames = true; })); }
public SerializedProjectSnapshot(string filePath, RazorConfiguration configuration, Project workspaceProject) { FilePath = filePath; Configuration = configuration; HostProject = new HostProject(filePath, configuration); WorkspaceProject = workspaceProject; TagHelpers = Array.Empty <TagHelperDescriptor>(); IsInitialized = true; Version = VersionStamp.Default; }
private RazorEngine CreateEngine() { var configuration = RazorConfiguration.Create(RazorLanguageVersion.Version_1_1, "test", Array.Empty <RazorExtension>()); return(RazorProjectEngine.Create(configuration, RazorProjectFileSystem.Empty, b => { // Notice we're not registering the InjectDirective.Pass here so we can run it on demand. b.AddDirective(InjectDirective.Directive); b.AddDirective(ModelDirective.Directive); }).Engine); }
public DefaultRazorParserOptionsBuilder(RazorConfiguration configuration, string fileKind) { if (configuration == null) { throw new ArgumentNullException(nameof(configuration)); } Configuration = configuration; LanguageVersion = configuration.LanguageVersion; FileKind = fileKind; }