source: spip-zone/_plugins_/langonet/inc/langonet_verifier_items.php @ 53957

Last change on this file since 53957 was 53957, checked in by esj@…, 9 years ago

langonet Attention aux libellés de 32 caractères sans espaces. Et évacuer qq indéfinis, ils n'aident pas à la mise au point.

File size: 8.8 KB
Line 
1<?php
2
3if (!defined('_ECRIRE_INC_VERSION')) return;
4
5// Les REGEXP de recherche de l'item de langue
6// (voir le fichier regexp.txt pour des exemples)
7
8// -- pour les fichiers .html et .php
9// sans detection de _L mais avec variables PHP eventuelles dans l'argument de _T
10define("_LANGONET_TROUVER_ITEM_HP", 
11        "#" .
12        "(?:<:|_[TU]\(['\"])" . // designation (<: pour squelette, T|U pour PHP)
13        "(?:([a-z0-9_]+):)?" .  // nom du module eventuel
14       "(" . "(?:\\$|[\"\']\s*\.\s*\\$*)?" . // delimiteur ' ou " pour T|U
15                "[A-Za-z0-9@_&;,.?!\s()-]+" . // item nu, pas forcement normalise
16               ")" .
17        "(" . "(?:{(?:[^\|=>]*=[^\|>]*)})?" . // argument entre accolades
18                "(?:(?:\|[^>]*)?)" . // filtre
19                "(?:['\"]\s*\.\s*[^\s]+)?" . // delimiteur ' ou " pour T|U
20        ")" .
21        "#iS"
22       );
23
24// -- pour les fichiers .xml
25define("_LANGONET_TROUVER_ITEM_X", ",<[a-z0-9_]+>[\n|\t|\s]*([a-z0-9_]+):([a-z0-9_]+)[\n|\t|\s]*</[a-z0-9_]+()>,iS");
26
27/**
28 * Verification de l'utilisation des items de langue
29 *
30 * @param string $rep
31 * @param string $module
32 * @param string $langue
33 * @param string $ou_langue
34 * @param string $ou_fichier
35 * @param string $verification
36 * @return array
37 */
38
39// $rep          => nom du repertoire parent de lang/
40// $module       => prefixe du fichier de langue
41// $langue       => index du nom de langue
42// $ou_lang      => chemin vers le fichier de langue a verifier
43// $ou_fichier   => racine de l'arborescence a verifier
44// $verification => type de verification a effectuer
45function inc_langonet_verifier_items($rep, $module, $langue, $ou_langue, $ou_fichier, $verification) {
46
47        // Initialisation du tableau des resultats
48        // Si une erreur se produit lors du deroulement de la fonction, le tableau contient le libelle
49        // de l'erreur dans $resultats['erreur'].
50        // Sinon, cet index n'existe pas
51        $item_non = $definition_non_mais_nok = $item_md5 = $fichier_non = $resultats = array();
52
53        // On charge le fichier de langue a verifier
54        // si il existe dans l'arborescence $ou_langue
55        // (evite le mecanisme standard de surcharge SPIP)
56        include_spip('inc/traduire');
57        include_spip('inc/langonet_verifier_l');
58        $var_source = "i18n_".$module."_".$langue;
59        if (empty($GLOBALS[$var_source])) {
60                $GLOBALS['idx_lang'] = $var_source;
61                include(_DIR_RACINE.$ou_langue.$module.'_'.$langue.'.php');
62        }
63
64        // On cherche l'ensemble des items utilises dans l'arborescence $ou_fichier
65        $utilises = array('items' => array(), 'suffixes' => array(), 'modules' => array());
66        // On ignore les ultimes sous-repertoires charsets/ ,
67        // lang/ , req/ . On ne scanne que les fichiers php, html ou xml
68        // (voir le fichier regexp.txt).
69        $files = preg_files(_DIR_RACINE.$ou_fichier, '(?<!/charsets|/lang|/req)(/[^/]*\.(html|php|xml|yaml))$');
70        foreach ($files as $_fichier) {
71                $re = strpos($_fichier, '.xml') ? _LANGONET_TROUVER_ITEM_X : _LANGONET_TROUVER_ITEM_HP;
72                foreach ($contenu = file($_fichier) as $ligne => $texte) {
73                        if (preg_match_all($re, $texte,  $m, PREG_SET_ORDER)) {
74                                foreach ($m as $occ) {
75                                        $suffixe = preg_replace(',\s*,', '', $occ[2]);
76                                // On traite les cas particuliers ou l'item est entierement une expression ou une variable:
77                                        if ((substr($suffixe, 0, 1) == "$") OR (substr($suffixe, 0, 2) == "'.") OR (substr($suffixe, 0, 2) == '".')) {
78                                                $suffixe = str_replace('$', '\$', $suffixe);
79                                        } else $suffixe = $occ[3];
80                                        $index = langonet_index_l($occ[2], $utilises['items']);
81                                        $utilises['items'][$index] = $occ[2];
82                                        $utilises['modules'][$index] = $occ[1];
83                                        $item_tous[$index][$_fichier][$ligne][] = trim($occ[0]);
84                                        // l'item est-il dynamique, hormis tableau d'arguments ou filtre ?
85                                        // (si oui c'est sale et on pourra pas faire grand chose)
86                                        $utilises['suffixes'][$index] = ($suffixe AND (strpos('|{', $suffixe[0] !== false)));
87                                }
88                        }
89                }
90        }
91
92        if ($verification == 'definition') {
93                // On construit la liste de tous les items definis
94                // dans tous les fichiers de langue presents sur le site.
95                // Par economie, on se limite au scan des '/lang/xxxx_fr.php'
96                foreach (preg_files(_DIR_RACINE, '/lang/[^/]+_fr\.php$') as $_fichier) {
97                        foreach ($contenu = file($_fichier) as $ligne => $texte) {
98                                if (preg_match_all("#^[\s\t]*['\"]([a-z0-9_]+)['\"][\s\t]*=>#i", $texte, $matches)) {
99                                        foreach ($matches[1] as $cet_item) {
100                                                $tous_lang[$cet_item][] = $_fichier;
101                                        }
102                                }
103                        }
104                }
105                // On construit la liste des items utilises mais non definis
106                foreach ($utilises['items'] as $_cle => $_valeur) {
107
108                        if (!isset($GLOBALS[$var_source][$_valeur])) {
109                                if (!$utilises['suffixes'][$_cle]) {
110                                        if ($utilises['modules'][$_cle] == $module) {
111                                                // L'item est vraiment non defini et c'est une erreur
112                                                $item_non[] = $_valeur;
113                                                if (is_array($item_tous[$_cle])) {
114                                                        $fichier_non[$_cle] = $item_tous[$_cle];
115                                                }
116                                        }
117                                        else {
118                                                // L'item est a priori defini dans un autre module. Le fait qu'il ne soit pas
119                                                // defini dans le fichier en cours de verification n'est pas forcement une erreur.
120                                                // On l'identifie donc a part
121                                                $definition_ok = false;
122                                                $definitions = array();
123                                                if (array_key_exists($_valeur, $tous_lang)) {
124                                                        $definitions = $tous_lang[$_valeur];
125                                                        while ((list($_index, $_fichier) = each($definitions)) AND !$definition_ok)  {
126                                                                preg_match(',/lang/([^/]+)_fr\.php$,i', $_fichier, $module_trouve);
127                                                                if ($module_trouve[1]) {
128                                                                        if ($module_trouve[1] == $utilises['modules'][$_cle]) {
129                                                                                $definition_ok = true;
130                                                                        }
131                                                                        else {
132                                                                                $definition_ok = ((($module_trouve[1]=='spip') OR ($module_trouve[1]=='ecrire') OR ($module_trouve[1]=='public')) AND (!$utilises['modules'][$_cle]));
133                                                                        }
134                                                                }
135                                                        }
136                                                }
137                                                if ($definition_ok) {
138                                                        $item_non_mais[] = $_valeur;
139                                                        if (is_array($item_tous[$_cle])) {
140                                                                $fichier_non_mais[$_cle] = $item_tous[$_cle];
141                                                        }
142                                                        if ($definitions)
143                                                                $definition_non_mais[$_valeur] = $definitions;
144                                                }
145                                                else {
146                                                        $item_non_mais_nok[] = $_cle;
147                                                        if (is_array($item_tous[$_cle])) {
148                                                                $fichier_non_mais_nok[$_cle] = $item_tous[$_cle];
149                                                // Si pas normalise, c'est une auto-definition
150                                                                if (!preg_match(',^\w+$,', $_valeur)) {
151                                                                        $item_md5[$_cle] = $_valeur;
152                                                                }
153                                                        }
154                                                        if ($definitions)
155                                                                $definition_non_mais_nok[$_cle] = $definitions;
156                                                }
157                                        }
158                                }
159                                else {
160                                        // L'item est defini dynamiquement (i.e. a l'execution)
161                                        // Il ne peut etre trouve directement dans le fichier de
162                                        // langue, donc on verifie que des items ressemblant
163                                        // existent dans le fichier de langue
164                                        $item_trouve = false;
165                                        foreach($GLOBALS[$var_source] as $_item => $_traduction) {
166                                                if (substr($_item, 0, strlen($_valeur)) == $_valeur) {
167                                                        $item_peut_etre[] = $_valeur;
168                                                        if (is_array($item_tous[$_cle])) {
169                                                                $fichier_peut_etre[$_item] = $item_tous[$_cle];
170                                                        }
171                                                        $item_trouve = true;
172                                                }
173                                        }
174                                        // Si on a pas trouve d'item pouvant correspondre c'est peut-etre que
175                                        // cet item est en fait une variable ou une expression.
176                                        // On ajoute ces cas aussi aux incertains (pas essentiel)
177                                        if (!$item_trouve) {
178                                                $_item = ltrim($_valeur, '\'".\\');
179                                                $item_peut_etre[] = $_item;
180                                                if (is_array($item_tous[$_cle])) {
181                                                        $fichier_peut_etre[$_item] = $item_tous[$_cle];
182                                                }
183                                        }
184                                }
185                        }
186                }
187        }
188        else {
189                // On construit la liste des items definis mais plus utilises
190                if ($GLOBALS[$var_source]) {
191                        foreach ($GLOBALS[$var_source] as $_item => $_traduction) {
192                                if (!in_array ($_item, $utilises['items'])) {
193                                        // L'item est soit non utilise, soit utilise dans un contexte variable
194                                        $contexte_variable = false;
195                                        foreach($utilises['items'] as $_cle => $_valeur) {
196                                                if ($utilises['suffixes'][$_cle]) {
197                                                        if (substr($_item, 0, strlen($_valeur)) == $_valeur) {
198                                                                $contexte_variable = true;
199                                                                break;
200                                                        }
201                                                }
202                                        }
203                                        if (!$contexte_variable) {
204                                                // L'item est vraiment non utilise
205                                                $item_non[] = $_item;
206                                        }
207                                        else {
208                                                // L'item est utilise dans un contexte variable
209                                                $item_peut_etre[] = $_item;
210                                                if (is_array($item_tous[$_valeur])) {
211                                                        $fichier_peut_etre[$_item] = $item_tous[$_valeur];
212                                                }
213                                        }
214                                }
215                        }
216                }
217        }
218
219        // On prepare le tableau des resultats
220        $resultats['module'] = $module;
221        $resultats['ou_fichier'] = $ou_fichier;
222        $resultats['langue'] = $ou_langue.$module.'_'.$langue.'.php';
223        $resultats['item_non'] = $item_non;
224        $resultats['item_non_mais'] = $item_non_mais;
225        $resultats['item_non_mais_nok'] = $item_non_mais_nok;
226        $resultats['fichier_non'] = $fichier_non;
227        $resultats['fichier_non_mais'] = $fichier_non_mais;
228        $resultats['fichier_non_mais_nok'] = $fichier_non_mais_nok;
229        $resultats['definition_non_mais'] = $definition_non_mais;
230        $resultats['definition_non_mais_nok'] = $definition_non_mais_nok;
231        $resultats['item_peut_etre'] = $item_peut_etre;
232        $resultats['fichier_peut_etre'] = $fichier_peut_etre;
233        $resultats['item_md5'] = $item_md5;
234
235        return $resultats;
236}
237
238?>
Note: See TracBrowser for help on using the repository browser.