Discussion :

[hucste]

Bonjour,

à un tableau donné, dont la structure peut fortement ressembler à celle qui suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
array(19) {
  [0]=>
  string(71) "Ceci est du texte -"
  [1]=>
  string(35) "Ceci est un paragraphe ?!"
  [2]=>
  string(0) ""
  [3]=>
  string(0) ""
  [4]=>
  string(51) "* Auteur a écrit:"
  [5]=>
  string(78) "> Oui, parce qu'il a dit !!!"
  [6]=>
  string(1) ">"
  [7]=>
  string(1) ">"
  [8]=>
  string(32) "> Author wrote:"
  [9]=>
  string(63) ">> * Auteur a écrit : le [18-05-2019 07:22:51 +0200]:"
  [10]=>
  string(61) ">>> Cette phrase qui n'a aucun sens !"
  [11]=>
  string(17) ">>> N'est-ce pas ?"
  [12]=>
  string(16) ">> Oui, en effet !"
  [13]=>
  string(4) "> --"
  [14]=>
  string(71) "> Première ligne de suite"
  [15]=>
  string(6) "> ----"
  [16]=>
  string(49) "> Deuxième ligne de signature"
  [17]=>
  string(37) "> Troisième ligne de signature"
  [18]=>
  string(1) ">"
  [19]=>
  string(0)
  [20]=>
  string(1) "!"
}

(bien sûr, ayant réécrit les phrases pour l'exemple, on s'en fout des compteurs de chaînes... ce n'est pas ça qui compte)

- Dans un premier temps, je recherche la présence d'une chaîne qui commence par '* ' pour lui supprimer ce caractère '*' - d'ailleurs, on remarquera que je fais quasiment le même traitement dans le contexte où j'ai la présence de '>' devant '*'... dixit ligne ci-dessous.
- Dans un second temps, je veux traiter la présence des chaînes qui commencent absolument par '>' pour ensuite les traiter, sachant que s'il y en a plusieurs, la première commence absolument par un seul '>' et que les lignes suivantes peuvent avoir par imbrication la présence d'un ou plusieurs '>'. (pour schématiser, on va dire que ce sont des blocs de futures citations, tel le codage en Markdown).
- Le tableau peut finir par la présence de différents caractères ou non...

Mon début de code PHP ressemble à ceci - et j'ai le terrible sentiment que je m'y prend très mal :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
    function mngMain($main) {
 
        $sign = false;
 
        foreach($main as $key => $line) {
 
            // if line start with '*' and end with ':'...
            if(strpos($line, '* ', 0) !== FALSE) {
                $main[$key] = preg_replace('/^\* (.*?):$/',"\n".'${1}:', $line);
            }
 
            /*
             * Treatment for blockquote: search all lines started with '>'.
             *
             * */
            if(strpos($line, '>', 0) !== FALSE) {
 
                // if line is only '> --', rewrite with start code block MD
                if(strcmp($line, '> --') == 0) {
                    $sign = true;
                    $main[$key] = ">\n \n> ```";
                }
                // if line start with '> *'
                elseif(strpos($line, '> *', 0) !== FALSE) {
                    $main[$key] = preg_replace('/^\> \* (.*?):$/',"\n".'> ${1}:', $line);
                }
                // ici je cherche à traiter les correspondances pour injecter un même pattern en début de la première ligne correspondante, 
                //  et en fin de la dernière ligne correspondante... 
                //   et/ou sur la même ligne si seule et si elle(s) existe(nt)
                elseif(strpos($line, '>>', 0) !== FALSE) {
                    preg_match('/^>>/', $line, $m); var_dump($m);
                }
                else $main[$key] = $line;
 
                $index = $key;
 
            }
 
        }
        unset($key, $line);
 
        if($sign) $main[$index] = $main[$index]."```\n";
 
       return $main;
    }

Une idée à me soumettre ? merci d'avance...

[CosmoKnacki]

Je me demande d'abord d'où provient le texte (fichier, données POST, bdd..?) et pourquoi est-il sous la forme d'un tableau de chaînes ?

Je vois des trucs inutiles dans ton code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
// if line start with '*' and end with ':'...
if(strpos($line, '* ', 0) !== FALSE) {
    $main[$key] = preg_replace('/^\* (.*?):$/',"\n".'${1}:', $line);
}

Ta condition if et ta pattern font deux fois la même chose: tester la présence de * au début de la ligne.
Écrire directement $main[$key] = preg_replace('/^\* (.*):$/', "\n$1:", $line); sans faire de if avant, revient strictement au même. Tu fais cette même erreur plusieurs fois dans le code (garde en tête que preg_replace trouve et remplace, donc pas la peine de faire des tests supplémentaires).

unset($key, $line); ne sert à rien.

Si tu es motivé (car ça peut te sembler ardu pour le moment), je te conseille de jeter un œil au livre Modern PHP chez O'Reilly (trouvable dans n'importe quelle bibliothèque universitaire), notamment en ce qui concerne les flux (streams au chapître 5), ce qui pourra te donner des idées pour une manière élégante de procéder (quelque soit la provenance du texte). Il y a d'ailleurs un exemple de traitement du markdown en exploitant les filtres de flux sur sitepoint.com.

