private void AddReference(InputProjectDriver inputProjectDriver, Project project, string reference) { string referenceFullPath = Path.GetFullPath(Path.Combine(AssemblyFolderHelper.GetTestAssemblyFolder(), reference)); string assemblyName = Path.GetFileNameWithoutExtension(referenceFullPath); Debug.Assert(assemblyName != null); project.AddItem("Reference", assemblyName, new[] { new KeyValuePair<string, string>("HintPath", referenceFullPath), }); }
public void ProjectGetter() { Project project = new Project(); ProjectItem item = project.AddItem("i", "i1")[0]; Assert.Equal(true, Object.ReferenceEquals(project, item.Project)); }
public static ProjectItem ThreadSafeAdd(this Microsoft.Build.Evaluation.Project thisp, string itemType, string unevaluatedInclude) { lock (thisp) { return(thisp.AddItem(itemType, unevaluatedInclude).First()); } }
/// <summary> /// Creates a temporary MSBuild content project in memory. /// </summary> void CreateBuildProject() { string projectPath = Path.Combine(buildDirectory, "content.contentproj"); string outputPath = Path.Combine(buildDirectory, "bin"); // Create the build project. projectRootElement = ProjectRootElement.Create(projectPath); // Include the standard targets file that defines how to build XNA Framework content. projectRootElement.AddImport("$(MSBuildExtensionsPath)\\Microsoft\\XNA Game Studio\\" + "v4.0\\Microsoft.Xna.GameStudio.ContentPipeline.targets"); buildProject = new Microsoft.Build.Evaluation.Project(projectRootElement); buildProject.SetProperty("XnaPlatform", "Windows"); buildProject.SetProperty("XnaProfile", "Reach"); buildProject.SetProperty("XnaFrameworkVersion", "v4.0"); buildProject.SetProperty("Configuration", "Release"); buildProject.SetProperty("OutputPath", outputPath); // Register any custom importers or processors. foreach (string pipelineAssembly in pipelineAssemblies) { buildProject.AddItem("Reference", pipelineAssembly); } // Hook up our custom error logger. errorLogger = new ErrorLogger(); buildParameters = new BuildParameters(ProjectCollection.GlobalProjectCollection); buildParameters.Loggers = new ILogger[] { errorLogger }; }
public static MSbuildResult BuildProject(MsBuildSettings settings, string projectFileName, DirectoryInfo dir) { var result = new MSbuildResult(); var path = Path.Combine(dir.FullName, projectFileName); var project = new Project(path, null, null, new ProjectCollection()); project.SetProperty("CscToolPath", settings.CompilerDirectory.FullName); var includes = new HashSet<string>( project.AllEvaluatedItems .Where(i => i.ItemType == "None" || i.ItemType == "Content") .Select(i => Path.GetFileName(i.EvaluatedInclude.ToLowerInvariant()))); foreach (var dll in settings.WellKnownLibsDirectory.GetFiles("*.dll")) if (!includes.Contains(dll.Name.ToLowerInvariant())) project.AddItem("None", dll.FullName); project.Save(); using (var stringWriter = new StringWriter()) { var logger = new ConsoleLogger(LoggerVerbosity.Minimal, stringWriter.Write, color => { }, () => { }); result.Success = SyncBuild(project, logger); if (result.Success) result.PathToExe = Path.Combine(project.DirectoryPath, project.GetPropertyValue("OutputPath"), project.GetPropertyValue("AssemblyName") + ".exe"); else result.ErrorMessage = stringWriter.ToString(); return result; } }
void CreateBuildProject() { string projectPath = Path.Combine(buildDirectory, "content.contentproj"); string outputPath = Path.Combine(buildDirectory, "bin"); // Create the build project. projectRootElement = ProjectRootElement.Create(projectPath); // Include the standard targets file that defines how to build XNA Framework content. projectRootElement.AddImport(Application.StartupPath + "\\Exporters\\FBX\\XNA\\XNA Game Studio\\" + "v4.0\\Microsoft.Xna.GameStudio.ContentPipeline.targets"); buildProject = new Project(projectRootElement); buildProject.SetProperty("XnaPlatform", "Windows"); buildProject.SetProperty("XnaProfile", "Reach"); buildProject.SetProperty("XnaFrameworkVersion", "v4.0"); buildProject.SetProperty("Configuration", "Release"); buildProject.SetProperty("OutputPath", outputPath); buildProject.SetProperty("ContentRootDirectory", "."); buildProject.SetProperty("ReferencePath", Application.StartupPath); // Register any custom importers or processors. foreach (string pipelineAssembly in pipelineAssemblies) { buildProject.AddItem("Reference", pipelineAssembly); } // Hook up our custom error logger. errorLogger = new ErrorLogger(); buildParameters = new BuildParameters(ProjectCollection.GlobalProjectCollection) {Loggers = new ILogger[] {errorLogger}}; }
public void ProjectGetter() { Project project = new Project(); ProjectItem item = project.AddItem("i", "i1")[0]; ProjectMetadata metadatum = item.SetMetadataValue("m", "m1"); Assert.AreEqual(true, Object.ReferenceEquals(project, metadatum.Project)); }
public static void IncludeFileInCurrentProject(string approved) { var p = new Project(GetCurrentProjectFile(approved)); if (!p.Items.Any(i => approved.EndsWith(i.UnevaluatedInclude))) { p.AddItem("Content", approved); p.Save(); } }
/// <summary> /// Checks if the same item already exists and only adds it to the project if it doesn't. /// </summary> /// <param name="project">The project to add the item to.</param> /// <param name="itemType">The item type of the added item.</param> /// <param name="unevaluatedInclude">Include attribute of the item to be added.</param> public static bool AddItemIfNotAlready(this Microsoft.Build.Evaluation.Project project, string itemType, string unevaluatedInclude) { if (project.Items.FirstOrDefault(i => i.EvaluatedInclude == unevaluatedInclude) != null) { return(false); } project.AddItem(itemType, unevaluatedInclude); return(true); }
public override void Generate(ProjectType projectType, MSBuild.Project project) { var filename = Path.Combine(project.DirectoryPath, Name); File.WriteAllText(filename, Content); if (!IsExcluded) { project.AddItem("Content", Name); } }
public override void Generate(ProjectType projectType, MSBuild.Project project) { if (!IsMissing) { Directory.CreateDirectory(Path.Combine(project.DirectoryPath, Name)); } if (!IsExcluded) { project.AddItem("Folder", Name); } }
public override void Generate(ProjectType projectType, MSBuild.Project project) { if (!IsMissing) { var absName = Path.IsPathRooted(Name) ? Name : Path.Combine(project.DirectoryPath, Name); var absReferencePath = Path.IsPathRooted(ReferencePath) ? ReferencePath : Path.Combine(project.DirectoryPath, ReferencePath); NativeMethods.CreateSymbolicLink(absName, absReferencePath); } if (!IsExcluded) { project.AddItem("Folder", Name); } }
public void SpecialCharactersInMetadataValueEvaluation() { Microsoft.Build.Evaluation.Project project = new Microsoft.Build.Evaluation.Project(); var metadata = new Dictionary <string, string> { { "EscapedSemicolon", "%3B" }, // Microsoft.Build.Internal.Utilities.Escape(";") { "EscapedDollarSign", "%24" }, // Microsoft.Build.Internal.Utilities.Escape("$") }; Microsoft.Build.Evaluation.ProjectItem item = project.AddItem( "None", "MetadataTests", metadata).Single(); SpecialCharactersInMetadataValueTests(item); project.ReevaluateIfNecessary(); SpecialCharactersInMetadataValueTests(item); }
/// <summary> /// Adds a new content file to the MSBuild project. The importer and /// processor are optional: if you leave the importer null, it will /// be autodetected based on the file extension, and if you leave the /// processor null, data will be passed through without any processing. /// </summary> /// <param name="filename">Content file.</param> /// <param name="name">Name of the compiled content.</param> /// <param name="importer">Importer to use.</param> /// <param name="processor">Processor to use.</param> public void Add(string filename, string name, string importer, string processor) { ProjectItem item = buildProject.AddItem("Compile", filename)[0]; item.SetMetadataValue("Link", Path.GetFileName(filename)); item.SetMetadataValue("Name", name); if (!string.IsNullOrEmpty(importer)) { item.SetMetadataValue("Importer", importer); } if (!string.IsNullOrEmpty(processor)) { item.SetMetadataValue("Processor", processor); } projectItems.Add(item); }
public override void Generate(ProjectType projectType, MSBuild.Project project) { if (!IsMissing) { var absName = Path.IsPathRooted(Name) ? Name : Path.Combine(project.DirectoryPath, Name); var absReferencePath = Path.IsPathRooted(ReferencePath) ? ReferencePath : Path.Combine(project.DirectoryPath, ReferencePath); try { NativeMethods.CreateSymbolicLink(absName, absReferencePath); } catch (UnauthorizedAccessException ex) { Assert.Inconclusive(ex.Message); } } if (!IsExcluded) { project.AddItem("Folder", Name); } }
public void LinkToFile(Project project, BuildAction buildAction, string includeValue, string projectTargetPath) { if(projectTargetPath.StartsWith("\\")) throw new Exception("project target path cannot begin with a backslash"); var matchingProjectItemByTargetPath = (from t in project.Items where t.HasMetadata("Link") && t.GetMetadataValue("Link") == projectTargetPath select t).SingleOrDefault(); if (matchingProjectItemByTargetPath != null) project.RemoveItem(matchingProjectItemByTargetPath); var buildActionName = Enum.GetName(typeof(BuildAction), buildAction); project.AddItem(buildActionName, includeValue, new[] {new KeyValuePair<string, string>("Link", projectTargetPath)}); }
public void AddItem_EscapedItemInclude() { Project project = new Project(); project.AddItem("i", "i%281%29"); string expected = ObjectModelHelpers.CleanupFileContents( @"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace""> <ItemGroup> <i Include=""i%281%29"" /> </ItemGroup> </Project>"); Helpers.VerifyAssertProjectContent(expected, project.Xml); List<ProjectItem> items = Helpers.MakeList(project.Items); Assert.Equal(1, items.Count); Assert.Equal("i", items[0].ItemType); Assert.Equal("i(1)", items[0].EvaluatedInclude); Assert.Equal("i(1)", Helpers.GetFirst(project.GetItems("i")).EvaluatedInclude); Assert.Equal("i(1)", Helpers.MakeList(project.CreateProjectInstance().GetItems("i"))[0].EvaluatedInclude); }
int IVsProject.AddItem(uint itemidLoc, VSADDITEMOPERATION dwAddItemOperation, string pszItemName, uint cFilesToOpen, string[] rgpszFilesToOpen, IntPtr hwndDlgOwner, VSADDRESULT[] pResult) { if (Directory.Exists(rgpszFilesToOpen[0])) { AddProject(new MockVsHierarchy(rgpszFilesToOpen[0], this)); } else { Children.Add(rgpszFilesToOpen[0]); if (_project != null) { FileInfo itemFileInfo = new FileInfo(rgpszFilesToOpen[0]); _project.Save(FileName); FileInfo projectFileInfo = new FileInfo(_project.ProjectFileLocation.File); string itemName = itemFileInfo.FullName.Substring(projectFileInfo.Directory.FullName.Length + 1); _project.AddItem("Compile", itemName); _project.Save(FileName); } } return(VSConstants.S_OK); }
public static void AddProjectFiles(FilePath ProjectFile, IReadOnlyList <FilePath> files, bool build = false) { var project = new MSEV.Project(ProjectFile); var projectFolder = ProjectFile.Folder; foreach (var file in files) { var itemType = StandardItemTypes.InferItemType(file.FileName); var relativePath = file.Value.Replace(projectFolder.FullPath, String.Empty); if (relativePath.StartsWith("\\")) { relativePath = relativePath.Substring(1); } project.AddItem(itemType, relativePath); } project.Save(); if (build) { project.Build(); } }
public override void Generate(ProjectType projectType, MSBuild.Project project) { var filename = Path.Combine(project.DirectoryPath, Name + projectType.CodeExtension); if (!IsMissing) { File.WriteAllText(filename, Content ?? projectType.SampleCode); } if (!IsExcluded) { List <KeyValuePair <string, string> > metadata = new List <KeyValuePair <string, string> >(); if (LinkFile != null) { metadata.Add(new KeyValuePair <string, string>("Link", LinkFile + projectType.CodeExtension)); } project.AddItem( "Compile", Name + projectType.CodeExtension, metadata ); } }
private void ToolStripButton3_Click(object sender, EventArgs e) { TreeNode node = treeView1.SelectedNode; if (node.ImageIndex == PROJECT || node.ImageIndex == FOLDER || node.ImageIndex == FOLDER_OPEN) { string path = _filePath.Replace(Path.DirectorySeparatorChar + Path.GetFileName(_filePath) ?? string.Empty, ""); string replace = node.FullPath?.Replace(Path.GetFileName(_filePath) ?? string.Empty, ""); string target = path + replace.Replace("\\", Path.DirectorySeparatorChar.ToString()); if (Directory.Exists(target)) { StringDialog dialog = new StringDialog((text) => !string.IsNullOrEmpty(text)); dialog.Description = "Create Directory Name"; dialog.ShowDialog(); if (dialog.DialogResult == DialogResult.OK) { string newDir = target + Path.DirectorySeparatorChar + dialog.ResultString; if (!Directory.Exists(newDir)) { Directory.CreateDirectory(newDir); string name = replace.Split(Path.DirectorySeparatorChar)[1]; Project proj = _projects[name]; proj.AddItem("Folder", newDir.Replace(path + "\\" + name + "\\", "") + "\\"); proj.Save(); LoadSolution(_solution, _filePath); } else { MessageBox.Show("Created Directory"); } } } } }
public void SetValueWithItemExpression() { Project project = new Project(); project.AddItem("i", "i1"); ProjectItem item = project.AddItem("j", "j1")[0]; ProjectMetadata metadatum = item.SetMetadataValue("m", "@(i)"); project.ReevaluateIfNecessary(); metadatum.UnevaluatedValue = "@(i)"; Assert.AreEqual("@(i)", metadatum.UnevaluatedValue); Assert.AreEqual("i1", metadatum.EvaluatedValue); }
/// <summary> /// Adds the specified factory to the project. If the factory was /// created by this provider, it will be added as an Interpreter element /// with full details. If the factory was not created by this provider, /// it will be added as an InterpreterReference element with only the /// ID and version. /// </summary> /// <param name="factory">The factory to add.</param> public void AddInterpreter(IPythonInterpreterFactory factory, bool disposeInterpreter = false) { if (factory == null) { throw new ArgumentNullException("factory"); } if (_factories.ContainsKey(factory)) { return; } MSBuild.ProjectItem item; var derived = factory as DerivedInterpreterFactory; if (derived != null) { var projectHome = CommonUtils.GetAbsoluteDirectoryPath(_project.DirectoryPath, _project.GetPropertyValue("ProjectHome")); var rootPath = CommonUtils.EnsureEndSeparator(factory.Configuration.PrefixPath); _rootPaths[factory.Id] = rootPath; item = _project.AddItem(InterpreterItem, CommonUtils.GetRelativeDirectoryPath(projectHome, rootPath), new Dictionary <string, string> { { IdKey, derived.Id.ToString("B") }, { BaseInterpreterKey, derived.BaseInterpreter.Id.ToString("B") }, { VersionKey, derived.BaseInterpreter.Configuration.Version.ToString() }, { DescriptionKey, derived.Description }, { InterpreterPathKey, CommonUtils.GetRelativeFilePath(rootPath, derived.Configuration.InterpreterPath) }, { WindowsPathKey, CommonUtils.GetRelativeFilePath(rootPath, derived.Configuration.WindowsInterpreterPath) }, { LibraryPathKey, CommonUtils.GetRelativeDirectoryPath(rootPath, derived.Configuration.LibraryPath) }, { PathEnvVarKey, derived.Configuration.PathEnvironmentVariable }, { ArchitectureKey, derived.Configuration.Architecture.ToString() } }).FirstOrDefault(); } else if (_service.FindInterpreter(factory.Id, factory.Configuration.Version) != null) { // The interpreter exists globally, so add a reference. item = _project.AddItem(InterpreterReferenceItem, string.Format("{0:B}\\{1}", factory.Id, factory.Configuration.Version) ).FirstOrDefault(); } else { // Can't find the interpreter anywhere else, so add its // configuration to the project file. var projectHome = CommonUtils.GetAbsoluteDirectoryPath(_project.DirectoryPath, _project.GetPropertyValue("ProjectHome")); var rootPath = CommonUtils.EnsureEndSeparator(factory.Configuration.PrefixPath); item = _project.AddItem(InterpreterItem, CommonUtils.GetRelativeDirectoryPath(projectHome, rootPath), new Dictionary <string, string> { { IdKey, factory.Id.ToString("B") }, { VersionKey, factory.Configuration.Version.ToString() }, { DescriptionKey, factory.Description }, { InterpreterPathKey, CommonUtils.GetRelativeFilePath(rootPath, factory.Configuration.InterpreterPath) }, { WindowsPathKey, CommonUtils.GetRelativeFilePath(rootPath, factory.Configuration.WindowsInterpreterPath) }, { LibraryPathKey, CommonUtils.GetRelativeDirectoryPath(rootPath, factory.Configuration.LibraryPath) }, { PathEnvVarKey, factory.Configuration.PathEnvironmentVariable }, { ArchitectureKey, factory.Configuration.Architecture.ToString() } }).FirstOrDefault(); } lock (_factoriesLock) { _factories[factory] = new FactoryInfo(item, disposeInterpreter); } OnInterpreterFactoriesChanged(); UpdateActiveInterpreter(); }
public void SettingItemExcludeDirties() { Project project = new Project(); ProjectItem item = project.AddItem("i", "i1")[0]; project.ReevaluateIfNecessary(); item.Xml.Exclude = "i1"; project.ReevaluateIfNecessary(); Assert.Equal(0, Helpers.MakeList(project.Items).Count); }
public void ItemsByEvaluatedIncludeDirectAdd() { Project project = new Project(); project.AddItem("i", "i1"); List<ProjectItem> items = Helpers.MakeList(project.GetItemsByEvaluatedInclude("i1")); Assert.Equal(1, items.Count); }
public void AddItemWithMetadata_DoesNotMatchWildcardWithNoMetadata() { Project project = new Project(); ProjectItemElement item1 = project.Xml.AddItem("i", "*.xxx"); project.ReevaluateIfNecessary(); Dictionary<string, string> metadata = new Dictionary<string, string>() { { "m", "m1" } }; ProjectItemElement item2 = project.AddItem("i", "i1.xxx", metadata)[0].Xml; string expected = ObjectModelHelpers.CleanupFileContents( @"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace""> <ItemGroup> <i Include=""*.xxx"" /> <i Include=""i1.xxx""> <m>m1</m> </i> </ItemGroup> </Project>"); Helpers.VerifyAssertProjectContent(expected, project); }
public void SpecialCharactersInMetadataValueEvaluation() { Microsoft.Build.Evaluation.Project project = new Microsoft.Build.Evaluation.Project(); var metadata = new Dictionary<string, string> { { "EscapedSemicolon", "%3B" }, // Microsoft.Build.Internal.Utilities.Escape(";") { "EscapedDollarSign", "%24" }, // Microsoft.Build.Internal.Utilities.Escape("$") }; Microsoft.Build.Evaluation.ProjectItem item = project.AddItem( "None", "MetadataTests", metadata).Single(); SpecialCharactersInMetadataValueTests(item); project.ReevaluateIfNecessary(); SpecialCharactersInMetadataValueTests(item); }
public void NormalizePaths(bool addImports) { List <_BE.ProjectItem> removeItems = new List <_BE.ProjectItem>(); foreach (_BE.ProjectItem folderItem in m_project.GetItems("Folder")) { string path = folderItem.Xml.Include; if (!path.Equals(GetRelativePath(path), StringComparison.OrdinalIgnoreCase)) { removeItems.Add(folderItem); continue; } if (!Directory.Exists(path)) { removeItems.Add(folderItem); continue; } } foreach (string groupName in ProjectEx.FileGroups) { List <MyImportItems> importItems = new List <MyImportItems>(); foreach (_BE.ProjectItem buildItem in m_project.GetItems(groupName)) { string projectRelativePath = GetRelativePath(buildItem.Xml.Include); // The path has to be an absolute path to somewhere // outside the project directory. if (projectRelativePath == null) { string origPath = Path.Combine(Path.GetDirectoryName(m_origProjPath), buildItem.EvaluatedInclude); if (File.Exists(origPath)) { projectRelativePath = buildItem.Xml.Include; externalFiles.Add(buildItem.Xml.Include, origPath); } else if (File.Exists(BuildTaskUtility.ExpandEnvironmentVariables(buildItem.Xml.Include))) { projectRelativePath = Path.GetFileName(buildItem.Xml.Include); externalFiles.Add( projectRelativePath, BuildTaskUtility.ExpandEnvironmentVariables(buildItem.Xml.Include)); } else if (!buildItem.IsImported) { // since the file doesn't even exist // remove it from the project removeItems.Add(buildItem); continue; } else { // This is an imported item // it can't be removed, so // ignore it. if (Task != null) { Task.Log.LogWarning("Ignoring missing imported build item, \"{0}, {1}\"", buildItem.ItemType, buildItem.Xml.Include); } continue; } } if (!buildItem.IsImported) { // Reset the path to the file relative to // the project buildItem.Xml.Include = projectRelativePath; } else if (addImports) { MyImportItems newItem = new MyImportItems(); newItem.name = buildItem.ItemType; newItem.include = projectRelativePath; newItem.meta = new Dictionary <string, string>(); foreach (_BE.ProjectMetadata meta in buildItem.Metadata) { newItem.meta.Add(meta.Name, meta.UnevaluatedValue); } importItems.Add(newItem); } } foreach (MyImportItems importItem in importItems) { m_project.AddItem(importItem.name, importItem.include, importItem.meta); } } foreach (_BE.ProjectItem removeItem in removeItems) { Task.Log.LogWarning("Removing missing build item, \"{0}, {1}\"", removeItem.ItemType, removeItem.Xml.Include); m_project.RemoveItem(removeItem); } }
public void AddItem_DoesntMatchComplicatedWildcard() { Project project = new Project(); ProjectItemElement item1 = project.Xml.AddItem("i", @"c:\subdir1\**\subdir2\**\*.x?x"); project.ReevaluateIfNecessary(); ProjectItemElement item2 = project.AddItem("i", @"c:\subdir1\a\b\c\i1.xyx")[0].Xml; string expected = ObjectModelHelpers.CleanupFileContents( @"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace""> <ItemGroup> <i Include=""c:\subdir1\**\subdir2\**\*.x?x"" /> <i Include=""c:\subdir1\a\b\c\i1.xyx"" /> </ItemGroup> </Project>"); Helpers.VerifyAssertProjectContent(expected, project); Assert.Equal(false, Object.ReferenceEquals(item1, item2)); }
public void SpecialCharactersInMetadataValueEvaluation() { Project project = new Project(); ProjectItem item = project.AddItem("None", "MetadataTests", new Dictionary<string, string> { {"EscapedSemicolon", "%3B"}, //Microsoft.Build.Evaluation.ProjectCollection.Escape(";") {"EscapedDollarSign", "%24"}, //Microsoft.Build.Evaluation.ProjectCollection.Escape("$") }).Single(); EscapingInProjectsHelper.SpecialCharactersInMetadataValueTests(item); project.ReevaluateIfNecessary(); EscapingInProjectsHelper.SpecialCharactersInMetadataValueTests(item); }
public void AddItem_MatchesWildcardWithCondition() { Project project = new Project(); ProjectItemElement itemElement = project.Xml.AddItem("i", "*.xxx"); itemElement.Condition = "true"; project.ReevaluateIfNecessary(); project.AddItem("i", "i1.xxx"); string expected = ObjectModelHelpers.CleanupFileContents( @"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace""> <ItemGroup> <i Include=""*.xxx"" Condition=""true"" /> <i Include=""i1.xxx"" /> </ItemGroup> </Project>"); Helpers.VerifyAssertProjectContent(expected, project); }
public void AddItem_ContainingSemicolonExistingWildcard() { Project project = new Project(); project.Xml.AddItem("i", "*.xxx"); project.ReevaluateIfNecessary(); project.AddItem("i", "i1.xxx;i2.xxx"); string expected = ObjectModelHelpers.CleanupFileContents( @"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace""> <ItemGroup> <i Include=""*.xxx"" /> <i Include=""i1.xxx;i2.xxx"" /> </ItemGroup> </Project>"); Helpers.VerifyAssertProjectContent(expected, project); }
private static void ReplaceReference(Project project, ProjectItem item, string reference, string path) { project.RemoveItem(item); project.AddItem("Reference", reference, new[] { new KeyValuePair <string, string>("HintPath", Path.Combine(path, reference + ".dll")) }); }
public void AddItem_MatchesWildcardWithPropertyReference() { Project project = new Project(); project.SetProperty("p", "xxx"); project.Xml.AddItem("i", "a;*.$(p);b"); project.ReevaluateIfNecessary(); project.AddItem("i", "i1.xxx"); string expected = ObjectModelHelpers.CleanupFileContents( @"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace""> <PropertyGroup> <p>xxx</p> </PropertyGroup> <ItemGroup> <i Include=""a;*.$(p);b"" /> </ItemGroup> </Project>"); Helpers.VerifyAssertProjectContent(expected, project); }
public void IsImportedFalse() { Project project = new Project(); ProjectMetadata metadata = project.AddItem("i", "i1")[0].SetMetadataValue("m", "m1"); Assert.AreEqual(false, metadata.IsImported); }
public void RenameItem_MatchesWildcard() { Project project = new Project(); project.AddItem("i", "*.xxx"); project.AddItem("i", "i1"); project.ReevaluateIfNecessary(); ProjectItem item = Helpers.GetLast(project.Items); item.Rename("i1.xxx"); string expected = ObjectModelHelpers.CleanupFileContents( @"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace""> <ItemGroup> <i Include=""*.xxx"" /> <i Include=""i1.xxx"" /> </ItemGroup> </Project>"); Helpers.VerifyAssertProjectContent(expected, project); }
public void SetUnchangedValue() { Project project = new Project(); ProjectItem item = project.AddItem("i", "i1")[0]; item.SetMetadataValue("m", "m1"); project.ReevaluateIfNecessary(); item.SetMetadataValue("m", "m1"); Assert.AreEqual(false, project.IsDirty); item.GetMetadata("m").UnevaluatedValue = "m1"; Assert.AreEqual(false, project.IsDirty); }
public void RenameItem_NewNameContainsPropertyExpression() { Project project = new Project(); project.SetProperty("p", "v1"); project.AddItem("i", "i1"); project.ReevaluateIfNecessary(); ProjectItem item = Helpers.GetFirst(project.Items); item.Rename("$(p)"); Assert.Equal("$(p)", item.UnevaluatedInclude); // Rename should have been expanded in this simple case Assert.Equal("v1", item.EvaluatedInclude); // The ProjectItemElement should be the same ProjectItemElement newItemElement = Helpers.GetFirst((Helpers.GetFirst(project.Xml.ItemGroups)).Items); Assert.Equal(true, Object.ReferenceEquals(item.Xml, newItemElement)); }
public void ItemsByEvaluatedIncludeDirectRemove() { Project project = new Project(); ProjectItem item1 = project.AddItem("i", "i1;j1")[0]; project.RemoveItem(item1); List<ProjectItem> items = Helpers.MakeList(project.GetItemsByEvaluatedInclude("i1")); Assert.Equal(0, items.Count); }
public void RenameItem_NewNameContainsItemExpressionExpandingToTwoItems() { Project project = new Project(); project.AddItem("h", "h1"); project.AddItem("h", "h2"); project.AddItem("i", "i1"); project.ReevaluateIfNecessary(); ProjectItem item = Helpers.GetLast(project.Items); item.Rename("@(h)"); Assert.Equal("@(h)", item.UnevaluatedInclude); Assert.Equal("@(h)", item.EvaluatedInclude); // The ProjectItemElement should be the same ProjectItemElement newItemElement = Helpers.GetLast((Helpers.GetLast(project.Xml.ItemGroups)).Items); Assert.Equal(true, Object.ReferenceEquals(item.Xml, newItemElement)); }
private static bool UpgadeCppConfiguration(Microsoft.Build.Evaluation.Project project, OldConfiguration cfg) { ProjectPropertyGroupElement propertyGroup = project.Xml.PropertyGroups.FirstOrDefault(g => g.Label.Equals("IceBuilder")); if (propertyGroup == null) { propertyGroup = project.Xml.AddPropertyGroup(); propertyGroup.Label = "IceBuilder"; } if (!string.IsNullOrEmpty(cfg.OutputDir)) { propertyGroup.AddProperty(PropertyNames.OutputDir, cfg.OutputDir); } if (!string.IsNullOrEmpty(cfg.HeaderExt)) { propertyGroup.AddProperty(PropertyNames.HeaderExt, cfg.HeaderExt); } if (!string.IsNullOrEmpty(cfg.SourceExt)) { propertyGroup.AddProperty(PropertyNames.SourceExt, cfg.SourceExt); } if (!string.IsNullOrEmpty(cfg.AdditionalOptions)) { propertyGroup.AddProperty(PropertyNames.AdditionalOptions, cfg.AdditionalOptions); } if (!string.IsNullOrEmpty(cfg.IncludeDirectories)) { propertyGroup.AddProperty(PropertyNames.IncludeDirectories, string.Format("{0};$({1})", cfg.IncludeDirectories, PropertyNames.IncludeDirectories)); } if (cfg.Stream) { propertyGroup.AddProperty(PropertyNames.Stream, "True"); } if (cfg.Checksum) { propertyGroup.AddProperty(PropertyNames.Checksum, "True"); } if (cfg.Ice) { propertyGroup.AddProperty(PropertyNames.AllowIcePrefix, "True"); } if (!string.IsNullOrEmpty(cfg.DLLExport)) { propertyGroup.AddProperty(PropertyNames.DLLExport, cfg.DLLExport); } foreach (ProjectItemDefinitionGroupElement group in project.Xml.ItemDefinitionGroups) { // // Remove old property sheet from all configurations // IEnumerable <ProjectImportElement> imports = project.Xml.Imports.Where( p => p.Project.Equals("$(ALLUSERSPROFILE)\\ZeroC\\Ice.props")); if (imports != null) { foreach (ProjectImportElement import in imports) { import.Parent.RemoveChild(import); } } // // WinRT SDK old property sheet // imports = project.Xml.Imports.Where( p => p.Project.IndexOf("CommonConfiguration\\Neutral\\Ice.props") != -1); if (imports != null) { foreach (ProjectImportElement import in imports) { import.Parent.RemoveChild(import); } } foreach (ProjectItemDefinitionElement i in group.ItemDefinitions) { if (i.ItemType.Equals("ClCompile")) { if (!string.IsNullOrEmpty(cfg.OutputDir)) { ProjectMetadataElement metaData = i.Metadata.FirstOrDefault( e => e.Name.Equals("AdditionalIncludeDirectories")); if (metaData != null) { List <string> values = new List <string>(metaData.Value.Split(new char[] { ';' })); values.Remove(cfg.OutputDir); metaData.Value = string.Join(";", values); if (values.Count == 0 || (values.Count == 1 && values[0].Equals("%(AdditionalIncludeDirectories)"))) { i.RemoveChild(metaData); } else { if (!values.Contains("%(AdditionalIncludeDirectories)")) { values.Add("%(AdditionalIncludeDirectories)"); } metaData.Value = string.Join(";", values); } } } } else if (i.ItemType.Equals("Link")) { ProjectMetadataElement metaData = i.Metadata.FirstOrDefault( e => e.Name.Equals("AdditionalDependencies")); if (metaData != null) { List <string> values = new List <string>(metaData.Value.Split(new char[] { ';' })); foreach (string name in Package.CppLibNames) { values.Remove(string.Format("{0}.lib", name)); values.Remove(string.Format("{0}d.lib", name)); } if (values.Count == 0 || (values.Count == 1 && values[0].Equals("%(AdditionalDependencies)"))) { i.RemoveChild(metaData); } else { metaData.Value = string.Join(";", values); } } metaData = i.Metadata.FirstOrDefault(e => e.Name.Equals("AdditionalLibraryDirectories")); if (metaData != null) { if (metaData.Value.Equals("%(AdditionalLibraryDirectories)")) { i.RemoveChild(metaData); } } } } } List <ProjectItem> sliceItems = project.GetItems("None").Where(item => Path.GetExtension(item.UnevaluatedInclude).Equals(".ice")).ToList(); // // Default output directory has changed // if (string.IsNullOrEmpty(cfg.OutputDir)) { foreach (string itemType in new string[] { "ClInclude", "ClCompile" }) { project.GetItems(itemType).Where( item => { return(sliceItems.FirstOrDefault( slice => { return slice.UnevaluatedInclude.Equals(Path.ChangeExtension(item.UnevaluatedInclude, ".ice")); }) != null); }) .ToList() .ForEach(item => project.RemoveItem(item)); } } sliceItems.ForEach(item => { project.RemoveItem(item); project.AddItem("IceBuilder", item.UnevaluatedInclude); }); return(true); }
public void RenameItem_NewNameContainsItemExpressionExpandingToZeroItems() { Project project = new Project(); project.AddItem("i", "i1"); project.ReevaluateIfNecessary(); ProjectItem item = Helpers.GetLast(project.Items); item.Rename("@(h)"); Assert.Equal("@(h)", item.UnevaluatedInclude); Assert.Equal("@(h)", item.EvaluatedInclude); }
public void SettingItemIncludeDirties() { Project project = new Project(); ProjectItem item = project.AddItem("i", "i1")[0]; project.ReevaluateIfNecessary(); item.Xml.Include = "i2"; project.ReevaluateIfNecessary(); Assert.Equal("i2", Helpers.GetFirst(project.Items).EvaluatedInclude); }
public void SetValueWithPropertyExpression() { Project project = new Project(); project.SetProperty("p", "p0"); ProjectItem item = project.AddItem("i", "i1")[0]; ProjectMetadata metadatum = item.SetMetadataValue("m", "m1"); project.ReevaluateIfNecessary(); metadatum.UnevaluatedValue = "$(p)"; Assert.AreEqual("$(p)", metadatum.UnevaluatedValue); Assert.AreEqual("p0", metadatum.EvaluatedValue); }
public void AddItem_MatchesWildcard() { Project project = new Project(); ProjectItemElement item1 = project.Xml.AddItem("i", "*.xxx"); project.ReevaluateIfNecessary(); ProjectItemElement item2 = project.AddItem("i", "i1.xxx")[0].Xml; string expected = ObjectModelHelpers.CleanupFileContents( @"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace""> <ItemGroup> <i Include=""*.xxx"" /> </ItemGroup> </Project>"); Helpers.VerifyAssertProjectContent(expected, project); Assert.Equal(true, Object.ReferenceEquals(item1, item2)); }
/// <summary> /// This function is the callback used to execute the command when the menu item is clicked. /// See the constructor to see how the menu item is associated with this function using /// OleMenuCommandService service and MenuCommand class. /// </summary> /// <param name="sender">Event sender.</param> /// <param name="e">Event args.</param> private void MenuItemCallback(object sender, EventArgs e) { string message = "Refactoy concluido com sucesso !"; string title = "Refactory - Microserviço"; IntPtr hierarchyPointer, selectionContainerPointer; Object selectedObject = null; IVsMultiItemSelect multiItemSelect; uint projectItemId; IVsMonitorSelection monitorSelection = (IVsMonitorSelection)Package.GetGlobalService( typeof(SVsShellMonitorSelection)); monitorSelection.GetCurrentSelection(out hierarchyPointer, out projectItemId, out multiItemSelect, out selectionContainerPointer); IVsHierarchy selectedHierarchy = Marshal.GetTypedObjectForIUnknown( hierarchyPointer, typeof(IVsHierarchy)) as IVsHierarchy; if (selectedHierarchy != null) { ErrorHandler.ThrowOnFailure(selectedHierarchy.GetProperty( projectItemId, (int)__VSHPROPID.VSHPROPID_ExtObject, out selectedObject)); } EnvDTE.Project selectedProject = selectedObject as EnvDTE.Project; string projectPath = selectedProject.FullName; var classesEncontradas = GetAllProjectFiles(selectedProject.ProjectItems, ".cs"); var projectEvalution = new Microsoft.Build.Evaluation.Project(projectPath); if (!Directory.Exists(Path.Combine(selectedProject.Properties.Item("FullPath").Value.ToString(), "Service"))) { selectedProject.ProjectItems.AddFolder("Service"); projectEvalution.AddItem("Folder", Path.Combine(selectedProject.Properties.Item("FullPath").Value.ToString(), "Service")); } foreach (string classe in classesEncontradas) { var newClass = AnalisadorAST.Analisar(Arquivo.LerClasse(classe)); if (newClass != null) { Arquivo.CriarArquivo(newClass.Interface, selectedProject, projectEvalution, "I" + newClass.Name + ".cs"); Arquivo.CriarArquivo(newClass.Classe, selectedProject, projectEvalution, newClass.Name + ".cs"); } } //Show a message box to prove we were here VsShellUtilities.ShowMessageBox( this.ServiceProvider, message, title, OLEMSGICON.OLEMSGICON_INFO, OLEMSGBUTTON.OLEMSGBUTTON_OK, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST); }
public void TestRunPythonCommand() { var expectedSearchPath = string.Format("['{0}', '{1}']", TestData.GetPath(@"TestData").Replace("\\", "\\\\"), TestData.GetPath(@"TestData\HelloWorld").Replace("\\", "\\\\") ); var proj = new Project(TestData.GetPath(@"TestData\Targets\Commands4.pyproj")); foreach (var version in PythonPaths.Versions) { var verStr = version.Version.ToVersion().ToString(); proj.SetProperty("InterpreterId", version.Id.ToString("B")); proj.SetProperty("InterpreterVersion", verStr); proj.RemoveItems(proj.ItemsIgnoringCondition.Where(i => i.ItemType == "InterpreterReference").ToArray()); proj.AddItem("InterpreterReference", string.Format("{0:B}\\{1}", version.Id, verStr)); proj.Save(); proj.ReevaluateIfNecessary(); var log = new StringLogger(LoggerVerbosity.Minimal); Assert.IsTrue(proj.Build("CheckCode", new ILogger[] { new ConsoleLogger(LoggerVerbosity.Detailed), log })); Console.WriteLine(); Console.WriteLine("Output from {0:B} {1}", version.Id, version.Version.ToVersion()); foreach (var line in log.Lines) { Console.WriteLine("* {0}", line.TrimEnd('\r', '\n')); } var logLines = log.Lines.Last().Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries); Assert.AreEqual(2, logLines.Length); Assert.AreEqual(version.Version.ToVersion().ToString(), logLines[0].Trim()); Assert.AreEqual(expectedSearchPath, logLines[1].Trim()); } }
public void AddItem_MatchesWildcardButNotItemType() { Project project = new Project(); project.Xml.AddItem("i", "*.xxx"); project.ReevaluateIfNecessary(); project.AddItem("j", "j1.xxx"); string expected = ObjectModelHelpers.CleanupFileContents( @"<Project ToolsVersion=""msbuilddefaulttoolsversion"" xmlns=""msbuildnamespace""> <ItemGroup> <i Include=""*.xxx"" /> </ItemGroup> <ItemGroup> <j Include=""j1.xxx"" /> </ItemGroup> </Project>"); Helpers.VerifyAssertProjectContent(expected, project); }