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 * Type de lien affecté au plugin référencé dans la base locale. Prend les valeurs :
79 * - local : le lien pointe vers la page publique du plugin sur le site lui-même. Il faut
80 * donc que le site propose des pages publiques pour les plugins sinon une 404 sera affichée;
81 * - pluginspip : le lien pointe vers la page du plugin sur le site de référence Plugins SPIP;
82 * - non : aucun lien n'est affiché.
84 * Texte informant des dépendances
86 function svp_afficher_dependances($balise_serialisee, $dependance='necessite', $sep='<br />', $lien='local') {
89 $t = unserialize($balise_serialisee);
90 $dependances = $t[$dependance];
91 if (is_array($dependances)) {
94 foreach($dependances as $_compatibilite => $_dependance) {
95 $compatibilite = ($_compatibilite !== 0)
96 ?
_T('svp:info_compatibilite_dependance', array('compatibilite' => svp_afficher_intervalle($_compatibilite, 'SPIP')))
99 $texte .= ($texte ?
str_repeat($sep, 2) : '') . $compatibilite;
100 foreach ($_dependance as $_plugin) {
103 if (($dependance == 'necessite' ) OR ($dependance == 'utilise')) {
104 if ($plugin = sql_fetsel('id_plugin, nom', 'spip_plugins', 'prefixe=' . sql_quote($_plugin['nom']))) {
105 $nom = extraire_multi($plugin['nom']);
109 $url = ($lien == 'local')
110 ?
generer_url_entite($plugin['id_plugin'], 'plugin')
111 : "http://plugins.spip.net/{$_plugin['nom']}.html";
112 $bulle = _T('svp:bulle_aller_plugin');
113 $logiciel = '<a href="' . $url . '" title="' . $bulle . '">' . $nom . '</a>';
116 // Cas ou le plugin n'est pas encore dans la base SVP.
117 // On affiche son préfixe, cependant ce n'est pas un affichage devant perdurer
118 $logiciel = $_plugin['nom'];
121 if (isset($_plugin['compatibilite'])) {
122 $intervalle = svp_afficher_intervalle($_plugin['compatibilite'], $logiciel);
124 $texte .= ($intervalle) ?
$intervalle : $logiciel;
127 // On demande l'affichage des librairies
128 $texte .= '<a href="' . $_plugin['lien'] . '" title="' . _T('svp:bulle_telecharger_librairie') . '">' . $_plugin['nom'] . '</a>';
137 * Teste si un plugin possède des dépendances
139 * @param string $balise_serialisee
140 * Informations des dépendances (tableau sérialisé) tel que stocké
141 * en base dans la table spip_paquets
143 * Le plugin possède t'il des dépendances ?
145 function svp_dependances_existe($balise_serialisee) {
146 $dependances = unserialize($balise_serialisee);
147 foreach($dependances as $_dependance) {
157 * Retourne un texte HTML présentant les crédits d'un plugin
159 * Des liens vers les crédits sont présents lorsqu'ils sont déclarés
160 * dans le paquet.xml.
162 * @param string $balise_serialisee
163 * Informations des crédits (tableau sérialisé) tel que stocké
164 * en base dans la table spip_paquets
166 * Séparateur entre les différents crédits
168 * Texte informant des crédits
170 function svp_afficher_credits($balise_serialisee, $sep=', ') {
173 $credits = unserialize($balise_serialisee);
174 if (is_array($credits)) {
175 foreach ($credits as $_credit) {
178 // Si le credit en cours n'est pas un array c'est donc un copyright
180 (!is_array($_credit))
181 ?
PtoBR(propre($_credit)) // propre pour les [lien->url] des auteurs de plugin.xml ...
182 : ($_credit['url'] ?
'<a href="' . $_credit['url'] . '">' : '') .
184 ($_credit['url'] ?
'</a>' : '');
193 * Retourne un texte HTML présentant la liste des langues et traducteurs d'un plugin
195 * Des liens vers les traducteurs sont présents lorsqu'ils sont connus.
197 * @param array $langues
198 * Tableau code de langue => traducteurs
200 * Séparateur entre les différentes langues
202 * Texte informant des langues et traducteurs
204 function svp_afficher_langues($langues, $sep=', '){
208 foreach ($langues as $_code => $_traducteurs) {
211 $traducteurs_langue = array();
212 foreach ($_traducteurs as $_traducteur) {
213 if (is_array($_traducteur))
214 $traducteurs_langue[] =
215 ($_traducteur['lien'] ?
'<a href="' . $_traducteur['lien'] . '">' : '') .
216 $_traducteur['nom'] .
217 ($_traducteur['lien'] ?
'</a>' : '');
219 $texte .= $_code . (count($traducteurs_langue) > 0 ?
' (' . implode(', ', $traducteurs_langue) . ')' : '');
228 * Retourne un texte HTML présentant des statistiques d'un dépot
230 * Liste le nombre de plugins et de paquets d'un dépot
231 * Indique aussi le nombre de dépots si l'on ne demande pas de dépot particulier.
233 * @param int $id_depot
234 * Identifiant du dépot
236 * Code HTML présentant les statistiques du dépot
238 function svp_afficher_statistiques_globales($id_depot=0){
241 $total = svp_compter('depot', $id_depot);
243 // Si on filtre pas sur un depot alors on affiche le nombre de depots
244 $info = '<li id="stats-depot" class="item">
245 <div class="unit size4of5">' . ucfirst(trim(_T('svp:info_depots_disponibles', array('total_depots'=>'')))) . '</div>
246 <div class="unit size1of5 lastUnit">' . $total['depot'] . '</div>
249 // Compteur des plugins filtre ou pas par depot
250 $info .= '<li id="stats-plugin" class="item">
251 <div class="unit size4of5">' . ucfirst(trim(_T('svp:info_plugins_heberges', array('total_plugins'=>'')))) . '</div>
252 <div class="unit size1of5 lastUnit">' . $total['plugin'] . '</div>
254 // Compteur des paquets filtre ou pas par depot
255 $info .= '<li id="stats-paquet" class="item">
256 <div class="unit size4of5">' . ucfirst(trim(_T('svp:info_paquets_disponibles', array('total_paquets'=>'')))) . '</div>
257 <div class="unit size1of5 lastUnit">' . $total['paquet'] . '</div>
265 * Retourne un texte indiquant un nombre total de paquets
267 * Calcule le nombre de paquets correspondant à certaines contraintes,
268 * tel que l'appartenance à un certain dépot, une certaine catégorie
269 * ou une certaine branche de SPIP et retourne une phrase traduite
270 * tel que «78 paquets disponibles»
272 * @param int $id_depot
273 * Identifiant du dépot
274 * Zéro (par défaut) signifie ici : «dans tous les dépots distants»
275 * (id_dépot>0) et non «dans le dépot local»
276 * @param string $categorie
277 * Type de catégorie (auteur, communication, date...)
278 * @param string $compatible_spip
279 * Numéro de branche de SPIP. (3.0, 2.1, ...)
281 * Texte indiquant un nombre total de paquets
283 function svp_compter_telechargements($id_depot=0, $categorie='', $compatible_spip=''){
284 $total = svp_compter('paquet', $id_depot, $categorie, $compatible_spip);
285 $info = _T('svp:info_paquets_disponibles', array('total_paquets'=>$total['paquet']));
290 * Retourne un texte indiquant un nombre total de contributions pour un dépot
292 * Calcule différents totaux pour un dépot donné et retourne un texte
293 * de ces différents totaux. Les totaux correspondent par défaut aux
294 * plugins et paquets, mais l'on peut demander le total des autres contributions
295 * avec le second paramètre.
297 * @param int $id_depot
298 * Identifiant du dépot
299 * Zéro (par défaut) signifie ici : «dans tous les dépots distants»
300 * (id_dépot>0) et non «dans le dépot local»
301 * @param string $contrib
302 * Type de total demandé ('plugin' ou autre)
303 * Si 'plugin' : indique le nombre de plugins et de paquets du dépot
304 * Si autre chose : indique le nombre des autres contributions, c'est
305 * à dire des zips qui ne sont pas des plugins, comme certaines libraires ou
306 * certains jeux de squelettes.
308 * Texte indiquant certains totaux tel que nombre de plugins, nombre de paquets...
310 function svp_compter_depots($id_depot, $contrib='plugin'){
313 $total = svp_compter('depot', $id_depot);
315 $info = _T('svp:info_depots_disponibles', array('total_depots'=>$total['depot'])) . ', ' .
316 _T('svp:info_plugins_heberges', array('total_plugins'=>$total['plugin'])) . ', ' .
317 _T('svp:info_paquets_disponibles', array('total_paquets'=>$total['paquet']));
320 if ($contrib == 'plugin') {
321 $info = _T('svp:info_plugins_heberges', array('total_plugins'=>$total['plugin'])) . ', ' .
322 _T('svp:info_paquets_disponibles', array('total_paquets'=>$total['paquet']-$total['autre']));
325 $info = _T('svp:info_contributions_hebergees', array('total_autres'=>$total['autre']));
333 * Retourne un texte indiquant un nombre total de plugins
335 * Calcule le nombre de plugins correspondant à certaines contraintes,
336 * tel que l'appartenance à un certain dépot, une certaine catégorie
337 * ou une certaine branche de SPIP et retourne une phrase traduite
338 * tel que «64 plugins disponibles»
340 * @param int $id_depot
341 * Identifiant du dépot
342 * Zéro (par défaut) signifie ici : «dans tous les dépots distants»
343 * (id_dépot>0) et non «dans le dépot local»
344 * @param string $categorie
345 * Type de catégorie (auteur, communication, date...)
346 * @param string $compatible_spip
347 * Numéro de branche de SPIP. (3.0, 2.1, ...)
349 * Texte indiquant un nombre total de paquets
351 function svp_compter_plugins($id_depot=0, $categorie='', $compatible_spip='') {
352 $total = svp_compter('plugin', $id_depot, $categorie, $compatible_spip);
353 $info = _T('svp:info_plugins_disponibles', array('total_plugins'=>$total['plugin']));
359 * Compte le nombre de plugins, paquets ou autres contributions
360 * en fonction de l'entité demandée et de contraintes
362 * Calcule, pour un type d'entité demandé (depot, plugin, paquet, catégorie)
363 * leur nombre en fonction de certaines contraintes, tel que l'appartenance
364 * à un certain dépot, une certaine catégorie ou une certaine branche de SPIP.
366 * Lorsque l'entité demandée est un dépot, le tableau des totaux possède,
367 * en plus du nombre de dépots, le nombre de plugins et paquets.
370 * Attention le critère de compatibilite SPIP pris en compte est uniquement
371 * celui d'une branche SPIP
373 * @param string $entite
374 * De quoi veut-on obtenir des comptes. Peut être 'depot', 'plugin',
375 * 'paquet' ou 'categorie'
376 * @param int $id_depot
377 * Identifiant du dépot
378 * Zéro (par défaut) signifie ici : «dans tous les dépots distants»
379 * (id_dépot>0) et non «dans le dépot local»
380 * @param string $categorie
381 * Type de catégorie (auteur, communication, date...)
382 * @param string $compatible_spip
383 * Numéro de branche de SPIP. (3.0, 2.1, ...)
385 * Couples (entite => nombre).
387 function svp_compter($entite, $id_depot=0, $categorie='', $compatible_spip=''){
388 $compteurs = array();
393 $where[] = "t1.id_depot=" . sql_quote($id_depot);
395 $where[] = "t1.id_depot>0";
397 if ($entite == 'plugin') {
398 $from = 'spip_plugins AS t2, spip_depots_plugins AS t1';
399 $where[] = "t1.id_plugin=t2.id_plugin";
401 $where[] = "t2.categorie=" . sql_quote($categorie);
402 if ($compatible_spip) {
403 $creer_where = charger_fonction('where_compatible_spip', 'inc');
404 $where[] = $creer_where($compatible_spip, 't2', '>');
406 $compteurs['plugin'] = sql_count(sql_select('t2.id_plugin', $from, $where));
408 elseif ($entite == 'paquet') {
410 $ids = sql_allfetsel('id_plugin', 'spip_plugins', 'categorie='.sql_quote($categorie));
411 $ids = array_map('reset', $ids);
412 $where[] = sql_in('t1.id_plugin', $ids);
414 if ($compatible_spip) {
415 $creer_where = charger_fonction('where_compatible_spip', 'inc');
416 $where[] = $creer_where($compatible_spip, 't1', '>');
418 $compteurs['paquet'] = sql_countsel('spip_paquets AS t1', $where);
420 elseif ($entite == 'depot') {
421 $champs = array('COUNT(t1.id_depot) AS depot',
422 'SUM(t1.nbr_plugins) AS plugin',
423 'SUM(t1.nbr_paquets) AS paquet',
424 'SUM(t1.nbr_autres) AS autre');
425 $compteurs = sql_fetsel($champs, 'spip_depots AS t1', $where);
427 elseif ($entite == 'categorie') {
428 $from = array('spip_plugins AS t2');
429 $where_depot = $where[0];
432 $ids = sql_allfetsel('id_plugin', 'spip_depots_plugins AS t1', $where_depot);
433 $ids = array_map('reset', $ids);
434 $where[] = sql_in('t2.id_plugin', $ids);
436 if ($compatible_spip) {
437 $creer_where = charger_fonction('where_compatible_spip', 'inc');
438 $where[] = $creer_where($compatible_spip, 't2', '>');
441 $where[] = "t2.categorie=" . sql_quote($categorie);
443 $group_by = array('t2.categorie');
444 $compteurs['categorie'] = sql_countsel($from, $where, $group_by);
452 * Compile la balise #SVP_CATEGORIES
454 * Cette balise retourne un tableau listant chaque type de catégorie
455 * en index, associé à sa traduction en valeur.
457 * Accepte 2 paramètres :
458 * 1) le type du tri (ordre_cle ou ordre_alpha)
459 * 2) une catégorie (dans ce cas, limite le tableau à cette seule catégorie si elle existe)
463 * #SVP_CATEGORIES{ordre_alpha}
464 * #SVP_CATEGORIES{ordre_cle,auteur}
466 * @balise svp_categories
467 * @see calcul_svp_categories()
469 * Pile au niveau de la balise
471 * Pile complétée par le code à générer
473 function balise_SVP_CATEGORIES($p) {
474 // tri, peut être 'ordre_cle' ou 'ordre_alpha'
475 if (!$tri = interprete_argument_balise(1,$p)) {
476 $tri = "'ordre_cle'";
478 // catégorie (pour n'en prendre qu'une au lieu de toutes)
479 if (!$categorie = interprete_argument_balise(2,$p)) {
482 $p->code
= 'calcul_svp_categories(' . $tri . ',' . $categorie . ')';
487 * Retourne un tableau listant chaque type de catégorie
488 * en index, associé à sa traduction en valeur.
491 * Type de tri (ordre_cle ou ordre_alpha)
492 * @param string $categorie
493 * Restreindre le tableau de retour à cette catégorie si elle existe
495 * Couples (type de catégorie => Texte de la catégorie)
497 function calcul_svp_categories($tri='ordre_cle', $categorie='') {
500 include_spip('inc/svp_phraser'); // pour $GLOBALS['categories_plugin']
501 $svp_categories = $GLOBALS['categories_plugin'];
503 if (is_array($svp_categories)) {
504 if (($categorie) AND in_array($categorie, $svp_categories))
505 $retour[$categorie] = _T('svp:categorie_' . strtolower($categorie));
507 if ($tri == 'ordre_alpha') {
508 sort($svp_categories);
509 // On positionne l'absence de categorie en fin du tableau
510 $svp_categories[] = array_shift($svp_categories);
512 foreach ($svp_categories as $_alias)
513 $retour[$_alias] = svp_traduire_categorie($_alias);
522 * Compile la balise #SVP_BRANCHES_SPIP
524 * Cette balise retourne une liste des branches de SPIP
526 * Avec un paramètre indiquant une branche, la balise retourne
527 * une liste des bornes mini et maxi de cette branche.
530 * #SVP_BRANCHES_SPIP : array('1.9', '2.0', '2.1', ....)
531 * #SVP_BRANCHES_SPIP{3.0} : array('3.0.0', '3.0.99')
533 * @balise svp_branches_spip
534 * @see calcul_svp_branches_spip()
537 * Pile au niveau de la balise
539 * Pile complétée par le code à générer
541 function balise_SVP_BRANCHES_SPIP($p) {
542 // nom d'une branche en premier argument
543 if (!$branche = interprete_argument_balise(1,$p)) {
546 $p->code
= 'calcul_svp_branches_spip('.$branche.')';
551 * Retourne une liste des branches de SPIP, ou les bornes mini et maxi
552 * d'une branche donnée
554 * @param string $branche
555 * Branche dont on veut récupérer les bornes mini et maxi
557 * Liste des branches array('1.9', '2.0', '2.1', ....)
558 * ou liste mini et maxi d'une branche array('3.0.0', '3.0.99')
560 function calcul_svp_branches_spip($branche) {
563 include_spip('inc/svp_outiller'); // pour $GLOBALS['infos_branches_spip']
564 $svp_branches = $GLOBALS['infos_branches_spip'];
566 if (is_array($svp_branches)) {
567 if (($branche) AND in_array($branche, $svp_branches))
568 // On renvoie les bornes inf et sup de la branche specifiee
569 $retour = $svp_branches[$branche];
571 // On renvoie uniquement les numeros de branches
572 $retour = array_keys($svp_branches);
580 * Traduit un type de catégorie de plugin
582 * @param string $alias
583 * Type de catégorie (auteur, communication, date...)
585 * Titre complet et traduit de la catégorie
587 function svp_traduire_categorie($alias) {
590 $traduction = _T('svp:categorie_' . strtolower($alias));
596 * Traduit un type de dépot de plugin
598 * @param string $type
599 * Type de dépot (svn, git, manuel)
601 * Titre complet et traduit du type de dépot
603 function svp_traduire_type_depot($type) {
607 $traduction = _T('svp:info_type_depot_' . $type);
613 * Critère de compatibilité avec une version précise ou une branche de SPIP.
615 * Fonctionne sur les tables spip_paquets et spip_plugins
617 * Si aucune valeur n'est explicité dans le critère, tous les enregistrements
620 * Le ! (NOT) fonctionne sur le critère BRANCHE
622 * @critere compatible_spip
625 * {compatible_spip 2.0.8} ou {compatible_spip 1.9}
626 * {compatible_spip #ENV{vers}} ou {compatible_spip #ENV{vers, 1.9.2}}
627 * {compatible_spip #GET{vers}} ou {compatible_spip #GET{vers, 2.1}}
629 * @param string $idb Identifiant de la boucle
630 * @param array $boucles AST du squelette
631 * @param Critere $crit Paramètres du critère dans cette boucle
634 function critere_compatible_spip_dist($idb, &$boucles, $crit) {
636 $boucle = &$boucles[$idb];
637 $table = $boucle->id_table
;
639 // Si on utilise ! la fonction LOCATE doit retourner 0.
640 // -> utilise uniquement avec le critere BRANCHE
641 $op = ($crit->not
== '!') ?
'=' : '>';
644 // COMPATIBILITE SPIP
645 $creer_where = charger_fonction(\'where_compatible_spip\', \'inc\');';
647 // version/branche explicite dans l'appel du critere
648 if (isset($crit->param
[0][0])) {
649 $version = calculer_liste(array($crit->param
[0][0]), array(), $boucles, $boucle->id_parent
);
651 $where = $creer_where('.$version.', \''.$table.'\', \''.$op.'\');
654 // pas de version/branche explicite dans l'appel du critere
655 // on regarde si elle est dans le contexte
658 $version = isset($Pile[0][\'compatible_spip\']) ? $Pile[0][\'compatible_spip\'] : \'\';
659 $where = $creer_where($version, \''.$table.'\', \''.$op.'\');
663 $boucle->where
[] = '$where';
667 * Retourne la liste des plugins trouvés par une recherche
669 * @filtre construire_recherche_plugins
670 * @param string $phrase
671 * Texte de la recherche
672 * @param string $categorie
673 * Type de catégorie de plugin (auteur, date...)
674 * @param string $etat
675 * État de plugin (stable, test...)
676 * @param string|int $depot
677 * Identifiant de dépot
678 * @param bool|string $afficher_exclusions
679 * Afficher aussi les paquets déjà installés (true ou 'oui')
680 * ou ceux qui ne le sont pas (false) ?
681 * @param bool|string $afficher_doublons
682 * Afficher toutes les versions de paquet (true ou 'oui')
683 * ou seulement la plus récente (false) ?
685 * Tableau classé par pertinence de résultat
686 * - 'prefixe' => tableau de description du paquet (si pas de doublons demandé)
687 * - n => tableau de descriptions du paquet (si doublons autorisés)
689 function filtre_construire_recherche_plugins($phrase='', $categorie='', $etat='', $depot='', $afficher_exclusions=true, $afficher_doublons=false) {
691 // On traite les paramètres d'affichage
692 $afficher_exclusions = ($afficher_exclusions == 'oui') ?
true : false;
693 $afficher_doublons = ($afficher_doublons == 'oui') ?
true : false;
695 $tri = ($phrase) ?
'score' : 'nom';
696 $version_spip = $GLOBALS['spip_version_branche'].".".$GLOBALS['spip_version_code'];
698 // On recupere la liste des paquets:
699 // - sans doublons, ie on ne garde que la version la plus recente
700 // - correspondant a ces criteres
701 // - compatible avec la version SPIP installee sur le site
702 // - et n'etant pas deja installes (ces paquets peuvent toutefois etre affiches)
703 // tries par nom ou score
704 include_spip('inc/svp_rechercher');
705 $plugins = svp_rechercher_plugins_spip(
706 $phrase, $categorie, $etat, $depot, $version_spip,
707 svp_lister_plugins_installes(), $afficher_exclusions, $afficher_doublons, $tri);
714 * Retourne le nombre d'heures entre chaque actualisation
715 * si le cron est activé.
718 * Nombre d'heures (sinon 0)
720 function filtre_svp_periode_actualisation_depots() {
721 include_spip('genie/svp_taches_generales_cron');
722 return _SVP_CRON_ACTUALISATION_DEPOTS ? _SVP_PERIODE_ACTUALISATION_DEPOTS
: 0;
727 * Retourne 'x.y.z' à partir de '00x.00y.00z'
729 * Retourne la chaine de la version x.y.z sous sa forme initiale,
730 * sans remplissage à gauche avec des 0.
732 * @see normaliser_version()
733 * @param string $version_normalisee
734 * Numéro de version normalisée
736 * Numéro de version dénormalisée
738 function denormaliser_version($version_normalisee='') {
741 if ($version_normalisee) {
742 $v = explode('.', $version_normalisee);
743 foreach($v as $_nombre) {
744 $n = ltrim($_nombre, '0');
745 // On traite les cas du type 001.002.000-dev qui doivent etre transformes en 1.2.0-dev.
746 // Etant donne que la denormalisation est toujours effectuee sur une version normalisee on sait
747 // que le suffixe commence toujours pas '-'
748 $vn[] = ((strlen($n)>0) AND substr($n, 0, 1)!='-' ) ?
$n : "0$n";
750 $version = implode('.', $vn);
756 * Teste l'utilisation du répertoire auto des plugins.
758 * Ce répertoire permet de télécharger dedans des plugins
759 * lorsqu'il est présent.
762 * Le répertoire de chargement des plugins auto est-il présent
765 function test_plugins_auto() {
767 if (is_null($test)) {
768 include_spip('inc/plugin'); // pour _DIR_PLUGINS_AUTO
769 $test = (defined('_DIR_PLUGINS_AUTO') and _DIR_PLUGINS_AUTO
and is_writable(_DIR_PLUGINS_AUTO
));