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

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

Encore des notices PHP

  • Property svn:eol-style set to native
File size: 11.4 KB
Line 
1<?php
2
3if (!defined('_ECRIRE_INC_VERSION')) return;
4
5
6// Version SPIP minimale quand un plugin ne le precise pas
7// -- Version SPIP correspondant a l'apparition des plugins
8if (!defined('_SVP_VERSION_SPIP_MIN')) {
9        define('_SVP_VERSION_SPIP_MIN', '1.9.0');
10}
11
12// -- Pour l'instant on ne connait pas la borne sup exacte
13if (!defined('_SVP_VERSION_SPIP_MAX')) {
14        define('_SVP_VERSION_SPIP_MAX', '3.1.99');
15}
16
17// Liste des branches significatives de SPIP et de leurs bornes (versions min et max)
18// A mettre a jour en fonction des sorties
19# define('_INFOS_BRANCHES_SPIP', serialize($infos_branches_spip));
20$GLOBALS['infos_branches_spip'] = array(
21        '1.9' => array(_SVP_VERSION_SPIP_MIN,'1.9.2'),
22        '2.0' => array('2.0.0','2.0.99'),
23        '2.1' => array('2.1.0','2.1.99'),
24        '3.0' => array('3.0.0','3.0.99'),
25        '3.1' => array('3.1.0',_SVP_VERSION_SPIP_MAX)
26);
27
28// Liste des licences de plugin
29# define('_LICENCES_PLUGIN', serialize($licences_plugin));
30$GLOBALS['licences_plugin'] = array(
31        'apache' => array(
32                'versions' => array('2.0', '1.1', '1.0'),
33                'nom' => 'Apache licence, version @version@',
34                'url' => 'http://www.apache.org/licenses/LICENSE-@version@'),
35        'art' => array(
36                'versions' => array('1.3'),
37                'nom' => 'Art libre @version@',
38                'url' => 'http://artlibre.org/licence/lal'),
39        'mit' => array(
40                'versions' => array(),
41                'nom' => 'MIT',
42                'url' => 'http://opensource.org/licenses/mit-license.php'),
43        'bsd' => array(
44                'versions' => array(),
45                'nom' => 'BSD',
46                'url' => 'http://www.freebsd.org/copyright/license.html'),
47        'agpl' => array(
48                'versions' => array('3'),
49                'nom' => 'AGPL @version@',
50                'url' => 'http://www.gnu.org/licenses/agpl.html'),
51        'fdl' => array(
52                'versions' => array('1.3', '1.2', '1.1'),
53                'nom' => 'FDL @version@',
54                'url' => 'http://www.gnu.org/licenses/fdl-@version@.html'),
55        'lgpl' => array(
56                'versions' => array('3.0', '2.1'),
57                'nom' => array('3.0' => 'LGPL 3', '2.1' => 'LGPL 2.1'),
58                'url' => 'http://www.gnu.org/licenses/lgpl-@version@.html'),
59        'gpl' => array(
60                'versions' => array('3', '2', '1'),
61                'nom' => 'GPL @version@',
62                'url' => 'http://www.gnu.org/licenses/gpl-@version@.0.html'),
63        'ccby' => array(
64                'versions' => array('2.0', '2.5', '3.0'),
65                'suffixes' => array('-sa', '-nc', '-nd', '-nc-nd', '-nc-sa'),
66                'nom' => 'CC BY@suffixe@ @version@',
67                'url' => 'http://creativecommons.org/licenses/by@suffixe@/@version@/')
68);
69
70
71function fusionner_intervalles($intervalle_a, $intervalle_b) {
72
73        // On recupere les bornes de chaque intervalle
74        $borne_a = extraire_bornes($intervalle_a);
75        $borne_b = extraire_bornes($intervalle_b);
76
77        // On initialise la borne min de chaque intervalle a 1.9.0 inclus si vide
78        if (!$borne_a['min']['valeur']) {
79                $borne_a['min']['valeur'] = _SVP_VERSION_SPIP_MIN;
80                $borne_a['min']['incluse'] = true;
81        }
82        if (!$borne_b['min']['valeur']) {
83                $borne_b['min']['valeur'] = _SVP_VERSION_SPIP_MIN;
84                $borne_b['min']['incluse'] = true;
85        }
86
87        // On initialise la borne max de chaque intervalle a la version SPIP max incluse si vide
88        if (!$borne_a['max']['valeur']) {
89                $borne_a['max']['valeur'] = _SVP_VERSION_SPIP_MAX;
90                $borne_a['max']['incluse'] = true;
91        }
92        if (!$borne_b['max']['valeur']) {
93                $borne_b['max']['valeur'] = _SVP_VERSION_SPIP_MAX;
94                $borne_b['max']['incluse'] = true;
95        }
96
97        // On calcul maintenant :
98        // -- la borne min de l'intervalle fusionne = min(min_a, min_b)
99        if (spip_version_compare($borne_a['min']['valeur'], $borne_b['min']['valeur'], '<='))
100                $bornes_fusionnees['min'] = $borne_a['min'];
101        else
102                $bornes_fusionnees['min'] = $borne_b['min'];
103        // -- la borne max de l'intervalle fusionne = max(max_a, max_b)
104        if (spip_version_compare($borne_a['max']['valeur'], $borne_b['max']['valeur'], '<='))
105                $bornes_fusionnees['max'] = $borne_b['max'];
106        else
107                $bornes_fusionnees['max'] = $borne_a['max'];
108
109        return construire_intervalle($bornes_fusionnees);
110}
111
112
113function extraire_bornes($intervalle, $initialiser=false) {
114        static $borne_vide = array('valeur' => '', 'incluse' => false);
115        static $borne_inf_init = array('valeur' => _SVP_VERSION_SPIP_MIN, 'incluse' => true);
116        static $borne_sup_init = array('valeur' => _SVP_VERSION_SPIP_MAX, 'incluse' => true);
117
118        if ($initialiser)
119                $bornes = array('min' => $borne_inf_init, 'max' => $borne_sup_init);
120        else
121                $bornes = array('min' => $borne_vide, 'max' => $borne_vide);
122
123        if ($intervalle
124        AND preg_match(',^[\[\(\]]([0-9.a-zRC\s\-]*)[;]([0-9.a-zRC\s\-\*]*)[\]\)\[]$,Uis', $intervalle, $matches)) {
125                if ($matches[1]) {
126                        $bornes['min']['valeur'] = trim($matches[1]);
127                        $bornes['min']['incluse'] = ($intervalle{0} == "[");
128                }
129                if ($matches[2]) {
130                        $bornes['max']['valeur'] = trim($matches[2]);
131                        $bornes['max']['incluse'] = (substr($intervalle,-1) == "]");
132                }
133        }
134
135       
136        return $bornes;
137}
138
139function construire_intervalle($bornes, $dtd='paquet') {
140        return ($bornes['min']['incluse'] ? '[' : ($dtd=='paquet' ? ']' : '('))
141                        . $bornes['min']['valeur'] . ';' . $bornes['max']['valeur']
142                        . ($bornes['max']['incluse'] ? ']' : ($dtd=='paquet' ? '[' : ')'));
143}
144
145
146function compiler_branches_spip($intervalle) {
147        include_spip('plugins/installer');
148
149        global $infos_branches_spip;
150        $liste_branches_spip = array_keys($GLOBALS['infos_branches_spip']);
151               
152        $bornes = extraire_bornes($intervalle, false);
153        // On traite d'abord les cas ou l'intervalle est :
154        // - vide
155        // - non vide mais avec les deux bornes vides
156        // Dans ces cas la compatibilite est totale, on renvoie toutes les branches
157        if (!$intervalle OR (!$bornes['min']['valeur'] AND !$bornes['max']['valeur']))
158                return implode(',', $liste_branches_spip);
159
160        // On force l'initialisation des bornes et on les nettoie des suffixes d'etat
161        $bornes = extraire_bornes($intervalle, true);
162        // Si les bornes sont en dehors de l'intervalle [_SVP_VERSION_SPIP_MIN;_SVP_VERSION_SPIP_MAX] on le reduit
163        if (spip_version_compare($bornes['min']['valeur'], _SVP_VERSION_SPIP_MIN, '<')) {
164                $bornes['min']['valeur'] = _SVP_VERSION_SPIP_MIN;
165                $bornes['min']['incluse'] = true;
166        }
167        if (spip_version_compare($bornes['max']['valeur'], _SVP_VERSION_SPIP_MAX, '>')) {
168                $bornes['max']['valeur'] = _SVP_VERSION_SPIP_MAX;
169                $bornes['max']['incluse'] = true;
170        }
171        // On les nettoie des suffixes d'etat
172        $borne_inf = strtolower(preg_replace(',([0-9])[\s-.]?(dev|alpha|a|beta|b|rc|pl|p),i','\\1',$bornes['min']['valeur']));
173        $borne_sup = strtolower(preg_replace(',([0-9])[\s-.]?(dev|alpha|a|beta|b|rc|pl|p),i','\\1',$bornes['max']['valeur']));
174
175        // On determine les branches inf et sup issues du phrasage de l'intervalle
176        // -- on initialise la branche inf de l'intervalle que l'on va preciser ensuite
177        $t = explode('.', $borne_inf);
178        $branche_inf = $t[0] . '.' . $t[1];
179        // -- pour eviter toutes erreur fatale on verifie que la branche est bien dans la liste des possibles
180        // -- -> si non, on renvoie vide
181        if (!in_array($branche_inf, $liste_branches_spip))
182                return '';
183        // -- on complete la borne inf de l'intervalle de x.y en x.y.z et on determine la vraie branche
184        if (!$t[2]) {
185                if ($bornes['min']['incluse'])
186                        $borne_inf = $infos_branches_spip[$branche_inf][0];
187                else {
188                        $branche_inf = $liste_branches_spip[array_search($branche_inf, $liste_branches_spip)+1];
189                        $borne_inf = $infos_branches_spip[$branche_inf][0];
190                }
191        }
192       
193        // -- on initialise la branche sup de l'intervalle que l'on va preciser ensuite
194        $t = explode('.', $borne_sup);
195        $branche_sup = $t[0] . '.' . $t[1];
196        // -- pour eviter toutes erreur fatale on verifie que la branche est bien dans la liste des possibles
197        // -- -> si non, on renvoie vide
198        if (!in_array($branche_sup, $liste_branches_spip))
199                return '';
200        // -- on complete la borne sup de l'intervalle de x.y en x.y.z et on determine la vraie branche
201        if (!$t[2]) {
202                if ($bornes['max']['incluse'])
203                        $borne_sup = $infos_branches_spip[$branche_sup][1];
204                else {
205                        $branche_sup = $liste_branches_spip[array_search($branche_sup, $liste_branches_spip)-1];
206                        $borne_sup = $infos_branches_spip[$branche_sup][1];
207                }
208        }
209
210        // -- on verifie que les bornes sont bien dans l'ordre :
211        //    -> sinon on retourne la branche sup uniquement
212        if (spip_version_compare($borne_inf, $borne_sup, '>='))
213                return $branche_sup;
214
215        // A ce stade, on a un intervalle ferme en bornes ou en branches
216        // Il suffit de trouver les branches qui y sont incluses, sachant que les branches inf et sup
217        // le sont a coup sur maintenant
218        $index_inf = array_search($branche_inf, $liste_branches_spip);
219        $index_sup = array_search($branche_sup, $liste_branches_spip);
220        $liste = array();
221        for ($i = $index_inf; $i <= $index_sup; $i++) {
222                $liste[] = $liste_branches_spip[$i];
223        }
224
225        return implode(',', $liste);
226}
227
228
229function entite2charset($texte) {
230        if (!strlen($texte)) return '';
231        include_spip('inc/charsets');
232        return unicode2charset(html_entity_decode(preg_replace('/&([lg]t;)/S', '&amp;\1', $texte), ENT_NOQUOTES, $GLOBALS['meta']['charset']));
233}
234
235
236function balise_identique($balise1, $balise2) {
237        if (is_array($balise1)) {
238                foreach ($balise1 as $_attribut1 => $_valeur1){
239                        if (!array_key_exists($_attribut1, $balise2))
240                                return false;
241                        else
242                                if ($_valeur1 != $balise2[$_attribut1])
243                                        return false;
244                }
245                return true;
246        }
247        else
248                return ($balise1 == $balise2);
249}
250
251
252// Determiner la licence exacte avec un nom et un lien de doc standardise
253function definir_licence($prefixe, $nom, $suffixe, $version) {
254        global $licences_plugin;
255        $licence = array();
256
257        $prefixe = strtolower($prefixe);
258        $nom = strtolower($nom);
259        $suffixe = strtolower($suffixe);
260
261        if (((trim($prefixe) == 'creative common') AND ($nom == 'attribution'))
262        OR (($prefixe == 'cc') AND ($nom == 'by')))
263                $nom = 'ccby';
264
265        if (array_key_exists($nom, $licences_plugin)) {
266                if (!$licences_plugin[$nom]['versions']) {
267                        // La licence n'est pas versionnee : on affecte donc directement le nom et l'url
268                        $licence['nom'] = $licences_plugin[$nom]['nom'];
269                        $licence['url'] = $licences_plugin[$nom]['url'];
270                }
271                else {
272                        // Si la version est pas bonne on prend la plus recente
273                        if (!$version OR !in_array($version, $licences_plugin[$nom]['versions'], true))
274                                $version = $licences_plugin[$nom]['versions'][0];
275                        if (is_array($licences_plugin[$nom]['nom']))
276                                $licence['nom'] = $licences_plugin[$nom]['nom'][$version];
277                        else
278                                $licence['nom'] = str_replace('@version@', $version, $licences_plugin[$nom]['nom']);
279                        $licence['url'] = str_replace('@version@', $version, $licences_plugin[$nom]['url']);
280
281                        if ($nom == 'ccby') {
282                                if ($suffixe == '-sharealike')
283                                        $suffixe = '-sa';
284                                if (!$suffixe OR !in_array($suffixe, $licences_plugin[$nom]['suffixes'], true))
285                                        $suffixe = '';
286                                $licence['nom'] = str_replace('@suffixe@', strtoupper($suffixe), $licence['nom']);
287                                $licence['url'] = str_replace('@suffixe@', $suffixe, $licence['url']);
288                        }
289                }
290        }
291
292        return $licence;
293}
294
295function svp_lister_librairies() {
296        $libs = array();
297        foreach (array_reverse(creer_chemin()) as $d) {
298                if (is_dir($dir = $d.'lib/') AND $t = @opendir($dir)) {
299                        while (($f = readdir($t)) !== false) {
300                                if ($f[0] != '.' AND is_dir("$dir/$f"))
301                                        $libs[$f] = $dir;
302                        }
303                }
304        }
305        return $libs;
306}
307
308
309
310/**
311 * Retourner la chaine de la version x.y.z sous une forme normalisee
312 * permettant le tri naturel.
313 *
314 * @return string
315**/
316function normaliser_version($version='') {
317
318        $version_normalisee = '';
319
320        if (preg_match(',([0-9.]+)[\s-.]?(dev|alpha|a|beta|b|rc|pl|p)?,i', $version, $matches)) {
321                if (isset($matches[1]) and $matches[1]) {
322                        $v = explode('.', $matches[1]);
323                        foreach($v as $_nombre) {
324                                $vn[] = str_pad($_nombre, 3, '0', STR_PAD_LEFT);
325                        }
326                        $version_normalisee = implode('.', $vn);
327                        if (isset($matches[2]) and $matches[2])
328                                $version_normalisee =  $version_normalisee . '-' . $matches[2];
329                }
330        }
331
332        return $version_normalisee;
333}
334
335?>
Note: See TracBrowser for help on using the repository browser.