Beispiel #1
0
/**
 * 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;
}
Beispiel #2
0
/**
 * 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);
}