source: spip-zone/_plugins_/cache/trunk/cache/cache.php @ 113793

Last change on this file since 113793 was 113793, checked in by root, 3 months ago

Ajout du service inverse à cache_composer()

  • Property svn:eol-style set to native
File size: 9.7 KB
Line 
1<?php
2/**
3 * Ce fichier contient les fonctions de service du plugin Cache.
4 *
5 * Chaque fonction, soit aiguille, si elle existe, vers une fonction "homonyme" propre au plugin appelant
6 * soit déroule sa propre implémentation.
7 * Ainsi, les plugins externes peuvent, si elle leur convient, utiliser l'implémentation proposée par Cache Factory.
8 *
9 * @package SPIP\CACHE\SERVICE
10 */
11if (!defined('_ECRIRE_INC_VERSION')) {
12        return;
13}
14
15
16// -----------------------------------------------------------------------
17// ---------------------- SERVICES SURCHARGEABLES ------------------------
18// -----------------------------------------------------------------------
19
20/**
21 * Récupère la configuration des caches d'un plugin, la complète et la stocke dans une meta.
22 *
23 * Le plugin Cache Factory propose une configuration par défaut des caches.
24 *
25 * @uses cache_chercher_service()
26 * @uses sous_repertoire()
27 * @uses lire_config()
28 * @uses ecrire_config()
29 *
30 * @param string $plugin
31 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
32 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
33 *
34 * @return array
35 *        Tableau de la configuration complétée des caches d'un plugin venant d'être enregistrée.
36 */
37function cache_cache_configurer($plugin) {
38
39        // Initialisation du tableau de configuration avec les valeurs par défaut du plugin Cache.
40        $configuration_defaut = array(
41                'racine'        => _DIR_CACHE,
42                'nom'           => array('nom'),
43                'extension'     => '.txt',
44                'securisation'  => false,
45                'serialisation' => true,
46                'separateur'    => '_'
47        );
48
49        // Le plugin utilisateur doit fournir un service propre pour la configuration de ses caches.
50        // Cette configuration peut-être partielle, dans ce cas les données manquantes sont complétées
51        // par celles par défaut.
52        $configuration_plugin = array();
53        if ($configurer = cache_chercher_service($plugin, 'cache_configurer')) {
54                // On passe le plugin appelant à la fonction car cela permet ainsi de mutualiser les services de stockage.
55                $configuration_plugin = $configurer($plugin);
56        }
57
58        // On merge la configuration du plugin avec celle par défaut pour assure la complétude.
59        $configuration = array_merge($configuration_defaut, $configuration_plugin);
60
61        // On vérifie l'indicateur de sécurisation : si le cache doit être sécurisé alors son extension
62        // doit absolument être .php. Si ce n'est pas le cas on la force.
63        if ($configuration['securisation']
64        and ($configuration['extension'] != '.php')) {
65                $configuration['extension'] = '.php';
66        }
67
68        // Pour faciliter la construction du chemin des caches on détermine une fois pour toute le dossier
69        // de base des caches du plugin.
70        // -- Vérification de la localisation de la racine qui ne peut être que dans les trois dossiers SPIP
71        //    prévus et de la présence du / final.
72        if (!in_array($configuration['racine'], array(_DIR_CACHE, _DIR_TMP, _DIR_VAR))) {
73                $configuration['racine'] = $configuration_defaut['racine'];
74        } else {
75                // On s'assure que la racine se termine toujours par un slash.
76                $configuration['racine'] = rtrim($configuration['racine'], '/') . '/';
77        }
78        // -- Sous-dossier spécifique au plugin
79        $sous_dossier = ($configuration['racine'] == _DIR_VAR) ? "cache-${plugin}" : "$plugin";
80        // -- Création et enregistrement du dossier de base
81        include_spip('inc/flock');
82        $configuration['dossier_base'] = sous_repertoire($configuration['racine'], $sous_dossier);
83       
84        // Enregistrement de la configuration du plugin utilisateur dans la meta prévue.
85        // Si une configuration existe déjà on l'écrase.
86        include_spip('inc/config');
87        $meta_cache = lire_config('cache', array());
88        $meta_cache[$plugin] = $configuration;
89        ecrire_config('cache', $meta_cache);
90
91        return $configuration;
92}
93
94
95/**
96 * Construit le chemin complet du fichier cache.
97 *
98 * @uses cache_chercher_service()
99 *
100 * @param string $plugin
101 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
102 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
103 * @param array  $cache
104 *        Tableau identifiant le cache pour lequel on veut construire le nom.
105 * @param array  $configuration
106 *        Configuration complète des caches du plugin utlisateur lue à partir de la meta de stockage.
107 *
108 * @return string
109 */
110function cache_cache_composer($plugin, $cache, $configuration) {
111
112        // Le plugin utilisateur peut fournir un service propre pour construire le chemin complet du fichier cache.
113        // Néanmoins, étant donné la généricité du mécanisme offert par le plugin Cache cela devrait être rare.
114        if ($composer = cache_chercher_service($plugin, 'cache_composer')) {
115                // On passe le plugin appelant à la fonction car cela permet ainsi de mutualiser les services de stockage.
116                $fichier_cache = $composer($plugin, $cache, $configuration);
117        } else {
118                // On utilise le mécanisme de nommage standard du plugin Cache.
119                // Initialisation du chemin complet du fichier cache
120                $fichier_cache = '';
121
122                // Détermination du répertoire final du fichier cache qui peut-être inclus dans un sous-dossier du dossier
123                // de base des caches du plugin.
124                $dir_cache = $configuration['dossier_base'];
125                if (!empty($cache['sous_dossier'])) {
126                        // Si le cache nécessite un sous-dossier, appelé service dans l'identifiant du cache.
127                        $dir_cache .= rtrim($cache['sous_dossier'], '/') . '/';
128                }
129
130                // Détermination du nom du cache sans extension.
131                // Celui-ci est construit à partir des éléments fournis sur le cache et de la configuration
132                // fournie par le plugin (liste ordonnée de composant).
133                $nom_cache = '';
134                foreach ($configuration['nom'] as $_composant) {
135                        if (isset($cache[$_composant])) {
136                                $nom_cache .= ($nom_cache ? $configuration['separateur'] : '') . $cache[$_composant];
137                        }
138                }
139
140                // Si le nom a pu être construit on finalise le chemin complet, sinon on renvoie une chaine vide.
141                if ($nom_cache) {
142                        // L'extension par défaut est dans la configuration mais peut-être forcée pour un cache donné.
143                        // Par contre, si le cache est sécurisé alors on ne tient pas compte du forçage éventuel car l'extension
144                        // doit toujours être .php et celle-ci a été forcée lors de la configuration des caches du plugin.
145                        $extension = (!empty($cache['extension']) and !$configuration['securisation'])
146                                ? $cache['extension']
147                                : $configuration['extension'];
148                        // Le chemin complet
149                        $fichier_cache = "${dir_cache}${nom_cache}${extension}";
150                }
151        }
152
153        return $fichier_cache;
154}
155
156
157/**
158 * Décompose le chemin complet du fichier cache en composants déterminé par configuration.
159 *
160 * @uses cache_chercher_service()
161 *
162 * @param string $plugin
163 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
164 *        ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
165 * @param array  $fichier_cache
166 *        Le chemin complet du fichier à phraser.
167 * @param array  $configuration
168 *        Configuration complète des caches du plugin utlisateur lue à partir de la meta de stockage.
169 *
170 * @return array
171 *         Tableau des composants constitutifs du cache
172 */
173function cache_cache_decomposer($plugin, $fichier_cache, $configuration) {
174
175        // Le plugin utilisateur peut fournir un service propre pour construire le chemin complet du fichier cache.
176        // Néanmoins, étant donné la généricité du mécanisme offert par le plugin Cache cela devrait être rare.
177        if ($decomposer = cache_chercher_service($plugin, 'cache_decomposer')) {
178                // On passe le plugin appelant à la fonction car cela permet ainsi de mutualiser les services de stockage.
179                $cache = $decomposer($plugin, $cache, $configuration);
180        } else {
181                // On utilise le mécanisme de nommage standard du plugin Cache. De fait, on considère qu'aucun composant
182                // n'est facultatif ou du moins qu'un seul composant est facultatif et positionné en dernier.
183
184                // Initialisation du tableau cache
185                $cache = array();
186
187                // On supprime le dossier de base pour n'avoir que la partie spécifique du cache.
188                $fichier_cache = str_replace($configuration['dossier_base'], '', $fichier_cache);
189
190                // Détermination du nom du cache sans extension et décomposition suivant la configuration du nom.               
191                $nom_cache = basename($fichier_cache, $configuration['extension']);
192                foreach (explode($configuration['separateur'], $nom_cache) as $_cle => $_composant) {
193                        $cache[$configuration['nom'][$_cle]] = $_composant;
194                }
195
196                // Identification d'un sous-dossier si il existe.
197                if ($sous_dossier = dirname($fichier_cache)) {
198                        $cache['sous_dossier'] = $sous_dossier;
199                }
200        }
201
202        return $cache;
203}
204
205
206// -----------------------------------------------------------------------
207// ----------------- UTILITAIRE PROPRE AU PLUGIN CACHE -------------------
208// -----------------------------------------------------------------------
209
210/**
211 * Cherche une fonction donnée en se basant sur le plugin appelant.
212 * Si le plugin utilisateur ne fournit pas la fonction demandée la chaîne vide est renvoyée.
213 *
214 * @internal
215 *
216 * @param string $plugin
217 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
218 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
219 * @param bool   $fonction
220 *        Nom de la fonction de service à chercher.
221 *
222 * @return string
223 *        Nom complet de la fonction si trouvée ou chaine vide sinon.
224 */
225function cache_chercher_service($plugin, $fonction) {
226
227        $fonction_trouvee = '';
228
229        // Eviter la réentrance si on demande explicitement le service du plugin Cache.
230        if ($plugin != 'cache') {
231                include_spip("cache/${plugin}");
232                $fonction_trouvee = "${plugin}_${fonction}";
233                if (!function_exists($fonction_trouvee)) {
234                        $fonction_trouvee = '';
235                }
236        }
237
238        return $fonction_trouvee;
239}
Note: See TracBrowser for help on using the repository browser.