Utilisateur:ZX81-bot/Journaux/2007053100

string[] AddPortails = new string[] { "Portail Valais" };
        string[] AddEbauches = new string[] { "Ébauche 1", "Ébauche 2" };
        string[] DelBandeaux = new string[] { "Bandeau 1", "Bandeau 2" };
        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;
            foreach (string bandeau in DelBandeaux)
            {
                BandeauxUniques[nbBU] = CleanBandeau(bandeau);
                nbBU++;
            }
 
            // 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(NettoyageBandeaux),
                RegexOptions.IgnoreCase);
            if (ArticleText != ArticleTextOld)
            {
                Summary += ", nett. 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
            string portail;
            foreach (string p in AddPortails)
            {
                portail = CleanBandeau(p);
                if (portail != String.Empty)
                {
                    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);
                            Summary += ", ajout bandeau " + portail;
                        }
                        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);
                            Summary += ", ajout bandeau " + portail;
                        }
                    }
                }
            }
            if (ArticleText != ArticleTextOld)
            {
                ArticleTextOld = ArticleText;
            }
            else
            {
                Skip = true;
                return 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;
            }
 
 
            // Suppression des retours à la ligne superflus entre modèles et bandeaux
            ArticleText = Regex.Replace(ArticleText,
                @"(?<=\}\})\s*(?=\{\{(?:Multi bandeau\|[^\}]+|Portail [^\|\}]+)\}\}.*)",
                "\r\n",
                RegexOptions.Singleline);
 
            // 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 m.Value.ToUpper();
        }
 
        private string CleanBandeau(string bandeau)
        {
            bandeau = bandeau.Trim();
            bandeau = Regex.Replace(bandeau, "_", " ");
            bandeau = Regex.Replace(bandeau, " +", " ");
            bandeau = Regex.Replace(bandeau, @"^(?:(?::? *fr *: *)?(?:Modèle|Template) *: *)?", "");
            bandeau = Tools.TurnFirstToUpper(bandeau);
            return bandeau;
        }
 
        private string NettoyageBandeaux(Match m)
        {
            string bandeau;
            string bandeaux = "";
            foreach (string b in m.Groups[2].Value.Split(new Char[] { '|' }))
            {
                bandeau = CleanBandeau(b);
                if (Regex.IsMatch(bandeau, @"^(?:Ébauche(?:s?| .+)|Portail .+)$"))
                {
                    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];
        }