public void WhenInitializedParameterLessItWillContainDefaultValues() { var instance = new ProjectFileInfo(); Assert.AreEqual("Project", instance.DefaultFileName); Assert.AreEqual("Game Project", instance.Description); Assert.AreEqual("atp", instance.Extension); }
public bool TryGetProject(string projectFilePath, out ProjectFileInfo projectFileInfo) => _projectFiles.TryGetValue(projectFilePath, out projectFileInfo);
private void UpdateProject(ProjectFileInfo projectFileInfo) { var project = _workspace.CurrentSolution.GetProject(projectFileInfo.WorkspaceId); var unusedDocuments = project.Documents.ToDictionary(d => d.FilePath, d => d.Id); foreach (var file in projectFileInfo.SourceFiles) { if (unusedDocuments.Remove(file)) { continue; } using (var stream = File.OpenRead(file)) { var sourceText = SourceText.From(stream, encoding: Encoding.UTF8); var id = DocumentId.CreateNewId(projectFileInfo.WorkspaceId); var version = VersionStamp.Create(); var loader = TextLoader.From(TextAndVersion.Create(sourceText, version)); _workspace.AddDocument(DocumentInfo.Create(id, file, filePath: file, loader: loader)); } } if (projectFileInfo.SpecifiedLanguageVersion.HasValue || projectFileInfo.DefineConstants != null) { var parseOptions = projectFileInfo.SpecifiedLanguageVersion.HasValue ? new CSharpParseOptions(projectFileInfo.SpecifiedLanguageVersion.Value) : new CSharpParseOptions(); if (projectFileInfo.DefineConstants != null && projectFileInfo.DefineConstants.Any()) { parseOptions = parseOptions.WithPreprocessorSymbols(projectFileInfo.DefineConstants); } if (projectFileInfo.GenerateXmlDocumentation) { parseOptions = parseOptions.WithDocumentationMode(DocumentationMode.Diagnose); } _workspace.SetParseOptions(project.Id, parseOptions); } foreach (var unused in unusedDocuments) { _workspace.RemoveDocument(unused.Value); } var unusedProjectReferences = new HashSet <ProjectReference>(project.ProjectReferences); foreach (var projectReferencePath in projectFileInfo.ProjectReferences) { ProjectFileInfo projectReferenceInfo; if (_context.Projects.TryGetValue(projectReferencePath, out projectReferenceInfo)) { var reference = new ProjectReference(projectReferenceInfo.WorkspaceId); if (unusedProjectReferences.Remove(reference)) { // This reference already exists continue; } _workspace.AddProjectReference(project.Id, reference); } else { _logger.LogWarning($"Unable to resolve project reference '{projectReferencePath}' for '{projectFileInfo}'."); } } foreach (var unused in unusedProjectReferences) { _workspace.RemoveProjectReference(project.Id, unused); } var unusedReferences = new HashSet <MetadataReference>(project.MetadataReferences); foreach (var referencePath in projectFileInfo.References) { if (!File.Exists(referencePath)) { _logger.LogWarning($"Unable to resolve assembly '{referencePath}'"); } else { var metadataReference = _metadataReferenceCache.GetMetadataReference(referencePath); if (unusedReferences.Remove(metadataReference)) { continue; } _logger.LogDebug($"Adding reference '{referencePath}' to '{projectFileInfo.ProjectFilePath}'."); _workspace.AddMetadataReference(project.Id, metadataReference); } } foreach (var reference in unusedReferences) { _workspace.RemoveMetadataReference(project.Id, reference); } }
private async Task <ResolvedReferences> ResolveReferencesAsync(ProjectId id, ProjectFileInfo projectFileInfo, CommandLineArguments commandLineArgs, CancellationToken cancellationToken) { // First, gather all of the metadata references from the command-line arguments. var resolvedMetadataReferences = commandLineArgs.ResolveMetadataReferences( new WorkspaceMetadataFileReferenceResolver( metadataService: GetWorkspaceService <IMetadataService>(), pathResolver: new RelativePathResolver(commandLineArgs.ReferencePaths, commandLineArgs.BaseDirectory))); var builder = new ResolvedReferencesBuilder(resolvedMetadataReferences); var projectDirectory = Path.GetDirectoryName(projectFileInfo.FilePath); // Next, iterate through all project references in the file and create project references. foreach (var projectFileReference in projectFileInfo.ProjectReferences) { var aliases = projectFileReference.Aliases; if (_pathResolver.TryGetAbsoluteProjectPath(projectFileReference.Path, baseDirectory: projectDirectory, _discoveredProjectOptions.OnPathFailure, out var projectReferencePath)) { // The easiest case is to add a reference to a project we already know about. if (TryAddReferenceToKnownProject(id, projectReferencePath, aliases, builder)) { continue; } // If we don't know how to load a project (that is, it's not a language we support), we can still // attempt to verify that its output exists on disk and is included in our set of metadata references. // If it is, we'll just leave it in place. if (!IsProjectLoadable(projectReferencePath) && await VerifyUnloadableProjectOutputExistsAsync(projectReferencePath, builder, cancellationToken).ConfigureAwait(false)) { continue; } // If metadata is preferred, see if the project reference's output exists on disk and is included // in our metadata references. If it is, don't create a project reference; we'll just use the metadata. if (_preferMetadataForReferencesOfDiscoveredProjects && await VerifyProjectOutputExistsAsync(projectReferencePath, builder, cancellationToken).ConfigureAwait(false)) { continue; } // Finally, we'll try to load and reference the project. if (await TryLoadAndAddReferenceAsync(id, projectReferencePath, aliases, builder, cancellationToken).ConfigureAwait(false)) { continue; } } // We weren't able to handle this project reference, so add it without further processing. var unknownProjectId = _projectMap.GetOrCreateProjectId(projectFileReference.Path); var newProjectReference = CreateProjectReference(@from: id, to: unknownProjectId, aliases); builder.AddProjectReference(newProjectReference); } // Are there still any unresolved metadata references? If so, remove them and report diagnostics. foreach (var unresolvedMetadataReference in builder.GetUnresolvedMetadataReferences()) { var filePath = unresolvedMetadataReference.Reference; builder.Remove(filePath); _diagnosticReporter.Report(new ProjectDiagnostic( WorkspaceDiagnosticKind.Warning, string.Format(WorkspaceMSBuildResources.Unresolved_metadata_reference_removed_from_project_0, filePath), id)); } return(builder.ToResolvedReferences()); }
private Task <ProjectInfo> CreateProjectInfoAsync(ProjectFileInfo projectFileInfo, ProjectId projectId, bool addDiscriminator, CancellationToken cancellationToken) { var language = projectFileInfo.Language; var projectPath = projectFileInfo.FilePath; var projectName = Path.GetFileNameWithoutExtension(projectPath); if (addDiscriminator && !string.IsNullOrWhiteSpace(projectFileInfo.TargetFramework)) { projectName += "(" + projectFileInfo.TargetFramework + ")"; } var version = VersionStamp.Create( FileUtilities.GetFileTimeStamp(projectPath)); if (projectFileInfo.IsEmpty) { var assemblyName = GetAssemblyNameFromProjectPath(projectPath); var parseOptions = GetLanguageService <ISyntaxTreeFactoryService>(language) .GetDefaultParseOptions(); var compilationOptions = GetLanguageService <ICompilationFactoryService>(language) .GetDefaultCompilationOptions(); return(Task.FromResult( ProjectInfo.Create( projectId, version, projectName, assemblyName: assemblyName, language: language, filePath: projectPath, outputFilePath: string.Empty, outputRefFilePath: string.Empty, compilationOptions: compilationOptions, parseOptions: parseOptions, documents: SpecializedCollections.EmptyEnumerable <DocumentInfo>(), projectReferences: SpecializedCollections.EmptyEnumerable <ProjectReference>(), metadataReferences: SpecializedCollections.EmptyEnumerable <MetadataReference>(), analyzerReferences: SpecializedCollections.EmptyEnumerable <AnalyzerReference>(), additionalDocuments: SpecializedCollections.EmptyEnumerable <DocumentInfo>(), isSubmission: false, hostObjectType: null))); } return(DoOperationAndReportProgressAsync(ProjectLoadOperation.Resolve, projectPath, projectFileInfo.TargetFramework, async() => { var projectDirectory = Path.GetDirectoryName(projectPath); // parse command line arguments var commandLineParser = GetLanguageService <ICommandLineParserService>(projectFileInfo.Language); var commandLineArgs = commandLineParser.Parse( arguments: projectFileInfo.CommandLineArgs, baseDirectory: projectDirectory, isInteractive: false, sdkDirectory: RuntimeEnvironment.GetRuntimeDirectory()); var assemblyName = commandLineArgs.CompilationName; if (string.IsNullOrWhiteSpace(assemblyName)) { // if there isn't an assembly name, make one from the file path. // Note: This may not be necessary any longer if the commmand line args // always produce a valid compilation name. assemblyName = GetAssemblyNameFromProjectPath(projectPath); } // Ensure sure that doc-comments are parsed var parseOptions = commandLineArgs.ParseOptions; if (parseOptions.DocumentationMode == DocumentationMode.None) { parseOptions = parseOptions.WithDocumentationMode(DocumentationMode.Parse); } // add all the extra options that are really behavior overrides var metadataService = GetWorkspaceService <IMetadataService>(); var compilationOptions = commandLineArgs.CompilationOptions .WithXmlReferenceResolver(new XmlFileResolver(projectDirectory)) .WithSourceReferenceResolver(new SourceFileResolver(ImmutableArray <string> .Empty, projectDirectory)) // TODO: https://github.com/dotnet/roslyn/issues/4967 .WithMetadataReferenceResolver(new WorkspaceMetadataFileReferenceResolver(metadataService, new RelativePathResolver(ImmutableArray <string> .Empty, projectDirectory))) .WithStrongNameProvider(new DesktopStrongNameProvider(commandLineArgs.KeyFileSearchPaths)) .WithAssemblyIdentityComparer(DesktopAssemblyIdentityComparer.Default); var documents = CreateDocumentInfos(projectFileInfo.Documents, projectId, commandLineArgs.Encoding); var additionalDocuments = CreateDocumentInfos(projectFileInfo.AdditionalDocuments, projectId, commandLineArgs.Encoding); CheckForDuplicateDocuments(documents, additionalDocuments, projectPath, projectId); var analyzerReferences = ResolveAnalyzerReferences(commandLineArgs); var resolvedReferences = await ResolveReferencesAsync(projectId, projectFileInfo, commandLineArgs, cancellationToken).ConfigureAwait(false); return ProjectInfo.Create( projectId, version, projectName, assemblyName, language, projectPath, outputFilePath: projectFileInfo.OutputFilePath, outputRefFilePath: projectFileInfo.OutputRefFilePath, compilationOptions: compilationOptions, parseOptions: parseOptions, documents: documents, projectReferences: resolvedReferences.ProjectReferences, metadataReferences: resolvedReferences.MetadataReferences, analyzerReferences: analyzerReferences, additionalDocuments: additionalDocuments, isSubmission: false, hostObjectType: null) .WithDefaultNamespace(projectFileInfo.DefaultNamespace); })); }
private void SetForm() { ProjectFolderRole role = this._TopFolder.ProjectFolderRole; this.cbRoles.IsEnabled = this._ProjectItem.IsFolder; this.chkSyncTemplate.IsEnabled = this._ProjectItem.IsFile && (role == ProjectFolderRole.ComponentLayout || role == ProjectFolderRole.PageLayout); if (role == ProjectFolderRole.ComponentLayout || role == ProjectFolderRole.PageLayout) { this.chkSyncTemplate.IsChecked = this._ProjectItem.IsSyncTemplate(); } else { this.chkSyncTemplate.IsChecked = false; } this.btnDebug.IsEnabled = this._ProjectItem.IsFile && (role == ProjectFolderRole.ComponentLayout || role == ProjectFolderRole.PageLayout); if (this.btnDebug.IsEnabled) { ProjectFileInfo projectFile = (ProjectFileInfo)this._ProjectItem; this.btnDebug.Foreground = new SolidColorBrush(!string.IsNullOrEmpty(projectFile.TestItemTcmId) && !string.IsNullOrEmpty(projectFile.TestTemplateTcmId) ? Colors.Green : Colors.Red); } else { this.btnDebug.Foreground = new SolidColorBrush(Colors.Gray); } this.cbRoles.SelectedValue = role; if (role == ProjectFolderRole.Other) { return; } if (role == ProjectFolderRole.Binary) { this.txtTemplateFormat.Text = String.Empty; this.txtTemplateFormat.IsEnabled = false; this.txtSchemaNames.Text = String.Empty; this.txtSchemaNames.IsEnabled = false; if (this._ProjectItem.IsFolder) { this.txtTitle.Text = null; this.txtTitle.IsEnabled = false; } else { ProjectFileInfo file = (ProjectFileInfo)this._ProjectItem; this.txtTitle.Text = String.IsNullOrEmpty(file.Title) ? Path.GetFileNameWithoutExtension(file.Path) : file.Title; file.Title = String.IsNullOrEmpty(this.txtTitle.Text) ? null : this.txtTitle.Text; this.txtTitle.IsEnabled = true; } this.txtTemplateTitle.Text = null; this.txtTemplateTitle.IsEnabled = false; } else { if (this._ProjectItem.IsFolder) { if (this._ProjectItem.Path == this._TopFolder.Path) { this.txtTemplateFormat.Text = this._TopFolder.TemplateFormat.PrettyXml(); this.txtTemplateFormat.IsEnabled = true; } else { this.txtTemplateFormat.Text = String.Empty; this.txtTemplateFormat.IsEnabled = false; } this.txtSchemaNames.Text = String.Empty; this.txtSchemaNames.IsEnabled = false; this.txtTitle.Text = null; this.txtTitle.IsEnabled = false; this.txtTemplateTitle.Text = null; this.txtTemplateTitle.IsEnabled = false; } else { ProjectFileInfo file = (ProjectFileInfo)this._ProjectItem; this.txtTemplateFormat.Text = this._TopFolder.TemplateFormat.PrettyXml(); this.txtTemplateFormat.IsEnabled = false; this.txtSchemaNames.Text = file.SchemaNames == null ? String.Empty : string.Join("\n", file.SchemaNames); this.txtSchemaNames.IsEnabled = true; string title = Path.GetFileNameWithoutExtension(file.Path); this.txtTitle.Text = String.IsNullOrEmpty(file.Title) ? (string.IsNullOrEmpty(title) ? null : title.Replace(" Layout", "") + " Layout") : file.Title; file.Title = String.IsNullOrEmpty(this.txtTitle.Text) ? null : this.txtTitle.Text; this.txtTitle.IsEnabled = true; this.txtTemplateTitle.Text = String.IsNullOrEmpty(file.TemplateTitle) ? (string.IsNullOrEmpty(title) ? null : title.Replace(" Layout", "")) : file.TemplateTitle; file.TemplateTitle = String.IsNullOrEmpty(this.txtTemplateTitle.Text) ? null : this.txtTemplateTitle.Text; this.txtTemplateTitle.IsEnabled = this.chkSyncTemplate.IsChecked == true; } } List <TridionFolderInfo> tridionFolders = this.TridionFolders.Where(x => x.TridionRole == this._TridionRole).ToList(); this.lstTridionFolders.SelectedIndex = tridionFolders.Any(x => x.TcmId == this._TopFolder.TcmId) ? tridionFolders.FindIndex(x => x.TcmId == this._TopFolder.TcmId) : 0; }
private static IEnumerable <ProjectContentItem> GetContentItems(XDocument document, ProjectFileInfo projectFileInfo) { var projectFileDirectoryPath = projectFileInfo.Value.Directory.FullName; var result = document.ElementsBy(ParserHelper.Content); var contentItems = result.Select( item => { var include = item.AttributeBy(ParserHelper.Include).ValueOrDefault(); var fileInfo = new FileInfo(Path.Combine(projectFileDirectoryPath, include)); return(new ProjectContentItem(include, fileInfo)); }); return(contentItems); }
private ProjectFileInfo LoadProject(string projectFilePath) => LoadOrReloadProject(projectFilePath, () => ProjectFileInfo.Load(projectFilePath, _projectLoader));
public static void AddChildItems(ProjectFolderInfo projectFolder, string rootPath) { if (projectFolder == null) return; if (String.IsNullOrEmpty(projectFolder.FullPath)) return; if (!Directory.Exists(projectFolder.FullPath)) Directory.CreateDirectory(projectFolder.FullPath); ProjectFolderInfo topFolder = projectFolder.GetTopFolder(); ProjectFolderRole role = topFolder.ProjectFolderRole; string[] extensions = role == Misc.ProjectFolderRole.Binary ? Const.Extensions.Keys.ToArray() : new[] { "*.cshtml" }; string[] directories = Directory.GetDirectories(projectFolder.FullPath); string[] files = IO.Service.GetFiles(projectFolder.FullPath, extensions); if (directories.Length == 0 && files.Length == 0) { projectFolder.ChildItems = null; return; } List<ProjectItemInfo> newChildItems = new List<ProjectItemInfo>(); foreach (string dir in directories) { ProjectFolderInfo childFolder = null; if (projectFolder.ChildItems != null) { childFolder = projectFolder.ChildItems.FirstOrDefault(x => x.IsFolder && x.FullPath == dir) as ProjectFolderInfo; } if (childFolder == null) { childFolder = new ProjectFolderInfo { RootPath = rootPath, Path = dir.Replace(rootPath, "").Trim('\\'), Checked = false }; } childFolder.Parent = projectFolder; AddChildItems(childFolder, rootPath); newChildItems.Add(childFolder); } foreach (string file in files) { ProjectFileInfo childFile = null; if (projectFolder.ChildItems != null) { childFile = projectFolder.ChildItems.FirstOrDefault(x => x.IsFile && x.FullPath == file) as ProjectFileInfo; } if (childFile == null) { childFile = new ProjectFileInfo { RootPath = rootPath, Path = file.Replace(rootPath, "").Trim('\\'), Checked = false }; } childFile.Parent = projectFolder; newChildItems.Add(childFile); } projectFolder.ChildItems = newChildItems.Count > 0 ? newChildItems : null; }
public static ProjectFolderInfo GetRootTree(ProjectFolderInfo projectFolder, string fullPath) { if (projectFolder == null) return null; if (!Directory.Exists(fullPath)) return null; if (!ExistFile(projectFolder, fullPath) && projectFolder.FullPath != fullPath) return null; if (projectFolder.FullPath == fullPath) { projectFolder.IsSelected = true; projectFolder.Expand(); return projectFolder; } string rootPath = projectFolder.RootPath; ProjectFolderInfo parentFolder = new ProjectFolderInfo { RootPath = rootPath, Path = fullPath.Replace(rootPath, "").Trim('\\'), Checked = false }; parentFolder.ChildItems = new List<ProjectItemInfo>(); foreach (string childFolderPath in Directory.GetDirectories(fullPath)) { ProjectFolderInfo childFolder = GetRootTree(projectFolder, childFolderPath); if (childFolder != null) { childFolder.Parent = parentFolder; parentFolder.ChildItems.Add(childFolder); } } foreach (string childFilePath in IO.Service.GetFiles(fullPath, projectFolder.ProjectFolderRole == Misc.ProjectFolderRole.Binary ? Const.Extensions.Keys.ToArray() : new[] { "*.cshtml" })) { ProjectFileInfo childFile = new ProjectFileInfo { RootPath = rootPath, Path = childFilePath.Replace(rootPath, "").Trim('\\'), Checked = false }; childFile.Parent = parentFolder; parentFolder.ChildItems.Add(childFile); } if (parentFolder.ChildItems.Count == 0) parentFolder.ChildItems = null; return parentFolder; }
internal ProjectFile( ProjectFileInfo projectFileInfo, string assemblyName, IEnumerable <AssemblyReference> assemblyReferences, IEnumerable <ProjectReference> projectReferences, IEnumerable <ProjectType> projectTypes, IEnumerable <Import> imports, IEnumerable <CSharpFileInfo> csharpFileInfos, IEnumerable <XAMLFileInfo> xamlFileInfos, IEnumerable <ProjectContentItem> projectContentItems, string targetFrameworkVersion) { if (projectFileInfo == null) { throw new ArgumentNullException(nameof(projectFileInfo)); } if (string.IsNullOrEmpty(assemblyName)) { throw new ArgumentException("The assembly name must not be null or empty", nameof(assemblyName)); } if (assemblyReferences == null) { throw new ArgumentNullException(nameof(assemblyReferences)); } if (projectReferences == null) { throw new ArgumentNullException(nameof(projectReferences)); } if (projectTypes == null) { throw new ArgumentNullException(nameof(projectTypes)); } if (imports == null) { throw new ArgumentNullException(nameof(imports)); } if (csharpFileInfos == null) { throw new ArgumentNullException(nameof(csharpFileInfos)); } if (xamlFileInfos == null) { throw new ArgumentNullException(nameof(xamlFileInfos)); } if (projectContentItems == null) { throw new ArgumentNullException(nameof(projectContentItems)); } if (targetFrameworkVersion == null) { throw new ArgumentNullException(nameof(targetFrameworkVersion)); } ProjectFileInfo = projectFileInfo; AssemblyName = assemblyName; AssemblyReferences = assemblyReferences; ProjectReferences = projectReferences; ProjectTypes = projectTypes; Imports = imports; CSharpFileInfos = csharpFileInfos; XAMLFileInfos = xamlFileInfos; ContentItems = projectContentItems; TargetFrameworkVersion = targetFrameworkVersion; }
private static void ReadProjectFile(XContainer file, ProjectFileInfo projectFileInfo, ref int segmentIdCounter) { foreach (var element in file.Elements()) { if (string.Compare(element.Name.LocalName, "header", StringComparison.InvariantCultureIgnoreCase) == 0) { foreach (var fileInfo in element.Elements()) { if (string.Compare(fileInfo.Name.LocalName, "file-info", StringComparison.InvariantCultureIgnoreCase) == 0) { foreach (var value in fileInfo.Elements()) { if (string.Compare(value.Name.LocalName, "value", StringComparison.InvariantCultureIgnoreCase) == 0) { if (!value.HasAttributes) { continue; } SetFileInfoAttributes(projectFileInfo, value); } } } if (string.Compare(fileInfo.Name.LocalName, "filetype-info", StringComparison.InvariantCultureIgnoreCase) == 0) { var fileType = fileInfo.Elements().FirstOrDefault(a => string.Compare(a.Name.LocalName, "filetype-id", StringComparison.InvariantCultureIgnoreCase) == 0); if (fileType != null) { projectFileInfo.FileTypeId = fileType.Value; } } if (string.Compare(fileInfo.Name.LocalName, "cxt-defs", StringComparison.InvariantCultureIgnoreCase) == 0) { foreach (var cxtdef in fileInfo.Elements()) { var contextDefinition = new ParagraphUnitContext(); foreach (var attribute in cxtdef.Attributes()) { if (string.Compare(attribute.Name.LocalName, "id", StringComparison.InvariantCultureIgnoreCase) == 0) { contextDefinition.Id = attribute.Value; } if (string.Compare(attribute.Name.LocalName, "type", StringComparison.InvariantCultureIgnoreCase) == 0) { contextDefinition.ContextType = attribute.Value; } if (string.Compare(attribute.Name.LocalName, "code", StringComparison.InvariantCultureIgnoreCase) == 0) { contextDefinition.DisplayCode = attribute.Value; } if (string.Compare(attribute.Name.LocalName, "descr", StringComparison.InvariantCultureIgnoreCase) == 0) { contextDefinition.Description = attribute.Value; } if (string.Compare(attribute.Name.LocalName, "color", StringComparison.InvariantCultureIgnoreCase) == 0) { contextDefinition.DisplayName = attribute.Value; } } var props = cxtdef.Elements().FirstOrDefault(a => string.Compare(a.Name.LocalName, "props", StringComparison.InvariantCultureIgnoreCase) == 0); if (props != null) { foreach (var value in props.Elements()) { if (string.Compare(value.Name.LocalName, "value", StringComparison.InvariantCultureIgnoreCase) == 0) { if (!value.HasAttributes) { continue; } foreach (var attribute in value.Attributes()) { if (!contextDefinition.MetaData.ContainsKey(attribute.Value)) { contextDefinition.MetaData.Add(attribute.Value, value.Value); } } } } projectFileInfo.ContextDefinitions.Add(contextDefinition); } } } } } if (string.Compare(element.Name.LocalName, "body", StringComparison.InvariantCultureIgnoreCase) == 0) { foreach (var group in element.Elements()) { if (string.Compare(group.Name.LocalName, "group", StringComparison.InvariantCultureIgnoreCase) == 0) { var contextDefinitions = new List <ParagraphUnitContext>(); var contexts = group.Elements().FirstOrDefault(a => string.Compare(a.Name.LocalName, "cxts", StringComparison.InvariantCultureIgnoreCase) == 0); if (contexts != null) { foreach (var value in contexts.Elements()) { if (string.Compare(value.Name.LocalName, "cxt", StringComparison.InvariantCultureIgnoreCase) == 0) { foreach (var attribute in value.Attributes()) { if (string.Compare(attribute.Name.LocalName, "id", StringComparison.InvariantCultureIgnoreCase) == 0) { var contextDefinition = projectFileInfo.ContextDefinitions.FirstOrDefault(a => a.Id == attribute.Value); if (contextDefinition != null) { contextDefinitions.Add(contextDefinition); } } } } } } var transUnits = group.Elements().Where(a => string.Compare(a.Name.LocalName, "trans-unit", StringComparison.InvariantCultureIgnoreCase) == 0); foreach (var transUnit in transUnits) { var paragraphInfos = GetParagraphInfo(transUnit, ref segmentIdCounter); paragraphInfos.ContextDefinitions = contextDefinitions; projectFileInfo.ParagraphInfos.Add(paragraphInfos); } } if (string.Compare(group.Name.LocalName, "trans-unit", StringComparison.InvariantCultureIgnoreCase) == 0) { var paragraphInfos = GetParagraphInfo(group, ref segmentIdCounter); paragraphInfos.ContextDefinitions = new List <ParagraphUnitContext>(); projectFileInfo.ParagraphInfos.Add(paragraphInfos); } } } } }
private ProjectFileInfo ReloadProject(ProjectFileInfo projectFileInfo) => LoadOrReloadProject(projectFileInfo.FilePath, () => projectFileInfo.Reload(_projectLoader));
private void UpdateProject(ProjectFileInfo projectFileInfo) { var project = _workspace.CurrentSolution.GetProject(projectFileInfo.WorkspaceId); var unusedDocuments = project.Documents.ToDictionary(d => d.FilePath, d => d.Id); foreach (var file in projectFileInfo.SourceFiles) { if (unusedDocuments.Remove(file)) { continue; } using (var stream = File.OpenRead(file)) { var sourceText = SourceText.From(stream, encoding: Encoding.UTF8); var id = DocumentId.CreateNewId(projectFileInfo.WorkspaceId); var version = VersionStamp.Create(); var loader = TextLoader.From(TextAndVersion.Create(sourceText, version)); _workspace.AddDocument(DocumentInfo.Create(id, file, filePath: file, loader: loader)); } } foreach (var unused in unusedDocuments) { _workspace.RemoveDocument(unused.Value); } var unusedProjectReferences = new HashSet<ProjectReference>(project.ProjectReferences); foreach (var projectReferencePath in projectFileInfo.ProjectReferences) { ProjectFileInfo projectReferenceInfo; if (_context.Projects.TryGetValue(projectReferencePath, out projectReferenceInfo)) { var reference = new ProjectReference(projectReferenceInfo.WorkspaceId); if (unusedProjectReferences.Remove(reference)) { // This reference already exists continue; } _workspace.AddProjectReference(project.Id, reference); } else { _logger.WriteWarning(string.Format("Unable to resolve project reference '{0}' for '{1}'.", projectReferencePath, projectFileInfo.ProjectFilePath)); } } foreach (var unused in unusedProjectReferences) { _workspace.RemoveProjectReference(project.Id, unused); } var unusedAnalyzers = new Dictionary<string, AnalyzerReference>(project.AnalyzerReferences.ToDictionary(a => a.FullPath)); foreach (var analyzerPath in projectFileInfo.Analyzers) { if (!File.Exists(analyzerPath)) { _logger.WriteWarning(string.Format("Unable to resolve assembly '{0}'", analyzerPath)); } else { if (unusedAnalyzers.Remove(analyzerPath)) { continue; } #if ASPNET50 var analyzerReference = new AnalyzerFileReference(analyzerPath); project.AddAnalyzerReference(analyzerReference); #endif } } foreach (var analyzerReference in unusedAnalyzers.Values) { project.RemoveAnalyzerReference(analyzerReference); } var unusedReferences = new HashSet<MetadataReference>(project.MetadataReferences); foreach (var referencePath in projectFileInfo.References) { if (!File.Exists(referencePath)) { _logger.WriteWarning(string.Format("Unable to resolve assembly '{0}'", referencePath)); } else { var metadataReference = _metadataReferenceCache.GetMetadataReference(referencePath); if (unusedReferences.Remove(metadataReference)) { continue; } _logger.WriteVerbose(string.Format("Adding reference '{0}' to '{1}'.", referencePath, projectFileInfo.ProjectFilePath)); _workspace.AddMetadataReference(project.Id, metadataReference); } } foreach (var reference in unusedReferences) { _workspace.RemoveMetadataReference(project.Id, reference); } }
private void UpdateProject(ProjectFileInfo projectFileInfo) { var project = _workspace.CurrentSolution.GetProject(projectFileInfo.WorkspaceId); var unusedDocuments = project.Documents.ToDictionary(d => d.FilePath, d => d.Id); foreach (var file in projectFileInfo.SourceFiles) { if (unusedDocuments.Remove(file)) { continue; } using (var stream = File.OpenRead(file)) { var sourceText = SourceText.From(stream, encoding: Encoding.UTF8); var id = DocumentId.CreateNewId(projectFileInfo.WorkspaceId); var version = VersionStamp.Create(); var loader = TextLoader.From(TextAndVersion.Create(sourceText, version)); _workspace.AddDocument(DocumentInfo.Create(id, file, filePath: file, loader: loader)); } } foreach (var unused in unusedDocuments) { _workspace.RemoveDocument(unused.Value); } var unusedProjectReferences = new HashSet <ProjectReference>(project.ProjectReferences); foreach (var projectReferencePath in projectFileInfo.ProjectReferences) { ProjectFileInfo projectReferenceInfo; if (_context.Projects.TryGetValue(projectReferencePath, out projectReferenceInfo)) { var reference = new ProjectReference(projectReferenceInfo.WorkspaceId); if (unusedProjectReferences.Remove(reference)) { // This reference already exists continue; } _workspace.AddProjectReference(project.Id, reference); } else { _logger.WriteWarning(string.Format("Unable to resolve project reference '{0}' for '{1}'.", projectReferencePath, projectFileInfo.ProjectFilePath)); } } foreach (var unused in unusedProjectReferences) { _workspace.RemoveProjectReference(project.Id, unused); } var unusedAnalyzers = new Dictionary <string, AnalyzerReference>(project.AnalyzerReferences.ToDictionary(a => a.FullPath)); foreach (var analyzerPath in projectFileInfo.Analyzers) { if (!File.Exists(analyzerPath)) { _logger.WriteWarning(string.Format("Unable to resolve assembly '{0}'", analyzerPath)); } else { if (unusedAnalyzers.Remove(analyzerPath)) { continue; } #if ASPNET50 var analyzerReference = new AnalyzerFileReference(analyzerPath); project.AddAnalyzerReference(analyzerReference); #endif } } foreach (var analyzerReference in unusedAnalyzers.Values) { project.RemoveAnalyzerReference(analyzerReference); } var unusedReferences = new HashSet <MetadataReference>(project.MetadataReferences); foreach (var referencePath in projectFileInfo.References) { if (!File.Exists(referencePath)) { _logger.WriteWarning(string.Format("Unable to resolve assembly '{0}'", referencePath)); } else { var metadataReference = _metadataReferenceCache.GetMetadataReference(referencePath); if (unusedReferences.Remove(metadataReference)) { continue; } _logger.WriteVerbose(string.Format("Adding reference '{0}' to '{1}'.", referencePath, projectFileInfo.ProjectFilePath)); _workspace.AddMetadataReference(project.Id, metadataReference); } } foreach (var reference in unusedReferences) { _workspace.RemoveMetadataReference(project.Id, reference); } }
private void UpdateProject(ProjectFileInfo projectFileInfo) { var project = _workspace.CurrentSolution.GetProject(projectFileInfo.WorkspaceId); var unusedDocuments = project.Documents.ToDictionary(d => d.FilePath, d => d.Id); foreach (var file in projectFileInfo.SourceFiles) { if (unusedDocuments.Remove(file)) { continue; } using (var stream = File.OpenRead(file)) { var sourceText = SourceText.From(stream, encoding: Encoding.UTF8); var id = DocumentId.CreateNewId(projectFileInfo.WorkspaceId); var version = VersionStamp.Create(); var loader = TextLoader.From(TextAndVersion.Create(sourceText, version)); _workspace.AddDocument(DocumentInfo.Create(id, file, filePath: file, loader: loader)); } } if (projectFileInfo.SpecifiedLanguageVersion.HasValue || projectFileInfo.DefineConstants != null) { var parseOptions = projectFileInfo.SpecifiedLanguageVersion.HasValue ? new CSharpParseOptions(projectFileInfo.SpecifiedLanguageVersion.Value) : new CSharpParseOptions(); if (projectFileInfo.DefineConstants != null && projectFileInfo.DefineConstants.Any()) { parseOptions = parseOptions.WithPreprocessorSymbols(projectFileInfo.DefineConstants); } _workspace.SetParseOptions(project.Id, parseOptions); } foreach (var unused in unusedDocuments) { _workspace.RemoveDocument(unused.Value); } var unusedProjectReferences = new HashSet<ProjectReference>(project.ProjectReferences); foreach (var projectReferencePath in projectFileInfo.ProjectReferences) { ProjectFileInfo projectReferenceInfo; if (_context.Projects.TryGetValue(projectReferencePath, out projectReferenceInfo)) { var reference = new ProjectReference(projectReferenceInfo.WorkspaceId); if (unusedProjectReferences.Remove(reference)) { // This reference already exists continue; } _workspace.AddProjectReference(project.Id, reference); } else { _logger.LogWarning($"Unable to resolve project reference '{projectReferencePath}' for '{projectFileInfo}'."); } } foreach (var unused in unusedProjectReferences) { _workspace.RemoveProjectReference(project.Id, unused); } var unusedAnalyzers = new Dictionary<string, AnalyzerReference>(project.AnalyzerReferences.ToDictionary(a => a.FullPath)); foreach (var analyzerPath in projectFileInfo.Analyzers) { if (!File.Exists(analyzerPath)) { _logger.LogWarning($"Unable to resolve assembly '{analyzerPath}'"); } else { if (unusedAnalyzers.Remove(analyzerPath)) { continue; } #if DNX451 var analyzerReference = new AnalyzerFileReference(analyzerPath); project.AddAnalyzerReference(analyzerReference); #endif } } foreach (var analyzerReference in unusedAnalyzers.Values) { project.RemoveAnalyzerReference(analyzerReference); } var unusedReferences = new HashSet<MetadataReference>(project.MetadataReferences); foreach (var referencePath in projectFileInfo.References) { if (!File.Exists(referencePath)) { _logger.LogWarning($"Unable to resolve assembly '{referencePath}'"); } else { var metadataReference = _metadataReferenceCache.GetMetadataReference(referencePath); if (unusedReferences.Remove(metadataReference)) { continue; } _logger.LogVerbose($"Adding reference '{referencePath}' to '{projectFileInfo.ProjectFilePath}'."); _workspace.AddMetadataReference(project.Id, metadataReference); } } foreach (var reference in unusedReferences) { _workspace.RemoveMetadataReference(project.Id, reference); } }
private ImmutableArray <PackageReference> FindUnresolvedPackageReferencesInLockFile(ProjectFileInfo projectFile, LockFile lockFile) { var libraryMap = CreateLibraryMap(lockFile); var unresolved = ImmutableArray.CreateBuilder <PackageReference>(); // Iterate through each package reference and see if we can find a library with the same name // that satisfies the reference's version range in the lock file. foreach (var reference in projectFile.PackageReferences) { if (!libraryMap.TryGetValue(reference.Dependency.Id, out var libraries)) { _logger.LogWarning($"{projectFile.Name}: Did not find '{reference.Dependency.Id}' in lock file."); unresolved.Add(reference); } else { var found = false; foreach (var library in libraries) { if (reference.Dependency.VersionRange.Satisfies(library.Version)) { found = true; break; } } if (!found) { var referenceText = reference.IsImplicitlyDefined ? "implicit package reference" : "package reference"; var versions = string.Join(", ", libraries.Select(l => '"' + l.Version.ToString() + '"')); _logger.LogWarning($"{projectFile.Name}: Found {referenceText} '{reference.Dependency.Id}', but none of the versions in the lock file ({versions}) satisfy {reference.Dependency.VersionRange}"); unresolved.Add(reference); } } } return(unresolved.ToImmutable()); }