Exemple #1
0
        public void CreateProjectInstanceWithItemsContainingProjects()
        {
            const string CapturedMetadataName = "DefiningProjectFullPath";
            var          pc    = new ProjectCollection();
            var          projA = ProjectRootElement.Create(pc);
            var          projB = ProjectRootElement.Create(pc);

            projA.FullPath = Path.Combine(Path.GetTempPath(), "a.proj");
            projB.FullPath = Path.Combine(Path.GetTempPath(), "b.proj");
            projB.AddImport("a.proj");
            projA.AddItem("Compile", "aItem.cs");
            projB.AddItem("Compile", "bItem.cs");

            var projBEval         = new Project(projB, null, null, pc);
            var projBInstance     = projBEval.CreateProjectInstance();
            var projBInstanceItem = projBInstance.GetItemsByItemTypeAndEvaluatedInclude("Compile", "bItem.cs").Single();
            var projAInstanceItem = projBInstance.GetItemsByItemTypeAndEvaluatedInclude("Compile", "aItem.cs").Single();

            Assert.AreEqual(ProjectCollection.Escape(projB.FullPath), projBInstanceItem.GetMetadataValue(CapturedMetadataName));
            Assert.AreEqual(ProjectCollection.Escape(projA.FullPath), projAInstanceItem.GetMetadataValue(CapturedMetadataName));

            // Although GetMetadataValue returns non-null, GetMetadata returns null...
            Assert.IsNull(projAInstanceItem.GetMetadata(CapturedMetadataName));

            // .. Just like built-in metadata does: (this segment just demonstrates similar functionality -- it's not meant to test built-in metadata)
            Assert.IsNotNull(projAInstanceItem.GetMetadataValue("Identity"));
            Assert.IsNull(projAInstanceItem.GetMetadata("Identity"));

            Assert.IsTrue(projAInstanceItem.HasMetadata(CapturedMetadataName));
            Assert.IsFalse(projAInstanceItem.Metadata.Any());
            Assert.IsTrue(projAInstanceItem.MetadataNames.Contains(CapturedMetadataName, StringComparer.OrdinalIgnoreCase));
            Assert.AreEqual(projAInstanceItem.MetadataCount, projAInstanceItem.MetadataNames.Count);
        }
Exemple #2
0
        public bool GenerateEFSQLScriptsInternal(bool isLoggingEnabled = true)
        {
            InitializeProperties();
            EFSQLScripts = new ITaskItem[EFMigrations.Length];
            int index = 0;

            foreach (ITaskItem dbContext in EFMigrations)
            {
                string outputFileFullPath           = Path.Combine(EFPublishDirectory, EFSQLScriptsFolderName, dbContext.ItemSpec + ".sql");
                bool   isScriptGenerationSuccessful = GenerateSQLScript(outputFileFullPath, dbContext.ItemSpec, isLoggingEnabled);
                if (!isScriptGenerationSuccessful)
                {
                    return(false);
                }

                ITaskItem sqlScriptItem = new TaskItem(outputFileFullPath);
                sqlScriptItem.SetMetadata("DBContext", dbContext.ItemSpec);
                string connectionStringEscaped = ProjectCollection.Escape(dbContext.GetMetadata("Value"));
                sqlScriptItem.SetMetadata("ConnectionString", connectionStringEscaped);
                EFSQLScripts[index] = sqlScriptItem;

                index++;
            }

            return(true);
        }