[hucste]

Merci pour les remarques, j'en tiens compte....

Bien que je ne voye pas l'intérêt de dire d'où vient les données : Quoiqu'il en soit je n'ai pas de problème pour ouvrir mon flux. C'est en effet une chaîne qui récupère le contenu d'un fichier texte qui n'est pas du tout du markdown, mais le corps de texte de mails. (écrit par un autre programme que je ne maîtrise pas).

Je l'analyse pour "corriger" les erreurs et en faire simplement un vrai markdown, qui passe à la moulinette de la class Parsedown, au lieu de MarkdownFilter.

Bref, la chaîne est simplement transformée en array par l'usage de la fonction explode...

[Invité]

Bonjour,

Savoir "d'où vien(nen)t les données" (et surtout sous quelle forme) permettrait peut-être de proposer une solution plus intelligente adaptée pour leur récupération / structuration.

[hucste]

Bonjour, @jreaux62 et au reste du monde aussi :p

Bon, alors pour tout raconter, c'est un fichier dont le nom change que je récupère sous forme d'objet avec un code qui ressemble à cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
        $info = new SplFileObject($file);
        (...)
 
        if(! empty($this->id) ) {
            $info->seek(3);
            $txt = '';
 
            while( ! $info->eof()) {
                $txt .= $info->fgets();
            }
 
            Parser::txtToMd($txt);
 
        }

- "$this->id" est un identifiant de fichier qui est envoyé plus tôt lors de l'appel du fichier.
- on va directement à la ligne qui est la plus intéressante : l'appel de mon Parser (classe statique)

Dans la class Parser, le code relatif à la méthode 'txtToMd()' est de cet acabit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
    public static function txtToMd($str) {
 
        self::toStr($str);
        self::strToArrays();
        (...)
 
    }

la méthode 'toStr()' - mal nommée, mais en attendant de trouver un nom plus explicite, ce n'est pas le propos - :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
private static function toStr($str)
    {
 
        $pattern = array(
            '/\A--(\s+)/',
            //'/(>\s(-{2})) /',
            '/\*\s(.*?):/',
            //'/(>+)\s\*\s(.*?):/',
        );
 
        $replace = array(
            "\n--\n",
            //"> --\n>",
            "$1:",
            //"*** $1 $2:",
        );
 
 
        $str = preg_replace($pattern, $replace, $str);
 
        self::$txt = $str; 
        unset($txt);
    }

- la méthode 'strToArrays()' - qui me permet de détecter la présence de la chaîne '--', si elle existe, pour l'exploser en deux arrays(), un considéré comme étant le corps de texte, et l'autre comme corps de signature.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
     /*
     * Explode String to get both arrays;
     * separate main and sign, segun characters '--' into string
     * */
    private static function strToArrays() {
 
        $array = explode("\n", self::$txt);
 
        if(in_array('--', $array)) {
            $c = count($array);
            $k = array_search('--', $array);
            self::$main = array_slice($array, 0, $k);
            self::$sign = array_slice($array, $k+1, $c-1);
            unset($c, $k);
        }
        else self::$main = $array;
 
        unset($array);
 
    }

