// 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;
}
}