Exemple #3
0
        public void EscapeDoesWTF()
        {
            string value_xml = "What are 'ESCAPE' & \"EVALUATE\" ? $ # % ^";
            string value     = "What are 'ESCAPE' & \"EVALUATE\" ? $ # % ^";
            string escaped   = "What are %27ESCAPE%27 & \"EVALUATE\" %3f %24 # %25 ^";
            string xml       = string.Format(@"<Project xmlns='http://schemas.microsoft.com/developer/msbuild/2003'>
	<PropertyGroup>
		<Foo>{0}</Foo>
		<Baz>$(FOO)</Baz>
	</PropertyGroup>
</Project>", value_xml);
            var    path      = "file://localhost/foo.xml";
            var    reader    = XmlReader.Create(new StringReader(xml), null, path);
            var    root      = ProjectRootElement.Create(reader);
            var    proj      = new Project(root);
            var    prop      = proj.Properties.First(p => p.Name == "Foo");

            Assert.AreEqual(value, prop.UnevaluatedValue, "#1");
            Assert.AreEqual(value, prop.EvaluatedValue, "#2");
            // eh?
            Assert.AreEqual(value, Project.GetPropertyValueEscaped(prop), "#3");
            prop = proj.Properties.First(p => p.Name == "Baz");
            Assert.AreEqual("$(FOO)", prop.UnevaluatedValue, "#4");
            Assert.AreEqual(value, prop.EvaluatedValue, "#5");
            // eh?
            Assert.AreEqual(value, Project.GetPropertyValueEscaped(prop), "#6");

            // OK you are fine.
            Assert.AreEqual(escaped, ProjectCollection.Escape(value), "#7");
        }
Exemple #4
0
        private void DoAdd(string itemType, string itemPath)
        {
            var added = this.itemProject.BuildProject.AddItem(itemType, ProjectCollection.Escape(itemPath));

            Debug.Assert(added.Count == 1, "adding a file created more than 1 new item, should not be possible since we escape wildcard characters");
            this.item = added[0];
        }
        public Task SetProjectGuidAsync(Guid value)
        {
            // Avoid searching for the <ProjectGuid/> if we've already checked previously in GetProjectGuidAsync.
            // This handles project open, avoids us needed to take another read-lock during setting of it.
            //
            // Technically a project could add a <ProjectGuid/> latter down the track by editing the project or
            // reloading from disk, however, both the solution, CPS and other components within Visual Studio
            // do not handle the GUID changing underneath them.
            if (_isPersistedInProject == false)
            {
                return(Task.CompletedTask);
            }

            return(_projectAccessor.OpenProjectXmlForUpgradeableReadAsync(_project, async(projectXml, cancellationToken) =>
            {
                ProjectPropertyElement property = FindProjectGuidProperty(projectXml);
                if (property != null)
                {
                    _isPersistedInProject = true;

                    // Avoid touching the project file unless the actual GUID has changed, regardless of format
                    if (!TryParseGuid(property, out Guid result) || value != result)
                    {
                        await _projectAccessor.OpenProjectXmlForWriteAsync(_project, (root) =>
                        {
                            property.Value = ProjectCollection.Escape(value.ToString("B").ToUpperInvariant());
                        }).ConfigureAwait(true);
                    }
                }
                else
                {
                    _isPersistedInProject = false;
                }
            }));
        }
Exemple #6
0
        public void DefiningProjectItemBuiltInMetadataFromWildcards()
        {
            const string CapturedMetadataName = "DefiningProjectFullPath";
            var          pc    = new ProjectCollection();
            var          projA = ProjectRootElement.Create(pc);
            var          projB = ProjectRootElement.Create(pc);

            string tempDir = Path.GetTempFileName();

            File.Delete(tempDir);
            Directory.CreateDirectory(tempDir);
            File.Create(Path.Combine(tempDir, "aItem.cs")).Dispose();

            projA.FullPath = Path.Combine(tempDir, "a.proj");
            projB.FullPath = Path.Combine(tempDir, "b.proj");
            projB.AddImport("a.proj");
            projA.AddItem("Compile", "*.cs");
            projB.AddItem("CompileB", "@(Compile)");

            var projBEval         = new Project(projB, null, null, pc);
            var projBInstance     = projBEval.CreateProjectInstance();
            var projAInstanceItem = projBInstance.GetItemsByItemTypeAndEvaluatedInclude("Compile", "aItem.cs").Single();
            var projBInstanceItem = projBInstance.GetItemsByItemTypeAndEvaluatedInclude("CompileB", "aItem.cs").Single();

            Assert.AreEqual(ProjectCollection.Escape(projA.FullPath), projAInstanceItem.GetMetadataValue(CapturedMetadataName));
            Assert.AreEqual(ProjectCollection.Escape(projB.FullPath), projBInstanceItem.GetMetadataValue(CapturedMetadataName));

            Assert.IsTrue(projAInstanceItem.HasMetadata(CapturedMetadataName));
            Assert.IsFalse(projAInstanceItem.Metadata.Any());
            Assert.IsTrue(projAInstanceItem.MetadataNames.Contains(CapturedMetadataName, StringComparer.OrdinalIgnoreCase));
            Assert.AreEqual(projAInstanceItem.MetadataCount, projAInstanceItem.MetadataNames.Count);
        }
            public IDictionary CloneCustomMetadataEscaped()
            {
                var ret = new Hashtable();

                foreach (DictionaryEntry e in metadata)
                {
                    ret [e.Key] = ProjectCollection.Escape((string)e.Value);
                }
                return(ret);
            }
Exemple #8
0
        System.Collections.IDictionary ITaskItem2.CloneCustomMetadataEscaped()
        {
            var dic = ((ITaskItem)this).CloneCustomMetadata();

            foreach (DictionaryEntry p in dic)
            {
                dic [p.Key] = ProjectCollection.Escape((string)p.Value);
            }
            return(dic);
        }
Exemple #9
0
 void GenerateCompileIncludes(ProjectItemGroupElement itemGroup)
 {
     foreach (var include in new[] { "Test.cs", "Test2.cs", "Test3.cs" }) {
                         itemGroup.AddItem ("Compile", ProjectCollection.Escape (include),
                                 new[] { new KeyValuePair<string, string> ("SubType", "Code") });
                 }
                 foreach (var resource in new[] { "Test.resx", "Test2.resx", "Test3.resx" }) {
                         itemGroup.AddItem ("EmbeddedResource", ProjectCollection.Escape (resource),
                                 new[] { new KeyValuePair<string, string> ("LogicalName", "Name.Space.Test") });
                 }
 }
Exemple #10
0
 void GenerateReferences(ProjectItemGroupElement itemGroup)
 {
     foreach (var reference in new[] { "Test.dll", "Test2.dll", "Test3.dll" }) {
                         var name = Path.GetFileNameWithoutExtension (reference);
                         itemGroup.AddItem ("Reference", name, new[] {
                                 new KeyValuePair<string, string> ("Name", name),
                                 new KeyValuePair<string, string> ("HintPath",
                                         ProjectCollection.Escape (reference)) });
                 }
                 foreach (var reference in new[] { "mscorlib", "System", "System.Xml" }) {
                         itemGroup.AddItem ("Reference", reference);
                 }
 }
Exemple #11
0
        public void Rename(string newPath)
        {
            string escapedPath = ProjectCollection.Escape(newPath);

            if (this.IsVirtual)
            {
                virtualProperties[ProjectFileConstants.Include] = escapedPath;
                return;
            }

            item.Rename(escapedPath);
            this.RefreshProperties();
        }
        internal Microsoft.Build.Evaluation.ProjectItem AddMsBuildItem(string itemType, string value)
        {
            string str = ProjectCollection.Escape(value);
            IList <Microsoft.Build.Evaluation.ProjectItem> projectItems = this.MsBuildProject.AddItem(itemType, str);

            if (projectItems.Count == 0)
            {
                return(null);
            }
            if (projectItems.Count > 1)
            {
                throw new InvalidOperationException();
            }
            return(projectItems[0]);
        }
        static ProjectRootElement CreateProject()
        {
            var monoDroidPath = XamarinAndroid.Path;
            var msBuildPath = Path.Combine(monoDroidPath, "lib", "xbuild", "Xamarin", "Android");
            if (!msBuildPath.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.OrdinalIgnoreCase))
                msBuildPath = msBuildPath + Path.DirectorySeparatorChar;

            var project = ProjectRootElement.Create();
            project.AddProperty("Configuration", "Release");
            project.AddProperty("Platform", "AnyCPU");
            project.AddProperty("PlatformTarget", "AnyCPU");
            project.AddProperty("OutputPath", "bin\\Release");
            project.AddProperty("TargetFrameworkDirectory", string.Join(";", XamarinAndroid.TargetFrameworkDirectories));
            project.AddImport(ProjectCollection.Escape(Path.Combine(msBuildPath, "Xamarin.Android.CSharp.targets")));

            return project;
        }
