www/plugins-dist/svp/plugins/fusion_plugin.php

   1 <?php
   2
   3 /**
   4  * Fichier permettant de calculer les descriptions
   5  * d'un plugin.xml contenant plusieurs balises <plugin>
   6  *
   7  * @plugin SVP pour SPIP
   8  * @license GPL
   9  * @package SPIP\SVP\Plugins
  10 **/
  11
  12 if (!defined('_ECRIRE_INC_VERSION')) return;
  13 include_spip('inc/plugin');
  14 include_spip('inc/svp_outiller');
  15
  16 /**
  17  * Fusion des informations de chaque balise plugin d'un plugin.xml en
  18  * considérant la compatibilité SPIP
  19  *
  20  * Pour les balises plugins uniques cette fonction permet de générer une structure
  21  * identique pour les balises dites techniques
  22  *
  23  * On limite le traitement a deux balises plugins maximum,
  24  * ce qui est le cas de tous les plugin.xml actuellement connus
  25  *
  26  * @param array $plugins
  27  *     Arbre des balises plugins présents dans un plugin.xml
  28  * @return array
  29  *     Fusion des éléments classé par balise, puis par compatibilité à SPIP.
  30  *     L'index 0 dans la compatibilité est valable quelque soit la version de SPIP.
  31  */
  32 function plugins_fusion_plugin($plugins) {
  33         global $balises_techniques;
  34
  35         $fusion = array();
  36         if (!$plugins)
  37                 return $fusion;
  38
  39         if (count($plugins) == 1) {
  40                 // Balise plugin unique : on ne traite que les balises techniques
  41                 $fusion = $plugins[0];
  42                 foreach ($balises_techniques as $_btech) {
  43                         if (isset($fusion[$_btech]) and $fusion[$_btech]) {
  44                                 $balise = $fusion[$_btech];
  45                                 unset($fusion[$_btech]);
  46                                 $fusion[$_btech][0] = $balise;
  47                         }
  48                         else {
  49                                 $fusion[$_btech] = array();
  50                         }
  51                 }
  52         }
  53         else {
  54                 // On initialise les informations a retourner avec le bloc a priori le plus recent determine par la compatibilite SPIP :
  55                 // On selectionne le bloc dont la borne min de compatibilite SPIP est la plus elevee
  56                 $cle_min_max = -1;
  57                 $borne_min_max = _SVP_VERSION_SPIP_MIN;
  58                 foreach ($plugins as $_cle => $_plugin) {
  59                         if (!$_plugin['compatibilite'])
  60                                 $borne_min = _SVP_VERSION_SPIP_MIN;
  61                         $bornes_spip = extraire_bornes($_plugin['compatibilite']);
  62                         $borne_min = ($bornes_spip['min']['valeur']) ? $bornes_spip['min']['valeur'] : _SVP_VERSION_SPIP_MIN;
  63                         if (spip_version_compare($borne_min_max, $borne_min, '<=')) {
  64                                 $cle_min_max = $_cle;
  65                                 $borne_min_max = $borne_min;
  66                         }
  67                 }
  68                 $fusion = $plugins[$cle_min_max];
  69
  70                 // On relit les autres blocs que celui venant d'etre selectionne et on fusionne les informations necessaires
  71                 // les traitements effectues sont les suivants :
  72                 // -- nom, prefix, documentation, version, etat, version_base, description : *rien*, on conserve ces informations en l'etat
  73                 // -- options, fonctions, install : *rien*, meme si certaines pourraient etre fusionnees ces infos ne sont pas stockees
  74                 // -- auteur, licence : *rien*, l'heuristique pour fusionner ces infos est trop compliquee aujourdhui car c'est du texte libre
  75                 // -- categorie, logo : si la valeur du bloc selectionne est vide on essaye d'en trouver une non vide dans les autres blocs
  76                 // -- compatible : on constuit l'intervalle global de compatibilite SPIP
  77                 // -- necessite, utilise, lib : on construit le tableau par intervalle de compatibilite SPIP
  78                 $cle_min_min = ($cle_min_max==0) ? 1 : 0;
  79                 if (!$fusion['categorie'] AND $plugins[$cle_min_min]['categorie'])
  80                         $fusion['categorie'] = $plugins[$cle_min_min]['categorie'];
  81                 if ((!isset($fusion['logo']) OR !$fusion['logo']) AND $plugins[$cle_min_min]['logo'])
  82                         $fusion['logo'] = $plugins[$cle_min_min]['logo'];
  83                 $fusion['compatibilite'] = fusionner_intervalles($fusion['compatibilite'], $plugins[$cle_min_min]['compatibilite']);
  84
  85                 // necessite, utilise, lib, chemin, pipeline, bouton, onglet : on indexe chaque liste de dependances
  86                 // par l'intervalle de compatibilite sans regrouper les doublons pour l'instant
  87                 foreach ($balises_techniques as $_btech) {
  88                         if (!isset($fusion[$_btech]) AND !isset($plugins[$cle_min_min][$_btech])) {
  89                                 // Aucun des tableaux ne contient cette balise technique : on la positionne a un array vide
  90                                 $fusion[$_btech] = array();
  91                         }
  92                         else if (!isset($fusion[$_btech]) OR !$fusion[$_btech]) {
  93                                 if ($plugins[$cle_min_min][$_btech]) {
  94                                         // La balise technique est vide dans le tableau de fusion mais non vide dans la deuxieme balise plugin
  95                                         // On range cette balise dans le tableau fusion de sa compatibilite et on cree la cle commune vide
  96                                         $fusion[$_btech][$plugins[$cle_min_min]['compatibilite']] = $plugins[$cle_min_min][$_btech];
  97                                         $fusion[$_btech][0] = array();
  98                                 }
  99                         }
 100                         else if (!isset($plugins[$cle_min_min][$_btech]) OR !$plugins[$cle_min_min][$_btech]) {
 101                                 // La balise technique est non vide dans le tableau de fusion mais vide dans la deuxieme balise plugin
 102                                 // On deplace cette balise dans le tableau fusion de sa compatibilite et on cree la cle commune vide
 103                                 $balise = $fusion[$_btech];
 104                                 unset($fusion[$_btech]);
 105                                 $fusion[$_btech][$plugins[$cle_min_max]['compatibilite']] = $balise;
 106                                 $fusion[$_btech][0] = array();
 107                         }
 108                         else {
 109                                 // Les deux tableaux contiennent une balise technique non vide : il faut fusionner cette balise technique !
 110                                 // On parcourt le premier tableau (fusion) en verifiant une egalite avec le deuxieme tableau
 111                                 foreach ($fusion[$_btech] as $_cle0 => $_balise0) {
 112                                         $balise_commune = false;
 113                                         foreach ($plugins[$cle_min_min][$_btech] as $_cle1 => $_balise1) {
 114                                                 if (balise_identique($_balise0, $_balise1)) {
 115                                                         // On classe cette balise dans le bloc commun (index 0) et on la supprime dans les
 116                                                         // 2 tableaux en cours de comparaison
 117                                                         unset($fusion[$_btech][$_cle0]);
 118                                                         $fusion[$_btech][0][] = $_balise1;
 119                                                         unset($plugins[$cle_min_min][$_btech][$_cle1]);
 120                                                         $balise_commune = true;
 121                                                         break;
 122                                                 }
 123                                         }
 124                                         if (!$balise_commune) {
 125                                                 $fusion[$_btech][$plugins[$cle_min_max]['compatibilite']][] = $_balise0;
 126                                                 unset($fusion[$_btech][$_cle0]);
 127                                         }
 128                                         if (!isset($fusion[$_btech][0]))
 129                                                 $fusion[$_btech][0] = array();
 130                                 }
 131
 132                                 // On traite maintenant les balises restantes du deuxieme tableau
 133                                 if ($plugins[$cle_min_min][$_btech]) {
 134                                         foreach ($plugins[$cle_min_min][$_btech] as $_balise2) {
 135                                                 $fusion[$_btech][$plugins[$cle_min_min]['compatibilite']][] = $_balise2;
 136                                         }
 137                                 }
 138                         }
 139                 }
 140
 141         }
 142
 143         return $fusion;
 144 }
 145
 146 ?>