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