- la méthode 'mngMain()' - sur laquelle je "travaille" - qui permet donc de traiter le corps de texte du fichier ASCII - et sur laquelle je n'arrive à rien de probant - les différents code en commentaires sont différents essais :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
 
    /*
     * Manage object main to rectify segun Markdown's definition
     * */
    private static function mngMain() {
 
        $index = null;
        $main = self::$main;    //var_dump($main);
        $sign = false;
 
        $b = $b1 = $b2 = $b3 = array();
 
        $b1 = preg_grep('/^>{1,}/', $main); //var_dump($b1);
 
        $k = array_key_last($b1);
        $k2 = array_keys($b1, '> --'); var_dump($k2);
 
        $b1[$k2] = '> -- ```';
        $b1[$k+1] = "```";  //var_dump($b1);
 
 
 
        //if(!empty($b1)) {
            //$b2 = preg_grep('/^>{2}/', $b1);
 
            //if(!empty($b2)) {
                //$k = array_key_last($b2);
 
                //$b2[$k+1] = ">";
                //var_dump($b2);
 
                ////$b3 = preg_grep('/^>{3}/', $b2);
 
                ////if(!empty($b3)) {
                    ////$k = array_key_last($b3);
                    //////array_unshift($b3, ">>");
 
                    ////$b2 = array_replace_recursive($b2, $b3);
                ////}
 
 
 
                //$b1 = array_replace_recursive($b1, $b2);
 
            //}
 
            //$b3 = preg_grep('/^>{3}/', $b1);
 
            //if(!empty($b3)) {
                //$k = array_key_last($b3);
                //$b3[$k+1] = ">>";
 
                ////$b1 = array_replace_recursive($b1, $b3);
            //}
 
        //}
 
 
        $main = array_replace_recursive($main, $b1);
        var_dump($main);
 
 
        //foreach($main as $key => $line) {
 
            //// if line start with '*' and end with ':'...
            //$main[$key] = preg_replace('/^\* (.*?):$/',"\n".'${1}:', $line);
 
            ///*
             //* Treatment for blockquote: search all lines started with '>'.
             //*
             //* */
            //if(strpos($line, '>', 0) !== FALSE) {                
 
                //// if line is only '> --', rewrite with start code block MD
                //if(strcmp($line, '> --') == 0) {
                    //$sign = true;
                    //$main[$key] = ">\n \n> ```";
                //}
                //// if line start with '> *'
                ////elseif(strpos($line, '> *', 0) !== FALSE) {
                    ////$main[$key] = preg_replace('/^\> \* (.*?):$/',"\n".'> ${1}:', $line);
                ////}
                ////elseif(strpos($line, '>>', 0) !== FALSE) {
                    //////$main[$key] = "\n".$line;
                    ////preg_match('/^>>/', $line, $m); var_dump($m);
                ////}
                //else $main[$key] = $line;
 
                //$index = $key;
 
            //}
 
        //}
        ////unset($key, $line);
 
        //// if exist line with '> --', then add end code block MD
        //if($sign) $main[$index] = $main[$index]."```\n";
 
        unset($sign, $index);
 
        self::$main = implode("\n",$main);  //var_dump(self::$main);
 
        return self::$main;
 
        unset($main);
 
    }

Bref, vous savez tout...

C'est un projet perso - sur lequel je "suis" - sur une liste de diffusion, en phase de test, dont les messages - des essais qui seront supprimés - sont traité avec un certain langage autre, et restitués sous forme ASCII.
Voici un exemple de fichier restitué - qui devient l'objet 'txt' dans le Parser que j'ai créé pour l'occasion :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
#Re: test sans sign GPG
**Stephane HUC ""**
*2019-05-18T07:29:10+02:00*
 
Tiens en passant, on peut remarquer qu'il y a un problème d'encodage -
miniml ne gère pas correctement ?!
 
 
On 5/18/19 7:27 AM, Stephane HUC  wrote:
> Par contre, le message avec ma signature GPG (ED25519), il l'a bloqué !!!
>
>
> On 5/18/19 7:25 AM, prx wrote:
>> * Stephane HUC <mail-AT-obsd4a.net> le [18-05-2019 07:22:51 +0200]:
>>> Ceci est un test d'envoi, sans sign, ni chiffrement GPG !
>>> Reçu ?
>> Reçu !
> --
> ~ " Fully Basic System Distinguish Life! " ~ " Libre as a BSD "	+=<<<
> ----
> <me>Stephane HUC </me>
> <mail>mail-AT-mondomaine.net</mail>
>
--
~ " Fully Basic System Distinguish Life! " ~ " Libre as a BSD "	+=<<<
----
<me>Stephane HUC</me>
<mail>mail-AT-mondomaine.net</mail>

Bien-sûr dans la forme le contenu du fichier ASCII peut changer et de toute façon de l'un à l'autre leur nom change.

