Changeset 45382 in spip-zone


Ignore:
Timestamp:
Mar 13, 2011, 6:56:15 PM (9 years ago)
Author:
eric@…
Message:

On découpe le code des fonctions de base afin de mieux préparer la migration vers la nouvelle DTD des plugins. C'est aussi plus clair

Location:
_plugins_/svp
Files:
3 added
3 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/svp/formulaires/ajouter_depot.php

    r43268 r45382  
    33if (!defined("_ECRIRE_INC_VERSION")) return;
    44
    5 include_spip('inc/svp_depoter');
    65
    76function formulaires_ajouter_depot_charger_dist(){
     
    1110
    1211function formulaires_ajouter_depot_verifier_dist(){
     12        include_spip('inc/svp_outiller');
     13       
    1314        $erreurs = array();
    1415        $xml = _request('xml_paquets');
     
    3031
    3132function formulaires_ajouter_depot_traiter_dist(){
     33        include_spip('inc/svp_depoter');
     34
    3235        $retour = array();
    3336        $xml = _request('xml_paquets');
  • _plugins_/svp/formulaires/charger_plugin.php

    r42826 r45382  
    22
    33if (!defined("_ECRIRE_INC_VERSION")) return;
    4 
    5 include_spip('inc/svp_depoter');
    64
    75function formulaires_charger_plugin_charger_dist(){
     
    1917
    2018function formulaires_charger_plugin_traiter_dist(){
     19        include_spip('inc/svp_rechercher');
     20
    2121        $retour = array();
    2222        $phrase = _request('phrase');
  • _plugins_/svp/inc/svp_depoter.php

    r43988 r45382  
    55
    66// ----------------------- Traitements des depots ---------------------------------
    7 
    8 /**
    9  * Teste la validite d'une url d'un depot de paquets
    10  *
    11  * @param string $url
    12  * @return boolean
    13  */
    14 
    15 // $url => url du fichier xml de description du depot
    16 function svp_verifier_adresse_depot($url){
    17         include_spip('inc/distant');
    18         return (!$xml = recuperer_page($url)) ? false : true;
    19 }
    20 
    217
    228/**
     
    229215               
    230216        // On initialise l'url de base des logos du depot et son type afin de calculer l'url complete de chaque logo
    231         // A REVOIR COMPLETEMENT !!!!
    232217        $depot = sql_fetsel('url_archives, type', 'spip_depots', 'id_depot=' . sql_quote($id_depot));
    233218       
     
    256241
    257242                // On verifie si le paquet est celui d'un plugin ou pas
     243                // -- Les traitements du XML dependent de la DTD utilisee
     244                $traiteur =  'svp_dtd_' . _SVP_DTD_PLUGIN;
     245                include_spip('inc/'. $traiteur);
    258246                if ($champs = svp_remplir_champs_sql($_infos['plugin'])) {
    259247                        $paquet_plugin = true;
     
    484472
    485473
    486 // Les archives xml sont deja applaties, pas la peine de se compliquer.
    487 function svp_remplir_champs_sql($p) {
    488 
    489         if (!$p)
    490                 return array();
    491 
    492         // On passe le prefixe en lettres majuscules comme ce qui est fait dans SPIP
    493         // Ainsi les valeurs dans la table spip_plugins coincideront avec celles de la meta plugin
    494         $p['prefix'] = strtoupper($p['prefix']);
    495 
    496         // calcul du tableau de dependances
    497         $dependances = array();
    498         $v_spip = '';
    499         if (is_array($p['necessite'])) {
    500                 foreach ($p['necessite'] as $c=>$n) {
    501                         $p['necessite'][$c]['id'] = strtoupper($n['id']);
    502                         if ($n['id'] == 'SPIP') {
    503                                 $v_spip = $n['version'];
    504                         }
    505                 }
    506                 $dependances['necessite'] = $p['necessite'];
    507         }
    508        
    509         if (is_array($p['utilise'])) {
    510                 foreach ($p['utilise'] as $c=>$n) {
    511                         $p['utilise'][$c]['id'] = strtoupper($n['id']);
    512                 }
    513                 $dependances['utilise'] = $p['utilise'];
    514         }
    515 
    516         // Etat numerique (pour simplifier la recherche de maj)
    517         $num = array('stable'=>4, 'test'=>3, 'dev'=>2, 'experimental'=>1);
    518         $etatnum = isset($num[$p['etat']]) ? $num[$p['etat']] : 0;
    519        
    520         // On passe en utf-8 avec le bon charset les champs pouvant contenir des entites html
    521         $p['description'] = unicode2charset(html2unicode($p['description']));
    522         $p['slogan'] = unicode2charset(html2unicode($p['slogan']));
    523         $p['nom'] = unicode2charset(html2unicode($p['nom']));
    524         $p['auteur'] = unicode2charset(html2unicode($p['auteur']));
    525         $p['licence'] = unicode2charset(html2unicode($p['licence']));
    526 
    527         // Nom, slogan et branche
    528         if ($p['prefix'] == _SVP_PREFIXE_PLUGIN_THEME) {
    529                 // Traitement specifique des themes qui aujourd'hui sont consideres comme des paquets
    530                 // d'un plugin unique de prefixe "theme"
    531                 $nom = _SVP_NOM_PLUGIN_THEME;
    532                 $slogan = _SVP_SLOGAN_PLUGIN_THEME;
    533         }
    534         else {
    535                 // Calcul *temporaire* de la nouvelles balise slogan si celle-ci n'est
    536                 // pas renseignee et de la balise nom. Ceci devrait etre temporaire jusqu'a la nouvelle ere
    537                 // glaciaire des plugins
    538                 // - Slogan     :       si vide alors on prend la premiere phrase de la description limitee a 255
    539                 $slogan = (!$p['slogan']) ? svp_remplir_slogan($p['description']) : $p['slogan'];
    540                 // - Nom :      on repere dans le nom du plugin un chiffre en fin de nom
    541                 //                      et on l'ampute de ce numero pour le normaliser
    542                 //                      et on passe tout en unicode avec le charset du site
    543                 $nom = svp_normaliser_nom($p['nom']);
    544         }
    545        
    546         return array(
    547                 'plugin' => array(
    548                         'prefixe' => $p['prefix'],
    549                         'nom' => $nom,
    550                         'slogan' => $slogan,
    551                         'categorie' => $p['categorie'],
    552                         'tags' => $p['tags']),
    553                 'paquet' => array(
    554                         'logo' => $p['icon'],
    555                         'description' => $p['description'],
    556                         'auteur' => $p['auteur'],
    557                         'version' => $p['version'],
    558                         'version_base' => $p['version_base'],
    559                         'version_spip' => $v_spip,
    560                         'etat' => $p['etat'],
    561                         'etatnum' => $etatnum,
    562                         'licence' => $p['licence'],
    563                         'lien' => $p['lien'],
    564                         'dependances' => serialize($dependances))
    565         );
    566 }
    567 
    568 function svp_remplir_slogan($description) {
    569         include_spip('inc/texte');
    570 
    571         // On extrait les traductions de l'eventuel multi
    572         // Si le nom n'est pas un multi alors le tableau renvoye est de la forme '' => 'nom'
    573         $descriptions = extraire_trads(str_replace(array('<multi>', '</multi>'), array(), $description, $nbr_replace));
    574         $multi = ($nbr_replace > 0) ? true : false;
    575 
    576         // On boucle sur chaque multi ou sur la chaine elle-meme en extrayant le slogan
    577         // dans les differentes langues
    578         $slogan = '';
    579         foreach ($descriptions as $_lang => $_descr) {
    580                 $_descr = trim($_descr);
    581                 if (!$_lang)
    582                         $_lang = 'fr';
    583                 $nbr_matches = preg_match(',^(.+)[.!?\r\n\f],Um', $_descr, $matches);
    584                 $slogan .= (($multi) ? '[' . $_lang . ']' : '') .
    585                                         (($nbr_matches > 0) ? trim($matches[1]) : couper($_descr, 150, ''));
    586         }
    587 
    588         if ($slogan)
    589                 // On renvoie un nouveau slogan multi ou pas
    590                 $slogan = (($multi) ? '<multi>' : '') . $slogan . (($multi) ? '</multi>' : '');
    591 
    592         return $slogan;
    593 }
    594 
    595 function svp_normaliser_nom($nom) {
    596         include_spip('inc/texte');
    597 
    598         // On extrait les traductions de l'eventuel multi
    599         // Si le nom n'est pas un multi alors le tableau renvoye est de la forme '' => 'nom'
    600         $noms = extraire_trads(str_replace(array('<multi>', '</multi>'), array(), $nom, $nbr_replace));
    601         $multi = ($nbr_replace > 0) ? true : false;
    602        
    603         $nouveau_nom = '';
    604         foreach ($noms as $_lang => $_nom) {
    605                 $_nom = trim($_nom);
    606                 if (!$_lang)
    607                         $_lang = 'fr';
    608                 $nbr_matches = preg_match(',(.+)(\s+[\d._]*)$,Um', $_nom, $matches);
    609                 $nouveau_nom .= (($multi) ? '[' . $_lang . ']' : '') .
    610                                                 (($nbr_matches > 0) ? trim($matches[1]) : $_nom);
    611         }
    612        
    613         if ($nouveau_nom)
    614                 // On renvoie un nouveau nom multi ou pas sans la valeur de la branche
    615                 $nouveau_nom = (($multi) ? '<multi>' : '') . $nouveau_nom . (($multi) ? '</multi>' : '');
    616                
    617         return $nouveau_nom;
    618 }
    619 
    620 
    621 // ----------------------- Analyses XML ---------------------------------
    622 
    623474// parse un fichier de source dont l'url est donnee
    624475// ce fichier est un fichier XML contenant <depot>...</depot>
     
    627478        include_spip('inc/xml');
    628479        include_spip('inc/distant');
     480        include_spip('inc/svp_outiller');
     481        // -- Les traitements du XML dependent de la DTD utilisee
     482        $traiteur =  'svp_dtd_' . _SVP_DTD_PLUGIN;
     483        include_spip('inc/'. $traiteur);
    629484
    630485        // On lit le fichier xml
     
    661516                // - cas 2 : c'est une archive non plugin, pas d'infos autres que celles de l'archive
    662517                if ($url = $c['file'][0]) {
    663                         if (is_array($c['plugin']))
    664                                 $plugin = svp_xml_parse_plugin($c['plugin'][0]);
     518                        if (is_array($c[_SVP_DTD_PLUGIN]))
     519                                $plugin = svp_xml_parse_plugin($c[_SVP_DTD_PLUGIN][0]);
    665520                        else
    666521                                $plugin = array();
     
    680535}
    681536
    682 
    683 // aplatit plusieurs cles d'un arbre xml dans un tableau
    684 // effectue un trim() au passage
    685 function svp_xml_aplatit_multiple($array, $arbre){
    686         $a = array();
    687         // array('uri','archive'=>'zip',...)
    688         foreach ($array as $i=>$n){
    689                 if (is_string($i)) $cle = $i;
    690                 else $cle = $n;
    691                 $a[$n] = trim(spip_xml_aplatit($arbre[$cle]));
    692         }
    693         return $a;     
    694 }
    695 
    696 
    697 // parse un plugin.xml genere par spip_xml_parse()
    698 // en un tableau plus facilement utilisable
    699 // cette fonction doit permettre de mapper des changements
    700 // de syntaxe entre plugin.xml et step
    701 function svp_xml_parse_plugin($arbre){
    702 
    703         if (!is_array($arbre))
    704                 return false;
    705        
    706         // on commence par les simples !
    707         $plug_arbre = svp_xml_aplatit_multiple(
    708                                 array('nom','icon','auteur','licence','version','version_base','etat','slogan','categorie','tags',
    709                                 'description','lien','options','fonctions','prefix','install'),
    710                                 $arbre);
    711         $plug_arbre['prefix'] = strtolower($plug_arbre['prefix']);
    712        
    713         // on continue avec les plus complexes...       
    714         // 1) balises avec attributs
    715         foreach (array(
    716                         'necessite'=>array('necessite', null),
    717                         'utilise'=>array('utilise', null),
    718                         'chemin'=>array('path', array('dir'=>'')))
    719                                 as $balise=>$p){
    720                 $params = $res = array();
    721                 // recherche de la balise et extraction des attributs
    722                 if (spip_xml_match_nodes(",^$balise,",$arbre, $res)){
    723                         foreach(array_keys($res) as $tag){
    724                                 list($tag,$att) = spip_xml_decompose_tag($tag);
    725                                 $params[] = $att;
    726                         }
    727                 }
    728                 // valeur par defaut
    729                 else {
    730                         if ($p[1]!==null)
    731                                 $params[] = $p[1];
    732                 }
    733                 $plug_arbre[$p[0]] = $params;           
    734         }
    735 
    736         return $plug_arbre;
    737 }
    738 
    739 
    740 // ----------------------- Recherches de plugins ---------------------------------
    741 
    742 function svp_rechercher_plugins_spip($phrase, $categorie, $etat, $depot, $version_spip='',
    743                                                                         $exclusions=array(), $afficher_exclusions=false, $doublon=false, $tri='nom') {
    744 
    745         include_spip('inc/rechercher');
    746        
    747         $plugins = array();
    748         $scores = array();
    749         $ids_paquets = array();
    750 
    751         // On prepare l'utilisation de la recherche en base SPIP en la limitant aux tables spip_plugins
    752         // et spip_paquets  si elle n'est pas vide
    753         if ($phrase) {
    754                 $liste = liste_des_champs();
    755                 $tables = array('plugin' => $liste['plugin'], 'paquet' => $liste['paquet']);
    756                 $options = array('jointures' => true, 'score' => true);
    757        
    758                 // On cherche dans tous les enregistrements de ces tables des correspondances les plugins qui
    759                 // correspondent a la phrase recherchee
    760                 // -- On obtient une liste d'id de plugins et d'id de paquets
    761                 $resultats = array('plugin' => array(), 'paquet' => array());
    762                 $resultats = recherche_en_base($phrase, $tables, $options);
    763                 // -- On prepare le tableau des scores avec les paquets trouves par la recherche
    764                 if ($resultats) {
    765                         // -- On convertit les id de plugins en id de paquets
    766                         $ids = array();
    767                         if ($resultats['plugin']) {
    768                                 $ids_plugin = array_keys($resultats['plugin']);
    769                                 $where[] = sql_in('id_plugin', $ids_plugin);
    770                                 $ids = sql_allfetsel('id_paquet, id_plugin', 'spip_paquets', $where);
    771                         }
    772                         // -- On prepare les listes des id de paquet et des scores de ces memes paquets
    773                         if ($resultats['paquet']) {
    774                                 $ids_paquets = array_keys($resultats['paquet']);
    775                                 foreach ($resultats['paquet'] as $_id => $_score) {
    776                                         $scores[$_id] = intval($resultats['paquet'][$_id]['score']);
    777                                 }
    778                         }
    779                         // -- On merge les deux tableaux de paquets sans doublon en mettant a jour un tableau des scores
    780                         foreach ($ids as $_ids) {
    781                                 $id_paquet = intval($_ids['id_paquet']);
    782                                 $id_plugin = intval($_ids['id_plugin']);
    783                                 if (array_search($id_paquet, $ids_paquets) === false) {
    784                                         $ids_paquets[] = $id_paquet;
    785                                         $scores[$id_paquet] = intval($resultats['plugin'][$id_plugin]['score']);
    786                                 }
    787                                 else {
    788                                         $scores[$id_paquet] = intval($resultats['paquet'][$id_paquet]['score'])
    789                                                                                 + intval($resultats['plugin'][$id_plugin]['score']);
    790                                 }
    791                         }
    792                 }
    793         }
    794 
    795         // Maintenant, on continue la recherche en appliquant, sur la liste des id de paquets,
    796         // les filtres complementaires : categorie, etat, exclusions et compatibilite spip
    797         // si on a bien trouve des resultats precedemment ou si aucune phrase n'a ete saisie
    798         // -- Preparation de la requete
    799         if (!$phrase OR $resultats) {
    800                 $from = array('spip_plugins AS t1', 'spip_paquets AS t2', 'spip_depots AS t3');
    801                 $select = array('t1.nom AS nom', 't1.slogan AS slogan', 't1.prefixe AS prefixe', 't1.id_plugin AS id_plugin',
    802                                                 't2.id_paquet AS id_paquet', 't2.description AS description', 't2.version_spip AS version_spip',
    803                                                 't2.auteur AS auteur', 't2.licence AS licence', 't2.etat AS etat',
    804                                                 't2.logo AS logo', 't2.version AS version', 't2.nom_archive AS nom_archive',
    805                                                 't3.url_archives AS url_archives', );
    806                 $where = array('t1.id_plugin=t2.id_plugin', 't2.id_depot=t3.id_depot');
    807                 if ($ids_paquets)
    808                         $where[] = sql_in('t2.id_paquet', $ids_paquets);
    809                 if (($categorie) AND ($categorie != 'toute_categorie'))
    810                         $where[] = 't1.categorie=' . sql_quote($categorie);
    811                 if (($etat) AND ($etat != 'tout_etat'))
    812                         $where[] = 't2.etat=' . sql_quote($etat);
    813                 if (($depot) AND ($depot != 'tout_depot'))
    814                         $where[] = 't2.id_depot=' . sql_quote($depot);
    815                 if ($exclusions AND !$afficher_exclusions)
    816                         $where[] = sql_in('t2.id_plugin', $exclusions, 'NOT');
    817        
    818                 if ($resultats = sql_select($select, $from, $where)) {
    819                         while ($paquets = sql_fetch($resultats)) {
    820                                 $prefixe = $paquets['prefixe'];
    821                                 $version = $paquets['version'];
    822                                 $nom = extraire_multi($paquets['nom']);
    823                                 $slogan = extraire_multi($paquets['slogan']);
    824                                 $description = extraire_multi($paquets['description']);
    825                                 if (svp_verifier_compatibilite_spip($paquets['version_spip'], $version_spip)) {
    826                                         // Le paquet remplit tous les criteres, on peut le selectionner
    827                                         // -- on utilise uniquement la langue du site
    828                                         $paquets['nom'] = $nom;
    829                                         $paquets['slogan'] = $slogan;
    830                                         $paquets['description'] = $description;
    831                                         // -- on ajoute le score si on a bien saisi une phrase
    832                                         if ($phrase)
    833                                                 $paquets['score'] = $scores[intval($paquets['id_paquet'])];
    834                                         else
    835                                                 $paquets['score'] = 0;
    836                                         // -- on construit l'url de l'archive
    837                                         $paquets['url_archive'] = $paquets['url_archives'] . '/' . $paquets['nom_archive'];
    838                                         // -- on gere les exclusions si elle doivent etre affichees
    839                                         if ($afficher_exclusions AND in_array($paquets['id_plugin'], $exclusions))
    840                                                 $paquets['installe'] = true;
    841                                         else
    842                                                 $paquets['installe'] = false;
    843                                         // -- On traite les doublons (meme plugin, versions differentes)
    844                                         if ($doublon)
    845                                                 // ajout systematique du paquet
    846                                                 $plugins[] = $paquets;
    847                                         else {
    848                                                 // ajout
    849                                                 // - si pas encore trouve
    850                                                 // - ou si sa version est inferieure (on garde que la derniere version)
    851                                                 if (!$plugins[$prefixe]
    852                                                 OR ($plugins[$prefixe] AND spip_version_compare($plugins[$prefixe]['version'], $version, '<'))) {
    853                                                         $plugins[$prefixe] = $paquets;
    854                                                 }
    855                                         }
    856                                 }
    857                         }
    858                 }
    859                
    860                 // On trie le tableau par score décroissant ou nom croissant
    861                 $fonction = 'svp_trier_par_' . $tri;
    862                 if ($doublon)
    863                         usort($plugins, $fonction);
    864                 else
    865                         uasort($plugins, $fonction);
    866         }
    867        
    868         return $plugins;
    869 }
    870 
    871 
    872 /**
    873  * Recuperation des id des plugins a exclure car deja installes
    874  *
    875  * @return array
    876  */
    877 function svp_lister_plugins_installes(){
    878 
    879         $ids = array();
    880 
    881         // On recupere la liste des plugins installes physiquement sur le site
    882         // Pour l'instant ce n'est pas possible avec les fonctions natives de SPIP
    883         // donc on se contente des plugins actifs
    884         // - liste des prefixes en lettres majuscules des plugins actifs
    885         include_spip('inc/plugin');
    886         $plugins = liste_plugin_actifs();
    887 
    888         // - liste des id de plugin correspondants
    889         //   Il se peut que certains plugins ne soient pas trouves dans la bdd car aucun zip n'est disponible
    890         //   (donc pas inclus dans archives.xml). C'est le cas des extensions du core
    891         $ids = sql_allfetsel('id_plugin', 'spip_plugins', sql_in('prefixe', array_keys($plugins)));
    892         $ids = array_map('reset', $ids);
    893         $ids = array_map('intval', $ids);
    894 
    895         return $ids;
    896 }
    897 
    898 
    899 /**
    900  * Test de la compatibilite du plugin avec une version donnee de SPIP
    901  *
    902  * @return boolean
    903  */
    904 function svp_verifier_compatibilite_spip($version, $version_spip) {
    905         include_spip('inc/plugin');
    906         if (!$version_spip)
    907                 $version_spip = $GLOBALS['spip_version_branche'].".".$GLOBALS['spip_version_code'];
    908         return plugin_version_compatible($version, $version_spip);
    909 }
    910 
    911 
    912 /**
    913  * Tri decroissant des resultats par score.
    914  * Cette fonction est appelee par un usort ou uasort
    915  *
    916  * @return int
    917  */
    918 function svp_trier_par_score($p1, $p2){
    919         if ($p1['score'] == $p2['score'])
    920                 $retour = 0;
    921         else
    922                 $retour = ($p1['score'] < $p2['score']) ? 1 : -1;
    923         return $retour;
    924 }
    925 
    926 
    927 /**
    928  * Tri croissant des resultats par nom.
    929  * Si le nom est identique on classe par version decroissante
    930  * Cette fonction est appelee par un usort ou uasort
    931  *
    932  * @return int
    933  */
    934 function svp_trier_par_nom($p1, $p2){
    935         $c1 = strcasecmp($p1['nom'], $p2['nom']);
    936         if ($c1 == 0) {
    937                 $c2 = spip_version_compare($p1['version'], $p1['version'], '<');
    938                 $retour = ($c2) ? 1 : -1;
    939         }
    940         else
    941                 $retour = ($c1 < 0) ? -1 : 1;
    942         return $retour;
    943 }
    944 
    945537?>
Note: See TracChangeset for help on using the changeset viewer.