Exemple #14
0
 void SetKnownProperties(ProjectPropertyGroupElement properties)
 {
     properties.AddProperty("AssemblyName", Path.GetFileNameWithoutExtension("ZigZag.exe"));
     properties.AddProperty("ProjectGuid", projectGuid.ToString("B"));
     properties.AddProperty("CheckForOverflowUnderflow", false.ToString());
     properties.AddProperty("CodePage", String.Empty);
     properties.AddProperty("DebugSymbols", true.ToString());
     properties.AddProperty("DebugType", "Full");
     properties.AddProperty("Optimize", false.ToString());
     properties.AddProperty("Platform", "AnyCPU");
     properties.AddProperty("ProjectTypeGuids", projectTypeGuid.ToString("B"));
     properties.AddProperty("AllowUnsafeBlocks", false.ToString());
     properties.AddProperty("WarningLevel", "4");
     properties.AddProperty("OutputPath", ProjectCollection.Escape("bin\\Debug"));
     properties.AddProperty("OutputType", "winexe");
     properties.AddProperty("DefineConstants", "DEBUG,TRACE");
     properties.AddProperty("TreatWarningsAsErrors", true.ToString());
 }
        public void BuildSourceLinkUrl_BitbucketEnterprise_PersonalToken()
        {
            var engine = new MockEngine();
            var task   = new GetSourceLinkUrl()
            {
                BuildEngine = engine,
                SourceRoot  = new MockItem("/src/", KVP("RepositoryUrl", ProjectCollection.Escape("https://user_name%40domain.com:[email protected]/scm/abc/project1.git")), KVP("SourceControl", "git"), KVP("RevisionId", "0123456789abcdefABCDEF000000000000000000")),
                Hosts       = new[]
                {
                    new MockItem("bitbucket.domain.tools", KVP("ContentUrl", "https://bitbucket.domain.tools")),
                }
            };

            bool result = task.Execute();

            AssertEx.AssertEqualToleratingWhitespaceDifferences("", engine.Log);
            AssertEx.AreEqual("https://bitbucket.domain.tools/projects/abc/repos/project1/raw/*?at=0123456789abcdefABCDEF000000000000000000", task.SourceLinkUrl);
            Assert.True(result);
        }
