6 * @plugin SVP pour SPIP
8 * @package SPIP\SVP\Fonctions
11 if (!defined('_ECRIRE_INC_VERSION')) return;
14 if (!defined('_SVP_VERSION_SPIP_MIN')) {
16 * Version SPIP minimale quand un plugin ne le precise pas
18 * Version SPIP correspondant à l'apparition des plugins */
19 define('_SVP_VERSION_SPIP_MIN', '1.9.0');
22 if (!defined('_SVP_VERSION_SPIP_MAX')) {
24 * Version SPIP maximale
26 * Pour l'instant on ne connait pas la borne sup exacte */
27 define('_SVP_VERSION_SPIP_MAX', '3.1.99');
31 * Liste des branches significatives de SPIP et de leurs bornes (versions min et max)
33 * À mettre a jour en fonction des sorties
34 * @global array $GLOBALS['infos_branches_spip']
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
)
43 # define('_INFOS_BRANCHES_SPIP', serialize($infos_branches_spip));
46 * Liste des licences de plugin
48 * @global array $GLOBALS['licences_plugin']
50 $GLOBALS['licences_plugin'] = 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@'),
56 'versions' => array('1.3'),
57 'nom' => 'Art libre @version@',
58 'url' => 'http://artlibre.org/licence/lal'),
60 'versions' => array(),
62 'url' => 'http://opensource.org/licenses/mit-license.php'),
64 'versions' => array(),
66 'url' => 'http://www.freebsd.org/copyright/license.html'),
68 'versions' => array('3'),
69 'nom' => 'AGPL @version@',
70 'url' => 'http://www.gnu.org/licenses/agpl.html'),
72 'versions' => array('1.3', '1.2', '1.1'),
73 'nom' => 'FDL @version@',
74 'url' => 'http://www.gnu.org/licenses/fdl-@version@.html'),
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'),
80 'versions' => array('3', '2', '1'),
81 'nom' => 'GPL @version@',
82 'url' => 'http://www.gnu.org/licenses/gpl-@version@.0.html'),
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@/')
89 # define('_LICENCES_PLUGIN', serialize($licences_plugin));
92 * Fusionne 2 intervalles de compatibilité
94 * Soit '[1.9;2.1]' et '[2.1;3.0.*]', la fonction retourne '[1.9;3.0.*]'
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.
100 * @param string $intervalle_a
101 * Intervalle de compatibilité
102 * @param string $intervalle_b
103 * Intervalle de compatibilité
105 * Intervalle de compatibilité
107 function fusionner_intervalles($intervalle_a, $intervalle_b) {
109 // On recupere les bornes de chaque intervalle
110 $borne_a = extraire_bornes($intervalle_a);
111 $borne_b = extraire_bornes($intervalle_b);
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;
118 if (!$borne_b['min']['valeur']) {
119 $borne_b['min']['valeur'] = _SVP_VERSION_SPIP_MIN
;
120 $borne_b['min']['incluse'] = true;
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;
128 if (!$borne_b['max']['valeur']) {
129 $borne_b['max']['valeur'] = _SVP_VERSION_SPIP_MAX
;
130 $borne_b['max']['incluse'] = true;
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'];
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'];
143 $bornes_fusionnees['max'] = $borne_a['max'];
145 return construire_intervalle($bornes_fusionnees);
149 * Extrait les valeurs d'un intervalle de compatibilité.
151 * Calcule les valeurs min, max et si ces valeurs sont intégrées ou non
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.
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.
166 function 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);
172 $bornes = array('min' => $borne_inf_init, 'max' => $borne_sup_init);
174 $bornes = array('min' => $borne_vide, 'max' => $borne_vide);
177 AND preg_match(',^[\[\(\]]([0-9.a-zRC\s\-]*)[;]([0-9.a-zRC\s\-\*]*)[\]\)\[]$,Uis', $intervalle, $matches)) {
179 $bornes['min']['valeur'] = trim($matches[1]);
180 $bornes['min']['incluse'] = ($intervalle{0} == "[");
183 $bornes['max']['valeur'] = trim($matches[2]);
184 $bornes['max']['incluse'] = (substr($intervalle,-1) == "]");
192 * Contruit un intervalle de compatibilité
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.
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)
204 * Intervalle de compatibilité tel que '[2.1;3.0]'
206 function 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' ?
'[' : ')'));
214 * Retourne la liste des branches de SPIP comprises dans un intervalle
215 * de compatibilité donné.
217 * @param string $intervalle
218 * Intervalle de compatibilité, tel que [2.0.0;3.0.0]
220 * Branches de SPIP séparées par des virgules, tel que 2.0,2.1,3.0
222 function compiler_branches_spip($intervalle) {
223 include_spip('plugins/installer');
225 global $infos_branches_spip;
226 $liste_branches_spip = array_keys($GLOBALS['infos_branches_spip']);
228 $bornes = extraire_bornes($intervalle, false);
229 // On traite d'abord les cas ou l'intervalle est :
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);
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;
243 if (spip_version_compare(_SVP_VERSION_SPIP_MAX
, $bornes['max']['valeur'], '<=')) {
244 $bornes['max']['valeur'] = _SVP_VERSION_SPIP_MAX
;
245 $bornes['max']['incluse'] = true;
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']));
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))
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];
264 $branche_inf = $liste_branches_spip[array_search($branche_inf, $liste_branches_spip)+
1];
265 $borne_inf = $infos_branches_spip[$branche_inf][0];
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] : '');
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))
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];
283 $branche_sup = $liste_branches_spip[array_search($branche_sup, $liste_branches_spip)-1];
284 $borne_sup = $infos_branches_spip[$branche_sup][1];
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, '>='))
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);
299 for ($i = $index_inf; $i <= $index_sup; $i++
) {
300 $liste[] = $liste_branches_spip[$i];
303 return implode(',', $liste);
308 * Transforme un texte écrit en entités HTML, dans le charset du site
310 * @param string $texte
311 * Texte avec des entités HTML
312 * @return string $texte
313 * Texte dans le charset du site
315 function entite2charset($texte) {
316 if (!strlen($texte)) return '';
317 include_spip('inc/charsets');
318 return unicode2charset(html_entity_decode(preg_replace('/&([lg]t;)/S', '&\1', $texte), ENT_NOQUOTES
, $GLOBALS['meta']['charset']));
322 * Teste si 2 balises XML sont identiques
324 * @param array|string $balise1
326 * @param array|string $balise2
329 * True si elles sont identiques, false sinon.
331 function balise_identique($balise1, $balise2) {
332 if (is_array($balise1)) {
333 foreach ($balise1 as $_attribut1 => $_valeur1){
334 if (!array_key_exists($_attribut1, $balise2))
337 if ($_valeur1 != $balise2[$_attribut1])
343 return ($balise1 == $balise2);
348 * Déterminer la licence exacte avec un nom et un lien de doc standardisé
350 * @param string $prefixe
351 * Préfixe de la licence tel que gnu, free, cc, creative common
353 * Nom de la licence tel que gpl, lgpl, agpl, fdl, mit, bsd...
354 * @param string $suffixe
355 * Suffixe de la licence tel que licence, -sharealike, -nc-nd ...
356 * @param string $version
357 * Version de la licence tel que 3.0
359 * Si la licence est connu, retourne 2 index :
360 * - nom : le nom le la licence
361 * - url : lien vers la licence
363 function definir_licence($prefixe, $nom, $suffixe, $version) {
364 global $licences_plugin;
367 $prefixe = strtolower($prefixe);
368 $nom = strtolower($nom);
369 $suffixe = strtolower($suffixe);
371 if (((trim($prefixe) == 'creative common') AND ($nom == 'attribution'))
372 OR (($prefixe == 'cc') AND ($nom == 'by')))
375 if (array_key_exists($nom, $licences_plugin)) {
376 if (!$licences_plugin[$nom]['versions']) {
377 // La licence n'est pas versionnee : on affecte donc directement le nom et l'url
378 $licence['nom'] = $licences_plugin[$nom]['nom'];
379 $licence['url'] = $licences_plugin[$nom]['url'];
382 // Si la version est pas bonne on prend la plus recente
383 if (!$version OR !in_array($version, $licences_plugin[$nom]['versions'], true))
384 $version = $licences_plugin[$nom]['versions'][0];
385 if (is_array($licences_plugin[$nom]['nom']))
386 $licence['nom'] = $licences_plugin[$nom]['nom'][$version];
388 $licence['nom'] = str_replace('@version@', $version, $licences_plugin[$nom]['nom']);
389 $licence['url'] = str_replace('@version@', $version, $licences_plugin[$nom]['url']);
391 if ($nom == 'ccby') {
392 if ($suffixe == '-sharealike')
394 if (!$suffixe OR !in_array($suffixe, $licences_plugin[$nom]['suffixes'], true))
396 $licence['nom'] = str_replace('@suffixe@', strtoupper($suffixe), $licence['nom']);
397 $licence['url'] = str_replace('@suffixe@', $suffixe, $licence['url']);
406 * Liste les librairies présentes
408 * Cherche des librairie dans tous les dossiers 'lib' présents dans chaque
409 * chemin déclaré (plugins, squelettes, SPIP). Un répertoire dans un dossier
410 * 'lib' est considéré comme une librairie, et le nom de ce répertoire est
411 * utilisé comme nom de la librairie.
414 * Tableau de couples (nom de la librairie => répertoire de la librairie)
416 function svp_lister_librairies() {
418 foreach (array_reverse(creer_chemin()) as $d) {
419 if (is_dir($dir = $d.'lib/') AND $t = @opendir
($dir)) {
420 while (($f = readdir($t)) !== false) {
421 if ($f[0] != '.' AND is_dir("$dir/$f"))
432 * Retourne '00x.00y.00z' à partir de 'x.y.z'
434 * Retourne la chaine de la version x.y.z sous une forme normalisée
435 * permettant le tri naturel. On complète à gauche d'un nombre de zéro
436 * manquant pour aller à 3 caractères entre chaque point.
438 * @see denormaliser_version()
439 * @param string $version
440 * Numéro de version dénormalisée
442 * Numéro de version normalisée
444 function normaliser_version($version='') {
446 $version_normalisee = '';
448 if (preg_match(',([0-9.]+)[\s-.]?(dev|alpha|a|beta|b|rc|pl|p)?,i', $version, $matches)) {
449 if (isset($matches[1]) and $matches[1]) {
450 $v = explode('.', $matches[1]);
451 foreach($v as $_nombre) {
452 $vn[] = str_pad($_nombre, 3, '0', STR_PAD_LEFT
);
454 $version_normalisee = implode('.', $vn);
455 if (isset($matches[2]) and $matches[2])
456 $version_normalisee = $version_normalisee . '-' . $matches[2];
460 return $version_normalisee;