Bref, comme je l'ai dit plus haut, cela peut ressembler à du Markdown, mais cela n'en est pas !
Et nécessite quelques petites corrections pour que ce soit bien traité par un parser MD ou l'autre... (dans l'immédiat, de l'analyseur en question, on s'en fiche un peu... )

On ne s'occupe pas du problème d'encodage apparent - c'est un faux problème !

Bien pour en faire un vrai fichier MD, il faut :

- que les caractères '--' sans rien d'autres, qui caractérisent dans un mail une signature, soient suivi d'un nouvelle ligne afin que le texte suivant - s'il y en a ne soit pas décodé par le Parser MD comme étant du texte de niveau 2 - sachant qu'ensuite il est traité à part puisque devient l'objet 'sign' dans la méthode 'strToArrays()' de mon Parser. Bon, je traite sans soucis, le cas où la change en question est suivi d'un ou plusieurs espaces... pour les réduire à rien

- que tout texte commençant par '*' et finissant par ':' soit traité pour supprimer le '*' afin qu'il ne soit pas confondu avec un début de liste par le Parser MD.
- traiter toute ligne commençant par '>' afin de créer une imbriquation correcte de blockquote pour le Parser MD.
- repérer toute présence de plusieurs '>' - sachant qu'il peut y en avoir autant que possible dans une citation de mail - et les traiter ainsi :
- '(>{2,})\s--' doit être suivi d'autant de '>' sur une nouvelle ligne.
- que la dernière ligne de chacun des multiples '>' soit suivie d'une nouvelle avec autant de '>' moins un.
- et le must dans ce contexte, de supprimer toute présence de signature - présence des '--' commençant par un ou plusieurs '>' et des lignes suivantes, ayant le même nombre de '>'.

Bon, j'espère n'avoir rien oublié !
(ce fut long à expliquer ; en espérant que c'est simple à comprendre)

[hucste]

Bon j'arrive à un résultat certain - peut-être pas le plus élégant mais fonctionnel :

- je vire la méthode 'strToArrays()'
- je fais tout dans 'mngMain()' :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
 
    private static function mngMain() {
 
        $b = array();               
        $array = explode("\n", self::$txt);  
 
        foreach($array as $key => $val) {    
 
            // search line starting with '--', follow with spaces to delete them
            if(preg_match('#\A--(\s*)#', $array[$key], $m))    $array[$key] = trim($array[$key]);
 
            // delete '*' if line start with...
            if(preg_match('#\A(.*)(\*)(.+)\Z#', $array[$key], $m))  $array[$key] = $m[1].$m[3];
 
            // search line start with '>'
            if(preg_match('/\A(>+)(.*)/', $array[$key], $m)) {
                $b[$key] = $m;
 
                unset($array[$key]);
            }
 
        }
 
        if(!empty($b)) {
            foreach($b as $key => $val) {
                if(strcmp("> --", $b[$key][0]) == 0) $k = $key;
                if(array_search(">", $b[$key])) $k1 = $key;
                if(array_search(">>", $b[$key])) $k2 = $key;
                //if(array_search(">>>", $b[$key])) $k3 = $key;
            }
 
            // delete sign into blockquote
            if(!empty($k)) {
                while($k <= $k1) { unset($b[$k]); $k++; }
            }
            unset($k, $k1);
 
            // add new line after '>>'
            if(!empty($k2)) {
                $b[$k2][0] = ">>\n".$b[$k2][0]."\n>";
            }
            unset($k2);
 
            // rebuild monodimensional array
            foreach($b as $key => $val) {
                $b1[$key] = $b[$key][0];
            }
 
            if(!empty($b1)) {
                $array = array_replace($array, $b1); 
            }
            // sort keys because are not in good place.
            ksort($array); 
 
            $array = array_values($array);
        }
 
        if(in_array('--', $array)) { 
            $c = count($array);
            $k = array_search('--', $array); 
            $main = array_slice($array, 0, $k);  
            self::$sign = array_slice($array, $k+1, $c-1);   
            unset($c, $k);
        }
        else $main = $array;
 
        self::$main = implode("\n",$main);  
 
        unset($main);
 
    }

Voilà, c'est déjà un début qui me semble intéressant !

[CosmoKnacki]

Merci pour ces précisions. Mais un exemple valant mieux qu'un long discours: peux-tu poster ton fichier d'exemple une fois transformé selon ton souhait pour illustrer ton propos?