Exemple #16
0
        public void Execute()
        {
            if (DebugOutput == null)
            {
                DebugOutput = false;
            }

            var json    = File.ReadAllText(SecretsJsonFilePath);
            var secrets = JObject.Parse(json);

            string replacement     = string.Empty;
            string safeReplacement = string.Empty;

            foreach (var secret in secrets)
            {
                replacement     += ProcessSecret(secret);
                safeReplacement += ProcessSecret(secret, true);
            }

            replacement = Regex.Replace(replacement, "\n\n$", "");

            var secretsClass = GenerateClass(replacement);

            Log.LogMessage((bool)DebugOutput ? secretsClass : GenerateClass(Regex.Replace(safeReplacement, "\n\n$", "")));

            var projectFile      = Path.Combine(OutputPath, $"{SecretsClassName}.cs");
            var intermediateFile = Path.Combine(IntermediateOutputPath, $"{SecretsClassName}.cs");
            var outputFile       = File.Exists(projectFile) ? projectFile : intermediateFile;

            Log.LogMessage($"Writing Secrets Class to: '{outputFile}'");
            GeneratedFiles = new ITaskItem[] {
                new TaskItem(ProjectCollection.Escape(outputFile))
            };

            File.WriteAllText(outputFile, secretsClass);
        }
        //=====================================================================

        /// <summary>
        /// This is used to HTML encode and escape an MSBuild property value
        /// </summary>
        /// <param name="unescapedValue">The unescaped value</param>
        /// <returns>The HTML encoded escaped value</returns>
        public static string Escape(string unescapedValue)
        {
            string escaped = HttpUtility.HtmlEncode(unescapedValue ?? String.Empty);

            return(ProjectCollection.Escape(escaped));
        }
