4 * Déclarations de fonctions
6 * @plugin SVP pour SPIP
8 * @package SPIP\SVP\Fonctions
11 function svp_importer_charset($texte) {
12 if ($GLOBALS['meta']['charset'] == 'utf-8') {
16 return importer_charset($texte, 'utf-8');
20 * Retourne un texte expliquant l'intervalle de compatibilité avec un plugin ou SPIP
22 * Retourne par exemple "2.0 <= SPIP < 3.1"
24 * @param string $intervalle
25 * L'intervalle tel que déclaré dans paquet.xml. Par exemple "[2.1;3.0.*]"
26 * @param string $logiciel
27 * Nom du plugin pour qui est cette intervalle
29 * Texte expliquant l'intervalle
31 function svp_afficher_intervalle($intervalle, $logiciel) {
32 if (!strlen($intervalle)) {
35 if (!defined('_EXTRAIRE_INTERVALLE')) {
36 include_spip('inc/plugin');
38 if (!preg_match(_EXTRAIRE_INTERVALLE
. 'Uis', $intervalle, $regs)) {
43 $majeure = preg_replace(',\.99$,', '.*', $regs[2]);
44 $mineure_inc = $intervalle{0} == "[";
45 $majeure_inc = substr($intervalle, -1) == "]";
46 if (strlen($mineure)) {
47 if (!strlen($majeure)) {
48 $version = _T('svp:info_logiciel_version', array(
49 'logiciel' => $logiciel,
50 'signe' => ($mineure_inc ?
'≥' : '>'),
51 'version' => $mineure,
54 $version = _T('svp:info_logiciel_version_intervalle', array(
55 'logiciel' => $logiciel,
56 'signe_min' => ($mineure_inc ?
'≥' : '>'),
57 'version_min' => $mineure,
58 'signe_max' => ($majeure_inc ?
'≤' : '<'),
59 'version_max' => $majeure,
63 if (!strlen($majeure)) {
66 $version = _T('svp:info_logiciel_version', array(
67 'logiciel' => $logiciel,
68 'signe' => ($majeure_inc ?
'≤' : '<'),
69 'version' => $majeure,
78 * Traduit un type d'état de plugin
80 * Si l'état n'existe pas, prendra par défaut 'developpement'
82 * @see plugin_etat_en_clair()
84 * Le type d'état (stable, test, ...)
86 * Traduction de l'état dans la langue en cours
88 function svp_afficher_etat($etat) {
89 include_spip('plugins/afficher_plugin');
91 return plugin_etat_en_clair($etat);
95 * Retourne un texte HTML présentant la liste des dépendances d'un plugin
97 * Des liens vers les plugins dépendants sont présents lorsque les plugins
98 * en dépendance sont connus dans notre base.
100 * @uses svp_afficher_intervalle()
101 * @param string $balise_serialisee
102 * Informations des dépendances (tableau sérialisé) tel que stocké
103 * en base dans la table spip_paquets
104 * @param string $dependance
105 * Type de dépendances à afficher (necessite ou utilise).
106 * Une autre valeur indique qu'on demande la liste des librairies dépendantes.
108 * Séparateur entre les noms de dépendances
109 * @param string $lien
110 * Type de lien affecté au plugin référencé dans la base locale. Prend les valeurs :
112 * - local : le lien pointe vers la page publique du plugin sur le site lui-même. Il faut
113 * donc que le site propose des pages publiques pour les plugins sinon une 404 sera affichée;
114 * - pluginspip : le lien pointe vers la page du plugin sur le site de référence Plugins SPIP;
115 * - non : aucun lien n'est affiché.
117 * Texte informant des dépendances
119 function svp_afficher_dependances($balise_serialisee, $dependance = 'necessite', $sep = '<br />', $lien = 'local') {
122 $t = unserialize($balise_serialisee);
123 $dependances = $t[$dependance];
124 if (is_array($dependances)) {
127 foreach ($dependances as $_compatibilite => $_dependance) {
128 $compatibilite = ($_compatibilite !== 0)
129 ?
_T('svp:info_compatibilite_dependance',
130 array('compatibilite' => svp_afficher_intervalle($_compatibilite, 'SPIP')))
132 if ($compatibilite) {
133 $texte .= ($texte ?
str_repeat($sep, 2) : '') . $compatibilite;
135 foreach ($_dependance as $_plugin) {
139 if (($dependance == 'necessite') or ($dependance == 'utilise')) {
140 if ($plugin = sql_fetsel('id_plugin, nom', 'spip_plugins', 'prefixe=' . sql_quote($_plugin['nom']))) {
141 $nom = extraire_multi($plugin['nom']);
142 if ($lien == 'non') {
145 $url = ($lien == 'local')
146 ?
generer_url_entite($plugin['id_plugin'], 'plugin')
147 : "https://plugins.spip.net/{$_plugin['nom']}.html";
148 $bulle = _T('svp:bulle_aller_plugin');
149 $logiciel = '<a href="' . $url . '" title="' . $bulle . '">' . $nom . '</a>';
152 // Cas ou le plugin n'est pas encore dans la base SVP.
153 // On affiche son préfixe, cependant ce n'est pas un affichage devant perdurer
154 $logiciel = $_plugin['nom'];
157 if (isset($_plugin['compatibilite'])) {
158 $intervalle = svp_afficher_intervalle($_plugin['compatibilite'], $logiciel);
160 $texte .= ($intervalle) ?
$intervalle : $logiciel;
161 } else // On demande l'affichage des librairies
163 $texte .= '<a href="' . $_plugin['lien'] . '" title="' . _T('svp:bulle_telecharger_librairie') . '">' . $_plugin['nom'] . '</a>';
173 * Teste si un plugin possède des dépendances
175 * @param string $balise_serialisee
176 * Informations des dépendances (tableau sérialisé) tel que stocké
177 * en base dans la table spip_paquets
179 * Le plugin possède t'il des dépendances ?
181 function svp_dependances_existe($balise_serialisee) {
182 $dependances = unserialize($balise_serialisee);
183 foreach ($dependances as $_dependance) {
194 * Retourne un texte HTML présentant les crédits d'un plugin
196 * Des liens vers les crédits sont présents lorsqu'ils sont déclarés
197 * dans le paquet.xml.
199 * @param string $balise_serialisee
200 * Informations des crédits (tableau sérialisé) tel que stocké
201 * en base dans la table spip_paquets
203 * Séparateur entre les différents crédits
205 * Texte informant des crédits
207 function svp_afficher_credits($balise_serialisee, $sep = ', ') {
210 $credits = unserialize($balise_serialisee);
211 if (is_array($credits)) {
212 foreach ($credits as $_credit) {
216 // Si le credit en cours n'est pas un array c'est donc un copyright
218 (!is_array($_credit))
219 ?
PtoBR(propre($_credit)) // propre pour les [lien->url] des auteurs de plugin.xml ...
220 : ($_credit['url'] ?
'<a href="' . $_credit['url'] . '">' : '') .
222 ($_credit['url'] ?
'</a>' : '');
231 * Retourne un texte HTML présentant la liste des langues et traducteurs d'un plugin
233 * Des liens vers les traducteurs sont présents lorsqu'ils sont connus.
235 * @param array $langues
236 * Tableau code de langue => traducteurs
238 * Séparateur entre les différentes langues
240 * Texte informant des langues et traducteurs
242 function svp_afficher_langues($langues, $sep = ', ') {
246 foreach ($langues as $_code => $_traducteurs) {
250 $traducteurs_langue = array();
251 foreach ($_traducteurs as $_traducteur) {
252 if (is_array($_traducteur)) {
253 $traducteurs_langue[] =
254 ($_traducteur['lien'] ?
'<a href="' . $_traducteur['lien'] . '">' : '') .
255 $_traducteur['nom'] .
256 ($_traducteur['lien'] ?
'</a>' : '');
259 $texte .= $_code . (count($traducteurs_langue) > 0 ?
' (' . implode(', ', $traducteurs_langue) . ')' : '');
268 * Retourne un texte HTML présentant des statistiques d'un dépot
270 * Liste le nombre de plugins et de paquets d'un dépot
271 * Indique aussi le nombre de dépots si l'on ne demande pas de dépot particulier.
273 * @uses svp_compter()
274 * @param int $id_depot
275 * Identifiant du dépot
277 * Code HTML présentant les statistiques du dépot
279 function svp_afficher_statistiques_globales($id_depot = 0) {
282 $total = svp_compter('depot', $id_depot);
284 // Si on filtre pas sur un depot alors on affiche le nombre de depots
285 $info = '<li id="stats-depot" class="item">
286 <div class="unit size4of5">' . ucfirst(trim(_T('svp:info_depots_disponibles', array('total_depots' => '')))) . '</div>
287 <div class="unit size1of5 lastUnit">' . $total['depot'] . '</div>
290 // Compteur des plugins filtre ou pas par depot
291 $info .= '<li id="stats-plugin" class="item">
292 <div class="unit size4of5">' . ucfirst(trim(_T('svp:info_plugins_heberges', array('total_plugins' => '')))) . '</div>
293 <div class="unit size1of5 lastUnit">' . $total['plugin'] . '</div>
295 // Compteur des paquets filtre ou pas par depot
296 $info .= '<li id="stats-paquet" class="item">
297 <div class="unit size4of5">' . ucfirst(trim(_T('svp:info_paquets_disponibles', array('total_paquets' => '')))) . '</div>
298 <div class="unit size1of5 lastUnit">' . $total['paquet'] . '</div>
306 * Retourne un texte indiquant un nombre total de paquets
308 * Calcule le nombre de paquets correspondant à certaines contraintes,
309 * tel que l'appartenance à un certain dépot, une certaine catégorie
310 * ou une certaine branche de SPIP et retourne une phrase traduite
311 * tel que «78 paquets disponibles»
313 * @uses svp_compter()
314 * @param int $id_depot
315 * Identifiant du dépot
316 * Zéro (par défaut) signifie ici : «dans tous les dépots distants»
317 * (id_dépot>0) et non «dans le dépot local»
318 * @param string $categorie
319 * Type de catégorie (auteur, communication, date...)
320 * @param string $compatible_spip
321 * Numéro de branche de SPIP. (3.0, 2.1, ...)
323 * Texte indiquant un nombre total de paquets
325 function svp_compter_telechargements($id_depot = 0, $categorie = '', $compatible_spip = '') {
326 $total = svp_compter('paquet', $id_depot, $categorie, $compatible_spip);
327 $info = _T('svp:info_paquets_disponibles', array('total_paquets' => $total['paquet']));
333 * Retourne un texte indiquant un nombre total de contributions pour un dépot
335 * Calcule différents totaux pour un dépot donné et retourne un texte
336 * de ces différents totaux. Les totaux correspondent par défaut aux
337 * plugins et paquets, mais l'on peut demander le total des autres contributions
338 * avec le second paramètre.
340 * @uses svp_compter()
341 * @param int $id_depot
342 * Identifiant du dépot
343 * Zéro (par défaut) signifie ici : «dans tous les dépots distants»
344 * (id_dépot>0) et non «dans le dépot local»
345 * @param string $contrib
346 * Type de total demandé ('plugin' ou autre)
347 * Si 'plugin' : indique le nombre de plugins et de paquets du dépot
348 * Si autre chose : indique le nombre des autres contributions, c'est
349 * à dire des zips qui ne sont pas des plugins, comme certaines libraires ou
350 * certains jeux de squelettes.
352 * Texte indiquant certains totaux tel que nombre de plugins, nombre de paquets...
354 function svp_compter_depots($id_depot, $contrib = 'plugin') {
357 $total = svp_compter('depot', $id_depot);
359 $info = _T('svp:info_depots_disponibles', array('total_depots' => $total['depot'])) . ', ' .
360 _T('svp:info_plugins_heberges', array('total_plugins' => $total['plugin'])) . ', ' .
361 _T('svp:info_paquets_disponibles', array('total_paquets' => $total['paquet']));
363 if ($contrib == 'plugin') {
364 $info = _T('svp:info_plugins_heberges', array('total_plugins' => $total['plugin'])) . ', ' .
365 _T('svp:info_paquets_disponibles', array('total_paquets' => $total['paquet'] - $total['autre']));
367 $info = _T('svp:info_contributions_hebergees', array('total_autres' => $total['autre']));
376 * Retourne un texte indiquant un nombre total de plugins
378 * Calcule le nombre de plugins correspondant à certaines contraintes,
379 * tel que l'appartenance à un certain dépot, une certaine catégorie
380 * ou une certaine branche de SPIP et retourne une phrase traduite
381 * tel que «64 plugins disponibles»
383 * @uses svp_compter()
384 * @param int $id_depot
385 * Identifiant du dépot
386 * Zéro (par défaut) signifie ici : «dans tous les dépots distants»
387 * (id_dépot>0) et non «dans le dépot local»
388 * @param string $categorie
389 * Type de catégorie (auteur, communication, date...)
390 * @param string $compatible_spip
391 * Numéro de branche de SPIP. (3.0, 2.1, ...)
393 * Texte indiquant un nombre total de paquets
395 function svp_compter_plugins($id_depot = 0, $categorie = '', $compatible_spip = '') {
396 $total = svp_compter('plugin', $id_depot, $categorie, $compatible_spip);
397 $info = _T('svp:info_plugins_disponibles', array('total_plugins' => $total['plugin']));
404 * Compte le nombre de plugins, paquets ou autres contributions
405 * en fonction de l'entité demandée et de contraintes
407 * Calcule, pour un type d'entité demandé (depot, plugin, paquet, catégorie)
408 * leur nombre en fonction de certaines contraintes, tel que l'appartenance
409 * à un certain dépot, une certaine catégorie ou une certaine branche de SPIP.
411 * Lorsque l'entité demandée est un dépot, le tableau des totaux possède,
412 * en plus du nombre de dépots, le nombre de plugins et paquets.
415 * Attention le critère de compatibilite SPIP pris en compte est uniquement
416 * celui d'une branche SPIP
418 * @param string $entite
419 * De quoi veut-on obtenir des comptes. Peut être 'depot', 'plugin',
420 * 'paquet' ou 'categorie'
421 * @param int $id_depot
422 * Identifiant du dépot
423 * Zéro (par défaut) signifie ici : «dans tous les dépots distants»
424 * (id_dépot>0) et non «dans le dépot local»
425 * @param string $categorie
426 * Type de catégorie (auteur, communication, date...)
427 * @param string $compatible_spip
428 * Numéro de branche de SPIP. (3.0, 2.1, ...)
430 * Couples (entite => nombre).
432 function svp_compter($entite, $id_depot = 0, $categorie = '', $compatible_spip = '') {
433 $compteurs = array();
438 $where[] = "t1.id_depot=" . sql_quote($id_depot);
440 $where[] = "t1.id_depot>0";
443 if ($entite == 'plugin') {
444 $from = 'spip_plugins AS t2, spip_depots_plugins AS t1';
445 $where[] = "t1.id_plugin=t2.id_plugin";
447 $where[] = "t2.categorie=" . sql_quote($categorie);
449 if ($compatible_spip) {
450 $creer_where = charger_fonction('where_compatible_spip', 'inc');
451 $where[] = $creer_where($compatible_spip, 't2', '>');
453 $compteurs['plugin'] = sql_count(sql_select('t2.id_plugin', $from, $where));
454 } elseif ($entite == 'paquet') {
456 $ids = sql_allfetsel('id_plugin', 'spip_plugins', 'categorie=' . sql_quote($categorie));
457 $ids = array_map('reset', $ids);
458 $where[] = sql_in('t1.id_plugin', $ids);
460 if ($compatible_spip) {
461 $creer_where = charger_fonction('where_compatible_spip', 'inc');
462 $where[] = $creer_where($compatible_spip, 't1', '>');
464 $compteurs['paquet'] = sql_countsel('spip_paquets AS t1', $where);
465 } elseif ($entite == 'depot') {
467 'COUNT(t1.id_depot) AS depot',
468 'SUM(t1.nbr_plugins) AS plugin',
469 'SUM(t1.nbr_paquets) AS paquet',
470 'SUM(t1.nbr_autres) AS autre'
472 $compteurs = sql_fetsel($champs, 'spip_depots AS t1', $where);
473 } elseif ($entite == 'categorie') {
474 $from = array('spip_plugins AS t2');
475 $where_depot = $where[0];
478 $ids = sql_allfetsel('id_plugin', 'spip_depots_plugins AS t1', $where_depot);
479 $ids = array_map('reset', $ids);
480 $where[] = sql_in('t2.id_plugin', $ids);
482 if ($compatible_spip) {
483 $creer_where = charger_fonction('where_compatible_spip', 'inc');
484 $where[] = $creer_where($compatible_spip, 't2', '>');
487 $where[] = "t2.categorie=" . sql_quote($categorie);
489 $group_by = array('t2.categorie');
491 $compteurs['categorie'] = sql_countsel($from, $where, $group_by);
499 * Compile la balise `#SVP_CATEGORIES`
501 * Cette balise retourne un tableau listant chaque type de catégorie
502 * en index, associé à sa traduction en valeur.
504 * Accepte 2 paramètres :
505 * 1) le type du tri (ordre_cle ou ordre_alpha)
506 * 2) une catégorie (dans ce cas, limite le tableau à cette seule catégorie si elle existe)
510 * #SVP_CATEGORIES{ordre_alpha}
511 * #SVP_CATEGORIES{ordre_cle,auteur}
514 * @see calcul_svp_categories()
516 * Pile au niveau de la balise
518 * Pile complétée par le code à générer
520 function balise_SVP_CATEGORIES($p) {
521 // tri, peut être 'ordre_cle' ou 'ordre_alpha'
522 if (!$tri = interprete_argument_balise(1, $p)) {
523 $tri = "'ordre_cle'";
525 // catégorie (pour n'en prendre qu'une au lieu de toutes)
526 if (!$categorie = interprete_argument_balise(2, $p)) {
529 $p->code
= 'calcul_svp_categories(' . $tri . ',' . $categorie . ')';
535 * Retourne un tableau listant chaque type de catégorie
536 * en index, associé à sa traduction en valeur.
538 * @uses svp_traduire_categorie()
541 * Type de tri (ordre_cle ou ordre_alpha)
542 * @param string $categorie
543 * Restreindre le tableau de retour à cette catégorie si elle existe
545 * Couples (type de catégorie => Texte de la catégorie)
547 function calcul_svp_categories($tri = 'ordre_cle', $categorie = '') {
550 include_spip('inc/svp_phraser'); // pour $GLOBALS['categories_plugin']
551 $svp_categories = $GLOBALS['categories_plugin'];
553 if (is_array($svp_categories)) {
554 if (($categorie) and in_array($categorie, $svp_categories)) {
555 $retour[$categorie] = _T('svp:categorie_' . strtolower($categorie));
557 if ($tri == 'ordre_alpha') {
558 sort($svp_categories);
559 // On positionne l'absence de categorie en fin du tableau
560 $svp_categories[] = array_shift($svp_categories);
562 foreach ($svp_categories as $_alias) {
563 $retour[$_alias] = svp_traduire_categorie($_alias);
573 * Compile la balise `#SVP_BRANCHES_SPIP`
575 * Cette balise retourne une liste des branches de SPIP
577 * Avec un paramètre indiquant une branche, la balise retourne
578 * une liste des bornes mini et maxi de cette branche.
581 * #SVP_BRANCHES_SPIP : array('1.9', '2.0', '2.1', ....)
582 * #SVP_BRANCHES_SPIP{3.0} : array('3.0.0', '3.0.99')
585 * @see calcul_svp_branches_spip()
588 * Pile au niveau de la balise
590 * Pile complétée par le code à générer
592 function balise_SVP_BRANCHES_SPIP($p) {
593 // nom d'une branche en premier argument
594 if (!$branche = interprete_argument_balise(1, $p)) {
597 $p->code
= 'calcul_svp_branches_spip(' . $branche . ')';
603 * Retourne une liste des branches de SPIP, ou les bornes mini et maxi
604 * d'une branche donnée
606 * @param string $branche
607 * Branche dont on veut récupérer les bornes mini et maxi
609 * Liste des branches array('1.9', '2.0', '2.1', ....)
610 * ou liste mini et maxi d'une branche array('3.0.0', '3.0.99')
612 function calcul_svp_branches_spip($branche) {
615 include_spip('inc/svp_outiller'); // pour $GLOBALS['infos_branches_spip']
616 $svp_branches = $GLOBALS['infos_branches_spip'];
618 if (is_array($svp_branches)) {
619 if (($branche) and in_array($branche, $svp_branches)) // On renvoie les bornes inf et sup de la branche specifiee
621 $retour = $svp_branches[$branche];
623 // On renvoie uniquement les numeros de branches
624 $retour = array_keys($svp_branches);
632 * Traduit un type de catégorie de plugin
634 * @param string $alias
635 * Type de catégorie (auteur, communication, date...)
637 * Titre complet et traduit de la catégorie
639 function svp_traduire_categorie($alias) {
642 $traduction = _T('svp:categorie_' . strtolower($alias));
649 * Traduit un type de dépot de plugin
651 * @param string $type
652 * Type de dépot (svn, git, manuel)
654 * Titre complet et traduit du type de dépot
656 function svp_traduire_type_depot($type) {
660 $traduction = _T('svp:info_type_depot_' . $type);
667 * Calcule l'url exacte d'un lien de démo en fonction de son écriture
669 * @param string $url_demo
670 * URL de démonstration telle que saisie dans le paquet.xml
671 * @param boolean $url_absolue
672 * Indique que seules les url absolues doivent être retournées par la fonction.
673 * Tous les autres types d'url renvoient une chaine vide
675 * URL calculée en fonction de l'URL d'entrée
677 function svp_calculer_url_demo($url_demo, $url_absolue = false) {
680 $url_demo = trim($url_demo);
681 if (strlen($url_demo) > 0) {
682 $url_elements = @parse_url
($url_demo);
683 if (isset($url_elements['scheme']) and $url_elements['scheme']) {
684 // Cas 1 : http://xxxx. C'est donc une url absolue que l'on conserve telle qu'elle.
685 $url_calculee = $url_demo;
688 if (isset($url_elements['query']) and $url_elements['query']) {
689 // Cas 2 : ?exec=xxx ou ?page=yyy. C'est donc une url relative que l'on transforme
690 // en url absolue privée ou publique en fonction de la query.
691 $egal = strpos($url_elements['query'], '=');
692 $page = substr($url_elements['query'], $egal +
1, strlen($url_elements['query']) - $egal - 1);
693 if (strpos($url_elements['query'], 'exec=') !== false) {
694 $url_calculee = generer_url_ecrire($page);
696 $url_calculee = generer_url_public($page);
698 } elseif (isset($url_elements['path']) and $url_elements['path']) {
699 // Cas 3 : xxx/yyy. C'est donc une url relative que l'on transforme
700 $url_calculee = generer_url_public($url_demo);
706 return $url_calculee;
710 * Critère de compatibilité avec une version précise ou une branche de SPIP.
712 * Fonctionne sur les tables spip_paquets et spip_plugins
714 * Si aucune valeur n'est explicité dans le critère, tous les enregistrements
717 * Le ! (NOT) fonctionne sur le critère BRANCHE
722 * {compatible_spip 2.0.8} ou {compatible_spip 1.9}
723 * {compatible_spip #ENV{vers}} ou {compatible_spip #ENV{vers, 1.9.2}}
724 * {compatible_spip #GET{vers}} ou {compatible_spip #GET{vers, 2.1}}
726 * @param string $idb Identifiant de la boucle
727 * @param array $boucles AST du squelette
728 * @param Critere $crit Paramètres du critère dans cette boucle
731 function critere_compatible_spip_dist($idb, &$boucles, $crit) {
733 $boucle = &$boucles[$idb];
734 $table = $boucle->id_table
;
736 // Si on utilise ! la fonction LOCATE doit retourner 0.
737 // -> utilise uniquement avec le critere BRANCHE
738 $op = ($crit->not
== '!') ?
'=' : '>';
741 // COMPATIBILITE SPIP
742 $creer_where = charger_fonction(\'where_compatible_spip\', \'inc\');';
744 // version/branche explicite dans l'appel du critere
745 if (isset($crit->param
[0][0])) {
746 $version = calculer_liste(array($crit->param
[0][0]), array(), $boucles, $boucle->id_parent
);
748 $where = $creer_where(' . $version . ', \'' . $table . '\', \'' . $op . '\');
751 // pas de version/branche explicite dans l'appel du critere
752 // on regarde si elle est dans le contexte
755 $version = isset($Pile[0][\'compatible_spip\']) ? $Pile[0][\'compatible_spip\'] : \'\';
756 $where = $creer_where($version, \'' . $table . '\', \'' . $op . '\');
760 $boucle->where
[] = '$where';
764 * Retourne la liste des plugins trouvés par une recherche
767 * @param string $phrase
768 * Texte de la recherche
769 * @param string $categorie
770 * Type de catégorie de plugin (auteur, date...)
771 * @param string $etat
772 * État de plugin (stable, test...)
773 * @param string|int $depot
774 * Identifiant de dépot
775 * @param bool|string $afficher_exclusions
776 * Afficher aussi les paquets déjà installés (true ou 'oui')
777 * ou ceux qui ne le sont pas (false) ?
778 * @param bool|string $afficher_doublons
779 * Afficher toutes les versions de paquet (true ou 'oui')
780 * ou seulement la plus récente (false) ?
782 * Tableau classé par pertinence de résultat
783 * - 'prefixe' => tableau de description du paquet (si pas de doublons demandé)
784 * - n => tableau de descriptions du paquet (si doublons autorisés)
786 function filtre_construire_recherche_plugins(
791 $afficher_exclusions = true,
792 $afficher_doublons = false
795 // On traite les paramètres d'affichage
796 $afficher_exclusions = ($afficher_exclusions == 'oui') ?
true : false;
797 $afficher_doublons = ($afficher_doublons == 'oui') ?
true : false;
799 $tri = ($phrase) ?
'score' : 'nom';
800 $version_spip = $GLOBALS['spip_version_branche'] . "." . $GLOBALS['spip_version_code'];
802 // On recupere la liste des paquets:
803 // - sans doublons, ie on ne garde que la version la plus recente
804 // - correspondant a ces criteres
805 // - compatible avec la version SPIP installee sur le site
806 // - et n'etant pas deja installes (ces paquets peuvent toutefois etre affiches)
807 // tries par nom ou score
808 include_spip('inc/svp_rechercher');
809 $plugins = svp_rechercher_plugins_spip(
810 $phrase, $categorie, $etat, $depot, $version_spip,
811 svp_lister_plugins_installes(), $afficher_exclusions, $afficher_doublons, $tri);
818 * Retourne le nombre d'heures entre chaque actualisation
819 * si le cron est activé.
822 * Nombre d'heures (sinon 0)
824 function filtre_svp_periode_actualisation_depots() {
825 include_spip('genie/svp_taches_generales_cron');
827 return _SVP_CRON_ACTUALISATION_DEPOTS ? _SVP_PERIODE_ACTUALISATION_DEPOTS
: 0;
832 * Retourne 'x.y.z' à partir de '00x.00y.00z'
834 * Retourne la chaine de la version x.y.z sous sa forme initiale,
835 * sans remplissage à gauche avec des 0.
837 * @see normaliser_version()
838 * @param string $version_normalisee
839 * Numéro de version normalisée
841 * Numéro de version dénormalisée
843 function denormaliser_version($version_normalisee = '') {
846 if ($version_normalisee) {
847 $v = explode('.', $version_normalisee);
848 foreach ($v as $_nombre) {
849 $n = ltrim($_nombre, '0');
850 // On traite les cas du type 001.002.000-dev qui doivent etre transformes en 1.2.0-dev.
851 // Etant donne que la denormalisation est toujours effectuee sur une version normalisee on sait
852 // que le suffixe commence toujours pas '-'
853 $vn[] = ((strlen($n) > 0) and substr($n, 0, 1) != '-') ?
$n : "0$n";
855 $version = implode('.', $vn);
862 * Teste l'utilisation du répertoire auto des plugins.
864 * Ce répertoire permet de télécharger dedans des plugins
865 * lorsqu'il est présent.
868 * Le répertoire de chargement des plugins auto est-il présent
871 function test_plugins_auto() {
873 if (is_null($test)) {
874 include_spip('inc/plugin'); // pour _DIR_PLUGINS_AUTO
875 $test = (defined('_DIR_PLUGINS_AUTO') and _DIR_PLUGINS_AUTO
and is_writable(_DIR_PLUGINS_AUTO
));