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

Last change on this file since 113782 was 113782, checked in by eric@…, 3 months ago

Inutile de définir des constantes qui sont accessibles finalement par la configuration par défaut de Cache Factory

  • Property svn:eol-style set to native
File size: 7.6 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 ($nommer = cache_chercher_service($plugin, 'cache_nommer')) {
115                // On passe le plugin appelant à la fonction car cela permet ainsi de mutualiser les services de stockage.
116                $fichier_cache = $nommer($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// ----------------- UTILITAIRE PROPRE AU PLUGIN CACHE -------------------
159// -----------------------------------------------------------------------
160
161/**
162 * Cherche une fonction donnée en se basant sur le plugin appelant.
163 * Si le plugin utilisateur ne fournit pas la fonction demandée la chaîne vide est renvoyée.
164 *
165 * @internal
166 *
167 * @param string $plugin
168 *        Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
169 *        un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
170 * @param bool   $fonction
171 *        Nom de la fonction de service à chercher.
172 *
173 * @return string
174 *        Nom complet de la fonction si trouvée ou chaine vide sinon.
175 */
176function cache_chercher_service($plugin, $fonction) {
177
178        $fonction_trouvee = '';
179
180        // Eviter la réentrance si on demande explicitement le service du plugin Cache.
181        if ($plugin != 'cache') {
182                include_spip("cache/${plugin}");
183                $fonction_trouvee = "${plugin}_${fonction}";
184                if (!function_exists($fonction_trouvee)) {
185                        $fonction_trouvee = '';
186                }
187        }
188
189        return $fonction_trouvee;
190}
Note: See TracBrowser for help on using the repository browser.