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

Last change on this file was 92499, checked in by real3t@…, 3 years ago

Notice PHP

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