4 * Déclarations de fonctions
6 * @plugin SVP pour SPIP
8 * @package SPIP\SVP\Fonctions
12 * Retourne un texte expliquant l'intervalle de compatibilité avec un plugin ou SPIP
14 * Retourne par exemple "2.0 <= SPIP < 3.1"
16 * @param string $intervalle
17 * L'intervalle tel que déclaré dans paquet.xml. Par exemple "[2.1;3.0.*]"
18 * @param string $logiciel
19 * Nom du plugin pour qui est cette intervalle
21 * Texte expliquant l'intervalle
23 function svp_afficher_intervalle($intervalle, $logiciel){
24 if (!strlen($intervalle)) return '';
25 if (!preg_match(',^[\[\(\]]([0-9.a-zRC\s\-]*)[;]([0-9.a-zRC\s\-\*]*)[\]\)\[]$,Uis',$intervalle,$regs)) return false;
27 $majeure = preg_replace(',\.99$,', '.*', $regs[2]);
28 $mineure_inc = $intervalle{0}=="[";
29 $majeure_inc = substr($intervalle,-1)=="]";
30 if (strlen($mineure)){
31 if (!strlen($majeure))
32 $version = $logiciel . ($mineure_inc ?
' ≥ ' : ' > ') . $mineure;
34 $version = $mineure . ($mineure_inc ?
' ≤ ' : ' < ') . $logiciel . ($majeure_inc ?
' ≤ ' : ' < ') . $majeure;
37 if (!strlen($majeure))
40 $version = $logiciel . ($majeure_inc ?
' ≤ ' : ' < ') . $majeure;
47 * Traduit un type d'état de plugin
49 * Si l'état n'existe pas, prendra par défaut 'developpement'
51 * @see plugin_etat_en_clair()
53 * Le type d'état (stable, test, ...)
55 * Traduction de l'état dans la langue en cours
57 function svp_afficher_etat($etat) {
58 include_spip('plugins/afficher_plugin');
59 return plugin_etat_en_clair($etat);
63 * Retourne un texte HTML présentant la liste des dépendances d'un plugin
65 * Des liens vers les plugins dépendants sont présents lorsque les plugins
66 * en dépendance sont connus dans notre base.
68 * @param string $balise_serialisee
69 * Informations des dépendances (tableau sérialisé) tel que stocké
70 * en base dans la table spip_paquets
71 * @param string $dependance
72 * Type de dépendances à afficher (necessite ou utilise).
73 * Une autre valeur indique qu'on demande la liste des librairies dépendantes.
75 * Séparateur entre les noms de dépendances
77 * Texte informant des dépendances
79 function svp_afficher_dependances($balise_serialisee, $dependance='necessite', $sep='<br />') {
82 $t = unserialize($balise_serialisee);
83 $dependances = $t[$dependance];
84 if (is_array($dependances)) {
87 foreach($dependances as $_compatibilite => $_dependance) {
88 $compatibilite = ($_compatibilite !== 0)
89 ?
_T('svp:info_compatibilite_dependance', array('compatibilite' => svp_afficher_intervalle($_compatibilite, 'SPIP')))
92 $texte .= ($texte ?
str_repeat($sep, 2) : '') . $compatibilite;
93 foreach ($_dependance as $_plugin) {
96 if (($dependance == 'necessite' ) OR ($dependance == 'utilise')) {
97 if ($plugin = sql_fetsel('id_plugin, nom', 'spip_plugins', 'prefixe=' . sql_quote($_plugin['nom']))) {
98 $logiciel = '<a href="' . generer_url_entite($plugin['id_plugin'], 'plugin') . '" title="' . _T('svp:bulle_aller_plugin') . '">' .
99 extraire_multi($plugin['nom']) . '</a>';
101 // Cas ou le plugin n'est pas encore dans la base SVP.
102 // On affiche son préfixe, cependant ce n'est pas un affichage devant perdurer
103 $logiciel = $_plugin['nom'];
106 if (isset($_plugin['compatibilite'])) {
107 $intervalle = svp_afficher_intervalle($_plugin['compatibilite'], $logiciel);
109 $texte .= ($intervalle) ?
$intervalle : $logiciel;
112 // On demande l'affichage des librairies
113 $texte .= '<a href="' . $_plugin['lien'] . '" title="' . _T('svp:bulle_telecharger_librairie') . '">' . $_plugin['nom'] . '</a>';
122 * Teste si un plugin possède des dépendances
124 * @param string $balise_serialisee
125 * Informations des dépendances (tableau sérialisé) tel que stocké
126 * en base dans la table spip_paquets
128 * Le plugin possède t'il des dépendances ?
130 function svp_dependances_existe($balise_serialisee) {
131 $dependances = unserialize($balise_serialisee);
132 foreach($dependances as $_dependance) {
142 * Retourne un texte HTML présentant les crédits d'un plugin
144 * Des liens vers les crédits sont présents lorsqu'ils sont déclarés
145 * dans le paquet.xml.
147 * @param string $balise_serialisee
148 * Informations des crédits (tableau sérialisé) tel que stocké
149 * en base dans la table spip_paquets
151 * Séparateur entre les différents crédits
153 * Texte informant des crédits
155 function svp_afficher_credits($balise_serialisee, $sep=', ') {
158 $credits = unserialize($balise_serialisee);
159 if (is_array($credits)) {
160 foreach ($credits as $_credit) {
163 // Si le credit en cours n'est pas un array c'est donc un copyright
165 (!is_array($_credit))
166 ?
PtoBR(propre($_credit)) // propre pour les [lien->url] des auteurs de plugin.xml ...
167 : ($_credit['url'] ?
'<a href="' . $_credit['url'] . '">' : '') .
169 ($_credit['url'] ?
'</a>' : '');
178 * Retourne un texte HTML présentant la liste des langues et traducteurs d'un plugin
180 * Des liens vers les traducteurs sont présents lorsqu'ils sont connus.
182 * @param array $langues
183 * Tableau code de langue => traducteurs
185 * Séparateur entre les différentes langues
187 * Texte informant des langues et traducteurs
189 function svp_afficher_langues($langues, $sep=', '){
193 foreach ($langues as $_code => $_traducteurs) {
196 $traducteurs_langue = array();
197 foreach ($_traducteurs as $_traducteur) {
198 if (is_array($_traducteur))
199 $traducteurs_langue[] =
200 ($_traducteur['lien'] ?
'<a href="' . $_traducteur['lien'] . '">' : '') .
201 $_traducteur['nom'] .
202 ($_traducteur['lien'] ?
'</a>' : '');
204 $texte .= $_code . (count($traducteurs_langue) > 0 ?
' (' . implode(', ', $traducteurs_langue) . ')' : '');
213 * Retourne un texte HTML présentant des statistiques d'un dépot
215 * Liste le nombre de plugins et de paquets d'un dépot
216 * Indique aussi le nombre de dépots si l'on ne demande pas de dépot particulier.
218 * @param int $id_depot
219 * Identifiant du dépot
221 * Code HTML présentant les statistiques du dépot
223 function svp_afficher_statistiques_globales($id_depot=0){
226 $total = svp_compter('depot', $id_depot);
228 // Si on filtre pas sur un depot alors on affiche le nombre de depots
229 $info = '<li id="stats-depot" class="item">
230 <div class="unit size4of5">' . ucfirst(trim(_T('svp:info_depots_disponibles', array('total_depots'=>'')))) . '</div>
231 <div class="unit size1of5 lastUnit">' . $total['depot'] . '</div>
234 // Compteur des plugins filtre ou pas par depot
235 $info .= '<li id="stats-plugin" class="item">
236 <div class="unit size4of5">' . ucfirst(trim(_T('svp:info_plugins_heberges', array('total_plugins'=>'')))) . '</div>
237 <div class="unit size1of5 lastUnit">' . $total['plugin'] . '</div>
239 // Compteur des paquets filtre ou pas par depot
240 $info .= '<li id="stats-paquet" class="item">
241 <div class="unit size4of5">' . ucfirst(trim(_T('svp:info_paquets_disponibles', array('total_paquets'=>'')))) . '</div>
242 <div class="unit size1of5 lastUnit">' . $total['paquet'] . '</div>
250 * Retourne un texte indiquant un nombre total de paquets
252 * Calcule le nombre de paquets correspondant à certaines contraintes,
253 * tel que l'appartenance à un certain dépot, une certaine catégorie
254 * ou une certaine branche de SPIP et retourne une phrase traduite
255 * tel que «78 paquets disponibles»
257 * @param int $id_depot
258 * Identifiant du dépot
259 * Zéro (par défaut) signifie ici : «dans tous les dépots distants»
260 * (id_dépot>0) et non «dans le dépot local»
261 * @param string $categorie
262 * Type de catégorie (auteur, communication, date...)
263 * @param string $compatible_spip
264 * Numéro de branche de SPIP. (3.0, 2.1, ...)
266 * Texte indiquant un nombre total de paquets
268 function svp_compter_telechargements($id_depot=0, $categorie='', $compatible_spip=''){
269 $total = svp_compter('paquet', $id_depot, $categorie, $compatible_spip);
270 $info = _T('svp:info_paquets_disponibles', array('total_paquets'=>$total['paquet']));
275 * Retourne un texte indiquant un nombre total de contributions pour un dépot
277 * Calcule différents totaux pour un dépot donné et retourne un texte
278 * de ces différents totaux. Les totaux correspondent par défaut aux
279 * plugins et paquets, mais l'on peut demander le total des autres contributions
280 * avec le second paramètre.
282 * @param int $id_depot
283 * Identifiant du dépot
284 * Zéro (par défaut) signifie ici : «dans tous les dépots distants»
285 * (id_dépot>0) et non «dans le dépot local»
286 * @param string $contrib
287 * Type de total demandé ('plugin' ou autre)
288 * Si 'plugin' : indique le nombre de plugins et de paquets du dépot
289 * Si autre chose : indique le nombre des autres contributions, c'est
290 * à dire des zips qui ne sont pas des plugins, comme certaines libraires ou
291 * certains jeux de squelettes.
293 * Texte indiquant certains totaux tel que nombre de plugins, nombre de paquets...
295 function svp_compter_depots($id_depot, $contrib='plugin'){
298 $total = svp_compter('depot', $id_depot);
300 $info = _T('svp:info_depots_disponibles', array('total_depots'=>$total['depot'])) . ', ' .
301 _T('svp:info_plugins_heberges', array('total_plugins'=>$total['plugin'])) . ', ' .
302 _T('svp:info_paquets_disponibles', array('total_paquets'=>$total['paquet']));
305 if ($contrib == 'plugin') {
306 $info = _T('svp:info_plugins_heberges', array('total_plugins'=>$total['plugin'])) . ', ' .
307 _T('svp:info_paquets_disponibles', array('total_paquets'=>$total['paquet']-$total['autre']));
310 $info = _T('svp:info_contributions_hebergees', array('total_autres'=>$total['autre']));
318 * Retourne un texte indiquant un nombre total de plugins
320 * Calcule le nombre de plugins correspondant à certaines contraintes,
321 * tel que l'appartenance à un certain dépot, une certaine catégorie
322 * ou une certaine branche de SPIP et retourne une phrase traduite
323 * tel que «64 plugins disponibles»
325 * @param int $id_depot
326 * Identifiant du dépot
327 * Zéro (par défaut) signifie ici : «dans tous les dépots distants»
328 * (id_dépot>0) et non «dans le dépot local»
329 * @param string $categorie
330 * Type de catégorie (auteur, communication, date...)
331 * @param string $compatible_spip
332 * Numéro de branche de SPIP. (3.0, 2.1, ...)
334 * Texte indiquant un nombre total de paquets
336 function svp_compter_plugins($id_depot=0, $categorie='', $compatible_spip='') {
337 $total = svp_compter('plugin', $id_depot, $categorie, $compatible_spip);
338 $info = _T('svp:info_plugins_disponibles', array('total_plugins'=>$total['plugin']));
344 * Compte le nombre de plugins, paquets ou autres contributions
345 * en fonction de l'entité demandée et de contraintes
347 * Calcule, pour un type d'entité demandé (depot, plugin, paquet, catégorie)
348 * leur nombre en fonction de certaines contraintes, tel que l'appartenance
349 * à un certain dépot, une certaine catégorie ou une certaine branche de SPIP.
351 * Lorsque l'entité demandée est un dépot, le tableau des totaux possède,
352 * en plus du nombre de dépots, le nombre de plugins et paquets.
355 * Attention le critère de compatibilite SPIP pris en compte est uniquement
356 * celui d'une branche SPIP
358 * @param string $entite
359 * De quoi veut-on obtenir des comptes. Peut être 'depot', 'plugin',
360 * 'paquet' ou 'categorie'
361 * @param int $id_depot
362 * Identifiant du dépot
363 * Zéro (par défaut) signifie ici : «dans tous les dépots distants»
364 * (id_dépot>0) et non «dans le dépot local»
365 * @param string $categorie
366 * Type de catégorie (auteur, communication, date...)
367 * @param string $compatible_spip
368 * Numéro de branche de SPIP. (3.0, 2.1, ...)
370 * Couples (entite => nombre).
372 function svp_compter($entite, $id_depot=0, $categorie='', $compatible_spip=''){
373 $compteurs = array();
378 $where[] = "t1.id_depot=" . sql_quote($id_depot);
380 $where[] = "t1.id_depot>0";
382 if ($entite == 'plugin') {
383 $from = 'spip_plugins AS t2, spip_depots_plugins AS t1';
384 $where[] = "t1.id_plugin=t2.id_plugin";
386 $where[] = "t2.categorie=" . sql_quote($categorie);
387 if ($compatible_spip) {
388 $creer_where = charger_fonction('where_compatible_spip', 'inc');
389 $where[] = $creer_where($compatible_spip, 't2', '>');
391 $compteurs['plugin'] = sql_count(sql_select('t2.id_plugin', $from, $where));
393 elseif ($entite == 'paquet') {
395 $ids = sql_allfetsel('id_plugin', 'spip_plugins', 'categorie='.sql_quote($categorie));
396 $ids = array_map('reset', $ids);
397 $where[] = sql_in('t1.id_plugin', $ids);
399 if ($compatible_spip) {
400 $creer_where = charger_fonction('where_compatible_spip', 'inc');
401 $where[] = $creer_where($compatible_spip, 't1', '>');
403 $compteurs['paquet'] = sql_countsel('spip_paquets AS t1', $where);
405 elseif ($entite == 'depot') {
406 $champs = array('COUNT(t1.id_depot) AS depot',
407 'SUM(t1.nbr_plugins) AS plugin',
408 'SUM(t1.nbr_paquets) AS paquet',
409 'SUM(t1.nbr_autres) AS autre');
410 $compteurs = sql_fetsel($champs, 'spip_depots AS t1', $where);
412 elseif ($entite == 'categorie') {
413 $from = array('spip_plugins AS t2');
414 $where_depot = $where[0];
417 $ids = sql_allfetsel('id_plugin', 'spip_depots_plugins AS t1', $where_depot);
418 $ids = array_map('reset', $ids);
419 $where[] = sql_in('t2.id_plugin', $ids);
421 if ($compatible_spip) {
422 $creer_where = charger_fonction('where_compatible_spip', 'inc');
423 $where[] = $creer_where($compatible_spip, 't2', '>');
426 $where[] = "t2.categorie=" . sql_quote($categorie);
428 $group_by = array('t2.categorie');
429 $compteurs['categorie'] = sql_countsel($from, $where, $group_by);
437 * Compile la balise #SVP_CATEGORIES
439 * Cette balise retourne un tableau listant chaque type de catégorie
440 * en index, associé à sa traduction en valeur.
442 * Accepte 2 paramètres :
443 * 1) le type du tri (ordre_cle ou ordre_alpha)
444 * 2) une catégorie (dans ce cas, limite le tableau à cette seule catégorie si elle existe)
448 * #SVP_CATEGORIES{ordre_alpha}
449 * #SVP_CATEGORIES{ordre_cle,auteur}
451 * @balise svp_categories
452 * @see calcul_svp_categories()
454 * Pile au niveau de la balise
456 * Pile complétée par le code à générer
458 function balise_SVP_CATEGORIES($p) {
459 // tri, peut être 'ordre_cle' ou 'ordre_alpha'
460 if (!$tri = interprete_argument_balise(1,$p)) {
461 $tri = "'ordre_cle'";
463 // catégorie (pour n'en prendre qu'une au lieu de toutes)
464 if (!$categorie = interprete_argument_balise(2,$p)) {
467 $p->code
= 'calcul_svp_categories(' . $tri . ',' . $categorie . ')';
472 * Retourne un tableau listant chaque type de catégorie
473 * en index, associé à sa traduction en valeur.
476 * Type de tri (ordre_cle ou ordre_alpha)
477 * @param string $categorie
478 * Restreindre le tableau de retour à cette catégorie si elle existe
480 * Couples (type de catégorie => Texte de la catégorie)
482 function calcul_svp_categories($tri='ordre_cle', $categorie='') {
485 include_spip('inc/svp_phraser'); // pour $GLOBALS['categories_plugin']
486 $svp_categories = $GLOBALS['categories_plugin'];
488 if (is_array($svp_categories)) {
489 if (($categorie) AND in_array($categorie, $svp_categories))
490 $retour[$categorie] = _T('svp:categorie_' . strtolower($categorie));
492 if ($tri == 'ordre_alpha') {
493 sort($svp_categories);
494 // On positionne l'absence de categorie en fin du tableau
495 $svp_categories[] = array_shift($svp_categories);
497 foreach ($svp_categories as $_alias)
498 $retour[$_alias] = svp_traduire_categorie($_alias);
507 * Compile la balise #SVP_BRANCHES_SPIP
509 * Cette balise retourne une liste des branches de SPIP
511 * Avec un paramètre indiquant une branche, la balise retourne
512 * une liste des bornes mini et maxi de cette branche.
515 * #SVP_BRANCHES_SPIP : array('1.9', '2.0', '2.1', ....)
516 * #SVP_BRANCHES_SPIP{3.0} : array('3.0.0', '3.0.99')
518 * @balise svp_branches_spip
519 * @see calcul_svp_branches_spip()
522 * Pile au niveau de la balise
524 * Pile complétée par le code à générer
526 function balise_SVP_BRANCHES_SPIP($p) {
527 // nom d'une branche en premier argument
528 if (!$branche = interprete_argument_balise(1,$p)) {
531 $p->code
= 'calcul_svp_branches_spip('.$branche.')';
536 * Retourne une liste des branches de SPIP, ou les bornes mini et maxi
537 * d'une branche donnée
539 * @param string $branche
540 * Branche dont on veut récupérer les bornes mini et maxi
542 * Liste des branches array('1.9', '2.0', '2.1', ....)
543 * ou liste mini et maxi d'une branche array('3.0.0', '3.0.99')
545 function calcul_svp_branches_spip($branche) {
548 include_spip('inc/svp_outiller'); // pour $GLOBALS['infos_branches_spip']
549 $svp_branches = $GLOBALS['infos_branches_spip'];
551 if (is_array($svp_branches)) {
552 if (($branche) AND in_array($branche, $svp_branches))
553 // On renvoie les bornes inf et sup de la branche specifiee
554 $retour = $svp_branches[$branche];
556 // On renvoie uniquement les numeros de branches
557 $retour = array_keys($svp_branches);
565 * Traduit un type de catégorie de plugin
567 * @param string $alias
568 * Type de catégorie (auteur, communication, date...)
570 * Titre complet et traduit de la catégorie
572 function svp_traduire_categorie($alias) {
575 $traduction = _T('svp:categorie_' . strtolower($alias));
581 * Traduit un type de dépot de plugin
583 * @param string $type
584 * Type de dépot (svn, git, manuel)
586 * Titre complet et traduit du type de dépot
588 function svp_traduire_type_depot($type) {
592 $traduction = _T('svp:info_type_depot_' . $type);
598 * Critère de compatibilité avec une version précise ou une branche de SPIP.
600 * Fonctionne sur les tables spip_paquets et spip_plugins
602 * Si aucune valeur n'est explicité dans le critère, tous les enregistrements
605 * Le ! (NOT) fonctionne sur le critère BRANCHE
607 * @critere compatible_spip
610 * {compatible_spip 2.0.8} ou {compatible_spip 1.9}
611 * {compatible_spip #ENV{vers}} ou {compatible_spip #ENV{vers, 1.9.2}}
612 * {compatible_spip #GET{vers}} ou {compatible_spip #GET{vers, 2.1}}
614 * @param string $idb Identifiant de la boucle
615 * @param array $boucles AST du squelette
616 * @param Critere $crit Paramètres du critère dans cette boucle
619 function critere_compatible_spip_dist($idb, &$boucles, $crit) {
621 $boucle = &$boucles[$idb];
622 $table = $boucle->id_table
;
624 // Si on utilise ! la fonction LOCATE doit retourner 0.
625 // -> utilise uniquement avec le critere BRANCHE
626 $op = ($crit->not
== '!') ?
'=' : '>';
629 // COMPATIBILITE SPIP
630 $creer_where = charger_fonction(\'where_compatible_spip\', \'inc\');';
632 // version/branche explicite dans l'appel du critere
633 if (isset($crit->param
[0][0])) {
634 $version = calculer_liste(array($crit->param
[0][0]), array(), $boucles, $boucle->id_parent
);
636 $where = $creer_where('.$version.', \''.$table.'\', \''.$op.'\');
639 // pas de version/branche explicite dans l'appel du critere
640 // on regarde si elle est dans le contexte
643 $version = isset($Pile[0][\'compatible_spip\']) ? $Pile[0][\'compatible_spip\'] : \'\';
644 $where = $creer_where($version, \''.$table.'\', \''.$op.'\');
648 $boucle->where
[] = '$where';
652 * Retourne la liste des plugins trouvés par une recherche
654 * @filtre construire_recherche_plugins
655 * @param string $phrase
656 * Texte de la recherche
657 * @param string $categorie
658 * Type de catégorie de plugin (auteur, date...)
659 * @param string $etat
660 * État de plugin (stable, test...)
661 * @param string|int $depot
662 * Identifiant de dépot
663 * @param bool|string $afficher_exclusions
664 * Afficher aussi les paquets déjà installés (true ou 'oui')
665 * ou ceux qui ne le sont pas (false) ?
666 * @param bool|string $afficher_doublons
667 * Afficher toutes les versions de paquet (true ou 'oui')
668 * ou seulement la plus récente (false) ?
670 * Tableau classé par pertinence de résultat
671 * - 'prefixe' => tableau de description du paquet (si pas de doublons demandé)
672 * - n => tableau de descriptions du paquet (si doublons autorisés)
674 function filtre_construire_recherche_plugins($phrase='', $categorie='', $etat='', $depot='', $afficher_exclusions=true, $afficher_doublons=false) {
676 // On traite les paramètres d'affichage
677 $afficher_exclusions = ($afficher_exclusions == 'oui') ?
true : false;
678 $afficher_doublons = ($afficher_doublons == 'oui') ?
true : false;
680 $tri = ($phrase) ?
'score' : 'nom';
681 $version_spip = $GLOBALS['spip_version_branche'].".".$GLOBALS['spip_version_code'];
683 // On recupere la liste des paquets:
684 // - sans doublons, ie on ne garde que la version la plus recente
685 // - correspondant a ces criteres
686 // - compatible avec la version SPIP installee sur le site
687 // - et n'etant pas deja installes (ces paquets peuvent toutefois etre affiches)
688 // tries par nom ou score
689 include_spip('inc/svp_rechercher');
690 $plugins = svp_rechercher_plugins_spip(
691 $phrase, $categorie, $etat, $depot, $version_spip,
692 svp_lister_plugins_installes(), $afficher_exclusions, $afficher_doublons, $tri);
699 * Retourne le nombre d'heures entre chaque actualisation
700 * si le cron est activé.
703 * Nombre d'heures (sinon 0)
705 function filtre_svp_periode_actualisation_depots() {
706 include_spip('genie/svp_taches_generales_cron');
707 return _SVP_CRON_ACTUALISATION_DEPOTS ? _SVP_PERIODE_ACTUALISATION_DEPOTS
: 0;
712 * Retourne 'x.y.z' à partir de '00x.00y.00z'
714 * Retourne la chaine de la version x.y.z sous sa forme initiale,
715 * sans remplissage à gauche avec des 0.
717 * @see normaliser_version()
718 * @param string $version_normalisee
719 * Numéro de version normalisée
721 * Numéro de version dénormalisée
723 function denormaliser_version($version_normalisee='') {
726 if ($version_normalisee) {
727 $v = explode('.', $version_normalisee);
728 foreach($v as $_nombre) {
729 $n = ltrim($_nombre, '0');
730 // On traite les cas du type 001.002.000-dev qui doivent etre transformes en 1.2.0-dev.
731 // Etant donne que la denormalisation est toujours effectuee sur une version normalisee on sait
732 // que le suffixe commence toujours pas '-'
733 $vn[] = ((strlen($n)>0) AND substr($n, 0, 1)!='-' ) ?
$n : "0$n";
735 $version = implode('.', $vn);
741 * Teste l'utilisation du répertoire auto des plugins.
743 * Ce répertoire permet de télécharger dedans des plugins
744 * lorsqu'il est présent.
747 * Le répertoire de chargement des plugins auto est-il présent
750 function test_plugins_auto() {
752 if (is_null($test)) {
753 include_spip('inc/plugin'); // pour _DIR_PLUGINS_AUTO
754 $test = (defined('_DIR_PLUGINS_AUTO') and _DIR_PLUGINS_AUTO
and is_writable(_DIR_PLUGINS_AUTO
));