PSR SPIP + fix typo + on change la catégorie c'est d'actualité

cachelab_fonctions.php

@@ -1,19 +1,24 @@
 <?php
-if (!defined('_ECRIRE_INC_VERSION')) return;
+if (!defined('_ECRIRE_INC_VERSION')) {
+	return;
+}
 
 include_spip('public/cachelab_balises');
 
 // loger tous les temps des ciblages
-if (!defined('LOG_CACHELAB_CHRONO'))
+if (!defined('LOG_CACHELAB_CHRONO')) {
 	define('LOG_CACHELAB_CHRONO', false);
+}
 
 // Seuil minimal des temps de ciblage à loger dans cachelab_slow (en ms)
-if (!defined('LOG_CACHELAB_SLOW'))
+if (!defined('LOG_CACHELAB_SLOW')) {
 	define('LOG_CACHELAB_SLOW', 70);
+}
 
 // Seuil minimal du nombre de caches invalidés en un seul ciblage pour le loger dans cachelab_toomany_del
-if (!defined('LOG_CACHELAB_TOOMANY_DEL'))
-	define('LOG_CACHELAB_TOOMANY_DEL',100);
+if (!defined('LOG_CACHELAB_TOOMANY_DEL')) {
+	define('LOG_CACHELAB_TOOMANY_DEL', 100);
+}
 
 /* Autres constantes utilisées-définies dans inc/cachelab_invalideur :
  *   LOG_BALISECACHE_FILTRES

cachelab_pipelines.php

@@ -16,5 +16,5 @@ function cachelab_insert_head_css($flux) {
 .cachelab_blocs small {margin: 2px; padding: 2px; font-size: 60%;}
 .cachelab_assert {background-color: orange}
 </style>\n";
-    return $flux;
+	return $flux;
 }

inc/cachelab.php

@@ -16,7 +16,7 @@ include_spip('public/cachelab_utils');
  * @param null $return : résultat éventuellement fourni, pour les actions list et get
  * @return bool : indique si l'action a pu être appliquée ou non
  */
