source: spip-zone/_plugins_/dictionnaires/trunk/inc/dictionnaires.php

Last change on this file was 115378, checked in by real3t@…, 13 days ago

[Dictionnaires] Le cache n'était mis à jour que sur changement du *contenu* d'une définition. Et pas sur le changement de statut de la définition ou du dictionnaire.
Par ailleurs, le cache n'était pas enregistré si aucune définition (ce qui conduisait à garder les définitions en cache si inactivation du dictionnaire complet).

File size: 6.9 KB
Line 
1<?php
2
3/**
4 * Fonctions et filtres du dictionnaires
5 *
6 * @package SPIP\Dictionnaires\Fonctions
7 */
8 
9// Sécurité
10if (!defined('_ECRIRE_INC_VERSION')) return;
11
12/**
13 * Liste les définitions en activité
14 *
15 * Récupére un tableau facilement utilisable de toutes les définitions en activité sur le site
16 * Une définition active est une définition publié ET dans un dico actif
17 *
18 * @param bool $purger
19 *     true pour vider le cache statique des définitions connues.
20 * @return array
21 *     Tableau des définitions
22 *      array(
23 *              array(
24 *                      'titre' => 'Truc',
25 *                      'texte' => 'Ma définition',
26 *                      'termes' => array('trucs', 'bidule'), // autres termes qui seront reconnus
27 *                      'type' => '' | 'abbr',
28 *              ),
29 *              array(
30 *                      ...
31 *              )
32 *      )
33 */
34function dictionnaires_lister_definitions($purger=false){
35        // Le nom du fichier de cache
36        $langue = false;
37        if(in_array('spip_definitions',explode(',',(isset($GLOBALS['meta']['multi_objets'])?$GLOBALS['meta']['multi_objets']:'')))){
38                $langue = _request('lang') ? _request('lang') : ($GLOBALS['spip_lang'] ? $GLOBALS['spip_lang'] : $GLOBALS['meta']['langue_site']);
39                if(!in_array($langue,explode(',', $GLOBALS['meta']['langues_multilingue'])))
40                        $langue = $GLOBALS['meta']['langue_site'];
41                $fichier_cache =  _DIR_CACHE.'definitions_'.$langue.'.txt';
42        }
43        else{
44                $fichier_cache =  _DIR_CACHE.'definitions.txt';
45        }
46
47        // Par défaut rien
48        static $definitions_actives;
49       
50        // Si ça contient déjà quelque chose à ce stade, c'est avec le static donc on ne fait rien d'autre
51        if (!$purger and is_array($definitions_actives)){
52                return $definitions_actives;
53        }
54        else{
55                $definitions_actives = array();
56        }
57       
58        // Si on le demande explicitement où si la lecture du fichier ne marche pas, on recalcule
59        if (
60                $purger == true
61                or !lire_fichier($fichier_cache, $definitions_actives)
62                or !(is_array($definitions_actives = unserialize($definitions_actives)))
63        ){
64                $definitions_actives = array();
65
66                // On récupère tous les dictionnaires actifs
67                $dicos_actifs = sql_allfetsel('id_dictionnaire', 'spip_dictionnaires', 'statut = '. sql_quote('actif'));
68                if ($dicos_actifs and is_array($dicos_actifs)){
69                        $dicos_actifs = array_map('reset', $dicos_actifs);
70                        $where = array(
71                                        sql_in('id_dictionnaire', $dicos_actifs),
72                                        'statut ='.sql_quote('publie')
73                                );
74                        if($langue){
75                                $where[] = "lang =".sql_quote($langue);
76                        }
77                        // À l'intérieur on récupère toutes les définitions publiées
78                        $definitions_publiees = sql_allfetsel(
79                                'id_dictionnaire, id_definition, titre, termes, type, casse, texte, url_externe, lang',
80                                'spip_definitions',
81                                $where
82                        );
83                       
84                        if ($definitions_publiees and is_array($definitions_publiees)){
85                                $definitions_actives = $definitions_publiees;
86                        }
87                }
88               
89                // On passe la liste des définitions actives dans un pipeline
90                $definitions_actives = pipeline('lister_definitions', $definitions_actives);
91
92                include_spip('inc/charsets');
93                // On traite maintenant le tableau pour ajouter des infos prêtes à l'emploi
94                foreach ($definitions_actives as $cle=>$definition){
95                        // Si les termes sont données en chaine, on coupe avec les virgules
96                        if (is_string($definition['termes'])){
97                                $definition['termes'] = array_map('trim', explode(',', $definition['termes']));
98                        }
99                        // Si c'est ni une string ni un tableau on met un tableau vide
100                        elseif (!is_array($definition['termes'])){
101                                $definition['termes'] = array();
102                        }
103                       
104                        // On ajoute le titre à la liste des termes reconnus
105                        $definition['termes'][] = $definition['titre'];
106                       
107                        // Si c'est une abbréviation, on reconnait automatique une version avec des p.o.i.n.t.s.?
108                        if ($definition['type'] == 'abbr'){
109                                $titre = $definition['casse'] ? $definition['titre'] : strtolower($definition['titre']);
110                                $avec_points = spip_substr($titre,0,1);
111                                $length = spip_strlen($titre);
112                                for ($i=1 ; $i<$length ; $i++){
113                                        $avec_points .= '.'.spip_substr($titre,$i,1);
114                                }
115                                $definition['termes'][] = $avec_points.'.';
116                                $definition['termes'][] = $avec_points;
117                        }
118                       
119                        // On nettoie les termes = pas de truc vide, tout en minuscule, pas de doublons
120                        $definition['termes'] = array_filter($definition['termes']);
121                        if (!$definition['casse']){
122                                $definition['termes'] = array_map('strtolower', $definition['termes']);
123                        }
124                        $definition['termes'] = array_unique($definition['termes']);
125                       
126                        // On génère le masque de recherche
127                        $definition['masque'] = '{([^\w@\.]|^)('
128                                .join(
129                                        '|',
130                                        array_map(
131                                                create_function('$mot', 'return str_replace(".", "\.", $mot);'),
132                                                $definition['termes']
133                                        )
134                                )
135                                .')(?=([^\w]|\s|&nbsp;|$))}su'.($definition['casse']?'':'i');
136                       
137                        // Et voilà
138                        $definitions_actives[$cle] = $definition;
139                }
140               
141                // Si on a des définitions à mettre en cache, on les écrit
142                if (is_writeable(_DIR_CACHE)){
143                        ecrire_fichier($fichier_cache, serialize($definitions_actives));
144                }
145        }
146        return $definitions_actives;
147}
148
149/**
150 * Lister les définitions par terme.
151 *
152 * Chaque clé du tableau est alors un terme reconnu, en minuscule.
153 * Une même définition peut donc se trouver plusieurs fois dans la liste, avec différentes clés.
154 *
155 * @return array Tableau des définitions classé par terme
156 */
157function dictionnaires_lister_definitions_par_terme(){
158        static $definitions_par_terme = array();
159        $definitions = dictionnaires_lister_definitions();
160       
161        if (!$definitions_par_terme and $definitions){
162                foreach ($definitions as $definition){
163                        foreach ($definition['termes'] as $terme){
164                                $definitions_par_terme[$terme] = $definition;
165                        }
166                }
167        }
168       
169        return $definitions_par_terme;
170}
171
172/**
173 * Fonction de remplacement par défaut pour les termes trouvés dans les textes
174 *
175 * @param string $mot
176 *     Le mot trouvé
177 * @param string $definition
178 *     La définition correspondante
179 * @return string
180 *     Code HTML de remplacement de la définition
181 */
182function dictionnaires_remplacer_defaut_dist($mot, $definition) {
183        $class="";
184        if ((!isset($definition['url']) OR !$url = $definition['url']) && (!isset($definition['url_externe']) OR !$url = $definition['url_externe'])) {
185                $url = generer_url_entite($definition['id_definition'],'definition');
186        }else{
187                if(strpos($url,'http') == 0)
188                        $class="spip_out";
189        }
190        $class = (strlen($class) > 0) ? " class='$class' " : "";
191        return $mot
192                .'<sup><a href="'.$url.'"'.$class.'title="'._T('definition:titre_definition').': '
193                        . couper(trim(attribut_html(supprimer_tags(typo(expanser_liens($definition['texte']))))),80).'">'
194                .'?'
195                .'</a></sup>';
196}
197
198/*
199 * Fonction de remplacement par défaut pour les abbréviations trouvées dans les textes
200 * Ceci est un EXEMPLE montrant qu'on peut mettre un truc différent pour un type de définition précis
201 * Mais ce code est une MAUVAISE PRATIQUE en accessibilité
202 * (car seuls les gens avec des yeux valides et un pointeur de souris ont accès à l'information)
203 */
204#function dictionnaires_remplacer_abbr_dist($mot, $definition){
205#       return '<abbr title="'.couper(trim(attribut_html(supprimer_tags(typo($definition['texte'])))),80).'">'.$mot.'</abbr>';
206#}
207
208
209?>
Note: See TracBrowser for help on using the repository browser.