www/plugins-dist/svp/inc/svp_outiller.php

   1 <?php
   2
   3 /**
   4  * Fichier de fonctions
   5  *
   6  * @plugin SVP pour SPIP
   7  * @license GPL
   8  * @package SPIP\SVP\Fonctions
   9 **/
  10
  11 if (!defined('_ECRIRE_INC_VERSION')) return;
  12
  13
  14 if (!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
  22 if (!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 **/
 107 function 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 **/
 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);
 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 **/
 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' ? '[' : ')'));
 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 **/
 222 function 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(_SVP_VERSION_SPIP_MAX, $bornes['max']['valeur'], '<=')) {
 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 **/
 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', '&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 function balise_identique($balise1, $balise2) {
 332         if (is_array($balise1)) {
 333                 foreach ($balise1 as $_attribut1 => $_valeur1){
 334                         if (!array_key_exists($_attribut1, $balise2))
 335                                 return false;
 336                         else
 337                                 if ($_valeur1 != $balise2[$_attribut1])
 338                                         return false;
 339                 }
 340                 return true;
 341         }
 342         else
 343                 return ($balise1 == $balise2);
 344 }
 345
 346
 347 /**
 348  * Déterminer la licence exacte avec un nom et un lien de doc standardisé
 349  *
 350  * @param string $prefixe
 351  *     Préfixe de la licence tel que gnu, free, cc, creative common
 352  * @param string $nom
 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
 358  * @return array
 359  *     Si la licence est connu, retourne 2 index :
 360  *     - nom : le nom le la licence
 361  *     - url : lien vers la licence
 362  */
 363 function definir_licence($prefixe, $nom, $suffixe, $version) {
 364         global $licences_plugin;
 365         $licence = array();
 366
 367         $prefixe = strtolower($prefixe);
 368         $nom = strtolower($nom);
 369         $suffixe = strtolower($suffixe);
 370
 371         if (((trim($prefixe) == 'creative common') AND ($nom == 'attribution'))
 372         OR (($prefixe == 'cc') AND ($nom == 'by')))
 373                 $nom = 'ccby';
 374
 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'];
 380                 }
 381                 else {
 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];
 387                         else
 388                                 $licence['nom'] = str_replace('@version@', $version, $licences_plugin[$nom]['nom']);
 389                         $licence['url'] = str_replace('@version@', $version, $licences_plugin[$nom]['url']);
 390
 391                         if ($nom == 'ccby') {
 392                                 if ($suffixe == '-sharealike')
 393                                         $suffixe = '-sa';
 394                                 if (!$suffixe OR !in_array($suffixe, $licences_plugin[$nom]['suffixes'], true))
 395                                         $suffixe = '';
 396                                 $licence['nom'] = str_replace('@suffixe@', strtoupper($suffixe), $licence['nom']);
 397                                 $licence['url'] = str_replace('@suffixe@', $suffixe, $licence['url']);
 398                         }
 399                 }
 400         }
 401
 402         return $licence;
 403 }
 404
 405 /**
 406  * Liste les librairies présentes
 407  *
 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.
 412  *
 413  * @return array
 414  *     Tableau de couples (nom de la librairie => répertoire de la librairie)
 415 **/
 416 function svp_lister_librairies() {
 417         $libs = array();
 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"))
 422                                         $libs[$f] = $dir;
 423                         }
 424                 }
 425         }
 426         return $libs;
 427 }
 428
 429
 430
 431 /**
 432  * Retourne '00x.00y.00z' à partir de 'x.y.z'
 433  *
 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.
 437  *
 438  * @see denormaliser_version()
 439  * @param string $version
 440  *     Numéro de version dénormalisée
 441  * @return string
 442  *     Numéro de version normalisée
 443 **/
 444 function normaliser_version($version='') {
 445
 446         $version_normalisee = '';
 447
 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);
 453                         }
 454                         $version_normalisee = implode('.', $vn);
 455                         if (isset($matches[2]) and $matches[2])
 456                                 $version_normalisee =  $version_normalisee . '-' . $matches[2];
 457                 }
 458         }
 459
 460         return $version_normalisee;
 461 }
 462
 463 ?>