Exemplo n.º 1
0
        public override void Run(IEnumerable <string> args)
        {
            string        rootdir     = "";
            string        omitlist    = "";
            string        processlist = "";
            string        pattern     = "";
            List <string> extras      = CommandUtils.ProcessFileArgs(args,
                                                                     ref rootdir,
                                                                     ref omitlist,
                                                                     ref processlist,
                                                                     ref pattern
                                                                     );

            string message = "For internal use only.";
            string sigil   = "To be added.";
            bool   nocheck = false;
            bool   nosigil = false;

            var opt = new OptionSet {
                { "m|message=", (m) => message = m },
                { "s|sigil=", (s) => sigil = s },
                { "no-check-browsable", (n) => nocheck = n != null },
                { "no-check-TBA", (t) => nosigil = t != null }
            };

            extras = opt.Parse(extras);

            CommandUtils.ThrowOnFiniteExtras(extras);

            Func <XElement, bool>  hassigil;
            Func <XDocument, bool> typehassigil;
            Func <XElement, bool>  qualifies;

            if (nosigil)
            {
                // Mark types and members internal, regardless of whether the summaries are filled out
                hassigil     = (x) => true;
                typehassigil = (x) => true;
            }
            else
            {
                hassigil     = (e) => e.Element("Docs").Element("summary").Value == sigil;
                typehassigil = (t) => t.Element("Type").Element("Docs").Element("summary").Value == sigil;
            }

            if (!nocheck)
            {
                qualifies = (e) =>
                {
                    return(e.Elements("Attributes")
                           .Any((XElement child) => child.Elements("Attribute")
                                .Any((XElement name) => name.Value.Contains("EditorBrowsableState.Never"))) &&
                           hassigil(e));
                };
            }
            else
            {
                qualifies = hassigil;
            }

            foreach (string file in CommandUtils.GetFileList(processlist, omitlist, rootdir, pattern))
            {
                XDocument xdoc = new XDocument(XElement.Load(file));
                // Find every member that has the internal marker and summary="To be added." (or the provided sigil)

                XElement memberRoot = xdoc.Element("Type").Element("Members");
                if (memberRoot == null || !memberRoot.Descendants().Any())
                {
                    continue;
                }

                IEnumerable <XElement> hits = memberRoot.Elements("Member").Where(s => qualifies(s));

                foreach (XElement x in hits)
                {
                    x.Element("Docs").Element("summary").Value = message;
                }

                if (typehassigil(xdoc))
                {
                    xdoc.Element("Type").Element("Docs").Element("summary").Value = message;
                }


                CommandUtils.WriteXDocument(xdoc, file);
            }
        }
Exemplo n.º 2
0
        public override void Run(IEnumerable <string> args)
        {
            // throw new NotImplementedException();

            string updatedDir  = "";
            string omitlist    = "";
            string processlist = "";
            string pattern     = "";

            List <string> extras = CommandUtils.ProcessFileArgs(args,
                                                                ref updatedDir,
                                                                ref omitlist,
                                                                ref processlist,
                                                                ref pattern);

            string oldFilesDir = "";
            bool   typeOnly    = false;
            string reportFile  = "";
            bool   nosigil     = false;

            var options = new OptionSet {
                { "previous=", (p) => oldFilesDir = p },
                { "typeonly", (t) => typeOnly = t != null },
                { "reportfile=", (r) => reportFile = r },
                { "no-check-TBA", (t) => nosigil = t != null }
            };

            extras = options.Parse(extras);

            CommandUtils.ThrowOnFiniteExtras(extras);

            if (String.IsNullOrEmpty(oldFilesDir))
            {
                throw new ArgumentException("You must supply a parallel directory from which to source new content with 'previous='.");
            }

            if (String.IsNullOrEmpty(reportFile) || !reportFile.EndsWith(".csv"))
            {
                throw new ArgumentException("'reportfile=' must be used, and its value must end with '.csv'.");
            }

            string bareReportDir = Path.GetDirectoryName(Path.GetFullPath(reportFile));

            if (!Directory.Exists(bareReportDir))
            {
                throw new ArgumentException(bareReportDir + " does not exist.");
            }

            IEnumerable <string> updated = CommandUtils.GetFileList(processlist, omitlist, updatedDir, pattern);

            StreamWriter reportStream = new StreamWriter(reportFile);

            reportStream.WriteLine(String.Format(CommandUtils.CSVFormatString(5), "File Name", "Type", "Member", "Need file summary", "Need member summary"));

            Func <XElement, bool> hasSigil = null;

            if (nosigil)
            {
                hasSigil = (XElement e) => true;
            }
            else
            {
                hasSigil = (XElement e) => e.Element("Docs").Element("summary").Value == "To be added.";
            }

            //Func<XElement, bool> needSummary = (XElement e) => e.Element("Docs").Element("summary").Value == "To be added.";

            Func <XElement, string> MemberLine = (XElement e) => {
                return(string.Format(
                           CommandUtils.CSVFormatString(5),
                           "",
                           "",
                           e.Attribute("MemberName").Value,
                           "",
                           hasSigil(e) ? "y" : "n"));
            };



            List <string> toWrite = new List <string>();

            foreach (string updatedXMLFile in updated)
            {
                bool fileLineAdded = false;

                XDocument updatedXDoc = XDocument.Load(updatedXMLFile);

                Func <string> FileLine = () =>
                {
                    return(string.Format(
                               CommandUtils.CSVFormatString(5),
                               updatedXMLFile,
                               updatedXDoc.Element("Type").Attribute("FullName").Value,
                               "",
                               hasSigil(updatedXDoc.Element("Type")) ? "y" : "n",
                               ""));
                };


                string    oldXMLFile = EcmaXmlHelper.GetParallelFilePathFor(updatedXMLFile, oldFilesDir, updatedDir);
                XDocument oldXDoc    = File.Exists(oldXMLFile) ? XDocument.Load(oldXMLFile) : null;
                if (null == oldXDoc && hasSigil(updatedXDoc.Element("Type")))
                {
                    toWrite.Add(FileLine());
                    fileLineAdded = true;
                }

                IEnumerable <XElement> newMembers = EcmaXmlHelper.NewMembers(updatedXDoc, oldXDoc);
                if (null != newMembers && newMembers.Where((f) => hasSigil(f)).Any())
                {
                    if (!fileLineAdded)
                    {
                        toWrite.Add(FileLine());
                    }

                    foreach (XElement e in newMembers.Where((f) => hasSigil(f)))
                    {
                        toWrite.Add(MemberLine(e));
                    }
                }

                // If toWrite isn't empty, write all lines
                if (toWrite.Any())
                {
                    foreach (string s in toWrite)
                    {
                        reportStream.WriteLine(s);
                    }
                }
                toWrite.Clear();
            }
            reportStream.Flush();
            reportStream.Close();
        }