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

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

Éviter une notice lors de l'affichage d'une description complète de plugin, lorsqu'une dépendance ne précise pas sa compatibilité.

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