public OOPTagHelperResolverTest() { HostProject_For_2_0 = new HostProject("Test.csproj", FallbackRazorConfiguration.MVC_2_0); HostProject_For_NonSerializableConfiguration = new HostProject( "Test.csproj", new ProjectSystemRazorConfiguration(RazorLanguageVersion.Version_2_1, "Blazor-0.1", Array.Empty <RazorExtension>())); CustomFactories = new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>[] { new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>( () => new LegacyProjectEngineFactory_2_0(), typeof(LegacyProjectEngineFactory_2_0).GetCustomAttribute <ExportCustomProjectEngineFactoryAttribute>()), // We don't really use this factory, we just use it to ensure that the call is going to go out of process. new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>( () => new LegacyProjectEngineFactory_2_1(), new ExportCustomProjectEngineFactoryAttribute("Blazor-0.1") { SupportsSerialization = false, }), }; FallbackFactory = new FallbackProjectEngineFactory(); Workspace = new AdhocWorkspace(); var info = ProjectInfo.Create(ProjectId.CreateNewId("Test"), VersionStamp.Default, "Test", "Test", LanguageNames.CSharp, filePath: "Test.csproj"); WorkspaceProject = Workspace.CurrentSolution.AddProject(info).GetProject(info.Id); ErrorReporter = new DefaultErrorReporter(); ProjectManager = new TestProjectSnapshotManager(Workspace); EngineFactory = new DefaultProjectSnapshotProjectEngineFactory(FallbackFactory, CustomFactories); }
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 void UpdateGuestProjectManager_ProjectChanged_ProjectWorkspaceStateChange() { // Arrange var oldHandle = new ProjectSnapshotHandleProxy( new Uri("vsls:/path/project.csproj"), RazorConfiguration.Default, "project", ProjectWorkspaceState.Default); var newProjectWorkspaceState = ProjectWorkspaceStateWithTagHelpers; var newHandle = new ProjectSnapshotHandleProxy( oldHandle.FilePath, oldHandle.Configuration, oldHandle.RootNamespace, newProjectWorkspaceState); 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.ProjectWorkspaceStateChanged(hostProject.FilePath, oldHandle.ProjectWorkspaceState); 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(RazorConfiguration.Default, project.Configuration); Assert.Same(newProjectWorkspaceState.TagHelpers, project.TagHelpers); }
public DefaultProjectResolver( ForegroundDispatcher foregroundDispatcher, FilePathNormalizer filePathNormalizer, RazorConfigurationResolver configurationResolver, ProjectSnapshotManagerAccessor projectSnapshotManagerAccessor) { if (foregroundDispatcher == null) { throw new ArgumentNullException(nameof(foregroundDispatcher)); } if (filePathNormalizer == null) { throw new ArgumentNullException(nameof(filePathNormalizer)); } if (configurationResolver == null) { throw new ArgumentNullException(nameof(configurationResolver)); } if (projectSnapshotManagerAccessor == null) { throw new ArgumentNullException(nameof(projectSnapshotManagerAccessor)); } _foregroundDispatcher = foregroundDispatcher; _filePathNormalizer = filePathNormalizer; _projectSnapshotManagerAccessor = projectSnapshotManagerAccessor; var miscellaneousProjectPath = Path.Combine(TempDirectory.Instance.DirectoryPath, "__MISC_RAZOR_PROJECT__"); _miscellaneousHostProject = new HostProject(miscellaneousProjectPath, configurationResolver.Default); }
public ProjectSnapshotManagerBenchmarkBase() { var current = new DirectoryInfo(AppContext.BaseDirectory); while (current != null && !File.Exists(Path.Combine(current.FullName, "Razor.sln"))) { current = current.Parent; } var root = current; var projectRoot = Path.Combine(root.FullName, "test", "testapps", "LargeProject"); HostProject = new HostProject(Path.Combine(projectRoot, "LargeProject.csproj"), FallbackRazorConfiguration.MVC_2_1); TextLoaders = new TextLoader[4]; for (var i = 0; i < 4; i++) { var filePath = Path.Combine(projectRoot, "Views", "Home", $"View00{i % 4}.cshtml"); var text = SourceText.From(filePath, encoding: null); TextLoaders[i] = TextLoader.From(TextAndVersion.Create(text, VersionStamp.Create())); } Documents = new HostDocument[100]; for (var i = 0; i < Documents.Length; i++) { var filePath = Path.Combine(projectRoot, "Views", "Home", $"View00{i % 4}.cshtml"); Documents[i] = new HostDocument(filePath, $"/Views/Home/View00{i}.cshtml", FileKinds.Legacy); } var tagHelpers = Path.Combine(root.FullName, "benchmarks", "Microsoft.AspNetCore.Razor.Performance", "taghelpers.json"); TagHelperResolver = new StaticTagHelperResolver(ReadTagHelpers(tagHelpers)); }
public void UpdateProject_KnownDocuments() { // Arrange var projectManager = TestProjectSnapshotManager.Create(Dispatcher); var hostProject = new HostProject("/path/to/project.csproj", RazorConfiguration.Default, "TestRootNamespace"); projectManager.ProjectAdded(hostProject); var document = new HostDocument("/path/to/file.cshtml", "file.cshtml", FileKinds.Legacy); projectManager.DocumentAdded(hostProject, document, Mock.Of <TextLoader>()); var projectService = CreateProjectService(Mock.Of <ProjectResolver>(), projectManager); var newDocument = new DocumentSnapshotHandle(document.FilePath, document.TargetPath, document.FileKind); projectManager.AllowNotifyListeners = true; projectManager.Changed += (sender, args) => { if (args.Kind == ProjectChangeKind.DocumentRemoved || args.Kind == ProjectChangeKind.DocumentChanged || args.Kind == ProjectChangeKind.DocumentAdded) { throw new XunitException("Should have nooped"); } }; // Act & Assert projectService.UpdateProject(hostProject.FilePath, hostProject.Configuration, hostProject.RootNamespace, ProjectWorkspaceState.Default, new[] { newDocument }); }
protected override async Task OnProjectChangedAsync() { ForegroundDispatcher.AssertBackgroundThread(); await ExecuteWithLockAsync(async() => { var referencedAssemblies = await DotNetProject.GetReferencedAssemblies(ConfigurationSelector.Default); var mvcReference = referencedAssemblies.FirstOrDefault(IsMvcAssembly); if (mvcReference == null) { // Ok we can't find an MVC version. Let's assume this project isn't using Razor then. await UpdateHostProjectUnsafeAsync(null).ConfigureAwait(false); return; } var version = GetAssemblyVersion(mvcReference.FilePath); if (version == null) { // Ok we can't find an MVC version. Let's assume this project isn't using Razor then. await UpdateHostProjectUnsafeAsync(null).ConfigureAwait(false); return; } var configuration = FallbackRazorConfiguration.SelectConfiguration(version); var hostProject = new HostProject(DotNetProject.FileName.FullPath, configuration, rootNamespace: null); await UpdateHostProjectUnsafeAsync(hostProject).ConfigureAwait(false); }); }
private void UpdateDocuments(HostProject hostProject, IEnumerable <IMSBuildItemEvaluated> projectItems) { var projectDirectory = Path.GetDirectoryName(hostProject.FilePath); var documentFilePaths = GetRazorDocuments(projectDirectory, projectItems); var oldFiles = _currentRazorFilePaths; var newFiles = documentFilePaths.ToImmutableHashSet(); var addedFiles = newFiles.Except(oldFiles); var removedFiles = oldFiles.Except(newFiles); _currentRazorFilePaths = documentFilePaths; _ = ProjectSnapshotManagerDispatcher.RunOnDispatcherThreadAsync(() => { foreach (var document in removedFiles) { RemoveDocument(hostProject, document); } foreach (var document in addedFiles) { var relativeFilePath = document.Substring(projectDirectory.Length + 1); AddDocument(hostProject, document, relativeFilePath); } }, CancellationToken.None); }
public DefaultVisualStudioDocumentTrackerTest() { RazorCoreContentType = Mock.Of <IContentType>(c => c.IsOfType(RazorLanguage.ContentType) == true); TextBuffer = Mock.Of <ITextBuffer>(b => b.ContentType == RazorCoreContentType); FilePath = TestProjectData.SomeProjectFile1.FilePath; ProjectPath = TestProjectData.SomeProject.FilePath; ImportDocumentManager = Mock.Of <ImportDocumentManager>(); WorkspaceEditorSettings = new DefaultWorkspaceEditorSettings(Mock.Of <ForegroundDispatcher>(), Mock.Of <EditorSettingsManager>()); SomeTagHelpers = new List <TagHelperDescriptor>() { TagHelperDescriptorBuilder.Create("test", "test").Build(), }; ProjectManager = new TestProjectSnapshotManager(Dispatcher, Workspace) { AllowNotifyListeners = true }; HostProject = new HostProject(ProjectPath, FallbackRazorConfiguration.MVC_2_1); UpdatedHostProject = new HostProject(ProjectPath, FallbackRazorConfiguration.MVC_2_0); OtherHostProject = new HostProject(TestProjectData.AnotherProject.FilePath, FallbackRazorConfiguration.MVC_2_0); DocumentTracker = new DefaultVisualStudioDocumentTracker( Dispatcher, FilePath, ProjectPath, ProjectManager, WorkspaceEditorSettings, Workspace, TextBuffer, ImportDocumentManager); }
protected override async Task OnProjectChangedAsync() { await ExecuteWithLockAsync(async() => { var projectProperties = DotNetProject.MSBuildProject.EvaluatedProperties; var projectItems = DotNetProject.MSBuildProject.EvaluatedItems; if (TryGetIntermediateOutputPath(projectProperties, out var intermediatePath)) { var projectConfigurationFile = Path.Combine(intermediatePath, _languageServerFeatureOptions.ProjectConfigurationFileName); ProjectConfigurationFilePathStore.Set(DotNetProject.FileName.FullPath, projectConfigurationFile); } if (TryGetConfiguration(projectProperties, projectItems, out var configuration)) { TryGetRootNamespace(projectProperties, out var rootNamespace); var hostProject = new HostProject(DotNetProject.FileName.FullPath, configuration, rootNamespace); await UpdateHostProjectUnsafeAsync(hostProject).ConfigureAwait(false); UpdateDocuments(hostProject, projectItems); } else { // Ok we can't find a configuration. Let's assume this project isn't using Razor then. await UpdateHostProjectUnsafeAsync(null).ConfigureAwait(false); } }); }
private void AttachToDocument(uint docCookie, string moniker) { _foregroundThreadAffinitization.AssertIsForeground(); var vsTextBuffer = (IVsTextBuffer)_runningDocumentTable.GetDocumentData(docCookie); var textBuffer = _editorAdaptersFactoryService.GetDocumentBuffer(vsTextBuffer); if (_fileTrackingMetadataAsSourceService.TryAddDocumentToWorkspace(moniker, textBuffer)) { // We already added it, so we will keep it excluded from the misc files workspace return; } // This should always succeed since we only got here if we already confirmed the moniker is acceptable var languageInformation = TryGetLanguageInformation(moniker); Contract.ThrowIfNull(languageInformation); var parseOptions = languageInformation.ParseOptions; if (Path.GetExtension(moniker) == languageInformation.ScriptExtension) { parseOptions = parseOptions.WithKind(SourceCodeKind.Script); } // First, create the project var hostProject = new HostProject(this, CurrentSolution.Id, languageInformation.LanguageName, parseOptions, _metadataReferences); // Now try to find the document. We accept any text buffer, since we've already verified it's an appropriate file in ShouldIncludeFile. var document = _documentProvider.TryGetDocumentForFile( hostProject, moniker, parseOptions.Kind, getFolderNames: _ => SpecializedCollections.EmptyReadOnlyList <string>(), canUseTextBuffer: _ => true); // If the buffer has not yet been initialized, we won't get a document. if (document == null) { return; } // Since we have a document, we can do the rest of the project setup. _hostProjects.Add(hostProject.Id, hostProject); OnProjectAdded(hostProject.CreateProjectInfoForCurrentState()); OnDocumentAdded(document.GetInitialState()); hostProject.Document = document; // Notify the document provider, so it knows the document is now open and a part of // the project _documentProvider.NotifyDocumentRegisteredToProjectAndStartToRaiseEvents(document); Contract.ThrowIfFalse(document.IsOpen); var buffer = document.GetOpenTextBuffer(); OnDocumentOpened(document.Id, document.GetOpenTextContainer()); _docCookiesToHostProject.Add(docCookie, hostProject); }
// Adapted from DocumentExcerptServiceTestBase's InitializeDocument. // Adds the text to a ProjectSnapshot, generates code, and updates the workspace. private Document InitializeDocument(SourceText sourceText) { var baseDirectory = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) ? "c:\\users\\example\\src" : "/home/example"; var hostProject = new HostProject( Path.Combine(baseDirectory, "SomeProject", "SomeProject.csproj"), RazorConfiguration.Default, "SomeProject"); var hostDocument = new HostDocument( Path.Combine(baseDirectory, "SomeProject", "File1.cshtml"), "File1.cshtml", FileKinds.Legacy); var project = new DefaultProjectSnapshot( ProjectState.Create(Workspace.Services, hostProject) .WithAddedHostDocument(hostDocument, () => Task.FromResult(TextAndVersion.Create(sourceText, VersionStamp.Create())))); var documentSnapshot = project.GetDocument(hostDocument.FilePath); var solution = Workspace.CurrentSolution.AddProject(ProjectInfo.Create( ProjectId.CreateNewId(Path.GetFileNameWithoutExtension(hostDocument.FilePath)), VersionStamp.Create(), Path.GetFileNameWithoutExtension(hostDocument.FilePath), Path.GetFileNameWithoutExtension(hostDocument.FilePath), LanguageNames.CSharp, hostDocument.FilePath)); solution = solution.AddDocument( DocumentId.CreateNewId(solution.ProjectIds.Single(), hostDocument.FilePath), hostDocument.FilePath, new GeneratedDocumentTextLoader(documentSnapshot, hostDocument.FilePath)); var document = solution.Projects.Single().Documents.Single(); return(document); }
private void AddDocumentToMiscellaneousOrMetadataAsSourceWorkspace(uint docCookie, string moniker) { var languageInformation = TryGetLanguageInformation(moniker); if (languageInformation != null && !_filesInProjects.Any(d => StringComparer.OrdinalIgnoreCase.Equals(d.Moniker, moniker)) && !_docCookiesToHostProject.ContainsKey(docCookie)) { // See if we should push to this to the metadata-to-source workspace instead. if (_runningDocumentTable.IsDocumentInitialized(docCookie)) { var vsTextBuffer = (IVsTextBuffer)_runningDocumentTable.GetDocumentData(docCookie); var textBuffer = _editorAdaptersFactoryService.GetDocumentBuffer(vsTextBuffer); if (_fileTrackingMetadataAsSourceService.TryAddDocumentToWorkspace(moniker, textBuffer)) { // We already added it, so we will keep it excluded from the misc files workspace return; } } var parseOptions = languageInformation.ParseOptions; if (Path.GetExtension(moniker) == languageInformation.ScriptExtension) { parseOptions = parseOptions.WithKind(SourceCodeKind.Script); } // First, create the project var hostProject = new HostProject(this, CurrentSolution.Id, languageInformation.LanguageName, parseOptions, _metadataReferences); // Now try to find the document. We accept any text buffer, since we've already verified it's an appropriate file in ShouldIncludeFile. var document = _documentProvider.TryGetDocumentForFile(hostProject, (uint)VSConstants.VSITEMID.Nil, moniker, parseOptions.Kind, t => true); // If the buffer has not yet been initialized, we won't get a document. if (document == null) { return; } // Since we have a document, we can do the rest of the project setup. _hostProjects.Add(hostProject.Id, hostProject); OnProjectAdded(hostProject.CreateProjectInfoForCurrentState()); OnDocumentAdded(document.GetInitialState()); hostProject.Document = document; // Notify the document provider, so it knows the document is now open and a part of // the project _documentProvider.NotifyDocumentRegisteredToProject(document); Contract.ThrowIfFalse(document.IsOpen); var buffer = document.GetOpenTextBuffer(); OnDocumentOpened(document.Id, document.GetOpenTextContainer()); _docCookiesToHostProject.Add(docCookie, hostProject); } }
protected void RemoveDocument(HostProject hostProject, string filePath) { if (_currentDocuments.TryGetValue(filePath, out var hostDocument)) { _projectSnapshotManager.DocumentRemoved(hostProject, hostDocument); _currentDocuments.Remove(filePath); } }
public DefaultWorkspaceSemanticTokensRefreshTriggerTest() { ProjectManager = TestProjectSnapshotManager.Create(LegacyDispatcher); ProjectManager.AllowNotifyListeners = true; HostProject = new HostProject("/path/to/project.csproj", RazorConfiguration.Default, "TestRootNamespace"); ProjectManager.ProjectAdded(HostProject); HostDocument = new HostDocument("/path/to/file.razor", "file.razor"); ProjectManager.DocumentAdded(HostProject, HostDocument, new EmptyTextLoader(HostDocument.FilePath)); }
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); }
public DefaultProjectSnapshotProjectEngineFactoryTest() { Project project = null; Workspace = TestWorkspace.Create(workspace => { var info = ProjectInfo.Create(ProjectId.CreateNewId("Test"), VersionStamp.Default, "Test", "Test", LanguageNames.CSharp, filePath: "/TestPath/SomePath/Test.csproj"); project = workspace.CurrentSolution.AddProject(info).GetProject(info.Id); }); WorkspaceProject = project; HostProject_For_1_0 = new HostProject("/TestPath/SomePath/Test.csproj", FallbackRazorConfiguration.MVC_1_0); HostProject_For_1_1 = new HostProject("/TestPath/SomePath/Test.csproj", FallbackRazorConfiguration.MVC_1_1); HostProject_For_2_0 = new HostProject("/TestPath/SomePath/Test.csproj", FallbackRazorConfiguration.MVC_2_0); HostProject_For_2_1 = new HostProject( "/TestPath/SomePath/Test.csproj", new ProjectSystemRazorConfiguration(RazorLanguageVersion.Version_2_1, "MVC-2.1", Array.Empty <RazorExtension>())); HostProject_For_3_0 = new HostProject( "/TestPath/SomePath/Test.csproj", new ProjectSystemRazorConfiguration(RazorLanguageVersion.Version_3_0, "MVC-3.0", Array.Empty <RazorExtension>())); HostProject_For_UnknownConfiguration = new HostProject( "/TestPath/SomePath/Test.csproj", new ProjectSystemRazorConfiguration(RazorLanguageVersion.Version_2_1, "Blazor-0.1", Array.Empty <RazorExtension>())); Snapshot_For_1_0 = new DefaultProjectSnapshot(ProjectState.Create(Workspace.Services, HostProject_For_1_0, WorkspaceProject)); Snapshot_For_1_1 = new DefaultProjectSnapshot(ProjectState.Create(Workspace.Services, HostProject_For_1_1, WorkspaceProject)); Snapshot_For_2_0 = new DefaultProjectSnapshot(ProjectState.Create(Workspace.Services, HostProject_For_2_0, WorkspaceProject)); Snapshot_For_2_1 = new DefaultProjectSnapshot(ProjectState.Create(Workspace.Services, HostProject_For_2_1, WorkspaceProject)); Snapshot_For_3_0 = new DefaultProjectSnapshot(ProjectState.Create(Workspace.Services, HostProject_For_3_0, WorkspaceProject)); Snapshot_For_UnknownConfiguration = new DefaultProjectSnapshot(ProjectState.Create(Workspace.Services, HostProject_For_UnknownConfiguration, WorkspaceProject)); CustomFactories = new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>[] { new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>( () => new LegacyProjectEngineFactory_1_0(), typeof(LegacyProjectEngineFactory_1_0).GetCustomAttribute <ExportCustomProjectEngineFactoryAttribute>()), new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>( () => new LegacyProjectEngineFactory_1_1(), typeof(LegacyProjectEngineFactory_1_1).GetCustomAttribute <ExportCustomProjectEngineFactoryAttribute>()), new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>( () => new LegacyProjectEngineFactory_2_0(), typeof(LegacyProjectEngineFactory_2_0).GetCustomAttribute <ExportCustomProjectEngineFactoryAttribute>()), new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>( () => new LegacyProjectEngineFactory_2_1(), typeof(LegacyProjectEngineFactory_2_1).GetCustomAttribute <ExportCustomProjectEngineFactoryAttribute>()), new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>( () => new LegacyProjectEngineFactory_3_0(), typeof(LegacyProjectEngineFactory_3_0).GetCustomAttribute <ExportCustomProjectEngineFactoryAttribute>()), }; FallbackFactory = new FallbackProjectEngineFactory(); }
public DefaultGeneratedDocumentPublisherTest() { Server = new TestServer(); ProjectManager = TestProjectSnapshotManager.Create(Dispatcher); ProjectManager.AllowNotifyListeners = true; HostProject = new HostProject("/path/to/project.csproj", RazorConfiguration.Default, "TestRootNamespace"); ProjectManager.ProjectAdded(HostProject); HostDocument = new HostDocument("/path/to/file.razor", "file.razor"); ProjectManager.DocumentAdded(HostProject, HostDocument, new EmptyTextLoader(HostDocument.FilePath)); }
public BackgroundDocumentGeneratorTest() { Documents = new HostDocument[] { new HostDocument("c:/Test1/Index.cshtml", "Index.cshtml"), new HostDocument("c:/Test1/Components/Counter.cshtml", "Components/Counter.cshtml"), }; HostProject1 = new HostProject("c:/Test1/Test1.csproj", RazorConfiguration.Default, "TestRootNamespace"); HostProject2 = new HostProject("c:/Test2/Test2.csproj", RazorConfiguration.Default, "TestRootNamespace"); }
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; }
public override void AddProject(string filePath) { _foregroundDispatcher.AssertForegroundThread(); var normalizedPath = _filePathNormalizer.Normalize(filePath); var hostProject = new HostProject(normalizedPath, RazorDefaults.Configuration, RazorDefaults.RootNamespace); _projectSnapshotManagerAccessor.Instance.ProjectAdded(hostProject); _logger.LogInformation($"Added project '{filePath}' to project system."); TryMigrateMiscellaneousDocumentsToProject(); }
public DocumentOutputReferenceCapturerTest() { ProjectManager = TestProjectSnapshotManager.Create(Dispatcher); ProjectManager.AllowNotifyListeners = true; HostProject = new HostProject("C:/path/to/project.csproj", RazorConfiguration.Default, "TestNamespace"); ProjectManager.ProjectAdded(HostProject); HostDocument = new HostDocument("C:/path/to/file.razor", "file.razor"); ProjectManager.DocumentAdded(HostProject, HostDocument, new EmptyTextLoader(HostDocument.FilePath)); DocumentOutputReferenceCapturer = new DocumentOutputReferenceCapturer(); DocumentOutputReferenceCapturer.Initialize(ProjectManager); }
public ProjectBuildChangeTriggerTest() { SomeProject = new HostProject("c:\\SomeProject\\SomeProject.csproj", FallbackRazorConfiguration.MVC_1_0, "SomeProject"); SomeOtherProject = new HostProject("c:\\SomeOtherProject\\SomeOtherProject.csproj", FallbackRazorConfiguration.MVC_2_0, "SomeOtherProject"); Workspace = TestWorkspace.Create(w => SomeWorkspaceProject = w.AddProject(ProjectInfo.Create( ProjectId.CreateNewId(), VersionStamp.Create(), "SomeProject", "SomeProject", LanguageNames.CSharp, filePath: SomeProject.FilePath))); }
public VsSolutionUpdatesProjectSnapshotChangeTriggerTest() { SomeProject = new HostProject(TestProjectData.SomeProject.FilePath, FallbackRazorConfiguration.MVC_1_0, TestProjectData.SomeProject.RootNamespace); SomeOtherProject = new HostProject(TestProjectData.AnotherProject.FilePath, FallbackRazorConfiguration.MVC_2_0, TestProjectData.AnotherProject.RootNamespace); Workspace = TestWorkspace.Create(w => SomeWorkspaceProject = w.AddProject(ProjectInfo.Create( ProjectId.CreateNewId(), VersionStamp.Create(), "SomeProject", "SomeProject", LanguageNames.CSharp, filePath: SomeProject.FilePath))); }
public async Task ProjectRemoved_UnSetPublishFilePath_NoopsAsync() { // Arrange var snapshotManager = CreateProjectSnapshotManager(allowNotifyListeners: true); var publisher = new TestDefaultRazorProjectChangePublisher(JoinableTaskContext, RazorLogger); publisher.Initialize(snapshotManager); var hostProject = new HostProject("/path/to/project.csproj", RazorConfiguration.Default, "TestRootNamespace"); await RunOnForegroundAsync(() => snapshotManager.ProjectAdded(hostProject)).ConfigureAwait(false); // Act & Assert await RunOnForegroundAsync(() => snapshotManager.ProjectRemoved(hostProject)).ConfigureAwait(false); }
public DefaultProjectSnapshotProjectEngineFactoryTest() { Workspace = TestWorkspace.Create(); ProjectWorkspaceState = ProjectWorkspaceState.Default; HostProject_For_1_0 = new HostProject("/TestPath/SomePath/Test.csproj", FallbackRazorConfiguration.MVC_1_0, "Test"); HostProject_For_1_1 = new HostProject("/TestPath/SomePath/Test.csproj", FallbackRazorConfiguration.MVC_1_1, "Test"); HostProject_For_2_0 = new HostProject("/TestPath/SomePath/Test.csproj", FallbackRazorConfiguration.MVC_2_0, "Test"); HostProject_For_2_1 = new HostProject( "/TestPath/SomePath/Test.csproj", new ProjectSystemRazorConfiguration(RazorLanguageVersion.Version_2_1, "MVC-2.1", Array.Empty <RazorExtension>()), "Test"); HostProject_For_3_0 = new HostProject( "/TestPath/SomePath/Test.csproj", new ProjectSystemRazorConfiguration(RazorLanguageVersion.Version_3_0, "MVC-3.0", Array.Empty <RazorExtension>()), "Test"); HostProject_For_UnknownConfiguration = new HostProject( "/TestPath/SomePath/Test.csproj", new ProjectSystemRazorConfiguration(RazorLanguageVersion.Version_2_1, "Random-0.1", Array.Empty <RazorExtension>()), rootNamespace: null); Snapshot_For_1_0 = new DefaultProjectSnapshot(ProjectState.Create(Workspace.Services, HostProject_For_1_0, ProjectWorkspaceState)); Snapshot_For_1_1 = new DefaultProjectSnapshot(ProjectState.Create(Workspace.Services, HostProject_For_1_1, ProjectWorkspaceState)); Snapshot_For_2_0 = new DefaultProjectSnapshot(ProjectState.Create(Workspace.Services, HostProject_For_2_0, ProjectWorkspaceState)); Snapshot_For_2_1 = new DefaultProjectSnapshot(ProjectState.Create(Workspace.Services, HostProject_For_2_1, ProjectWorkspaceState)); Snapshot_For_3_0 = new DefaultProjectSnapshot(ProjectState.Create(Workspace.Services, HostProject_For_3_0, ProjectWorkspaceState)); Snapshot_For_UnknownConfiguration = new DefaultProjectSnapshot(ProjectState.Create(Workspace.Services, HostProject_For_UnknownConfiguration, ProjectWorkspaceState)); CustomFactories = new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>[] { new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>( () => new LegacyProjectEngineFactory_1_0(), typeof(LegacyProjectEngineFactory_1_0).GetCustomAttribute <ExportCustomProjectEngineFactoryAttribute>()), new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>( () => new LegacyProjectEngineFactory_1_1(), typeof(LegacyProjectEngineFactory_1_1).GetCustomAttribute <ExportCustomProjectEngineFactoryAttribute>()), new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>( () => new LegacyProjectEngineFactory_2_0(), typeof(LegacyProjectEngineFactory_2_0).GetCustomAttribute <ExportCustomProjectEngineFactoryAttribute>()), new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>( () => new LegacyProjectEngineFactory_2_1(), typeof(LegacyProjectEngineFactory_2_1).GetCustomAttribute <ExportCustomProjectEngineFactoryAttribute>()), new Lazy <IProjectEngineFactory, ICustomProjectEngineFactoryMetadata>( () => new LegacyProjectEngineFactory_3_0(), typeof(LegacyProjectEngineFactory_3_0).GetCustomAttribute <ExportCustomProjectEngineFactoryAttribute>()), }; FallbackFactory = new FallbackProjectEngineFactory(); }
public BackgroundDocumentGeneratorTest() { Documents = new HostDocument[] { new HostDocument("c:\\Test1\\Index.cshtml", "Index.cshtml"), new HostDocument("c:\\Test1\\Components\\Counter.cshtml", "Components\\Counter.cshtml"), }; HostProject1 = new HostProject("c:\\Test1\\Test1.csproj", RazorConfiguration.Default); HostProject2 = new HostProject("c:\\Test2\\Test2.csproj", RazorConfiguration.Default); var projectId1 = ProjectId.CreateNewId("Test1"); var projectId2 = ProjectId.CreateNewId("Test2"); }
public DefaultVisualStudioDocumentTrackerTest() { RazorCoreContentType = Mock.Of <IContentType>(c => c.IsOfType(RazorLanguage.ContentType) == true); TextBuffer = Mock.Of <ITextBuffer>(b => b.ContentType == RazorCoreContentType); FilePath = "C:/Some/Path/TestDocumentTracker.cshtml"; ProjectPath = "C:/Some/Path/TestProject.csproj"; ImportDocumentManager = Mock.Of <ImportDocumentManager>(); WorkspaceEditorSettings = new DefaultWorkspaceEditorSettings(Mock.Of <ForegroundDispatcher>(), Mock.Of <EditorSettingsManager>()); TagHelperResolver = new TestTagHelperResolver(); SomeTagHelpers = new List <TagHelperDescriptor>() { TagHelperDescriptorBuilder.Create("test", "test").Build(), }; HostServices = TestServices.Create( new IWorkspaceService[] { }, new ILanguageService[] { TagHelperResolver, }); Workspace = TestWorkspace.Create(HostServices, w => { WorkspaceProject = w.AddProject(ProjectInfo.Create( ProjectId.CreateNewId(), new VersionStamp(), "Test1", "TestAssembly", LanguageNames.CSharp, filePath: ProjectPath)); }); ProjectManager = new TestProjectSnapshotManager(Dispatcher, Workspace) { AllowNotifyListeners = true }; HostProject = new HostProject(ProjectPath, FallbackRazorConfiguration.MVC_2_1); OtherHostProject = new HostProject(ProjectPath, FallbackRazorConfiguration.MVC_2_0); DocumentTracker = new DefaultVisualStudioDocumentTracker( Dispatcher, FilePath, ProjectPath, ProjectManager, WorkspaceEditorSettings, Workspace, TextBuffer, ImportDocumentManager); }
public OmniSharpHostProject(string projectFilePath, RazorConfiguration razorConfiguration, string rootNamespace) { if (projectFilePath == null) { throw new ArgumentNullException(nameof(projectFilePath)); } if (razorConfiguration == null) { throw new ArgumentNullException(nameof(razorConfiguration)); } InternalHostProject = new HostProject(projectFilePath, razorConfiguration, rootNamespace); }
protected void AddDocument(HostProject hostProject, string filePath, string relativeFilePath) { ProjectSnapshotManagerDispatcher.AssertDispatcherThread(); if (_currentDocuments.ContainsKey(filePath)) { return; } var hostDocument = new HostDocument(filePath, relativeFilePath); _projectSnapshotManager.DocumentAdded(hostProject, hostDocument, new FileTextLoader(filePath, defaultEncoding: null)); _currentDocuments[filePath] = hostDocument; }
private void AttachToDocument(uint docCookie, string moniker) { var vsTextBuffer = (IVsTextBuffer)_runningDocumentTable.GetDocumentData(docCookie); var textBuffer = _editorAdaptersFactoryService.GetDocumentBuffer(vsTextBuffer); if (_fileTrackingMetadataAsSourceService.TryAddDocumentToWorkspace(moniker, textBuffer)) { // We already added it, so we will keep it excluded from the misc files workspace return; } // This should always succeed since we only got here if we already confirmed the moniker is acceptable var languageInformation = TryGetLanguageInformation(moniker); Contract.ThrowIfNull(languageInformation); var parseOptions = languageInformation.ParseOptions; if (Path.GetExtension(moniker) == languageInformation.ScriptExtension) { parseOptions = parseOptions.WithKind(SourceCodeKind.Script); } // First, create the project var hostProject = new HostProject(this, CurrentSolution.Id, languageInformation.LanguageName, parseOptions, _metadataReferences); // Now try to find the document. We accept any text buffer, since we've already verified it's an appropriate file in ShouldIncludeFile. var document = _documentProvider.TryGetDocumentForFile( hostProject, (uint)VSConstants.VSITEMID.Nil, moniker, parseOptions.Kind, canUseTextBuffer: _ => true); // If the buffer has not yet been initialized, we won't get a document. if (document == null) { return; } // Since we have a document, we can do the rest of the project setup. _hostProjects.Add(hostProject.Id, hostProject); OnProjectAdded(hostProject.CreateProjectInfoForCurrentState()); OnDocumentAdded(document.GetInitialState()); hostProject.Document = document; // Notify the document provider, so it knows the document is now open and a part of // the project _documentProvider.NotifyDocumentRegisteredToProject(document); Contract.ThrowIfFalse(document.IsOpen); var buffer = document.GetOpenTextBuffer(); OnDocumentOpened(document.Id, document.GetOpenTextContainer()); _docCookiesToHostProject.Add(docCookie, hostProject); }