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

Last change on this file since 65485 was 65485, checked in by marcimat@…, 7 years ago

Poursuite du passage à SPIP 3 du plugin dictionnaire. On utilise l'api d'objets éditoriaux et on ne met que les squelettes nécessaires dans le plugin. Au passage on PHPDoc toutes les fonctions.

File size: 6.1 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        $fichier_cache =  _DIR_CACHE.'definitions.txt';
37       
38        // Par défaut rien
39        static $definitions_actives;
40       
41        // Si ça contient déjà quelque chose à ce stade, c'est avec le static donc on ne fait rien d'autre
42        if (!$purger and $definitions_actives and is_array($definitions_actives)){
43                return $definitions_actives;
44        }
45        else{
46                $definitions_actives = array();
47        }
48       
49        // Si on le demande explicitement où si la lecture du fichier ne marche pas, on recalcule
50        if (
51                $purger == true
52                or !lire_fichier($fichier_cache, $definitions_actives)
53                or !($definitions_actives = unserialize($definitions_actives))
54                or !is_array($definitions_actives)
55        ){
56                $definitions_actives = array();
57               
58                // On récupère tous les dictionnaires actifs
59                $dicos_actifs = sql_allfetsel('id_dictionnaire', 'spip_dictionnaires', 'statut = '. sql_quote('actif'));
60                if ($dicos_actifs and is_array($dicos_actifs)){
61                        $dicos_actifs = array_map('reset', $dicos_actifs);
62               
63                        // À l'intérieur on récupère toutes les définitions publiées
64                        $definitions_publiees = sql_allfetsel(
65                                'id_dictionnaire, id_definition, titre, termes, type, casse, texte',
66                                'spip_definitions',
67                                array(
68                                        sql_in('id_dictionnaire', $dicos_actifs),
69                                        'statut ='.sql_quote('publie')
70                                )
71                        );
72                       
73                        if ($definitions_publiees and is_array($definitions_publiees)){
74                                $definitions_actives = $definitions_publiees;
75                        }
76                }
77               
78                // On passe la liste des définitions actives dans un pipeline
79                $definitions_actives = pipeline('lister_definitions', $definitions_actives);
80               
81                // On traite maintenant le tableau pour ajouter des infos prêtes à l'emploi
82                foreach ($definitions_actives as $cle=>$definition){
83                        // Si les termes sont données en chaine, on coupe avec les virgules
84                        if (is_string($definition['termes'])){
85                                $definition['termes'] = array_map('trim', explode(',', $definition['termes']));
86                        }
87                        // Si c'est ni une string ni un tableau on met un tableau vide
88                        elseif (!is_array($definition['termes'])){
89                                $definition['termes'] = array();
90                        }
91                       
92                        // On ajoute le titre à la liste des termes reconnus
93                        $definition['termes'][] = $definition['titre'];
94                       
95                        // Si c'est une abbréviation, on reconnait automatique une version avec des p.o.i.n.t.s.?
96                        if ($definition['type'] == 'abbr'){
97                                $titre = $definition['casse'] ? $definition['titre'] : strtolower($definition['titre']);
98                                $avec_points = $titre[0];
99                                for ($i=1 ; $i<strlen($titre) ; $i++){
100                                        $avec_points .= '.'.$titre{$i};
101                                }
102                                $definition['termes'][] = $avec_points.'.';
103                                $definition['termes'][] = $avec_points;
104                        }
105                       
106                        // On nettoie les termes = pas de truc vide, tout en minuscule, pas de doublons
107                        $definition['termes'] = array_filter($definition['termes']);
108                        if (!$definition['casse']){
109                                $definition['termes'] = array_map('strtolower', $definition['termes']);
110                        }
111                        $definition['termes'] = array_unique($definition['termes']);
112                       
113                        // On génère le masque de recherche
114                        $definition['masque'] = '{([^\w@\.]|^)('
115                                .join(
116                                        '|',
117                                        array_map(
118                                                create_function('$mot', 'return str_replace(".", "\.", $mot);'),
119                                                $definition['termes']
120                                        )
121                                )
122                                .')(?=([^\w]|\s|&nbsp;|$))}s'.($definition['casse']?'':'i');
123                       
124                        // Et voilà
125                        $definitions_actives[$cle] = $definition;
126                }
127               
128                // Si on a des définitions à mettre en cache, on les écrit
129                if ($definitions_actives and is_writeable(_DIR_CACHE)){
130                        ecrire_fichier($fichier_cache, serialize($definitions_actives));
131                }
132        }
133       
134        return $definitions_actives;
135}
136
137/**
138 * Lister les définitions par terme.
139 *
140 * Chaque clé du tableau est alors un terme reconnu, en minuscule.
141 * Une même définition peut donc se trouver plusieurs fois dans la liste, avec différentes clés.
142 *
143 * @return array Tableau des définitions classé par terme
144 */
145function dictionnaires_lister_definitions_par_terme(){
146        static $definitions_par_terme = array();
147        $definitions = dictionnaires_lister_definitions();
148       
149        if (!$definitions_par_terme and $definitions){
150                foreach ($definitions as $definition){
151                        foreach ($definition['termes'] as $terme){
152                                $definitions_par_terme[$terme] = $definition;
153                        }
154                }
155        }
156       
157        return $definitions_par_terme;
158}
159
160/**
161 * Fonction de remplacement par défaut pour les termes trouvés dans les textes
162 *
163 * @param string $mot
164 *     Le mot trouvé
165 * @param string $definition
166 *     La définition correspondante
167 * @return string
168 *     Code HTML de remplacement de la définition
169 */
170function dictionnaires_remplacer_defaut_dist($mot, $definition) {
171        if (!isset($definition['url']) OR !$url = $definition['url']) {
172                $url = generer_url_entite($definition['id_definition'],'definition');
173        }
174        return $mot
175                .'<sup><a href="'.$url.'" title="'._T('definition:titre_definition').': '
176                        . couper(trim(attribut_html(supprimer_tags(typo($definition['texte'])))),80).'">'
177                .'?'
178                .'</a></sup>';
179}
180
181/*
182 * Fonction de remplacement par défaut pour les abbréviations trouvées dans les textes
183 * Ceci est un EXEMPLE montrant qu'on peut mettre un truc différent pour un type de définition précis
184 * Mais ce code est une MAUVAISE PRATIQUE en accessibilité
185 * (car seuls les gens avec des yeux valides et un pointeur de souris ont accès à l'information)
186 */
187#function dictionnaires_remplacer_abbr_dist($mot, $definition){
188#       return '<abbr title="'.couper(trim(attribut_html(supprimer_tags(typo($definition['texte'])))),80).'">'.$mot.'</abbr>';
189#}
190
191?>
Note: See TracBrowser for help on using the repository browser.