// Retourne le commentaire sans les tags // Sinon retourne une chaine de caractère vierge private bool CheckTags(string tag, string content, TagParsingEnum current, ref string RetValue) { // Tag de documentation seul if (string.Format("<{0}></{0}>", tag) == content.Trim()) { RetValue = string.Empty; return(true); } // Tag de documentation encadrant sur la meme ligne bool Result = CheckTag(string.Format("(<{0}>)(?<name>.*)(</{0}>)", tag), content, current, ref RetValue); if (Result == true) { return(true); } // Tag de documentation encadrant commencant sur la ligne Result = CheckTag(string.Format("(<{0}>)(?<name>.*[^(</{0}>)])", tag), content, current, ref RetValue); if (Result == true) { return(true); } // Tag de documentation encadrant finisant sur la ligne Result = CheckTag(string.Format("(?<name>.*[^(<{0}>)])(</{0}>)", tag), content, current, ref RetValue); if (Result == true) { return(true); } return(false); }
private void ReturnDefaultText() { if (returnText.Count == 0) { TagModified = TagParsingEnum.Return; ParamModified = null; returnText.Add(GetDefaultReturn()); DisplayNewWin(this.returnText, ref this.returnText); this.hasReturn = true; } }
private void DisplayCompareWin(bool _isDefault, List <string> otherTxt, ref List <string> CurrentTxt, TagParsingEnum tag, bool displayNew = true, ParameterComment paramModified = null) { TagModified = tag; ParamModified = paramModified; // On affiche une interface utilisateur if (displayNew == true /*&& MainWindow.IsClose == false*/) { // Si nouveau texte vierge if (IsEmptyList(CurrentTxt) == true) { // On affiche la boite de dialogue nouveau DisplayNewWin(otherTxt, ref CurrentTxt); return; } // Si c'est le texte par défaut pour le précédent commentaire else if (_isDefault == true) { // On garde le texte return; } // On compare l'ancien et le nouveau texte if (DisplayCompareUI != null) { DisplayCompareUI(this, otherTxt, ref CurrentTxt); } } else { // Pas de texte à fusionner if (IsEmptyList(otherTxt) == true && IsEmptyList(CurrentTxt) == true) { return; } // On garde le texte précédent if (IsEmptyList(otherTxt) == false && IsEmptyList(CurrentTxt) == true) { CurrentTxt.AddRange(otherTxt); return; } // Pour le cas inverse on ne fait rien! } }
private bool CheckTag(string search, string content, TagParsingEnum current, ref string RetValue) { Regex TagRegEx = new Regex(search); Match m = TagRegEx.Match(content); if (m.Success == true) { TagParsing = current; // On extrait entre les tags de début et de fin le contenu RetValue = m.Groups["name"].Value; if (string.IsNullOrEmpty(RetValue) == true) { return(false); } return(true); } RetValue = string.Empty; return(false); }
private bool CheckTagParameter(string search, string content, ref string RetName, ref string RetValue) { Regex TagRegEx = new Regex(search); Match m = TagRegEx.Match(content); if (m.Success == true) { TagParsing = TagParsingEnum.Parameters; // On extrait entre les tags de début et de fin le contenu RetName = m.Groups["name"].Value; RetValue = CleanTagCode(m.Groups["value"].Value); // Si rien n'a été trouvé if (string.IsNullOrEmpty(RetName) == true && string.IsNullOrEmpty(RetValue) == true) { return(false); } return(true); } return(false); }
// To merge a original documentation with the new one public bool Merge(Comments others) { bool isMerged = false; // Est-ce-que les 2 codenames sont égaux? if (this.codeName != others.codeName || string.IsNullOrEmpty(this.codeName) == true || string.IsNullOrWhiteSpace(this.codeName) == true || string.IsNullOrEmpty(others.codeName) == true || string.IsNullOrWhiteSpace(others.codeName) == true) { // Ce n'est pas normal! return(false); } others.SetDefaultForEmpty(); // On compare les textes // Si texte pareil, ne rien faire // Si texte différent, Réaliser une interface pour l'utilisateur pour réaliser le choix // , Si texte d'origine ou vierge est la traduction par défaut // proposé une interface pour saisir commentaire DisplayCompareWin(others.isDefault, others.comments, ref this.comments, TagParsingEnum.Summary); // Si pas de return, on vide le texte if (this.hasReturn == false && others.hasReturn == false) { returnText.Clear(); } else { // Est-ce-que les 2 commentaires ont des return? if (others.hasReturn == true) { // On doit comparer le texte des returns // Le texte des valeurs de retour // Texte pareil, ne rien faire // Si texte différent, Réaliser une interface pour l'utilisateur pour réaliser le choix // , Si texte d'origine ou vierge est la traduction par défaut // proposé une interface pour saisir commentaire if (this.returnText.SequenceEqual(others.returnText) == false) { // Si le texte du précédent return est vierge if (returnText.Count == 0) { // Selon la valeur du commentaire pour le return existant if (others.returnText.Count == 0) { returnText.Add(GetDefaultReturn()); } else { this.returnText = others.returnText; } TagModified = TagParsingEnum.Return; ParamModified = null; DisplayNewWin(this.returnText, ref this.returnText); this.hasReturn = true; } } else { ReturnDefaultText(); } } // Sinon on met une valeur par défaut si nécessaire else { ReturnDefaultText(); } } // Si pas de propriété on vide le texte if (this.isProperty == false) { valueText.Clear(); } // Est-ce-que ceux sont 2 propriétés ou pas? else if (others.isProperty == this.isProperty) { // Le texte des valeurs des propriétés // Si texte pareil, ne rien faire // Si texte différent, Réaliser une interface pour l'utilisateur pour réaliser le choix // , Si texte d'origine ou vierge est la traduction par défaut // proposé une interface pour saisir commentaire DisplayCompareWin(others.isDefault, others.valueText, ref this.valueText, TagParsingEnum.Property, false); } // Les paramètres à vérifier // Si paramètres pareil, ne rien faire. // Si paramètre différent, les paramètres bon sont dans this obligatoirement // , Recopier les commentaires des memes paramètres nom et type de valeur // , Les paramètres supprimés, la doc est à supprimer aussi if (this.parameters.SequenceEqual(others.parameters) == false) { // Pour chaque paramètres dans la nouvelle documentation foreach (ParameterComment newparam in parameters) { // On recherche le meme paramétre dans l'ancienne documentation List <ParameterComment> Found = others.parameters.FindAll(delegate(ParameterComment itm) { return(itm.Name == newparam.Name); }); // Si plusieurs paramètre, il y a un problème switch (Found.Count) { case 0: TagModified = TagParsingEnum.Parameters; ParamModified = newparam; // Paramètre vraiment nouveau! DisplayNewWin(newparam.GetText(), ref newparam.Comment); continue; case 1: DisplayCompareWin(others.isDefault, Found[0].Comment, ref newparam.Comment, TagParsingEnum.Parameters, false, newparam); /* * // Si aucun commentaire dans le commentaire précédent * if (string.IsNullOrEmpty(newparam.Comment) == true || * string.IsNullOrWhiteSpace(newparam.Comment) == true) * // On merge les commentaires * newparam.Comment = Found[0].Comment; */ continue; default: // ERROR: Impossible to have same name for multiple parameters continue; } } } // Le texte des remarques // Si texte pareil, ne rien faire // Si texte différent, Réaliser une interface pour l'utilisateur pour réaliser le choix // , Si texte d'origine ou vierge est la traduction par défaut // proposé une interface pour saisir commentaire DisplayCompareWin(others.isDefault, others.remarksText, ref this.remarksText, TagParsingEnum.Remark, false); // Le texte exemples DisplayCompareWin(others.isDefault, others.exampleText, ref this.exampleText, TagParsingEnum.Example, false); return(isMerged); }
// To parse a comment public void Parse(string Content, bool isComment = false) { // Les chaines de caractéres vides ne sont pas gérés if (string.IsNullOrEmpty(Content) == true || string.IsNullOrWhiteSpace(Content) == true) { comments.Add(string.Empty); return; } string cleanContent = CleanTagCode(Content); // Les summary string Result = string.Empty; // Ce n'est pas la peine d'aller plus loin if (StartEndTagAlone("summary", cleanContent) == true) { TagParsing = TagParsingEnum.Summary; return; } // Est-ce un summary de documentation? if (CheckTags("summary", cleanContent, TagParsingEnum.Summary, ref Result) == true) { if (string.IsNullOrEmpty(Result) == false && string.IsNullOrWhiteSpace(Result) == false) { comments.Add(Result); } return; } // Si c'est juste un commentaire if (isComment == true) { comments.Add(cleanContent); // Pas la peine d'aller plus loin return; } bool multiline = false; string Name = string.Empty; // Ce n'est pas la peine d'aller plus loin if (StartEndTagAlone("typeparam", Content) == true) { TagParsing = TagParsingEnum.Parameters; return; } // Les paramètres génériques if (CheckTagParameters("typeparam", Content, ref Name, ref Result, ref multiline) == true) { AddParameter(Name, Result, multiline, true); return; } // Les paramètres // Ce n'est pas la peine d'aller plus loin if (StartEndTagAlone("param", Content) == true) { TagParsing = TagParsingEnum.Parameters; return; } if (CheckTagParameters("param", Content, ref Name, ref Result, ref multiline) == true) { AddParameter(Name, Result, multiline, false); return; } // Les remarques // Ce n'est pas la peine d'aller plus loin if (StartEndTagAlone("remark", cleanContent) == true) { TagParsing = TagParsingEnum.Remark; return; } if (CheckTags("remark", cleanContent, TagParsingEnum.Remark, ref Result) == true) { if (string.IsNullOrEmpty(Result) == false && string.IsNullOrWhiteSpace(Result) == false) { remarksText.Add(Result); } return; } // Les returns // Ce n'est pas la peine d'aller plus loin if (StartEndTagAlone("returns", cleanContent) == true) { hasReturn = true; TagParsing = TagParsingEnum.Return; return; } if (CheckTags("returns", cleanContent, TagParsingEnum.Return, ref Result) == true) { hasReturn = true; if (string.IsNullOrEmpty(Result) == false && string.IsNullOrWhiteSpace(Result) == false) { returnText.Add(Result); } return; } // Les propriétés // Ce n'est pas la peine d'aller plus loin if (StartEndTagAlone("value", cleanContent) == true) { TagParsing = TagParsingEnum.Property; return; } if (CheckTags("value", cleanContent, TagParsingEnum.Property, ref Result) == true) { isProperty = true; if (string.IsNullOrEmpty(Result) == false && string.IsNullOrWhiteSpace(Result) == false) { valueText.Add(Result); } return; } // Les examples de code if (StartEndTagAlone("example", cleanContent) == true) { TagParsing = TagParsingEnum.Example; return; } if (CheckTags("example", cleanContent, TagParsingEnum.Example, ref Result) == true) { if (string.IsNullOrEmpty(Result) == false && string.IsNullOrWhiteSpace(Result) == false) { exampleText.Add(Result); } return; } switch (TagParsing) { case TagParsingEnum.Summary: comments.Add(cleanContent); return; case TagParsingEnum.Parameters: // Pour ajouter une description d'un paramètre multiligne int nb = parameters.Count; if (nb == 0) { return; } parameters[nb - 1].AddComment(CleanTagCode(Content)); return; case TagParsingEnum.Return: returnText.Add(cleanContent); return; case TagParsingEnum.Property: valueText.Add(cleanContent); return; case TagParsingEnum.Remark: remarksText.Add(cleanContent); return; case TagParsingEnum.Example: exampleText.Add(cleanContent); return; default: // On ne connait cet état!!! return; } }