-function cachelab_appliquer ($action, $cle, $data=null, $options='', &$return=null) {
+function cachelab_appliquer($action, $cle, $data = null, $options = '', &$return = null) {
 global $Memoization;
 	if (!isset($Memoization) or !$Memoization) {
 		spip_log("cachelab_appliquer ($action, $cle...) : Memoization n'est pas activé", 'cachelab_erreur');
@@ -24,52 +24,56 @@ global $Memoization;
 	}
 
 static $len_prefix;
-	if (!$len_prefix)
+	if (!$len_prefix) {
 		$len_prefix = strlen(_CACHE_NAMESPACE);
+	}
 	$joliecle = substr($cle, $len_prefix);
 
 	switch ($action) {
-	case 'del' :
+	case 'del':
 		$del = $Memoization->del($joliecle);
 		if (!$del) {
-			spip_log ("Échec 'del' $joliecle", 'cachelab_erreur');
+			spip_log("Échec 'del' $joliecle", 'cachelab_erreur');
 			return false;
 		};
-		break;
+			break;
 
 	// gérés par cachelab_cibler
-	case 'pass' :	// passe
-	case 'list' :	// renvoie les clés
-	case 'clean' :	// nettoie
-		break;
+	case 'pass':	// passe
+	case 'list':	// renvoie les clés
+	case 'clean':	// nettoie
+			break;
 		
-	case 'list_html' :	// renvoie les contenus indexés par les clés sans préfixes
+	case 'list_html':	// renvoie les contenus indexés par les clés sans préfixes
 						// attention ça peut grossir !
-		if (!is_array($return))
+		if (!is_array($return)) {
 			$return = array();
+		}
 		$return[$joliecle] = $data['texte'];
-		break;
+			break;
 
-	case 'get' :	// renvoie le 1er cache ciblé
-		if (!$data)
+	case 'get':	// renvoie le 1er cache ciblé
+		if (!$data) {
 			$data = $Memoization->get($joliecle);
+		}
 		$return = $data;
-		break;
+			break;
 
-	case 'get_html' :	// renvoie le contenu du 1er cache
-		if (!$data)
+	case 'get_html':	// renvoie le contenu du 1er cache
+		if (!$data) {
 			$data = $Memoization->get($joliecle);
+		}
 		$return = $data['texte'];
-		break;
+			break;
 
-	default :
+	default:
 		$f = 'cachelab_appliquer_'.$action;
-		if (function_exists($f))
+		if (function_exists($f)) {
 			return $f($action, $cle, $data, $options, $return);
-		else {
-			spip_log ("L'action $action n'est pas définie pour cachelab_applique", 'cachelab_erreur');
+		} else {
+			spip_log("L'action $action n'est pas définie pour cachelab_applique", 'cachelab_erreur');
 			return false;
-		};
+		}
 	}
 	return true;
 }
@@ -88,18 +92,19 @@ static $len_prefix;
  *      la liste des stats sinon, avec éventuellement la liste des résultats s'ils sont demandés (pour 'list_html'...)
  *
  */
-function cachelab_cibler ($action, $conditions=array(), $options=array()) {
+function cachelab_cibler($action, $conditions = array(), $options = array()) {
 global $Memoization;
 	if (!isset($Memoization) or !$Memoization or !in_array($Memoization->methode(), array('apc', 'apcu'))) {
-		spip_log("cachelab_cibler($action...) : le plugin Mémoization doit être activé avec APC ou APCu", 'cachelab_erreur');
-		die ("cachelab_cibler($action...) : le plugin Mémoization doit être activé avec APC ou APCu");
+		spip_log("cachelab_cibler($action...) : Mémoization n'est pas activé avec APC ou APCu", 'cachelab_erreur');
+		die("cachelab_cibler($action...) : le plugin Mémoization doit être activé avec APC ou APCu");
 	}
 	$return = null;
 
 	// filtrage
 	$session = (isset($conditions['session']) ? $conditions['session'] : null);
-	if ($session=='courante')
+	if ($session=='courante') {
 		$session = spip_session();
+	}
 
 	$chemin = (isset($conditions['chemin']) ? $conditions['chemin'] : null);
 	$chemins = explode('|', $chemin); // sert seulement pour methode_chemin == strpos
@@ -107,34 +112,35 @@ global $Memoization;
 	$cle_objet = (isset($conditions['cle_objet']) ? $conditions['cle_objet'] : null);
 	$id_objet = (isset($conditions['id_objet']) ? $conditions['id_objet'] : null);
 	if ($cle_objet and !$id_objet) {
-		spip_log("cachelab_cibler : $cle_objet inconnu\n".print_r(debug_backtrace(),1), "cachelab_erreur");
+		spip_log("cachelab_cibler : $cle_objet inconnu\n".print_r(debug_backtrace(), 1), 'cachelab_erreur');
 		$cle_objet=null;
 	}
 
 	// pour 'contexte' on simule un 'plus' pour donner un exemple d'extension
-	if (isset($conditions['contexte']) and $conditions['contexte'] and !isset($conditions['plus']))
+	if (isset($conditions['contexte']) and $conditions['contexte'] and !isset($conditions['plus'])) {
 		$conditions['plus'] = 'contexte';
+	}
 	if ($plus = (isset($conditions['plus']) ? (string)$conditions['plus'] : '')) {
 		$plusfunc='cachelab_ciblercache_'.$plus;
 		// Signature nécessaire : $plusfunc ($action, $conditions, $options, &$stats)
 		if (!function_exists($plusfunc)) {
-			spip_log ("La fonction '$plusfunc' n'est pas définie", 'cachelab_erreur');
-			return;
+			spip_log("La fonction '$plusfunc' n'est pas définie", 'cachelab_erreur');
+			return null;
 		}
-	}
-	else
+	} else {
 		$plusfunc = '';
+	}
 
 	// options
 	// explode+strpos par défaut pour les chemins
-	$methode_chemin = (isset ($options['methode_chemin']) ? $options['methode_chemin'] : 'strpos');
-	$partie_chemin = (isset ($options['partie_chemin']) ? $options['partie_chemin'] : 'tout');
+	$methode_chemin = (isset($options['methode_chemin']) ? $options['methode_chemin'] : 'strpos');
+	$partie_chemin = (isset($options['partie_chemin']) ? $options['partie_chemin'] : 'tout');
 	// clean par défaut
-	$do_clean = (isset ($options['clean']) ? $options['clean'] : (!defined('CACHELAB_CLEAN') or CACHELAB_CLEAN)); 
+	$do_clean = (isset($options['clean']) ? $options['clean'] : (!defined('CACHELAB_CLEAN') or CACHELAB_CLEAN));
 	// pas de listes par défaut
-	$do_lists = ($action == 'list') or (isset ($options['list']) and $options['list']);
-	include_spip ('lib/microtime.inc');
-	microtime_do ('begin');
+	$do_lists = ($action == 'list') or (isset($options['list']) and $options['list']);
+	include_spip('lib/microtime.inc');
+	microtime_do('begin');
 
 	// retours
 	$stats=array();
@@ -146,7 +152,7 @@ global $Memoization;
 	$meta_derniere_modif = lire_meta('derniere_modif');
 	$len_prefix = strlen(_CACHE_NAMESPACE);
 
-	foreach($cache['cache_list'] as $i => $d) {
+	foreach ($cache['cache_list'] as $i => $d) {
 		// on "continue=passe au suivant" dés qu'on sait que le cache n'est pas cible
 
 		$cle = $d['info'];
@@ -154,23 +160,25 @@ global $Memoization;
 
 		// on saute les caches d'autres origines
 		// (et les caches d'un autre _CACHE_NAMESPACE pour ce même site)
-		if (strpos ($cle, _CACHE_NAMESPACE) !== 0) {
+		if (strpos($cle, _CACHE_NAMESPACE) !== 0) {
 			$stats['nb_alien']++;
 			continue;
 		}
 
 		// on ne veut examiner que les caches de squelettes SPIP
-		if (substr($cle, $len_prefix-1, 7) != ':cache:')
+		if (substr($cle, $len_prefix-1, 7) != ':cache:') {
 			continue;
+		}
 
 		// effacer ou sauter les caches invalidés par une invalidation totale
 		// ou que apcu ne suit plus
 		if ($meta_derniere_modif > $d['creation_time']
 			or !apcu_exists($cle)) {
 			if ($do_clean) {
-				$del=$Memoization->del(substr($cle,$len_prefix));
-				if (!$del)
-					spip_log ("Echec du clean du cache $cle (création : {$d['creation_time']}, invalidation : $meta_derniere_modif)", "cachelab_erreur");
+				$del=$Memoization->del(substr($cle, $len_prefix));
+				if (!$del) {
+					spip_log("Echec du clean du cache $cle (création : {$d['creation_time']}, invalidation : $meta_derniere_modif)", 'cachelab_erreur');
+				}
 				$stats['nb_clean']++;
 			};
 			continue;
@@ -181,44 +189,49 @@ global $Memoization;
 
 		// 1er filtrage : par la session
 		if ($session) {
-			if (substr ($cle, -9) != "_$session")
-				continue;
+			if (substr($cle, -9) != "_$session") {
+			continue;
+			}
 		}
 
 		// 2eme filtrage : par le chemin
 		if ($chemin) {
 			switch ($partie_chemin) {
-			case 'tout' :
-			case 'chemin' :
+			case 'tout':
+			case 'chemin':
 				$partie_cle = $cle;
-				break;
-			case 'fichier' :
+					break;
+			case 'fichier':
 				$parties = explode('/', $cle);
 				$partie_cle = array_pop($parties);
-				break;
-			case 'dossier' :
+					break;
+			case 'dossier':
 				$parties = explode('/', $cle);
 				$parties = array_pop($parties);
 				$partie_cle = array_pop($parties);
-				break;
-			default :
-				spip_log ("Option partie_chemin incorrecte : '$partie_chemin'", 'cachelab_erreur');
-				return;
+					break;
+			default:
+				spip_log("Option partie_chemin incorrecte : '$partie_chemin'", 'cachelab_erreur');
+					return null;
 			}
-			// mémo php : « continue resumes execution just before the closing curly bracket ( } ), and break resumes execution just after the closing curly bracket. »
+			// mémo php : « continue resumes execution just before the closing curly bracket ( } ),
+			// and break resumes execution just after the closing curly bracket. »
 			switch ($methode_chemin) {
-			case 'strpos' :
-				foreach ($chemins as $unchemin)
-					if ($unchemin and (strpos ($partie_cle, $unchemin) !== false))
+			case 'strpos':
+				foreach ($chemins as $unchemin) {
+					if ($unchemin and (strpos($partie_cle, $unchemin) !== false)) {
 						break 2;	// trouvé : sort du foreach et du switch et poursuit le test des autres conditions
-				continue 2;	 // échec : passe à la $cle suivante
-			case 'regexp' :
-				if ($chemin and ($danslechemin = preg_match(",$chemin,i", $partie_cle)))
+					}
+				}
+					continue 2;	 // échec : passe à la $cle suivante
+			case 'regexp':
+				if ($chemin and ($danslechemin = preg_match(",$chemin,i", $partie_cle))) {
 					break;	// trouvé : poursuit le test des autres conditions
-				continue 2;	// échec : passe à la clé suivante
-			default :
-				spip_log ("Méthode '$methode_chemin' pas prévue pour le filtrage par le chemin", 'cachelab_erreur');
-				return;
+				}
+					continue 2;	// échec : passe à la clé suivante
+			default:
+				spip_log("Méthode '$methode_chemin' pas prévue pour le filtrage par le chemin", 'cachelab_erreur');
+					return null;
 			};
 		}
 
@@ -227,49 +240,58 @@ global $Memoization;
 			global $Memoization;
 			$data = $Memoization->get(substr($cle, $len_prefix));
 			if (!$data or !is_array($data)) {
-				spip_log ("clé=$cle : data est vide ou n'est pas un tableau : ".print_r($data,1), 'cachelab_erreur');
+				spip_log("clé=$cle : data est vide ou n'est pas un tableau : ".print_r($data, 1), 'cachelab_erreur');
 				continue;
 			};
 		};
 
 		// 3eme filtre : par une valeur dans l'environnement
 		if ($cle_objet
-			and (!isset ($data['contexte'][$cle_objet])
-				or ($data['contexte'][$cle_objet]!=$id_objet)))
+			and (!isset($data['contexte'][$cle_objet])
+				or ($data['contexte'][$cle_objet]!=$id_objet))) {
 			continue;
+		}
 
 		// 4eme filtre : par une extension
 		if ($plusfunc
-			and !$plusfunc ($action, $conditions, $options, $cle, $data, $stats))
+			and !$plusfunc($action, $conditions, $options, $cle, $data, $stats)) {
 			continue;
+		}
 
 		// restent les cibles
 		$stats['nb_cible']++;
-		if ($do_lists) 
+		if ($do_lists) {
 			$stats['l_cible'][] = $cle;
+		}
 
-		cachelab_appliquer ($action, $cle, $data, $options, $return);
+		cachelab_appliquer($action, $cle, $data, $options, $return);
 
-		if ($return 
-			and (($action=='get') 
-				or (substr($action,0,4)=='get_')))
+		if ($return
+			and (($action=='get')
+				or (substr($action, 0, 4)=='get_'))) {
 			return $return; // TODO chrono aussi dans ce cas
+		}
 	}
 
-	$stats['chrono'] = microtime_do ('end', 'ms');
-	$msg = "cachelab_cibler($action) en {$stats['chrono']} ms ({$stats['nb_cible']} caches sur {$stats['nb_candidats']})"
+	$stats['chrono'] = microtime_do('end', 'ms');
+	$msg = "cachelab_cibler($action) en {$stats['chrono']}ms ({$stats['nb_cible']} caches sur {$stats['nb_candidats']})"
 		."\n".print_r($conditions, 1);
-	if (count($options))
+	if (count($options)) {
 		$msg .= "\n".print_r($options, 1);
-	if (defined ('LOG_CACHELAB_CHRONO') and LOG_CACHELAB_CHRONO)
-		spip_log ($msg, 'cachelab_chrono.'._LOG_INFO);
-	if (defined ('LOG_CACHELAB_SLOW') and ($stats['chrono']  > LOG_CACHELAB_SLOW))
-		spip_log ($msg, 'cachelab_slow.'._LOG_INFO_IMPORTANTE);
-	if (($action=='del') and defined ('LOG_CACHELAB_TOOMANY_DEL') and ($stats['nb_cible']  > LOG_CACHELAB_TOOMANY_DEL))
-		spip_log ($msg, 'cachelab_toomany_del.'._LOG_INFO_IMPORTANTE);
-
-	if ($return)
+	}
+	if (defined('LOG_CACHELAB_CHRONO') and LOG_CACHELAB_CHRONO) {
+		spip_log($msg, 'cachelab_chrono.'._LOG_INFO);
+	}
+	if (defined('LOG_CACHELAB_SLOW') and ($stats['chrono']  > LOG_CACHELAB_SLOW)) {
+		spip_log($msg, 'cachelab_slow.'._LOG_INFO_IMPORTANTE);
+	}
+	if (($action=='del') and defined('LOG_CACHELAB_TOOMANY_DEL') and ($stats['nb_cible']  > LOG_CACHELAB_TOOMANY_DEL)) {
+		spip_log($msg, 'cachelab_toomany_del.'._LOG_INFO_IMPORTANTE);
+	}
+
+	if ($return) {
 		$stats['val'] = $return;
+	}
 	return $stats;
 }
 
@@ -277,30 +299,31 @@ global $Memoization;
  * @param $action
  * @param array $objets_invalidants
  */
-function controler_invalideur($action, $objets_invalidants=array()) {
+function controler_invalideur($action, $objets_invalidants = array()) {
 static $prev_derniere_modif_invalide;
-	switch($action) {
-	case 'stop' :
+	switch ($action) {
+	case 'stop':
 		$objets_invalidants = array();
 		// nobreak;
-	case 'select' :
+	case 'select':
 		$prev_derniere_modif_invalide = $GLOBALS['derniere_modif_invalide'];
-		if (is_array($objets_invalidants))
+		if (is_array($objets_invalidants)) {
 			$GLOBALS['derniere_modif_invalide'] = $objets_invalidants;
-		break;
-	case 'go' :
+		}
+			break;
+	case 'go':
 		$GLOBALS['derniere_modif_invalide'] = $prev_derniere_modif_invalide;
-		break;
+			break;
 	}
 }
 
 //
 // Exemple d'extension utilisable avec 'plus'=>'contexte'
 // Filtrer non sur une seule valeur de l'environnement comme avec 'cle_objet'
-// mais sur un ensemble de valeurs spécifié par $conditions['contexte'] 
+// mais sur un ensemble de valeurs spécifié par $conditions['contexte']
 // qui est un tableau de (clé, valeur)
 // Toutes les valeurs doivent être vérifiées dans l'environnement.
-// 
+//
 /**
  * @param $action
  * @param $conditions
@@ -311,10 +334,11 @@ static $prev_derniere_modif_invalide;
  * @return bool
  */
 function cachelab_ciblercache_contexte($action, $conditions, $options, $cle, &$data, &$stats) {
-	if (!isset ($data['contexte'])
+	if (!isset($data['contexte'])
 		or !isset($conditions['contexte'])
-		or !is_array($conditions['contexte']))
+		or !is_array($conditions['contexte'])) {
 		return false;
+	}
 	$diff = array_diff_assoc($conditions['contexte'], $data['contexte']);
 	return empty($diff);
 }

inc/cachelab_invalideur.php

@@ -9,11 +9,13 @@ if (!defined('_ECRIRE_INC_VERSION')) {
 }
 include_spip('inc/cachelab_utils');
 
-if (!defined('LOG_BALISECACHE_FILTRES'))
+if (!defined('LOG_BALISECACHE_FILTRES')) {
 	define('LOG_BALISECACHE_FILTRES', 'oui');
+}
 
-if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES'))
+if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES')) {
 	define('LOG_BALISECACHE_DUREES_DYNAMIQUES', false);
+}
 
 
 /**
@@ -26,7 +28,7 @@ if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES'))
  * pour le type d'objet en question (non utilisé cependant) et pour
  * tout le site (sur la meta `derniere_modif`)
  *
- * @global derniere_modif_invalide
+ * @global bool|array derniere_modif_invalide
  *     Par défaut à `true`, la meta `derniere_modif` est systématiquement
  *     calculée dès qu'un invalideur se présente. Cette globale peut
  *     être mise à `false` (aucun changement sur `derniere_modif`) ou
@@ -54,19 +56,19 @@ function suivre_invalideur($cond, $modif = true) {
 			// stocker la date_modif_extra_$extra (ne sert a rien)
 			ecrire_meta('derniere_modif_extra_' . $r[1], time());
 			$f="cachelab_suivre_invalideur_{$r[1]}";
-		}
-		else {
+		} else {
 			// stocker la date_modif_$objet (ne sert a rien)
 			ecrire_meta('derniere_modif_' . $objet, time());
 			$f="cachelab_suivre_invalideur_$objet";
 		}
 
 		if (function_exists($f)) {
-			spip_log ("suivre_invalideur appelle $f($cond,$modif)", "cachelab");
+			spip_log("suivre_invalideur appelle $f($cond,$modif)", 'cachelab');
 			$modif = $f($cond, $modif);	 // $f renvoie la nouvelle valeur de $modif
 			// si l'invalidation a été totalement traitée par $f, ya plus rien à faire
-			if (!$modif)
+			if (!$modif) {
 				return;
+			}
 		}
 	}
 
@@ -77,11 +79,11 @@ function suivre_invalideur($cond, $modif = true) {
 		or ($objet
 			and in_array($objet, $GLOBALS['derniere_modif_invalide']))) {
 		ecrire_meta('derniere_modif', time());
-		include_spip ('inc/cachelab');
-		spip_log ("invalidation totale / signal '$cond' avec objet '$objet'", "suivre_invalideur");
+		include_spip('inc/cachelab');
+		spip_log("invalidation totale / signal '$cond' avec objet '$objet'", 'suivre_invalideur');
+	} else {
+		spip_log("invalidation totale évitée : $cond", 'cachelab_effondrement_evite');
 	}
-	else 
-		spip_log ("invalidation totale évitée : $cond", "cachelab_effondrement_evite");
 }
 
 //
@@ -89,13 +91,13 @@ function suivre_invalideur($cond, $modif = true) {
 // le core indique : "Calcul des pages : noter dans la base les liens d'invalidation"
 //
 // Appelé à la fin de creer_cache
-// $page est le tableau décrivant le cache qui vient d'être calculé 
-// avec les clés suivantes pour ses métadonnées : 
+// $page est le tableau décrivant le cache qui vient d'être calculé
+// avec les clés suivantes pour ses métadonnées :
 // squelette,source,process_ins,invalideurs,entetes,duree,texte,notes,contexte,lastmodified,sig
 // http://code.spip.net/@maj_invalideurs
 //
 // S'il y a une entete X-Spip-Methode-Duree-Cache on récupère la méthode
-// et on appelle la fonction cachelab_calcule_duree_cache_lamethode 
+// et on appelle la fonction cachelab_calcule_duree_cache_lamethode
 // avec en argument la valeur de l'argument dans l'envt ou de date_creation par défaut
 // On corrige alors la durée du cache avec la valeur retournée.
 //
@@ -107,22 +109,24 @@ function suivre_invalideur($cond, $modif = true) {
 // define ('LOG_INVALIDATION_CORE', true);
 function maj_invalideurs($fichier, &$page) {
 global $Memoization;
-// Rq : ici, le texte du cache est non zipé (cf function creer_cache dans memoization), 
+// Rq : ici, le texte du cache est non zipé (cf function creer_cache dans memoization),
 // tandis que la version en cache peut être zipée (avec index 'gz').
-	if  (LOG_INVALIDATION_CORE) {
+	if (LOG_INVALIDATION_CORE) {
 		// Abondamment appelé. À part pour pas noyer les autres
-		spip_log ("maj_invalideurs($fichier, &page)", "invalideur_core_maj_invalideurs");
-		spip_log ("maj_invalideurs($fichier, &page)\n".print_r($page,1), "invalideur_core_maj_invalideurs_details");
+		spip_log("maj_invalideurs($fichier, &page)", 'invalideur_core_maj_invalideurs');
+		spip_log("maj_invalideurs($fichier, &page)\n".print_r($page, 1), 'invalideur_core_maj_invalideurs_details');
 	};
 
 static $var_cache;
 	$infos = $hint_squel = '';
-	if (!isset($var_cache))
+	if (!isset($var_cache)) {
 		$var_cache = _request('var_cache');
-	if ($var_cache=='sessionnement') // on veut le sessionnement seul à l'écran
+	}
+	if ($var_cache=='sessionnement') { // on veut le sessionnement seul à l'écran
 		$hint_squel = ' title="'.attribut_html($page['source']).'" ';
-	else
+	} else {
 		$infos = $page['source'];		// on prépare les infos supplémentaires
+	}
 
 	// Pour le calcul dynamique d'une durée de cache, la fonction user
 	// reçoit la *valeur* de l'une des valeurs de l'environnement (par défaut "date_creation")
@@ -132,16 +136,18 @@ static $var_cache;
 		list ($f, $arg) = split_first_arg($f, 'date_creation');
 		if (function_exists($f)) {
 			if (!isset($page['contexte'][$arg])) {
-				spip_log ("#CACHE avec squelette {$page['source']} et calcul de durée avec $f mais pas de '$arg' dans le contexte ".print_r($page['contexte'],1), "cachelab_erreur");
+				spip_log("#CACHE avec squelette {$page['source']} et calcul de durée avec $f mais pas de '$arg' dans le contexte ".print_r($page['contexte'], 1), 'cachelab_erreur');
 				return;
 			}
-			$duree = $f($page['contexte'][$arg],$page);
+			$duree = $f($page['contexte'][$arg], $page);
 			if (!is_null($duree)) {
-				if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES') or LOG_BALISECACHE_DUREES_DYNAMIQUES)
-					spip_log ("#CACHE $f (arg={$page['contexte'][$arg]}) renvoie : $duree s", 'balisecache_duree_dynamique');
+				if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES') or LOG_BALISECACHE_DUREES_DYNAMIQUES) {
+					spip_log("#CACHE $f (arg={$page['contexte'][$arg]}) renvoie : $duree s", 'balisecache_duree_dynamique');
+				}
 
-				if ($var_cache)
+				if ($var_cache) {
 					echo "<div class='cachelab_blocs' $hint_squel><h6>Durée dynamique : $duree</h6><small>$infos</small></div>";
+				}
 
 				$page['duree'] = $duree;
 				$page['entetes']['X-Spip-Cache']=$duree;
@@ -156,23 +162,25 @@ static $var_cache;
 				// sur le cache quand la base de donnees est plantée (à tester)"
 				$Memoization->set($fichier, $page, 3600+$duree);
 			}
+		} else {
+			spip_log("#CACHE duree cache : la fonction '$f' n'existe pas (arg='$arg')\n".print_r($page, 1), 'cachelab_erreur');
 		}
-		else 
-			spip_log ("#CACHE duree cache : la fonction '$f' n'existe pas (arg='$arg')\n".print_r($page,1), "cachelab_erreur");
 	}
 	
 	// Exemple : <INCLURE{fond=mes_scores,duree-cache=#GET{duree_sicestmoi_oupas}}/>
 	if (isset($page['contexte']['duree-cache'])) {
-		if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES') or LOG_BALISECACHE_DUREES_DYNAMIQUES)
-			spip_log ("Pour $fichier, contexte[duree-cache]={$page['contexte']['duree-cache']}", 'balisecache_duree_dynamique');
+		if (!defined('LOG_BALISECACHE_DUREES_DYNAMIQUES') or LOG_BALISECACHE_DUREES_DYNAMIQUES) {
+			spip_log("Pour $fichier, contexte[duree-cache]={$page['contexte']['duree-cache']}", 'balisecache_duree_dynamique');
+		}
 
-		if ($var_cache)
+		if ($var_cache) {
 			echo "<div class='cachelab_blocs' $hint_squel><h6>Contexte duree-cache : $duree</h6><small>$infos</small></div>";
+		}
 
 		$page['entetes']['X-Spip-Cache']
 		= $page['entetes']['X-Spip-Contexte-Duree-Cache']
-		= $page['duree'] 
-		= $duree 
+		= $page['duree']
+		= $duree
 		= intval($page['contexte']['duree-cache']);
 
 		// (idem : creer_cache appelle maj_invalideurs *aprés* d'avoir écrit le cache)
@@ -187,19 +195,22 @@ static $var_cache;
 		$f = 'cachelab_filtre_'.$page['entetes']['X-Spip-Filtre-Cache'];
 		list ($f, $arg) = split_first_arg($f);
 		if (function_exists($f)) {
-			if (!defined('LOG_BALISECACHE_FILTRES') or LOG_CACHELAB_FILTRES)
-				spip_log ("#CACHE appelle le filtre $f ($arg)", 'balisecache_filtres');
+			if (!defined('LOG_BALISECACHE_FILTRES') or LOG_BALISECACHE_FILTRES) {
+				spip_log("#CACHE appelle le filtre $f ($arg)", 'balisecache_filtres');
+			}
 			$toset = $f($page, $arg);
 			// Le filtre renvoie un booléen qui indique s'il faut mémoizer le cache
-			if ($toset)
+			if ($toset) {
 				$Memoization->set($fichier, $page, $page['entete']['X-Spip-Cache']);
+			}
+		} else {
+			spip_log("#CACHE filtre : la fonction '$f' n'existe pas (arg='$arg')\n".print_r($page, 1), 'cachelab_erreur');
 		}
-		else 
-			spip_log ("#CACHE filtre : la fonction '$f' n'existe pas (arg='$arg')\n".print_r($page,1), "cachelab_erreur");
 	}
 	
-	if ($var_cache)
+	if ($var_cache) {
 		echo '<div class="cachelab_blocs" '.$hint_squel.'><h6>Sessionnement : '
 				.cachelab_etat_sessionnement($page['invalideurs'], 'précis')
 			 .'</h6><small>'.$infos.'</small></div>';
+	}
 }

inc/cachelab_utils.php

@@ -6,7 +6,7 @@ if (!defined('_ECRIRE_INC_VERSION')) {
 
 //
 // sépare à la lisp le premier mot et les autres
-// 
+//
 // $f (string) : liste à séparer
 // $cdr (string ou array) : valeur par défaut pour le 2eme élt renvoyé
 // $string_wanted (bool) : type du 2eme élément renvoyé
@@ -15,36 +15,37 @@ if (!defined('_ECRIRE_INC_VERSION')) {
 // retour[0] (string) : 1er élément de la liste
 // retour[1] (string ou array selon $string_wanted) : reste de la liste
 //
-function split_first_arg($l, $cdr='', $string_wanted=true) {
+function split_first_arg($l, $cdr = '', $string_wanted = true) {
 	$l = preg_replace('/\s+/', ' ', trim($l), -1, $n);
 	$lparts = explode(' ', $l);
 	if ($lparts != array_filter($lparts)) {
-	    spip_log ("split_first_arg($l, $cdr, $string_wanted); mauvais format du 1er argument".print_r($lparts,1), "cachelab_ASSERT");
-	    exit;
+		spip_log("split_first_arg($l, $cdr, $string_wanted); mauvais format du 1er argument".print_r($lparts, 1), 'cachelab_ASSERT');
+		exit;
 	}
 	$car = array_shift($lparts);
 	if (!$car) {
-	    spip_log ("split_first_arg($l,$cdr,$string_wanted) : pb avec le 1er argument, reste lparts=".print_r($lparts,1), "cachelab_ASSERT");
-	    exit;
+		spip_log("split_first_arg($l,$cdr,$string_wanted) : pb avec le 1er argument, reste lparts=".print_r($lparts, 1), 'cachelab_ASSERT');
+		exit;
 	}
 
 	if ($lparts) {
-	    if ($string_wanted)
-		    $cdr = implode(' ', $lparts);
-	    else
-		    $cdr = $lparts;
+		if ($string_wanted) {
+			$cdr = implode(' ', $lparts);
+		} else {
+			$cdr = $lparts;
+		}
 	}
 
 	return array ($car, $cdr);
 }
 
-function split_f_arg($f, $arg='') {
-	spip_log("split_f_arg($f, $arg", "cachelab_OBSOLETE");
-	return split_first_arg ($f, $arg);
+function split_f_arg($f, $arg = '') {
+	spip_log("split_f_arg($f, $arg", 'cachelab_OBSOLETE');
+	return split_first_arg($f, $arg);
 }
 
-function slug_chemin($chemin, $sep='_') {
-	return str_replace ('/', $sep, $chemin);
+function slug_chemin($chemin, $sep = '_') {
+	return str_replace('/', $sep, $chemin);
 }
 
 if (!function_exists('plugin_est_actif')) {
@@ -53,4 +54,3 @@ if (!function_exists('plugin_est_actif')) {
 		return $f($prefixe, 'est_actif');
 	}
 }
-

inc/invalideur.php

@@ -92,9 +92,9 @@ function taille_du_cache() {
 	$time = isset($GLOBALS['meta']['cache_mark']) ? $GLOBALS['meta']['cache_mark'] : 0;
 	for ($i=0; $i < 256; $i++) {
 		$dir = _DIR_CACHE.sprintf('%02s', dechex($i));
-		if (@is_dir($dir) AND is_readable($dir) AND $d = @opendir($dir)) {
+		if (@is_dir($dir) and is_readable($dir) and $d = @opendir($dir)) {
 			while (($f = readdir($d)) !== false) {
-				if (preg_match(',^[[0-9a-f]+\.cache$,S', $f) AND $a = stat("$dir/$f")) {
+				if (preg_match(',^[[0-9a-f]+\.cache$,S', $f) and $a = stat("$dir/$f")) {
 					$n++;
 					if ($a['mtime'] >= $time) {
 						if ($a['blocks'] > 0) {
@@ -134,7 +134,10 @@ function taille_du_cache() {
  *     Nombre de fichiers supprimés
  **/
 function purger_repertoire($dir, $options = array()) {
-	$handle = @opendir($dir);
+	if (!is_dir($dir) or !is_readable($dir)) {
+		return;
+	}
+	$handle = opendir($dir);
 	if (!$handle) {
 		return;
 	}
@@ -157,8 +160,8 @@ function purger_repertoire($dir, $options = array()) {
 		} else {
 			if (is_dir($chemin)) {
 				$opts = $options;
-				if (isset($otpions['limit'])) {
-					$otps['limit'] = $otpions['limit'] - $total;
+				if (isset($options['limit'])) {
+					$opts ['limit'] = $options['limit'] - $total;
 				}
 				$total += purger_repertoire($chemin, $opts);
 				if (isset($options['subdir']) && $options['subdir']) {
@@ -195,9 +198,10 @@ function appliquer_quota_cache() {
 	$dir = sous_repertoire(_DIR_CACHE, $l);
 	list($nombre, $taille) = nombre_de_fichiers_repertoire($dir);
 	$total_cache = $taille * $nombre;
-	if ($total_cache)	// Ajout / core car c'est vide avec la memoization
+	if ($total_cache) {	// Ajout / core car c'est vide avec la memoization
 		spip_log("Taille du CACHE estimee ($l): "
-			. (intval(16 * $total_cache / (1024 * 1024 / 10)) / 10) . " Mo", "invalideur");
+			. (intval(16 * $total_cache / (1024 * 1024 / 10)) / 10) . ' Mo', 'invalideur');
+	}
 
 	// Nombre max de fichiers a supprimer
 	if ($GLOBALS['quota_cache'] > 0
@@ -206,16 +210,17 @@ function appliquer_quota_cache() {
 		$trop = $total_cache - ($GLOBALS['quota_cache'] / 16) * 1024 * 1024;
 		$trop = 3 * intval($trop / $taille);
 		if ($trop > 0) {
-			$n = purger_repertoire($dir,
+			$n = purger_repertoire(
+				$dir,
 				array(
 					'atime' => time() - _AGE_CACHE_ATIME,
 					'limit' => $trop,
 					'subdir' => true // supprimer les vieux sous repertoire de session (avant [15851])
 				)
 			);
-			spip_log("$dir : $n/$trop caches supprimes [taille moyenne $taille]", "invalideur");
+			spip_log("$dir : $n/$trop caches supprimes [taille moyenne $taille]", 'invalideur');
 			$total_cache = intval(max(0, (16 * $total_cache) - $n * $taille) / (1024 * 1024) * 10) / 10;
-			spip_log("cache restant estime : $total_cache Mo, ratio " . $total_cache / $GLOBALS['quota_cache'], "invalideur");
+			spip_log("cache restant estime : $total_cache Mo, ratio " . $total_cache / $GLOBALS['quota_cache'], 'invalideur');
 
 			// redemander la main pour eviter que le cache ne gonfle trop
 			// mais pas si on ne peut pas purger car les fichiers sont trops recents
@@ -224,7 +229,7 @@ function appliquer_quota_cache() {
 				and $n * 50 > $trop
 			) {
 				$encore = true;
-				spip_log("Il faut encore purger", "invalideur");
+				spip_log('Il faut encore purger', 'invalideur');
 			}
 		}
 	}
@@ -241,8 +246,9 @@ function appliquer_quota_cache() {
 function retire_cache($cache) {
 
 	if (preg_match(
-		"|^([0-9a-f]/)?([0-9]+/)?[0-9a-f]+\.cache(\.gz)?$|i",
-		$cache)) {
+		'|^([0-9a-f]/)?([0-9]+/)?[0-9a-f]+\.cache(\.gz)?$|i',
+		$cache
+	)) {
 		// supprimer le fichier (de facon propre)
 		supprimer_fichier(_DIR_CACHE . $cache);
 	} else {
@@ -257,8 +263,9 @@ function retire_cache($cache) {
 ## mais ici elles ne font plus rien
 ##
 
-if  (!defined('LOG_INVALIDATION_CORE'))
-	define ('LOG_INVALIDATION_CORE', false);
+if (!defined('LOG_INVALIDATION_CORE')) {
+	define('LOG_INVALIDATION_CORE', false);
+}
 
 // Supprimer les caches marques "x"
 // A priori dans cette version la fonction ne sera pas appelee, car
@@ -267,11 +274,13 @@ if  (!defined('LOG_INVALIDATION_CORE'))
 function retire_caches($chemin = '') {
 	if (isset($GLOBALS['meta']['invalider_caches'])) {
 		effacer_meta('invalider_caches');
-		if  (LOG_INVALIDATION_CORE)
-			spip_log ("retire_caches($chemin = '') ne devrait pas être appelé car ['meta']['invalider_caches'] devrait être false", "invalideur_core_retire_caches_BUG");
+		if (LOG_INVALIDATION_CORE) {
+			spip_log("retire_caches($chemin = '') ne devrait pas être appelé car ['meta']['invalider_caches'] devrait être false", 'invalideur_core_retire_caches_BUG');
+		}
 	} # concurrence
-	if  (LOG_INVALIDATION_CORE)
-		spip_log ("retire_caches($chemin = '')", "invalideur_core_retire_caches");
+	if (LOG_INVALIDATION_CORE) {
+		spip_log("retire_caches($chemin = '')", 'invalideur_core_retire_caches');
+	}
 }
 
 
@@ -286,18 +295,20 @@ function calcul_invalideurs($corps, $primary, &$boucles, $id_boucle) {
 // invoquee quand on vide tout le cache en bloc (action/purger)
 //
 // http://code.spip.net/@supprime_invalideurs
-function supprime_invalideurs() { 
-	if  (LOG_INVALIDATION_CORE)
-		spip_log ("supprime_invalideurs()", "invalideur_core");
+function supprime_invalideurs() {
+	if (LOG_INVALIDATION_CORE) {
+		spip_log('supprime_invalideurs()', 'invalideur_core');
+	}
 }
 
 // les invalideurs sont en général de la forme "objet/id_objet"
 // http://code.spip.net/@insere_invalideur
-// JAMAIS appelé par le noyau, 
+// JAMAIS appelé par le noyau,
 // ÉTAIT un hook post maj_invalideurs appelé avec $page['invalideurs'] et $fichier
-function insere_invalideur($inval, $fichier) { 
-	if  (LOG_INVALIDATION_CORE)
-		spip_log ("insere_invalideur($inval, $fichier)", "invalideur_core");
+function insere_invalideur($inval, $fichier) {
+	if (LOG_INVALIDATION_CORE) {
+		spip_log("insere_invalideur($inval, $fichier)", 'invalideur_core');
+	}
 }
 
 //
@@ -306,7 +317,8 @@ function insere_invalideur($inval, $fichier) {
 // http://code.spip.net/@applique_invalideur
 // JAMAIS appelé par le noyau
 // ÉTAIT un hook post suivre_invalideur avec la liste calculée des fichiers caches à invalider
-function applique_invalideur($depart) { 
-	if  (LOG_INVALIDATION_CORE)
-		spip_log ("applique_invalideur($depart)", "invalideur_core");
+function applique_invalideur($depart) {
+	if (LOG_INVALIDATION_CORE) {
+		spip_log("applique_invalideur($depart)", 'invalideur_core');
+	}
 }

lib/microtime.inc.php

@@ -2,56 +2,59 @@
 //
 // Chronométrage des appels php
 
-function eleg_microtime($time, $unit='') {
+function eleg_microtime($time, $unit = '') {
 	$time = round($time, 6);
 
 	switch ($unit) {
-	case 'ms' :
-		return ($time*1000).' ms';
-	case 'us' :
-	case 'µs' :
-		return ($time*1000000).' µs';
-	case 's' : nobreak;
-		return $time.'s';
-	case '' :
-		return $time;
+	case 'ms':
+			return ($time*1000).' ms';
+	case 'us':
+	case 'µs':
+			return ($time*1000000).' µs';
+	case 's':
+			nobreak;
+			return $time.'s';
+	case '':
+			return $time;
 	}
+	spip_log('mauvais parametre unit pour eleg_microtime', 'erreur_microtime');
+	return '';
 }
 // microtime_do reçoit des commandes et l'unité d'affichage us, ms ou s
 // begin : reset
 // now : microtime depuis init
 // end : now + begin
 // last : microtime depuis le dernier appel, sauf now
-function microtime_do ($command, $unit='') {
+function microtime_do($command, $unit = '') {
 static $u_init = 0;
 static $s_init = 0;
 static $u_last = 0;
 static $s_last = 0;
 	switch ($command) {
-	case 'begin' :
-	case 'init' :
+	case 'begin':
+	case 'init':
 		list ($u_last, $s_last) = list ($u_init, $s_init) = explode(' ', microtime());
-		return 0;
+			return 0;
 
-	case 'now' :
-		list ($u_last, $s_last) = explode(' ', microtime()); 
-		return eleg_microtime(($s_last - $s_init)+($u_last - $u_init), $unit);
+	case 'now':
+		list ($u_last, $s_last) = explode(' ', microtime());
+			return eleg_microtime(($s_last - $s_init)+($u_last - $u_init), $unit);
 
-	case 'end' :
-		list ($u_last, $s_last) = explode(' ', microtime()); 
+	case 'end':
+		list ($u_last, $s_last) = explode(' ', microtime());
 		$res = ($s_last - $s_init)+($u_last - $u_init);
 		$u_init = $u_last;
 		$s_init = $s_last;
-		return eleg_microtime($res, $unit);
+			return eleg_microtime($res, $unit);
 
-	case 'last' :
-		list ($u_now, $s_now) = explode(' ', microtime()); 
+	case 'last':
+		list ($u_now, $s_now) = explode(' ', microtime());
 		$res = ($s_now - $s_last)+($u_now - $u_last);
 		$u_last = $u_now;
 		$s_last = $s_now;
-		return eleg_microtime($res, $unit);
+			return eleg_microtime($res, $unit);
 
-	default :
-		die ("unknown microtime_do command « $command »");
-	};
+	default:
+			die("unknown microtime_do command « $command »");
+	}
 };

paquet.xml

@@ -1,14 +1,14 @@
 <paquet
 	prefix="cachelab"
-	categorie="outil"
-	version="0.99.0"
+	categorie="performance"
+	version="0.99.1"
 	etat="dev"
 	compatibilite="[3.0.0;3.3.*]"
 	logo="images/cachelab-32.png"
 	documentation="https://contrib.spip.net/5033"
 >
 	<nom>CacheLab</nom>
-	<!-- Invalidation ciblée et autres actions sur des caches APC filtrés des squelettes SPIP -->
+	<!-- Invalidation ciblée et autres actions sur les caches APC filtrés des squelettes SPIP -->
 	<auteur lien="https://contrib.spip.net/JLuc">JLuc</auteur>
 	<credit lien="https://thenounproject.com/term/lab/1796357/">Icone de Nawicon Studio, Licence Creative Commons</credit>
 

public/cachelab_balises.php

@@ -15,10 +15,10 @@ include_spip('inc/cachelab_utils');
  * - `cache-client` autorise gestion du IF_MODIFIED_SINCE
  * - `statique` ne respecte pas l'invalidation par modif de la base
  *   (mais s'invalide tout de même à l'expiration du delai)
- * - `calcul-methode` où la partie `methode` est variable et indique 
- *    la méthode de calcul dynamique de la durée cache à partir 
+ * - `calcul-methode` où la partie `methode` est variable et indique
+ *    la méthode de calcul dynamique de la durée cache à partir
  *    de son contenu yc ses métadonnées et notamment l'env
- *    Dans ce cas le 1er argument sert seulement pour compatibilité 
+ *    Dans ce cas le 1er argument sert seulement pour compatibilité
  *    si on désactive cachelab
  *
  * @balise
@@ -41,7 +41,7 @@ include_spip('inc/cachelab_utils');
  *     #CACHE{log,session anonyme}
  *     ```
  * @note
- *   En absence de durée indiquée par cette balise, 
+ *   En absence de durée indiquée par cette balise,
  *   la durée du cache est donnée
  *   par la constante `_DUREE_CACHE_DEFAUT`
  *
@@ -50,7 +50,7 @@ include_spip('inc/cachelab_utils');
  * @return Champ
  *     Pile complétée par le code à générer
  **/
-function balise_CACHE ($p) {
+function balise_CACHE($p) {
 	if ($p->param) {
 		$i = 0;
 
@@ -110,36 +110,36 @@ function balise_CACHE ($p) {
 				$methode = substr($pa, 6);
 				$ajout = "'<'.'" . '?php header("X-Spip-Methode-Duree-Cache: '.$methode.'"); ?' . "'.'>'";
 				$code .= $concat.$ajout;
-				spip_log ("#CACHE($pa) sur $sourcefile avec méthode de calcul de la durée du cache : $methode", 'cachelab_OBSOLETE');
+				spip_log("#CACHE($pa) sur $sourcefile avec méthode de calcul de la durée du cache : $methode", 'cachelab_OBSOLETE');
 			}
 
 			if (strpos($pa, 'filtre-')===0) {
-				$methode = substr($pa, 7); 
+				$methode = substr($pa, 7);
 				$ajout = "'<'.'" . '?php header("X-Spip-Filtre-Cache: '.$methode.'"); ?' . "'.'>'";
-				$code .= $concat.$ajout; 
-				spip_log ("#CACHE($pa) sur $sourcefile avec filtre sur le cache complet : $methode", 'cachelab_OBSOLETE');
+				$code .= $concat.$ajout;
+				spip_log("#CACHE($pa) sur $sourcefile avec filtre sur le cache complet : $methode", 'cachelab_OBSOLETE');
 			}
 // fin des syntaxes obsolètes
 
-			list ($func, $args) = split_first_arg ($pa);
+			list ($func, $args) = split_first_arg($pa);
 			switch ($func) {
 			// TODO : également traiter ici les morceaux du core traités plus haut
-			case 'statique' : 
-			case 'duree' :
+			case 'statique':
+			case 'duree':
 				$ajout = "'<'.'" . "?php header(\"X-Spip-Methode-Duree-Cache: $args\"); ?" . "'.'>'";
 				$code .= $concat.$ajout;
-				spip_log ("#CACHE{$pa} sur $sourcefile avec méthode de calcul de la durée du cache : $args", 'cachelab');
-				break;
+				spip_log("#CACHE{$pa} sur $sourcefile avec méthode de calcul de la durée du cache : $args", 'cachelab');
+					break;
 			
-			case 'log' :
-			case 'session' :
-			case 'filtre' :
+			case 'log':
+			case 'session':
+			case 'filtre':
 				$ajout = "'<'.'" . '?php header("X-Spip-Filtre-Cache: '.$pa.'"); ?' . "'.'>'";
-				$code .= $concat.$ajout; 
-				spip_log ("#CACHE{$pa} sur $sourcefile : filtre  $func($args) sur le cache complet", 'cachelab');
-				break;
-			default :
-				break;
+				$code .= $concat.$ajout;
+				spip_log("#CACHE{$pa} sur $sourcefile : filtre  $func($args) sur le cache complet", 'cachelab');
+					break;
+			default:
+					break;
 			}
 		}
 	} else {
@@ -153,7 +153,7 @@ function balise_CACHE ($p) {
 
 
 //
-// Calcul de durée de cache dynamique progressive 
+// Calcul de durée de cache dynamique progressive
 // adapté pour un affichage approximatif et habituel
 // du type "il y a 20 secondes", "il y a 3 minutes", "ce matin",
 // "hier soir", "la semaine dernière" ou "il y a 3 mois"
@@ -168,30 +168,41 @@ function balise_CACHE ($p) {
 //
 function cachelab_duree_progapprox($date_creation) {
 	$dt_creation = new DateTime($date_creation);
-	if (!$dt_creation)
+	if (!$dt_creation) {
 		return _DUREE_CACHE_DEFAUT;
+	}
 
-	$interval = $dt_creation->diff(new DateTime('NOW'),true); // valeur absolue
-	if (!$interval)
+	$interval = $dt_creation->diff(new DateTime('NOW'), true); // valeur absolue
+	if (!$interval) {
 		return _DUREE_CACHE_DEFAUT;
-	if ($interval->y > 2)
+	}
+	if ($interval->y > 2) {
 		return 6*30*24*3600; // 6 mois si plus de 2 ans
-	if ($interval->y)
+	}
+	if ($interval->y) {
 		return 30*24*3600;	// 1 mois si plus d'un an
-	if ($interval->m)
+	}
+	if ($interval->m) {
 		return 7*24*3600;	// 1 semaine si plus d'un mois
-	if ($interval->d > 7)
+	}
+	if ($interval->d > 7) {
 		return 24*3600;		// 1 jour si plus d'une semaine
-	if ($interval->d)
+	}
+	if ($interval->d) {
 		return 6*3600;		// 6h si plus d'un jour
-	if ($interval->h > 6)
+	}
+	if ($interval->h > 6) {
 		return 3600;		// 1h si plus de 6h
-	if ($interval->h)
+	}
+	if ($interval->h) {
 		return 30*60;		// 1/2h si plus d'1h
-	if ($interval->i > 10)
+	}
+	if ($interval->i > 10) {
 		return 10*60;		// 10 minutes si plus de 10 minutes
-	if ($interval->i)
+	}
+	if ($interval->i) {
 		return 60;			// chaque minute si plus d'une minute
+	}
 	return 10;				// 10secondes si moins d'une minute
 }
 
@@ -202,7 +213,7 @@ function cachelab_duree_progapprox($date_creation) {
  * @return int : le nombre de secondes restant jusqu'au prochain minuit cinq
  */
 function cachelab_duree_jusqueminuit($date_unused) {
-    return strtotime('tomorrow') + 300 - time();
+	return strtotime('tomorrow') + 300 - time();
 }
 
 //
@@ -210,7 +221,7 @@ function cachelab_duree_jusqueminuit($date_unused) {
 // dans un fichier de log dont le nom reprend le chemin du squelette
 // (avec les / remplacés par des _)
 //
-// Exemples d'usages : 
+// Exemples d'usages :
 //	#CACHE{3600,log} : log tout le cache, méta et html
 //	#CACHE{log lastmodified}  : log l'entrée lastmodified du cache
 // 	#CACHE{log contexte} : log tout le tableau d'environnement
@@ -218,24 +229,22 @@ function cachelab_duree_jusqueminuit($date_unused) {
 //
 function cachelab_filtre_log($cache, $arg) {
 	if (!is_array($cache) or !isset($cache['source']) or !isset($cache['lastmodified']) or !isset($cache['invalideurs'])) {
-		spip_log ("cachelab_duree_progapprox ne reçoit pas un cache mais".print_r($cache,1), "cachelab_assert");
+		spip_log('cachelab_duree_progapprox ne reçoit pas un cache mais'.print_r($cache, 1), 'cachelab_assert');
 		return null;
 	}
 	$source_limace = slug_chemin($cache['source']);
 	$arg=trim($arg);
-	if ($arg) { 
+	if ($arg) {
 		if (strpos($arg, '/')) {	#CACHE{log i/j}
-			$ij=explode('/',$arg);
+			$ij=explode('/', $arg);
 			$c = $cache[$i=trim(array_shift($ij))];
-			$c = $c[trim($j=array_shift($ij))];
-		}
-		else {						#CACHE{log i}
+			$c = $c[trim($j = array_shift($ij))];
+		} else {						#CACHE{log i}
 			$c = $cache[$arg];
 		}
+	} else { 		$c = $cache;				#CACHE{log}
 	}
-	else
-		$c = $cache;				#CACHE{log}
-	spip_log ("cache[$arg] : ".print_r($c,1), "cachelab_".$source_limace);
+	spip_log("cache[$arg] : ".print_r($c, 1), 'cachelab_'.$source_limace);
 }
 
 
@@ -255,15 +264,15 @@ function cachelab_filtre_log($cache, $arg) {
 // #CACHE{session assert oui_login} s'assure que tous les emplois sont sessionnés avec un internaute identifié
 // #CACHE{session assert oui_anonyme} s'assure que tous les emplois sont sessionnés avec un internaute identifié (inutile ?)
 // #CACHE{session assert anonyme} s'assure que tous les emplois sans internaute identifié
-// 
+//
 // #CACHE{session log} loge l'état du sessionnement dans un cache dédié à ce squelette
 // #CACHE{session insert} insère à la fin du cache l'affichage de l'état du sessionnement
-// #CACHE{session echo} affiche l'état du sessionnement comme var_cache 
+// #CACHE{session echo} affiche l'état du sessionnement comme var_cache
 // mais pour ce cache seulement et seulement pour les caches dynamiques
 //
-function cachelab_filtre_session (&$cache, $totarg) {
+function cachelab_filtre_session(&$cache, $totarg) {
 	if (!is_array($cache) or !isset($cache['source']) or !isset($cache['lastmodified']) or !isset($cache['invalideurs'])) {
-		spip_log ("cachelab_filtre_assertsession ne reçoit pas un cache mais".print_r($cache,1), "cachelab_assert");
+		spip_log('cachelab_filtre_assertsession ne reçoit pas un cache mais'.print_r($cache, 1), 'cachelab_assert');
 		return null;
 	}
 	$source = $cache['source'];
@@ -275,27 +284,27 @@ function cachelab_filtre_session (&$cache, $totarg) {
 	$sess = cachelab_etat_sessionnement($invalideurs, 'avec_details');
 	$avec_echo = false;
 	switch ($func) {
-		case 'assert_echo' :
+		case 'assert_echo':
 			$avec_echo = true;
-		case 'assert' :
-			switch($what) {
-				case 'oui_login' :
-				case 'oui_anonyme' :
-				case 'non' :
+		case 'assert':
+			switch ($what) {
+				case 'oui_login':
+				case 'oui_anonyme':
+				case 'non':
 					$ok = ($sess==$what);
 					break;
-				case 'anonyme' :
+				case 'anonyme':
 					$ok = empty($invalideurs['session']);	// oui_anonyme ou non
 					break;
-				case 'oui' :
+				case 'oui':
 					$ok = isset($invalideurs['session']);	// oui_anonyme ou oui_login
 					break;
 				default:
-					spip_log ("Erreur de syntaxe : '$what' incorrect dans #CACHE{session $totarg}, il faut oui, oui_login, oui_anonyme, non ou anonyme", 'cachelab_erreur');
+					spip_log("Erreur de syntaxe : '$what' incorrect dans #CACHE{session $totarg}, il faut oui, oui_login, oui_anonyme, non ou anonyme", 'cachelab_erreur');
 					break 2;
 			}
-			if (!$ok)  {
-				spip_log ("$source : session n'est pas '$what'. invalideurs=".print_r($invalideurs,1), "cachelab_assertsession");
+			if (!$ok) {
+				spip_log("$source : session n'est pas '$what'. invalideurs=".print_r($invalideurs, 1), 'cachelab_assertsession');
 				if ($avec_echo) {
 					echo "<div class='cachelab_blocs cachelab_assert'>
 						<h6>Sessionnement $sess devrait être $what</h6>
@@ -305,34 +314,36 @@ function cachelab_filtre_session (&$cache, $totarg) {
 			}
 			break;
 
-	case 'insert' :
+	case 'insert':
 		global $Memoization;
 		if (!isset($Memoization)) {
-			spip_log ("Erreur dans $source : #CACHE{session insert} nécessite que le plugin Memoization soit activé", 'cachelab_erreur');
+			spip_log("Erreur dans $source : #CACHE{session insert} nécessite que le plugin Memoization soit activé", 'cachelab_erreur');
 			echo "<div class='cachelab_blocs'><h6>Erreur dans $source : #CACHE{session insert} nécessite que le plugin Memoization soit activé</h6></div>";
 			break;
 		}
 		$cache['texte'] .= '<'."?php echo '<div class=\"cachelab_blocs\"><h6>$source sessionné : $sess</h6></div>' ?>";
 		$cache['process_ins'] = 'php';
-		break;
-	case 'echo' :
+			break;
+	case 'echo':
 		echo "<div class='cachelab_blocs'><h6>$source sessionné : $sess</h6></div>";
-		break;
-	case 'log' :
-		spip_log ('session : '.$sess, 'cachelab_session_'.$source_limace);
-		break;
-	default : 
-		spip_log ("Syntaxe incorrecte dans $source : $func inconnu dans #CACHE{session $totarg}", 'cachelab_erreur');
-		break;
+			break;
+	case 'log':
+		spip_log('session : '.$sess, 'cachelab_session_'.$source_limace);
+			break;
+	default:
+		spip_log("Syntaxe incorrecte dans $source : $func inconnu dans #CACHE{session $totarg}", 'cachelab_erreur');
+			break;
 	}
 }
 
-function cachelab_etat_sessionnement ($invalideurs, $detail=false) {
-	if (!isset($invalideurs['session']))
+function cachelab_etat_sessionnement($invalideurs, $detail = false) {
+	if (!isset($invalideurs['session'])) {
 		return 'non';
-	if (!$detail)
+	}
+	if (!$detail) {
 		return 'oui';
-	elseif ($invalideurs['session'])
+	} elseif ($invalideurs['session']) {
 		return 'oui_login';
+	}
 	return 'oui_anonyme';
 }