예제 #1
0
        public string GetEvaluatedProperty(string propertyName)
        {
            string originalPropertyName = propertyName;

            if (overloadedProperties.ContainsKey(propertyName))
            {
                return(overloadedProperties[propertyName] as string);
            }

            string propertyValue = null;

            if (m_project != null)
            {
                propertyValue = m_project.GetPropertyValue(propertyName);
            }

            if (!string.IsNullOrEmpty(propertyValue))
            {
                BuildTaskUtility.RegexProperties(
                    ref propertyValue,
                    PropertyMatch);
            }

            return(propertyValue);
        }
예제 #2
0
        private void PropertyMatch(ref string source, System.Text.RegularExpressions.Capture capture)
        {
            string propertyName = BuildTaskUtility.PropertyNameFromCapture(capture);

            string propertyValue = GetEvaluatedProperty(propertyName);

            source.Replace(capture.Value, propertyValue);
        }
예제 #3
0
        public string GetRelativePath(string path)
        {
            string relativePath      = null;
            string previousDirectory = Environment.CurrentDirectory;

            Environment.CurrentDirectory = this.ProjectDirectory;
            string filePath =
                Path.GetFullPath(
                    BuildTaskUtility.ExpandEnvironmentVariables(path));

            if (File.Exists(filePath) || Directory.Exists(filePath))
            {
                relativePath = BuildTaskUtility.GetRelativePath(
                    this.ProjectDirectory,
                    filePath);
            }

            Environment.CurrentDirectory = previousDirectory;
            return(relativePath);
        }
예제 #4
0
        public void AddExtraFile(string extraFile)
        {
            string relativePath = GetRelativePath(extraFile);

            if (relativePath != null)
            {
                extraFiles.Add(relativePath);
            }
            else if (File.Exists(extraFile))
            {
                extraFile = BuildTaskUtility.ExpandEnvironmentVariables(extraFile);
                string fileName = Path.GetFileName(extraFile);
                extraFiles.Add(fileName);
                externalFiles.Add(fileName, extraFile);
            }
            else if (Task != null)
            {
                Task.Log.LogWarning("Ignoring missing ExtraFile \"{0}\"", extraFile);
            }
        }
        private TaskItem CreateExtraFile(string extraFile, ITaskItem projectItem)
        {
            string path     = BuildTaskUtility.ExpandEnvironmentVariables(extraFile);
            string fullPath = Path.GetFullPath(path);

            if (!File.Exists(fullPath))
            {
                Log.LogWarning("Cannot find extra file {0} for project {1}", extraFile, projectItem.ItemSpec);
                return(null);
            }

            TaskItem file           = new TaskItem(path);
            bool     doReplacements = TransmorgificationUtilities.ValidMimeTypeForReplacements(extraFile);

            file.SetMetadata("DoReplacements", doReplacements.ToString().ToLowerInvariant());
            file.SetMetadata("ItemCollection", "Extra");
            file.SetMetadata("ParentProject", projectItem.ItemSpec);
            file.SetMetadata("ProjectDir", projectItem.GetMetadata("RelativeDir"));

            return(file);
        }
예제 #6
0
        public string GetFullPath(string path)
        {
            // If the true path to the file is
            // external to the project, return the
            // true path.
            if (externalFiles.ContainsKey(path))
            {
                return(externalFiles[path]);
            }

            string previousDirectory = Environment.CurrentDirectory;

            Environment.CurrentDirectory = this.ProjectDirectory;

            string absolutePath = BuildTaskUtility.ExpandEnvironmentVariables(
                Path.GetFullPath(path));

            Environment.CurrentDirectory = previousDirectory;

            return(absolutePath);
        }
예제 #7
0
        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);
            }
        }
예제 #8
0
        private XmlDocument ExpandProject(XmlDocument projectDocument)
        {
            XmlNamespaceManager nsmgr = new XmlNamespaceManager(projectDocument.NameTable);

            nsmgr.AddNamespace(
                "msbuild",
                projectDocument.DocumentElement.Attributes["xmlns"].Value);

            XmlNode node = projectDocument.SelectSingleNode(
                "msbuild:Project/msbuild:PropertyGroup/msbuild:ImportToSDK",
                nsmgr);

            if (node != null && node.InnerText.ToLower() != "true")
            {
                return(null);
            }

            Hashtable importReplacements = new Hashtable();

            foreach (XmlNode importNode in projectDocument.SelectNodes(
                         "msbuild:Project/msbuild:Import", nsmgr))
            {
                string importProjFilePath =
                    BuildTaskUtility.ExpandEnvironmentVariables(importNode.Attributes["Project"].Value);
                if (!File.Exists(importProjFilePath))
                {
                    continue;
                }

                int searchResult = Array.BinarySearch <string>(
                    terminals,
                    importProjFilePath,
                    StringComparer.OrdinalIgnoreCase);

                if (searchResult >= 0)
                {
                    continue;
                }

                XmlDocument importDocument = new XmlDocument();
                importDocument.Load(importProjFilePath);

                string currentDirectory = Environment.CurrentDirectory;
                if (Directory.Exists(Path.GetDirectoryName(importProjFilePath)))
                {
                    Environment.CurrentDirectory = Path.GetDirectoryName(importProjFilePath);
                }
                importDocument = ExpandProject(importDocument);
                Environment.CurrentDirectory = currentDirectory;

                if (importDocument != null)
                {
                    importReplacements.Add(importNode, importDocument);
                }
            }

            IDictionaryEnumerator ienum = importReplacements.GetEnumerator();

            while (ienum.MoveNext())
            {
                XmlNode     replaceMe      = ienum.Key as XmlNode;
                XmlDocument importDocument = ienum.Value as XmlDocument;

                foreach (XmlNode child in importDocument.DocumentElement.ChildNodes)
                {
                    replaceMe.ParentNode.InsertBefore(
                        projectDocument.ImportNode(child, true),
                        replaceMe);
                }

                replaceMe.ParentNode.RemoveChild(replaceMe);
            }

            return(projectDocument);
        }