Exemple #18
0
        internal static void WriteProjectXml(
            IInterpreterRegistryService service,
            TextWriter writer,
            string projectPath,
            string sourcePath,
            string filters,
            string searchPaths,
            string startupFile,
            PythonInterpreterView selectedInterpreter,
            ProjectCustomization customization,
            bool detectVirtualEnv
            )
        {
            var projectHome = PathUtils.GetRelativeDirectoryPath(Path.GetDirectoryName(projectPath), sourcePath);

            var project = ProjectRootElement.Create();

            project.DefaultTargets = "Build";
            project.ToolsVersion   = "4.0";

            var globals = project.AddPropertyGroup();

            globals.AddProperty("Configuration", "Debug").Condition = " '$(Configuration)' == '' ";
            globals.AddProperty("SchemaVersion", "2.0");
            globals.AddProperty("ProjectGuid", Guid.NewGuid().ToString("B"));
            globals.AddProperty("ProjectHome", projectHome);
            if (PathUtils.IsValidPath(startupFile))
            {
                globals.AddProperty("StartupFile", startupFile);
            }
            else
            {
                globals.AddProperty("StartupFile", "");
            }
            globals.AddProperty("SearchPath", searchPaths);
            globals.AddProperty("WorkingDirectory", ".");
            globals.AddProperty("OutputPath", ".");

            globals.AddProperty("ProjectTypeGuids", "{888888a0-9f3d-457c-b088-3a5042f75d52}");
            globals.AddProperty("LaunchProvider", DefaultLauncherProvider.DefaultLauncherName);

            var interpreterId = globals.AddProperty(PythonConstants.InterpreterId, "");

            if (selectedInterpreter != null && !String.IsNullOrWhiteSpace(selectedInterpreter.Id))
            {
                interpreterId.Value = selectedInterpreter.Id;
            }

            // VS requires property groups with conditions for Debug
            // and Release configurations or many COMExceptions are
            // thrown.
            var debugGroup   = project.AddPropertyGroup();
            var releaseGroup = project.AddPropertyGroup();

            debugGroup.Condition   = "'$(Configuration)' == 'Debug'";
            releaseGroup.Condition = "'$(Configuration)' == 'Release'";


            var folders         = new HashSet <string>();
            var virtualEnvPaths = detectVirtualEnv ? new List <string>() : null;

            foreach (var unescapedFile in EnumerateAllFiles(sourcePath, filters, virtualEnvPaths))
            {
                var file     = ProjectCollection.Escape(unescapedFile);
                var ext      = Path.GetExtension(file);
                var fileType = "Content";
                if (PythonConstants.FileExtension.Equals(ext, StringComparison.OrdinalIgnoreCase) ||
                    PythonConstants.WindowsFileExtension.Equals(ext, StringComparison.OrdinalIgnoreCase))
                {
                    fileType = "Compile";
                }
                folders.Add(Path.GetDirectoryName(file));

                project.AddItem(fileType, file);
            }

            foreach (var folder in folders.Where(s => !string.IsNullOrWhiteSpace(s)).OrderBy(s => s))
            {
                project.AddItem("Folder", folder);
            }

            if (selectedInterpreter != null && !String.IsNullOrWhiteSpace(selectedInterpreter.Id))
            {
                project.AddItem(
                    MSBuildConstants.InterpreterReferenceItem,
                    selectedInterpreter.Id
                    );
            }
            if (virtualEnvPaths != null && virtualEnvPaths.Any() && service != null)
            {
                foreach (var path in virtualEnvPaths)
                {
                    var shortId = PathUtils.GetFileOrDirectoryName(path);
                    var longId  = MSBuildProjectInterpreterFactoryProvider.GetInterpreterId("$(MSBuildProjectFullPath)", shortId);
                    var config  = VirtualEnv.FindInterpreterConfiguration(longId, path, service);
                    if (config != null)
                    {
                        AddVirtualEnvironment(project, sourcePath, shortId, config);

                        if (string.IsNullOrEmpty(interpreterId.Value))
                        {
                            interpreterId.Value = longId;
                        }
                    }
                }
            }

            var imports = project.AddPropertyGroup();

            imports.AddProperty("VisualStudioVersion", "10.0").Condition = " '$(VisualStudioVersion)' == '' ";

            (customization ?? DefaultProjectCustomization.Instance).Process(
                sourcePath,
                project,
                new Dictionary <string, ProjectPropertyGroupElement> {
                { "Globals", globals },
                { "Imports", imports },
                { "Debug", debugGroup },
                { "Release", releaseGroup }
            }
                );

            project.Save(writer);
        }
 public string GetMetadataValueEscaped(string metadataName)
 {
     return(ProjectCollection.Escape((string)metadata [metadataName]));
 }
Exemple #20
0
        public static string GetMetadataValueEscaped(ProjectItemInstance item, string name)
        {
            var md = item.Metadata.FirstOrDefault(m => m.Name.Equals(name, StringComparison.OrdinalIgnoreCase));

            return(md != null?ProjectCollection.Escape(md.EvaluatedValue) : null);
        }
Exemple #21
0
 public static string GetMetadataValueEscaped(ProjectMetadataInstance metadatum)
 {
     return(ProjectCollection.Escape(metadatum.EvaluatedValue));
 }
Exemple #22
0
 public static string GetEvaluatedItemIncludeEscaped(ProjectItemInstance item)
 {
     return(ProjectCollection.Escape(item.EvaluatedInclude));
 }
Exemple #23
0
 string ITaskItem2.GetMetadataValueEscaped(string metadataName)
 {
     return(ProjectCollection.Escape(GetMetadataValue(metadataName)));
 }