Utilisateur:Erabot/Journaux/20070728

string portail = "portail animation";
        string SummaryTemp;
 
        string[] BandeauxUniques;
        int nbBU;
        public string ProcessArticle(string ArticleText, string ArticleTitle, int wikiNamespace, out string Summary, out bool Skip)
        {
            Skip = false;
            Summary = "";
 
            string ArticleTextOld = ArticleText;
            SummaryTemp = "";
 
            BandeauxUniques = new string[100];
            nbBU = 0;
 
            // Remplacement des divers modèles de multi bandeaux par le modèle {{Multi bandeau}}
            ArticleText = Regex.Replace(ArticleText,
                @"\{\{ *(?:(?::? *fr *: *)?(?:Modèle|Template) *: *)?(?:Multi[ _]+bandeaux?|Multi-?bandeau|Multib) *(\|[^\}]*)?\}\}",
                "{{Multi bandeau$1}}",
                RegexOptions.IgnoreCase);
            if (ArticleText != ArticleTextOld)
            {
                Summary += ", rempl. modèle";
                ArticleTextOld = ArticleText;
            }
 
            // Suppression des modèles multi bandeaux ou des paramètres vides se trouvant à l'intérieur d'un modèle {{Multi bandeau}}
            ArticleText = Regex.Replace(ArticleText,
                @"(?<=\{\{Multi bandeau(?:\|[^\|\}]*)*?)\| *(?:(?::? *fr *: *)?(?:Modèle|Template) *: *)?(?:Multi[ _]+bandeaux?|Multi-?bandeau|Multib|) *(?=(?:\|[^\|\}]*)*\}\})",
                "",
                RegexOptions.IgnoreCase);
            if (ArticleText != ArticleTextOld)
            {
                Summary += ", suppr. modèle à l'intérieur";
                ArticleTextOld = ArticleText;
            }
 
            // Nettoyage des (multi-)bandeaux et suppression des doublons
            ArticleText = Regex.Replace(ArticleText,
                @"(\{\{(?:Multi bandeau\|)?)((?<=\{\{Multi bandeau\|)[^\}]+|(?<=\{\{) *(?:(?::? *fr *: *)?(?:Modèle|Template) *: *)?(?:Ébauche(?:s?|[ _]+[^\|\}]+)|Portail[ _]+[^\|\}]+))(\}\}(?s:\s*))",
                new MatchEvaluator(NettoyageBandeau),
                RegexOptions.IgnoreCase);
            if (ArticleText != ArticleTextOld)
            {
                Summary += ", net. modèle";
                Summary += SummaryTemp;
                SummaryTemp = "";
                ArticleTextOld = ArticleText;
            }
 
            // Groupement des bandeaux ébauches dans un unique modèle {{Multi bandeau}}
            ArticleText = Regex.Replace(ArticleText,
                @"(?:\{\{(?:Multi bandeau\|)?((?<=\{\{Multi bandeau\|)(?:[^\}]+\|)?Ébauche[s ][^\}]+|Ébauche(?:s?| [^\|\}]+))\}\}(\s*)){2,}",
                new MatchEvaluator(MultiBandeau),
                RegexOptions.Singleline);
 
            // Groupement des bandeaux portail dans un unique modèle {{Multi bandeau}}
            ArticleText = Regex.Replace(ArticleText,
                @"(?:\{\{(?:Multi bandeau\|)?((?<=\{\{Multi bandeau\|)(?:[^\}]+\|)?Portail [^\}]+|Portail [^\|\}]+)\}\}(\s*)){2,}",
                new MatchEvaluator(MultiBandeau),
                RegexOptions.Singleline);
 
            if (ArticleText != ArticleTextOld)
            {
                Summary += ", group. bandeaux";
                ArticleTextOld = ArticleText;
            }
 
            // Ajout portail
            portail = portail.Trim();
            if (portail != String.Empty)
            {
                portail = Regex.Replace(portail, "_", " ");
                portail = Regex.Replace(portail, " +", " ");
                portail = Regex.Replace(portail, @"^(?:(?::? *fr *: *)?(?:Modèle|Template) *: *)?", "");
                portail = Tools.TurnFirstToUpper(portail);
 
                if (Array.IndexOf(BandeauxUniques, portail) == -1)
                {
                    if (Regex.IsMatch(ArticleText, @"\{\{(?:Multi bandeau\|(?:[^\}]+\|)?Portail [^\}]+|Portail [^\|\}]+)\}\}"))
                    {
                        ArticleText = Regex.Replace(ArticleText,
                            @"(.*\{\{)(?:Multi bandeau\|((?:[^\}]+\|)?Portail [^\}]+)|(Portail [^\|\}]+))(?=\}\})",
                            "$1Multi bandeau|$2$3|" + portail,
                            RegexOptions.Singleline | RegexOptions.Multiline);
                    }
                    else if (Regex.IsMatch(ArticleText, @"(?:\{\{ *DEFAULTSORT *:[^\}]+\}\}\s*)?\[\[ *Catégorie *:[^\]]+\]\]", RegexOptions.IgnoreCase))
                    {
                        ArticleText = Regex.Replace(ArticleText,
                            @"((?:\{\{ *DEFAULTSORT *:[^\}]+\}\}\s*)?\[\[ *Catégorie *:[^\]]+\]\].*)",
                            "{{" + portail + "}}\n\n$1",
                            RegexOptions.Singleline | RegexOptions.IgnoreCase);
                    }
                    else
                    {
                        Skip = true;
                        return ArticleText;
                    }
                }
                else
                {
                    Skip = true;
                    return ArticleText;
                }
            }
            if (ArticleText != ArticleTextOld)
            {
                Summary += ", ajout bandeau " + portail;
                ArticleTextOld = ArticleText;
            }
 
            // Suppression des modèles {{Multi bandeau}} vide ou avec un seul bandeau
            ArticleText = Regex.Replace(ArticleText,
                @"\{\{Multi bandeau\|?\}\}\s*|(?<=\{\{)Multi bandeau\|(?=[^\|\}]+\}\})",
                "");
            if (ArticleText != ArticleTextOld)
            {
                Summary += ", suppr. modèle inutile";
                ArticleTextOld = ArticleText;
            }
 
            // Correction des retours à la ligne entre bandeaux et catégories
            ArticleText = Regex.Replace(ArticleText,
                @"(?<=\{\{(?:Multi bandeau\|[^\}]+|Portail [^\|\}]+)\}\})\s*(?=(?:\{\{ *DEFAULTSORT *:[^\}]+\}\}\s*)?\[\[ *Catégorie *:[^\]]+\]\].*)",
                "\r\n\r\n",
                RegexOptions.Singleline);
            if (ArticleText != ArticleTextOld)
            {
                Summary += ", corr. \\r\\n";
                ArticleTextOld = ArticleText;
            }
 
            ArticleText = Regex.Replace(ArticleText, @"\[\[ *Cat(?:égorie|egory) *: *(?=[^\]]+\]\])", "[[Catégorie:", RegexOptions.IgnoreCase);
            ArticleText = Regex.Replace(ArticleText, @"\[\[Catégorie:(\p{Ll})", new MatchEvaluator(UpFirstChar));
            ArticleText = Regex.Replace(ArticleText, @"(?<=\{\{)(?::? *fr *: *)?(?:Modèle|Template) *: *(?=[^\}]+\}\})", "", RegexOptions.IgnoreCase);
 
            return ArticleText;
        }
 
        private string UpFirstChar(Match m)
        {
            return "[[Catégorie:" + m.Groups[1].ToString().ToUpper();
        }
 
        private string NettoyageBandeau(Match m)
        {
            string bandeau;
            string bandeaux = "";
            foreach (string b in m.Groups[2].Value.Split(new Char[] { '|' }))
            {
                bandeau = b.Trim();
                bandeau = Regex.Replace(bandeau, "_", " ");
                bandeau = Regex.Replace(bandeau, " +", " ");
                bandeau = Regex.Replace(bandeau, @"^(?:(?::? *fr *: *)?(?:Modèle|Template) *: *)?", "");
                bandeau = Tools.TurnFirstToUpper(bandeau);
                if (Regex.IsMatch(bandeau, @"^(?:Ébauche(?:s?| .+)|Portail .+)$", RegexOptions.IgnoreCase))
                {
                    if (Array.IndexOf(BandeauxUniques, bandeau) == -1)
                    {
                        BandeauxUniques[nbBU] = bandeau;
                        nbBU++;
                        bandeaux += bandeau + "|";
                    }
                    else
                    {
                        SummaryTemp += ", suppr. doublon " + bandeau;
                    }
                }
                else
                {
                    bandeaux += bandeau + "|";
                }
            }
            if (bandeaux == String.Empty)
            {
                return String.Empty;
            } else {
                return m.Groups[1].Value + bandeaux.Trim(new Char[] { '|' }) + m.Groups[3].Value;
            }
        }
        private string MultiBandeau(Match m)
        {
            string bandeaux = "";
            foreach (Capture c in m.Groups[1].Captures)
            {
                bandeaux += "|" + c.Value;
            }
            return "{{Multi bandeau" + bandeaux + "}}" + m.Groups[2].Captures[m.Groups[2].Captures.Count-1];
        }