source: spip-zone/_core_/plugins/svp/inc/svp_outiller.php

Last change on this file was 112275, checked in by marcimat@…, 5 months ago

Ticket #4205 : Compatibilité PHP 7.3. La librairie PCRE passe en v2, et est moins tolérante.
Le caractère -, indiqué dans un bloc de caractères [ - ], pour ne pas être pris pour une déclaration d’intervalle (comme [a-z]), doit être soit échappé avec \ soit être en tête ou en fin de la structure.
(Francky)

  • Property svn:eol-style set to native
File size: 16.1 KB
Line 
1<?php
2
3/**
4 * Fichier de fonctions
5 *
6 * @plugin SVP pour SPIP
7 * @license GPL
8 * @package SPIP\SVP\Fonctions
9 **/
10
11if (!defined('_ECRIRE_INC_VERSION')) {
12        return;
13}
14
15
16if (!defined('_SVP_VERSION_SPIP_MIN')) {
17        /**
18         * Version SPIP minimale quand un plugin ne le precise pas
19         *
20         * Version SPIP correspondant à l'apparition des plugins */
21        define('_SVP_VERSION_SPIP_MIN', '1.9.0');
22}
23
24if (!defined('_SVP_VERSION_SPIP_MAX')) {
25        /**
26         * Version SPIP maximale
27         *
28         * Pour l'instant on ne connait pas la borne sup exacte */
29        define('_SVP_VERSION_SPIP_MAX', '3.3.99');
30}
31
32/**
33 * Liste des branches significatives de SPIP et de leurs bornes (versions min et max)
34 *
35 * À mettre a jour en fonction des sorties
36 *
37 * @global array $GLOBALS ['infos_branches_spip']
38 */
39$GLOBALS['infos_branches_spip'] = array(
40        '1.9' => array(_SVP_VERSION_SPIP_MIN, '1.9.2'),
41        '2.0' => array('2.0.0', '2.0.99'),
42        '2.1' => array('2.1.0', '2.1.99'),
43        '3.0' => array('3.0.0', '3.0.99'),
44        '3.1' => array('3.1.0', '3.1.99'),
45        '3.2' => array('3.2.0', '3.2.99'),
46        '3.3' => array('3.3.0', _SVP_VERSION_SPIP_MAX),
47);
48# define('_INFOS_BRANCHES_SPIP', serialize($infos_branches_spip));
49
50/**
51 * Liste des licences de plugin
52 *
53 * @global array $GLOBALS ['licences_plugin']
54 */
55$GLOBALS['licences_plugin'] = array(
56        'apache' => array(
57                'versions' => array('2.0', '1.1', '1.0'),
58                'nom' => 'Apache licence, version @version@',
59                'url' => 'http://www.apache.org/licenses/LICENSE-@version@'
60        ),
61        'art' => array(
62                'versions' => array('1.3'),
63                'nom' => 'Art libre @version@',
64                'url' => 'http://artlibre.org/licence/lal'
65        ),
66        'mit' => array(
67                'versions' => array(),
68                'nom' => 'MIT',
69                'url' => 'http://opensource.org/licenses/mit-license.php'
70        ),
71        'bsd' => array(
72                'versions' => array(),
73                'nom' => 'BSD',
74                'url' => 'http://www.freebsd.org/copyright/license.html'
75        ),
76        'agpl' => array(
77                'versions' => array('3'),
78                'nom' => 'AGPL @version@',
79                'url' => 'http://www.gnu.org/licenses/agpl.html'
80        ),
81        'fdl' => array(
82                'versions' => array('1.3', '1.2', '1.1'),
83                'nom' => 'FDL @version@',
84                'url' => 'http://www.gnu.org/licenses/fdl-@version@.html'
85        ),
86        'lgpl' => array(
87                'versions' => array('3.0', '2.1'),
88                'nom' => array('3.0' => 'LGPL 3', '2.1' => 'LGPL 2.1'),
89                'url' => 'http://www.gnu.org/licenses/lgpl-@version@.html'
90        ),
91        'gpl' => array(
92                'versions' => array('3', '2', '1'),
93                'nom' => 'GPL @version@',
94                'url' => 'http://www.gnu.org/licenses/gpl-@version@.0.html'
95        ),
96        'ccby' => array(
97                'versions' => array('2.0', '2.5', '3.0'),
98                'suffixes' => array('-sa', '-nc', '-nd', '-nc-nd', '-nc-sa'),
99                'nom' => 'CC BY@suffixe@ @version@',
100                'url' => 'http://creativecommons.org/licenses/by@suffixe@/@version@/'
101        )
102);
103# define('_LICENCES_PLUGIN', serialize($licences_plugin));
104
105/**
106 * Fusionne 2 intervalles de compatibilité
107 *
108 * Soit '[1.9;2.1]' et '[2.1;3.0.*]', la fonction retourne '[1.9;3.0.*]'
109 *
110 * En gros la fonction est utilisé pour calculer l'intervalle de validité
111 * d'un plugin ayant plusieurs paquets avec des compatibilités différentes.
112 * La compatibilité du plugin est le total de toutes les compatibilités.
113 *
114 * @uses  extraire_bornes()
115 * @uses  construire_intervalle()
116 * @param string $intervalle_a
117 *     Intervalle de compatibilité
118 * @param string $intervalle_b
119 *     Intervalle de compatibilité
120 * @return string
121 *     Intervalle de compatibilité
122 **/
123function fusionner_intervalles($intervalle_a, $intervalle_b) {
124
125        // On recupere les bornes de chaque intervalle
126        $borne_a = extraire_bornes($intervalle_a);
127        $borne_b = extraire_bornes($intervalle_b);
128
129        // On initialise la borne min de chaque intervalle a 1.9.0 inclus si vide
130        if (!$borne_a['min']['valeur']) {
131                $borne_a['min']['valeur'] = _SVP_VERSION_SPIP_MIN;
132                $borne_a['min']['incluse'] = true;
133        }
134        if (!$borne_b['min']['valeur']) {
135                $borne_b['min']['valeur'] = _SVP_VERSION_SPIP_MIN;
136                $borne_b['min']['incluse'] = true;
137        }
138
139        // On initialise la borne max de chaque intervalle a la version SPIP max incluse si vide
140        if (!$borne_a['max']['valeur']) {
141                $borne_a['max']['valeur'] = _SVP_VERSION_SPIP_MAX;
142                $borne_a['max']['incluse'] = true;
143        }
144        if (!$borne_b['max']['valeur']) {
145                $borne_b['max']['valeur'] = _SVP_VERSION_SPIP_MAX;
146                $borne_b['max']['incluse'] = true;
147        }
148
149        // On calcul maintenant :
150        // -- la borne min de l'intervalle fusionne = min(min_a, min_b)
151        if (spip_version_compare($borne_a['min']['valeur'], $borne_b['min']['valeur'], '<=')) {
152                $bornes_fusionnees['min'] = $borne_a['min'];
153        } else {
154                $bornes_fusionnees['min'] = $borne_b['min'];
155        }
156        // -- la borne max de l'intervalle fusionne = max(max_a, max_b)
157        if (spip_version_compare($borne_a['max']['valeur'], $borne_b['max']['valeur'], '<=')) {
158                $bornes_fusionnees['max'] = $borne_b['max'];
159        } else {
160                $bornes_fusionnees['max'] = $borne_a['max'];
161        }
162
163        return construire_intervalle($bornes_fusionnees);
164}
165
166/**
167 * Extrait les valeurs d'un intervalle de compatibilité.
168 *
169 * Calcule les valeurs min, max et si ces valeurs sont intégrées ou non
170 * à l'intervalle.
171 *
172 * @param string $intervalle
173 *     Intervalle de compatibilité, tel que '[2.1;3.0]'
174 * @param bool $initialiser
175 *     - True pour mettre les valeurs connues mini et maxi de SPIP lorsque
176 *     les bornes ne sont pas renseignées dans l'intervalle.
177 *     - False pour ne rien mettre sinon.
178 * @return array
179 *     Tableau avec les index :
180 *     - min : la borne inférieure, qui contient les index 'valeur' et 'incluse'
181 *     - max : la borne  supérieure, qui contient les index 'valeur' et 'incluse'
182 *     Le sous index 'incluse' vaut true si cette borne est incluse dans l'intervalle.
183 **/
184function extraire_bornes($intervalle, $initialiser = false) {
185        static $borne_vide = array('valeur' => '', 'incluse' => false);
186        static $borne_inf_init = array('valeur' => _SVP_VERSION_SPIP_MIN, 'incluse' => true);
187        static $borne_sup_init = array('valeur' => _SVP_VERSION_SPIP_MAX, 'incluse' => true);
188
189        if ($initialiser) {
190                $bornes = array('min' => $borne_inf_init, 'max' => $borne_sup_init);
191        } else {
192                $bornes = array('min' => $borne_vide, 'max' => $borne_vide);
193        }
194
195        if ($intervalle
196                and preg_match(',^[\[\(\]]([0-9.a-zRC\s\-]*)[;]([0-9.a-zRC\s\-\*]*)[\]\)\[]$,Uis', $intervalle, $matches)
197        ) {
198                if ($matches[1]) {
199                        $bornes['min']['valeur'] = trim($matches[1]);
200                        $bornes['min']['incluse'] = ($intervalle{0} == "[");
201                }
202                if ($matches[2]) {
203                        $bornes['max']['valeur'] = trim($matches[2]);
204                        $bornes['max']['incluse'] = (substr($intervalle, -1) == "]");
205                }
206        }
207
208        return $bornes;
209}
210
211/**
212 * Contruit un intervalle de compatibilité
213 *
214 * @param array $bornes
215 *     L'intervalle décrit sous forme de tableau avec pour index :
216 *     - min : la borne inférieure, qui contient les index 'valeur' et 'incluse'
217 *     - max : la borne  supérieure, qui contient les index 'valeur' et 'incluse'
218 *     Le sous index 'incluse' vaut true si cette borne est incluse dans l'intervalle.
219 * @param string $dtd
220 *     DTD de destination (paquet ou plugin) qui influera sur l'écriture à faire
221 *     en utilisant des parenthèses ou des crochets pour définir l'exclusion d'une intervalle
222 *     tel que ']2.1.2,3.0.1[' (paquet) ou '(2.1.2,3.0.1)' (plugin)
223 * @return string
224 *     Intervalle de compatibilité tel que '[2.1;3.0]'
225 **/
226function construire_intervalle($bornes, $dtd = 'paquet') {
227        return ($bornes['min']['incluse'] ? '[' : ($dtd == 'paquet' ? ']' : '('))
228        . $bornes['min']['valeur'] . ';' . $bornes['max']['valeur']
229        . ($bornes['max']['incluse'] ? ']' : ($dtd == 'paquet' ? '[' : ')'));
230}
231
232
233/**
234 * Retourne la liste des branches de SPIP comprises dans un intervalle
235 * de compatibilité donné.
236 *
237 * @uses  extraire_bornes()
238 * @param string $intervalle
239 *     Intervalle de compatibilité, tel que [2.0.0;3.0.0]
240 * @return string
241 *     Branches de SPIP séparées par des virgules, tel que 2.0,2.1,3.0
242 **/
243function compiler_branches_spip($intervalle) {
244        include_spip('plugins/installer');
245
246        global $infos_branches_spip;
247        $liste_branches_spip = array_keys($GLOBALS['infos_branches_spip']);
248
249        $bornes = extraire_bornes($intervalle, false);
250        // On traite d'abord les cas ou l'intervalle est :
251        // - vide
252        // - non vide mais avec les deux bornes vides
253        // Dans ces cas la compatibilite est totale, on renvoie toutes les branches
254        if (!$intervalle or (!$bornes['min']['valeur'] and !$bornes['max']['valeur'])) {
255                return implode(',', $liste_branches_spip);
256        }
257
258        // On force l'initialisation des bornes et on les nettoie des suffixes d'etat
259        $bornes = extraire_bornes($intervalle, true);
260        // Si les bornes sont en dehors de l'intervalle [_SVP_VERSION_SPIP_MIN;_SVP_VERSION_SPIP_MAX] on le reduit
261        if (spip_version_compare($bornes['min']['valeur'], _SVP_VERSION_SPIP_MIN, '<')) {
262                $bornes['min']['valeur'] = _SVP_VERSION_SPIP_MIN;
263                $bornes['min']['incluse'] = true;
264        }
265        if (spip_version_compare(_SVP_VERSION_SPIP_MAX, $bornes['max']['valeur'], '<=')) {
266                $bornes['max']['valeur'] = _SVP_VERSION_SPIP_MAX;
267                $bornes['max']['incluse'] = true;
268        }
269        // On les nettoie des suffixes d'etat
270        $borne_inf = strtolower(preg_replace(',([0-9])[\s.-]?(dev|alpha|a|beta|b|rc|pl|p),i', '\\1',
271                $bornes['min']['valeur']));
272        $borne_sup = strtolower(preg_replace(',([0-9])[\s.-]?(dev|alpha|a|beta|b|rc|pl|p),i', '\\1',
273                $bornes['max']['valeur']));
274
275        // On determine les branches inf et sup issues du phrasage de l'intervalle
276        // -- on initialise la branche inf de l'intervalle que l'on va preciser ensuite
277        $t = explode('.', $borne_inf);
278        $branche_inf = $t[0] . '.' . $t[1];
279        // -- pour eviter toutes erreur fatale on verifie que la branche est bien dans la liste des possibles
280        // -- -> si non, on renvoie vide
281        if (!in_array($branche_inf, $liste_branches_spip)) {
282                return '';
283        }
284        // -- on complete la borne inf de l'intervalle de x.y en x.y.z et on determine la vraie branche
285        if (!isset($t[2]) or !$t[2]) {
286                if ($bornes['min']['incluse']) {
287                        $borne_inf = $infos_branches_spip[$branche_inf][0];
288                } else {
289                        $branche_inf = $liste_branches_spip[array_search($branche_inf, $liste_branches_spip) + 1];
290                        $borne_inf = $infos_branches_spip[$branche_inf][0];
291                }
292        }
293
294        // -- on initialise la branche sup de l'intervalle que l'on va preciser ensuite
295        $t = explode('.', $borne_sup);
296        // des gens mettent juste * (pas glop)
297        $branche_sup = $t[0] . (isset($t[1]) ? '.' . $t[1] : '');
298
299        // -- pour eviter toutes erreur fatale on verifie que la branche est bien dans la liste des possibles
300        // -- -> si non, on renvoie vide
301        if (!in_array($branche_sup, $liste_branches_spip)) {
302                return '';
303        }
304        // -- on complete la borne sup de l'intervalle de x.y en x.y.z et on determine la vraie branche
305        if (!isset($t[2]) or !$t[2]) {
306                if ($bornes['max']['incluse']) {
307                        $borne_sup = $infos_branches_spip[$branche_sup][1];
308                } else {
309                        $branche_sup = $liste_branches_spip[array_search($branche_sup, $liste_branches_spip) - 1];
310                        $borne_sup = $infos_branches_spip[$branche_sup][1];
311                }
312        }
313
314        // -- on verifie que les bornes sont bien dans l'ordre :
315        //    -> sinon on retourne la branche sup uniquement
316        if (spip_version_compare($borne_inf, $borne_sup, '>=')) {
317                return $branche_sup;
318        }
319
320        // A ce stade, on a un intervalle ferme en bornes ou en branches
321        // Il suffit de trouver les branches qui y sont incluses, sachant que les branches inf et sup
322        // le sont a coup sur maintenant
323        $index_inf = array_search($branche_inf, $liste_branches_spip);
324        $index_sup = array_search($branche_sup, $liste_branches_spip);
325        $liste = array();
326        for ($i = $index_inf; $i <= $index_sup; $i++) {
327                $liste[] = $liste_branches_spip[$i];
328        }
329
330        return implode(',', $liste);
331}
332
333
334/**
335 * Transforme un texte écrit en entités HTML, dans le charset du site
336 *
337 * @param string $texte
338 *     Texte avec des entités HTML
339 * @param string $charset
340 * @return string $texte
341 *     Texte dans le charset du site
342 **/
343function entite2charset($texte, $charset = null) {
344        if (!strlen($texte)) {
345                return '';
346        }
347        if (!$charset) {
348                $charset = $GLOBALS['meta']['charset'];
349        }
350        include_spip('inc/charsets');
351
352        return unicode2charset(html_entity_decode(preg_replace('/&([lg]t;)/S', '&amp;\1', $texte), ENT_NOQUOTES, $charset));
353}
354
355/**
356 * Teste si 2 balises XML sont identiques
357 *
358 * @param array|string $balise1
359 *     Balise à comparer
360 * @param array|string $balise2
361 *     Balise à comparer
362 * @return bool
363 *     True si elles sont identiques, false sinon.
364 **/
365function balise_identique($balise1, $balise2) {
366        if (is_array($balise1)) {
367                foreach ($balise1 as $_attribut1 => $_valeur1) {
368                        if (!array_key_exists($_attribut1, $balise2)) {
369                                return false;
370                        } else {
371                                if ($_valeur1 != $balise2[$_attribut1]) {
372                                        return false;
373                                }
374                        }
375                }
376
377                return true;
378        } else {
379                return ($balise1 == $balise2);
380        }
381}
382
383
384/**
385 * Déterminer la licence exacte avec un nom et un lien de doc standardisé
386 *
387 * @param string $prefixe
388 *     Préfixe de la licence tel que gnu, free, cc, creative common
389 * @param string $nom
390 *     Nom de la licence tel que gpl, lgpl, agpl, fdl, mit, bsd...
391 * @param string $suffixe
392 *     Suffixe de la licence tel que licence, -sharealike, -nc-nd ...
393 * @param string $version
394 *     Version de la licence tel que 3.0
395 * @return array
396 *     Si la licence est connu, retourne 2 index :
397 *     - nom : le nom le la licence
398 *     - url : lien vers la licence
399 */
400function definir_licence($prefixe, $nom, $suffixe, $version) {
401        global $licences_plugin;
402        $licence = array();
403
404        $prefixe = strtolower($prefixe);
405        $nom = strtolower($nom);
406        $suffixe = strtolower($suffixe);
407
408        if (((trim($prefixe) == 'creative common') and ($nom == 'attribution'))
409                or (($prefixe == 'cc') and ($nom == 'by'))
410        ) {
411                $nom = 'ccby';
412        }
413
414        if (array_key_exists($nom, $licences_plugin)) {
415                if (!$licences_plugin[$nom]['versions']) {
416                        // La licence n'est pas versionnee : on affecte donc directement le nom et l'url
417                        $licence['nom'] = $licences_plugin[$nom]['nom'];
418                        $licence['url'] = $licences_plugin[$nom]['url'];
419                } else {
420                        // Si la version est pas bonne on prend la plus recente
421                        if (!$version or !in_array($version, $licences_plugin[$nom]['versions'], true)) {
422                                $version = $licences_plugin[$nom]['versions'][0];
423                        }
424                        if (is_array($licences_plugin[$nom]['nom'])) {
425                                $licence['nom'] = $licences_plugin[$nom]['nom'][$version];
426                        } else {
427                                $licence['nom'] = str_replace('@version@', $version, $licences_plugin[$nom]['nom']);
428                        }
429                        $licence['url'] = str_replace('@version@', $version, $licences_plugin[$nom]['url']);
430
431                        if ($nom == 'ccby') {
432                                if ($suffixe == '-sharealike') {
433                                        $suffixe = '-sa';
434                                }
435                                if (!$suffixe or !in_array($suffixe, $licences_plugin[$nom]['suffixes'], true)) {
436                                        $suffixe = '';
437                                }
438                                $licence['nom'] = str_replace('@suffixe@', strtoupper($suffixe), $licence['nom']);
439                                $licence['url'] = str_replace('@suffixe@', $suffixe, $licence['url']);
440                        }
441                }
442        }
443
444        return $licence;
445}
446
447/**
448 * Liste les librairies présentes
449 *
450 * Cherche des librairie dans tous les dossiers 'lib' présents dans chaque
451 * chemin déclaré (plugins, squelettes, SPIP). Un répertoire dans un dossier
452 * 'lib' est considéré comme une librairie, et le nom de ce répertoire est
453 * utilisé comme nom de la librairie.
454 *
455 * @return array
456 *     Tableau de couples (nom de la librairie => répertoire de la librairie)
457 **/
458function svp_lister_librairies() {
459        $libs = array();
460        foreach (array_reverse(creer_chemin()) as $d) {
461                if (is_dir($dir = $d . 'lib/') and $t = opendir($dir)) {
462                        while (($f = readdir($t)) !== false) {
463                                if ($f[0] != '.' and is_dir("$dir/$f")) {
464                                        $libs[$f] = $dir;
465                                }
466                        }
467                }
468        }
469
470        return $libs;
471}
472
473
474/**
475 * Retourne '00x.00y.00z' à partir de 'x.y.z'
476 *
477 * Retourne la chaine de la version x.y.z sous une forme normalisée
478 * permettant le tri naturel. On complète à gauche d'un nombre de zéro
479 * manquant pour aller à 3 caractères entre chaque point.
480 *
481 * @see denormaliser_version()
482 * @param string $version
483 *     Numéro de version dénormalisée
484 * @return string
485 *     Numéro de version normalisée
486 **/
487function normaliser_version($version = '') {
488
489        $version_normalisee = '';
490
491        if (preg_match(',([0-9.]+)[\s.-]?(dev|alpha|a|beta|b|rc|pl|p)?,i', $version, $matches)) {
492                if (isset($matches[1]) and $matches[1]) {
493                        $v = explode('.', $matches[1]);
494                        $vn = array();
495                        foreach ($v as $_nombre) {
496                                $vn[] = str_pad($_nombre, 3, '0', STR_PAD_LEFT);
497                        }
498                        $version_normalisee = implode('.', $vn);
499                        if (isset($matches[2]) and $matches[2]) {
500                                $version_normalisee = $version_normalisee . '-' . $matches[2];
501                        }
502                }
503        }
504
505        return $version_normalisee;
506}
Note: See TracBrowser for help on using the repository browser.