/**
* Fusion des informations de chaque balise plugin d'un plugin.xml en
* considérant la compatibilité SPIP
*
* Pour les balises plugins uniques cette fonction permet de générer une structure
* identique pour les balises dites techniques
*
* On limite le traitement a deux balises plugins maximum,
* ce qui est le cas de tous les plugin.xml actuellement connus
*
* @param array $plugins
* Arbre des balises plugins présents dans un plugin.xml
* @return array
* Fusion des éléments classé par balise, puis par compatibilité à SPIP.
* L'index 0 dans la compatibilité est valable quelque soit la version de SPIP.
*/
function plugins_fusion_plugin($plugins)
{
global $balises_techniques;
$fusion = array();
if (!$plugins) {
return $fusion;
}
if (count($plugins) == 1) {
// Balise plugin unique : on ne traite que les balises techniques
$fusion = $plugins[0];
foreach ($balises_techniques as $_btech) {
if (isset($fusion[$_btech]) and $fusion[$_btech]) {
$balise = $fusion[$_btech];
unset($fusion[$_btech]);
$fusion[$_btech][0] = $balise;
} else {
$fusion[$_btech] = array();
}
}
} else {
// On initialise les informations a retourner avec le bloc a priori le plus recent determine par la compatibilite SPIP :
// On selectionne le bloc dont la borne min de compatibilite SPIP est la plus elevee
$cle_min_max = -1;
$borne_min_max = _SVP_VERSION_SPIP_MIN;
foreach ($plugins as $_cle => $_plugin) {
if (!$_plugin['compatibilite']) {
$borne_min = _SVP_VERSION_SPIP_MIN;
}
$bornes_spip = extraire_bornes($_plugin['compatibilite']);
$borne_min = $bornes_spip['min']['valeur'] ? $bornes_spip['min']['valeur'] : _SVP_VERSION_SPIP_MIN;
if (spip_version_compare($borne_min_max, $borne_min, '<=')) {
$cle_min_max = $_cle;
$borne_min_max = $borne_min;
}
}
$fusion = $plugins[$cle_min_max];
// On relit les autres blocs que celui venant d'etre selectionne et on fusionne les informations necessaires
// les traitements effectues sont les suivants :
// -- nom, prefix, documentation, version, etat, version_base, description : *rien*, on conserve ces informations en l'etat
// -- options, fonctions, install : *rien*, meme si certaines pourraient etre fusionnees ces infos ne sont pas stockees
// -- auteur, licence : *rien*, l'heuristique pour fusionner ces infos est trop compliquee aujourdhui car c'est du texte libre
// -- categorie, logo : si la valeur du bloc selectionne est vide on essaye d'en trouver une non vide dans les autres blocs
// -- compatible : on constuit l'intervalle global de compatibilite SPIP
// -- necessite, utilise, lib : on construit le tableau par intervalle de compatibilite SPIP
$cle_min_min = $cle_min_max == 0 ? 1 : 0;
if (!$fusion['categorie'] and $plugins[$cle_min_min]['categorie']) {
$fusion['categorie'] = $plugins[$cle_min_min]['categorie'];
}
if ((!isset($fusion['logo']) or !$fusion['logo']) and $plugins[$cle_min_min]['logo']) {
$fusion['logo'] = $plugins[$cle_min_min]['logo'];
}
$fusion['compatibilite'] = fusionner_intervalles($fusion['compatibilite'], $plugins[$cle_min_min]['compatibilite']);
// necessite, utilise, lib, chemin, pipeline, bouton, onglet : on indexe chaque liste de dependances
// par l'intervalle de compatibilite sans regrouper les doublons pour l'instant
foreach ($balises_techniques as $_btech) {
if (!isset($fusion[$_btech]) and !isset($plugins[$cle_min_min][$_btech])) {
// Aucun des tableaux ne contient cette balise technique : on la positionne a un array vide
$fusion[$_btech] = array();
} else {
if (!isset($fusion[$_btech]) or !$fusion[$_btech]) {
if ($plugins[$cle_min_min][$_btech]) {
// La balise technique est vide dans le tableau de fusion mais non vide dans la deuxieme balise plugin
// On range cette balise dans le tableau fusion de sa compatibilite et on cree la cle commune vide
$fusion[$_btech][$plugins[$cle_min_min]['compatibilite']] = $plugins[$cle_min_min][$_btech];
$fusion[$_btech][0] = array();
}
} else {
if (!isset($plugins[$cle_min_min][$_btech]) or !$plugins[$cle_min_min][$_btech]) {
// La balise technique est non vide dans le tableau de fusion mais vide dans la deuxieme balise plugin
// On deplace cette balise dans le tableau fusion de sa compatibilite et on cree la cle commune vide
$balise = $fusion[$_btech];
unset($fusion[$_btech]);
$fusion[$_btech][$plugins[$cle_min_max]['compatibilite']] = $balise;
$fusion[$_btech][0] = array();
} else {
// Les deux tableaux contiennent une balise technique non vide : il faut fusionner cette balise technique !
// On parcourt le premier tableau (fusion) en verifiant une egalite avec le deuxieme tableau
foreach ($fusion[$_btech] as $_cle0 => $_balise0) {
$balise_commune = false;
foreach ($plugins[$cle_min_min][$_btech] as $_cle1 => $_balise1) {
if (balise_identique($_balise0, $_balise1)) {
// On classe cette balise dans le bloc commun (index 0) et on la supprime dans les
// 2 tableaux en cours de comparaison
unset($fusion[$_btech][$_cle0]);
$fusion[$_btech][0][] = $_balise1;
unset($plugins[$cle_min_min][$_btech][$_cle1]);
$balise_commune = true;
break;
}
}
if (!$balise_commune) {
$fusion[$_btech][$plugins[$cle_min_max]['compatibilite']][] = $_balise0;
unset($fusion[$_btech][$_cle0]);
}
if (!isset($fusion[$_btech][0])) {
$fusion[$_btech][0] = array();
}
}
// On traite maintenant les balises restantes du deuxieme tableau
if ($plugins[$cle_min_min][$_btech]) {
foreach ($plugins[$cle_min_min][$_btech] as $_balise2) {
$fusion[$_btech][$plugins[$cle_min_min]['compatibilite']][] = $_balise2;
}
}
}
}
}
}
}
return $fusion;
}
/**
* Retourne la liste des branches de SPIP comprises dans un intervalle
* de compatibilité donné.
*
* @param string $intervalle
* Intervalle de compatibilité, tel que [2.0.0;3.0.0]
* @return string
* Branches de SPIP séparées par des virgules, tel que 2.0,2.1,3.0
**/
function compiler_branches_spip($intervalle)
{
include_spip('plugins/installer');
global $infos_branches_spip;
$liste_branches_spip = array_keys($GLOBALS['infos_branches_spip']);
$bornes = extraire_bornes($intervalle, false);
// On traite d'abord les cas ou l'intervalle est :
// - vide
// - non vide mais avec les deux bornes vides
// Dans ces cas la compatibilite est totale, on renvoie toutes les branches
if (!$intervalle or !$bornes['min']['valeur'] and !$bornes['max']['valeur']) {
return implode(',', $liste_branches_spip);
}
// On force l'initialisation des bornes et on les nettoie des suffixes d'etat
$bornes = extraire_bornes($intervalle, true);
// Si les bornes sont en dehors de l'intervalle [_SVP_VERSION_SPIP_MIN;_SVP_VERSION_SPIP_MAX] on le reduit
if (spip_version_compare($bornes['min']['valeur'], _SVP_VERSION_SPIP_MIN, '<')) {
$bornes['min']['valeur'] = _SVP_VERSION_SPIP_MIN;
$bornes['min']['incluse'] = true;
}
if (spip_version_compare(_SVP_VERSION_SPIP_MAX, $bornes['max']['valeur'], '<=')) {
$bornes['max']['valeur'] = _SVP_VERSION_SPIP_MAX;
$bornes['max']['incluse'] = true;
}
// On les nettoie des suffixes d'etat
$borne_inf = strtolower(preg_replace(',([0-9])[\\s-.]?(dev|alpha|a|beta|b|rc|pl|p),i', '\\1', $bornes['min']['valeur']));
$borne_sup = strtolower(preg_replace(',([0-9])[\\s-.]?(dev|alpha|a|beta|b|rc|pl|p),i', '\\1', $bornes['max']['valeur']));
// On determine les branches inf et sup issues du phrasage de l'intervalle
// -- on initialise la branche inf de l'intervalle que l'on va preciser ensuite
$t = explode('.', $borne_inf);
$branche_inf = $t[0] . '.' . $t[1];
// -- pour eviter toutes erreur fatale on verifie que la branche est bien dans la liste des possibles
// -- -> si non, on renvoie vide
if (!in_array($branche_inf, $liste_branches_spip)) {
return '';
}
// -- on complete la borne inf de l'intervalle de x.y en x.y.z et on determine la vraie branche
if (!isset($t[2]) or !$t[2]) {
if ($bornes['min']['incluse']) {
$borne_inf = $infos_branches_spip[$branche_inf][0];
} else {
$branche_inf = $liste_branches_spip[array_search($branche_inf, $liste_branches_spip) + 1];
$borne_inf = $infos_branches_spip[$branche_inf][0];
}
}
// -- on initialise la branche sup de l'intervalle que l'on va preciser ensuite
$t = explode('.', $borne_sup);
// des gens mettent juste * (pas glop)
$branche_sup = $t[0] . (isset($t[1]) ? '.' . $t[1] : '');
// -- pour eviter toutes erreur fatale on verifie que la branche est bien dans la liste des possibles
// -- -> si non, on renvoie vide
if (!in_array($branche_sup, $liste_branches_spip)) {
return '';
}
// -- on complete la borne sup de l'intervalle de x.y en x.y.z et on determine la vraie branche
if (!isset($t[2]) or !$t[2]) {
if ($bornes['max']['incluse']) {
$borne_sup = $infos_branches_spip[$branche_sup][1];
} else {
$branche_sup = $liste_branches_spip[array_search($branche_sup, $liste_branches_spip) - 1];
$borne_sup = $infos_branches_spip[$branche_sup][1];
}
}
// -- on verifie que les bornes sont bien dans l'ordre :
// -> sinon on retourne la branche sup uniquement
if (spip_version_compare($borne_inf, $borne_sup, '>=')) {
return $branche_sup;
}
// A ce stade, on a un intervalle ferme en bornes ou en branches
// Il suffit de trouver les branches qui y sont incluses, sachant que les branches inf et sup
// le sont a coup sur maintenant
$index_inf = array_search($branche_inf, $liste_branches_spip);
$index_sup = array_search($branche_sup, $liste_branches_spip);
$liste = array();
for ($i = $index_inf; $i <= $index_sup; $i++) {
$liste[] = $liste_branches_spip[$i];
}
return implode(',', $liste);
}