Browse Source

Sauvegarde parce les reboots ça commence à bien faire.

svn/attic/tags/v010/106508
eric@smellup.net 5 years ago
parent
commit
d1f4674a37
  1. 6
      inc/ncore_cache.php
  2. 61
      inc/ncore_compilation.php
  3. 99
      inc/ncore_noisette.php
  4. 368
      inc/ncore_type_noisette.php
  5. 212
      ncore_fonctions.php
  6. 221
      ncoredata/ncore.php

6
inc/ncore_cache.php

@ -55,7 +55,7 @@ if (!defined('_NCORE_NOMCACHE_NOISETTE_CONTEXTE')) {
/**
* Lit le cache spécifié pour un plugin donné et renvoie le contenu sous forme de tableau
* Lit le cache spécifié d'un plugin donné et renvoie le contenu sous forme de tableau
* éventuellement vide.
*
* @api
@ -88,7 +88,7 @@ function cache_lire($plugin, $nom_cache) {
/**
* Ecrit le contenu d'un tableau dans le cache spécifié pour un plugin donné.
* Ecrit le contenu d'un tableau dans le cache spécifié d'un plugin donné.
*
* @api
* @uses ecrire_fichier_securise()
@ -124,7 +124,7 @@ function cache_ecrire($plugin, $nom_cache, $contenu_cache) {
/**
* Supprime le cache cache spécifié pour un plugin donné.
* Supprime le cache cache spécifié d'un plugin donné.
*
* @api
* @uses supprimer_fichier()

61
inc/ncore_compilation.php

@ -0,0 +1,61 @@
<?php
/**
* Ce fichier contient les fonctions du service N-Core pour les noisettes.
*
* Chaque fonction, soit aiguille vers une fonction "homonyme" propre au service si elle existe,
* soit déroule sa propre implémentation pour le service appelant.
* Ainsi, les services externes peuvent, si elle leur convient, utiliser l'implémentation proposée par N-Core
* sans coder la moindre fonction.
*
* @package SPIP\NCORE\NOISETTE\SERVICE
*/
if (!defined('_ECRIRE_INC_VERSION')) {
return;
}
if (!defined('_NCORE_CONFIG_AJAX_DEFAUT')) {
/**
* Valeur par défaut de la configuration AJAX des noisettes.
* Pour N-Core, le défaut est `true`.
*
*/
define('_NCORE_CONFIG_AJAX_DEFAUT', true);
}
if (!defined('_NCORE_DYNAMIQUE_DEFAUT')) {
/**
* Valeur par défaut de l'indicateur d'inclusion dynamique des noisettes.
* Pour N-Core, le défaut est `false`.
*/
define('_NCORE_DYNAMIQUE_DEFAUT', false);
}
/**
* Renvoie la configuration par défaut de l'ajax à appliquer pour les noisettes.
* Cette information est utilisée si la description YAML d'une noisette ne contient pas de tag ajax
* ou contient un tag ajax à `defaut`.
*
* Le service N-Core considère que toute noisette est par défaut insérée en ajax.
*
* @param string $service
* Le service permet de distinguer l'appelant qui peut-être un plugin comme le noiZetier ou
* un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
* Cet argument n'est utilisé que si la fonction N-Core est appelée.
*
* @return bool
* `true` si par défaut une noisette est insérée en ajax, `false` sinon.
*/
function ncore_noisette_config_ajax($service) {
// On recherche au préalable si il existe une fonction propre au service et si oui on l'appelle.
include_spip("ncore/${service}");
$config_ajax = "${service}_noisette_config_ajax";
if (function_exists($config_ajax)) {
$defaut_ajax = $config_ajax();
} else {
// Le service ne propose pas de fonction propre, on utilise celle de N-Core.
$defaut_ajax = _NCORE_CONFIG_AJAX_DEFAUT;
}
return $defaut_ajax;
}

99
inc/ncore_noisette.php

@ -1,99 +0,0 @@
<?php
if (!defined('_ECRIRE_INC_VERSION')) {
return;
}
/**
* Phrase le fichier YAML d'une espece de noisette et renvoie sa description si celle-ci a changé
* sinon renvoie un indicateur permettant de savoir que le YAML est identique.
*
* @param string $noisette
* @param array $options
*
* @return array
*/
function noisette_phraser($noisette, $options = array()) {
// Initialisation de la description
$description = array();
// Initialiser le contexte de chargement
if (!isset($options['dossier'])) {
$options['dossier'] = 'noisettes/';
}
if (!isset($options['recharger'])) {
$options['recharger'] = false;
}
if (!isset($options['md5']) or $options['recharger']) {
$options['md5'] = '';
}
// Initialiser les composants de l'identifiant de la noisette:
// - type-noisette si la noisette est dédiée uniquement à une page
// - type-composition-noisette si la noisette est dédiée uniquement à une composition
// - noisette sinon
$type = '';
$composition = '';
$identifiants = explode('-', $noisette);
if (isset($identifiants[1])) {
$type = $identifiants[0];
}
if (isset($identifiants[2])) {
$composition = $identifiants[1];
}
// Initialisation de la description par défaut de la page
$description_defaut = array(
'noisette' => $noisette,
'type' => $type,
'composition' => $composition,
'nom' => $noisette,
'description' => '',
'icon' => 'noisette-24.png',
'necessite' => array(),
'contexte' => array(),
'ajax' => 'defaut',
'inclusion' => 'statique',
'parametres' => array(),
'signature' => '',
);
// Recherche des noisettes par leur fichier YAML uniquement.
$md5 = '';
$fichier = isset($options['yaml']) ? $options['yaml'] : find_in_path("{$options['dossier']}${noisette}.yaml");
if ($fichier) {
// il y a un fichier YAML de configuration, on vérifie le md5 avant de charger le contenu.
$md5 = md5_file($fichier);
if ($md5 != $options['md5']) {
include_spip('inc/yaml');
$description = yaml_charger_inclusions(yaml_decode_file($fichier));
// Traitements des champs pouvant être soit une chaine soit un tableau
if (!empty($description['necessite']) and is_string($description['necessite'])) {
$description['necessite'] = array($description['necessite']);
}
if (!empty($description['contexte']) and is_string($description['contexte'])) {
$description['contexte'] = array($description['contexte']);
}
}
}
// Si la description est remplie c'est que le chargement a correctement eu lieu.
// Sinon, si la noisette n'a pas changée on renvoie une description limitée à un indicateur d'identité pour
// distinguer ce cas avec une erreur de chargement qui renvoie une description vide.
if ($description) {
// Mise à jour du md5
$description['signature'] = $md5;
// Complétude de la description avec les valeurs par défaut
$description = array_merge($description_defaut, $description);
// Sérialisation des champs necessite, contexte et parametres qui sont des tableaux
$description['necessite'] = serialize($description['necessite']);
$description['contexte'] = serialize($description['contexte']);
$description['parametres'] = serialize($description['parametres']);
} elseif ($md5 == $options['md5']) {
$description['identique'] = true;
}
return $description;
}

368
inc/ncore_type_noisette.php

@ -0,0 +1,368 @@
<?php
/**
* Ce fichier contient l'API N-Core de gestion des types de noisettes (squelettes).
*
* @package SPIP\NCORE\TYPE_NOISETTE
*/
if (!defined('_ECRIRE_INC_VERSION')) {
return;
}
/**
* Charge ou recharge les descriptions des types de noisette à partir des fichiers YAML.
* Les types de noisettes (squelettes) sont recherchés dans un répertoire relatif fourni en argument.
* La fonction optimise le chargement en effectuant uniquement les traitements nécessaires
* en fonction des modifications, ajouts et suppressions des types de noisettes identifiés en comparant les md5
* des fichiers YAML.
*
* @api
*
* @param string $plugin
* Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier
* ou un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
* @param string $dossier
* Chemin relatif (avec un `/` final) dans lequel chercher les fichiers YAML de description des noisettes.
* Par défaut, les noisettes seront recherchées dans le dossier `noisettes/`.
* @param bool $recharger
* Si `true` force le rechargement de toutes les types de noisettes, sinon le chargement se base sur le
* md5 des fichiers YAML. Par défaut vaut `false`.
* @param string $stockage
* `stockage` : impose le type de stockage à utiliser pour les descriptions d'types de noisette et
* les signatures des fichiers YAML. Par défaut, la fonction cherche à utiliser le stockage fourni par le
* le plugin appelant et, à défaut, celui fourni par N-Core.
*
* @return bool
* `false` si une erreur s'est produite, `true` sinon.
*/
function ncore_type_noisette_charger($plugin, $dossier = 'noisettes/', $recharger = false, $stockage = '') {
// Retour de la fonction
$retour = true;
// Initialiser le contexte de rechargement
// TODO : voir si on ajoute un var_mode=recalcul_noisettes ?
// On recherche les types de noisette directement par leur fichier YAML de configuration car il est
// obligatoire. La recherche s'effectue dans le path en utilisant le dossier relatif fourni.
if ($fichiers = find_all_in_path($dossier, '.+[.]yaml$')) {
// On charge l'API de stockge de N-Core.
// Ce sont ces fonctions qui aiguillent ou pas vers une éventuelle fonction spécifique de stockage.
include_spip("ncoredata/ncore");
// Initialisation des tableaux de types de noisette.
$types_a_ajouter = $types_a_changer = $types_a_effacer = array();
// Récupération des signatures md5 des noisettes déjà enregistrées.
// Si on force le rechargement il est inutile de gérer les signatures et les noisettes modifiées ou obsolètes.
$signatures = array();
if (!$recharger) {
$signatures = ncore_type_noisette_lister($plugin, 'signature', $stockage);
// On initialise la liste des types de noisette à supprimer avec l'ensemble des types de noisette déjà stockés.
$types_a_effacer = $signatures ? array_keys($signatures) : array();
}
foreach ($fichiers as $_squelette => $_chemin) {
$type_noisette = basename($_squelette, '.yaml');
// Si on a forcé le rechargement ou si aucun md5 n'est encore stocké pour le type de noisette
// on positionne la valeur du md5 stocké à chaine vide.
// De cette façon, on force la lecture du fichier YAML du type de noisette.
$md5_stocke = (isset($signatures[$type_noisette]) and !$recharger)
? $signatures[$type_noisette]
: '';
// Initialiser les composants de l'identifiant du type de noisette:
// - type_page-type_noisette si le type de noisette est dédié uniquement à une page
// - type_page-composition-type_noisette si le type de noisette est dédié uniquement à une composition
// - type_noisette sinon
$type = '';
$composition = '';
$identifiants = explode('-', $type_noisette);
if (isset($identifiants[1])) {
$type = $identifiants[0];
}
if (isset($identifiants[2])) {
$composition = $identifiants[1];
}
// Initialisation de la description par défaut du type de noisette
// -- on y inclut le plugin appelant et la signature
$description_defaut = array(
'noisette' => $type_noisette,
'plugin' => $plugin,
'type' => $type,
'composition' => $composition,
'nom' => $type_noisette,
'description' => '',
'icon' => 'noisette-24.png',
'necessite' => array(),
'contexte' => array(),
'ajax' => 'defaut',
'inclusion' => 'statique',
'parametres' => array(),
'signature' => '',
);
// On vérifie que le md5 du fichier YAML est bien différent de celui stocké avant de charger
// le contenu. Sinon, on passe au fichier suivant.
$md5 = md5_file($_chemin);
if ($md5 != $md5_stocke) {
include_spip('inc/yaml');
$description = yaml_charger_inclusions(yaml_decode_file($_chemin));
// Traitements des champs pouvant être soit une chaine soit un tableau
if (!empty($description['necessite']) and is_string($description['necessite'])) {
$description['necessite'] = array($description['necessite']);
}
if (!empty($description['contexte']) and is_string($description['contexte'])) {
$description['contexte'] = array($description['contexte']);
}
// On n'inclue ce type de noisette que si les plugins qu'il nécessite explicitement dans son
// fichier de configuration sont bien tous activés.
// Rappel: si un type de noisette est incluse dans un plugin non actif elle ne sera pas détectée
// lors du find_all_in_path() puisque le plugin n'est pas dans le path SPIP.
// Ce n'est pas ce cas qui est traité ici.
$type_noisette_a_garder = true;
if (!empty($description['necessite'])) {
foreach ($description['necessite'] as $_plugin_necessite) {
if (!defined('_DIR_PLUGIN_'.strtoupper($_plugin_necessite))) {
$type_noisette_a_garder = false;
break;
}
}
}
// Si la noisette est à garder on finalise sa description et on détermine si elle est nouvelle ou modifiée.
// En mode rechargement forcé toute noisette est considérée comme nouvelle.
// Sinon, la noisette doit être retirée de la base car un plugin qu'elle nécessite a été désactivée:
// => il suffit pour cela de la laisser dans la liste des noisettes obsolètes.
if ($type_noisette_a_garder) {
// Mise à jour du md5
$description['signature'] = $md5;
// Complétude de la description avec les valeurs par défaut
$description = array_merge($description_defaut, $description);
// Sérialisation des champs necessite, contexte et parametres qui sont des tableaux
$description['necessite'] = serialize($description['necessite']);
$description['contexte'] = serialize($description['contexte']);
$description['parametres'] = serialize($description['parametres']);
if (!$md5_stocke or $recharger) {
// Le type de noisette est soit nouveau soit on est en mode rechargement forcé:
// => il faut le rajouter.
$types_a_ajouter[] = $description;
} else {
// La description stockée a été modifiée et le mode ne force pas le rechargement:
// => il faut mettre à jour le type de noisette.
$types_a_changer[] = $description;
// => et il faut donc le supprimer de la liste de types de noisette obsolètes
$types_a_effacer = array_diff($types_a_effacer, array($type_noisette));
}
} else {
// Le type de noisette ne peut plus être utilisé car un des plugins qu'il nécessite n'est plus actif.
// => il faut le laisser dans la liste des obsolètes.
continue;
}
} else {
// Le type de noisette n'a pas changé et n'a donc pas été réchargé:
// => Il faut donc juste indiquer qu'il n'est pas obsolète.
$types_a_effacer = array_diff($types_a_effacer, array($type_noisette));
}
}
// Mise à jour du stockage des types de noisette si au moins un des 3 tableaux est non vide et que le chargement forcé
// n'est pas demandé:
// -- Suppression des types de noisettes obsolètes ou de tous les types de noisettes si on est en mode rechargement forcé.
// Pour permettre une optimisation du traitement en mode rechargement forcé on passe toujours le mode.
// -- Update des types de noisette modifiés.
// -- Insertion des nouveaux types de noisette.
if ($recharger
or (!$recharger and ($types_a_ajouter or $types_a_effacer or $types_a_changer))) {
$types_noisette = array('a_ajouter' => $types_a_ajouter);
if (!$recharger) {
$types_noisette['a_effacer'] = $types_a_effacer;
$types_noisette['a_changer'] = $types_a_changer;
}
$retour = ncore_type_noisette_stocker($plugin, $types_noisette, $recharger, $stockage);
}
}
return $retour;
}
/**
* Retourne la description complète ou seulement une information précise pour une noisette donnée.
* Les données textuelles peuvent subir une traitement typo si demandé.
*
* @api
*
* @param string $plugin
* Le service permet de distinguer l'appelant qui peut-être un plugin comme le noiZetier ou
* un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
* La fonction utilisera la fonction de lecture de la description brute d'une noisette, spécifique
* au service, ou à défaut, celle fournie par N-Core.
* @param string $noisette
* Identifiant de la $noisette.
* @param string $information
* Information spécifique à retourner ou vide pour retourner toute la description.
* @param boolean $traiter_typo
* Indique si les données textuelles doivent être retournées brutes ou si elles doivent être traitées
* en utilisant la fonction _T_ou_typo. Par défaut l'indicateur vaut `false`.
* Les champs sérialisés sont eux toujours désérialisés.
*
* @return array|string
* La description complète ou l'information précise demandée pour une noisette donnée. Les champs
* de type tableau sont systématiquement désérialisés et si demandé, les champs textuels peuvent être
* traités avec la fonction _T_ou_typo().
*/
function ncore_type_noisette_informer($plugin, $noisette, $information = '', $traiter_typo = false) {
// On indexe le tableau des indicateurs ajax par le plugin appelant en cas d'appel sur le même hit
// par deux plugins différents.
static $donnees_typo = array('nom', 'description');
static $description_noisette = array();
// Stocker la description de la noisette si besoin
if (!isset($description_noisette[$plugin][$noisette])) {
// On charge l'API de N-Core.
// Ce sont ces fonctions qui aiguillent ou pas vers une fonction spécifique du service.
include_spip("ncoredata/ncore");
// Lecture de toute la configuration de la noisette: les données retournées sont brutes.
$description = ncore_type_noisette_decrire($plugin, $noisette);
// Sauvegarde de la description de la page pour une consultation ultérieure dans le même hit.
if ($description) {
// Traitements des champs tableaux sérialisés
$description['contexte'] = unserialize($description['contexte']);
$description['necessite'] = unserialize($description['necessite']);
$description['parametres'] = unserialize($description['parametres']);
// Stockage de la description
$description_noisette[$plugin][$noisette] = $description;
} else {
$description_noisette[$plugin][$noisette] = array();
}
}
if ($information) {
if (isset($description_noisette[$plugin][$noisette][$information])) {
if (in_array($information, $donnees_typo) and $traiter_typo) {
// Traitements de la donnée textuelle
$retour = _T_ou_typo($description_noisette[$plugin][$noisette][$information]);
} else {
$retour = $description_noisette[$plugin][$noisette][$information];
}
} else {
$retour = '';
}
} else {
$retour = $description_noisette[$plugin][$noisette];
// Traitements des données textuels
if ($traiter_typo) {
$retour['nom'] = _T_ou_typo($retour['nom']);
if (isset($retour['description'])) {
$retour['description'] = _T_ou_typo($retour['description']);
}
}
}
return $retour;
}
/**
* Phrase le fichier YAML d'une espece de noisette et renvoie sa description si celle-ci a changé
* sinon renvoie un indicateur permettant de savoir que le YAML est identique.
*
* @param string $noisette
* @param array $options
*
* @return array
*/
function noisette_phraser($noisette, $options = array()) {
// Initialisation de la description
$description = array();
// Initialiser le contexte de chargement
if (!isset($options['dossier'])) {
$options['dossier'] = 'noisettes/';
}
if (!isset($options['recharger'])) {
$options['recharger'] = false;
}
if (!isset($options['md5']) or $options['recharger']) {
$options['md5'] = '';
}
// Initialiser les composants de l'identifiant de la noisette:
// - type-noisette si la noisette est dédiée uniquement à une page
// - type-composition-noisette si la noisette est dédiée uniquement à une composition
// - noisette sinon
$type = '';
$composition = '';
$identifiants = explode('-', $noisette);
if (isset($identifiants[1])) {
$type = $identifiants[0];
}
if (isset($identifiants[2])) {
$composition = $identifiants[1];
}
// Initialisation de la description par défaut de la page
$description_defaut = array(
'noisette' => $noisette,
'type' => $type,
'composition' => $composition,
'nom' => $noisette,
'description' => '',
'icon' => 'noisette-24.png',
'necessite' => array(),
'contexte' => array(),
'ajax' => 'defaut',
'inclusion' => 'statique',
'parametres' => array(),
'signature' => '',
);
// Recherche des noisettes par leur fichier YAML uniquement.
$md5 = '';
$fichier = isset($options['yaml']) ? $options['yaml'] : find_in_path("{$options['dossier']}${noisette}.yaml");
if ($fichier) {
// il y a un fichier YAML de configuration, on vérifie le md5 avant de charger le contenu.
$md5 = md5_file($fichier);
if ($md5 != $options['md5']) {
include_spip('inc/yaml');
$description = yaml_charger_inclusions(yaml_decode_file($fichier));
// Traitements des champs pouvant être soit une chaine soit un tableau
if (!empty($description['necessite']) and is_string($description['necessite'])) {
$description['necessite'] = array($description['necessite']);
}
if (!empty($description['contexte']) and is_string($description['contexte'])) {
$description['contexte'] = array($description['contexte']);
}
}
}
// Si la description est remplie c'est que le chargement a correctement eu lieu.
// Sinon, si la noisette n'a pas changée on renvoie une description limitée à un indicateur d'identité pour
// distinguer ce cas avec une erreur de chargement qui renvoie une description vide.
if ($description) {
// Mise à jour du md5
$description['signature'] = $md5;
// Complétude de la description avec les valeurs par défaut
$description = array_merge($description_defaut, $description);
// Sérialisation des champs necessite, contexte et parametres qui sont des tableaux
$description['necessite'] = serialize($description['necessite']);
$description['contexte'] = serialize($description['contexte']);
$description['parametres'] = serialize($description['parametres']);
} elseif ($md5 == $options['md5']) {
$description['identique'] = true;
}
return $description;
}

212
ncore_fonctions.php

@ -12,218 +12,6 @@ if (!defined('_ECRIRE_INC_VERSION')) {
// ------------------------- API COMPILATION ---------------------------
// -------------------------------------------------------------------
/**
* Charge ou recharge les descriptions de noisettes à partir des fichiers YAML.
* Les noisettes sont recherchées dans un répertoire relatif fourni en argument.
* La fonction optimise le chargement en effectuant uniquement les traitements nécessaires
* en fonction des modifications, ajouts et suppressions de noisettes identifiés en comparant les md5
* des fichiers YAML.
*
* @api
*
* @param string $service
* Le service permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
* un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
* La fonction utilisera les fonctions de lecture des md5 et de stockage des descriptions de noisettes,
* spécifiques au service, ou à défaut, celles fournies par N-Core.
* @param string $dossier
* Chemin relatif (avec un `/` final) dans lequel chercher les fichiers YAML de description des noisettes.
* Par défaut, les noisettes seront recherchées dans le dossier `noisettes/`.
* @param bool $recharger
* Si `true` forcer le rechargement de toutes les noisettes, sinon le traitement se base sur
* le md5 des fichiers YAML.
*
* @return bool
* `false` si une erreur s'est produite, `true` sinon.
*/
function ncore_noisette_charger($service, $dossier = 'noisettes/', $recharger = false) {
// Retour de la fonction
$retour = true;
// Initialiser le contexte de rechargement
// -- TODO : en attente de voir si on rajoute un var_mode=recalcul_noisettes
$options['recharger'] = $recharger;
// On recherche les noisettes directement par leur fichier YAML de configuration car il est obligatoire
// -- la recherche s'effectue dans
if ($fichiers = find_all_in_path($dossier, '.+[.]yaml$')) {
// On charge l'API de NCore.
// Ce sont ces fonctions qui aiguillent ou pas vers une fonction spécifique du service.
include_spip("ncore/ncore");
// Initialisation des tableaux de noisettes
$noisettes_nouvelles = $noisettes_modifiees = $noisettes_obsoletes = array();
// Récupération des signatures md5 des noisettes déjà enregistrées.
// Si on force le rechargement il est inutile de gérer les signatures et les noisettes modifiées ou obsolètes.
$signatures = array();
if (!$options['recharger']) {
$signatures = ncore_noisette_lister_signatures($service);
// On initialise la liste des noisettes à supprimer avec l'ensemble des noisettes en base de données.
$noisettes_obsoletes = $signatures ? array_keys($signatures) : array();
}
include_spip('inc/ncore_noisette');
foreach ($fichiers as $_squelette => $_chemin) {
$noisette = basename($_squelette, '.yaml');
// On passe le md5 de la page si il existe sinon la chaine vide. Cela permet de déterminer
// si on doit ajouter la page ou la mettre à jour.
// Si le md5 est le même et qu'il n'est donc pas utile de recharger la page, la configuration
// retournée est vide.
$options['md5'] = isset($signatures[$noisette]) ? $signatures[$noisette] : '';
$options['yaml'] = $_chemin;
if ($configuration = noisette_phraser($noisette, $options)) {
if (empty($configuration['identique'])) {
// La noisette a été chargée (nouvelle) ou rechargée (modifiée).
// Néanmoins, on n'inclue cette noisette que si les plugins qu'elle nécessite explicitement dans son
// fichier de configuration sont bien tous activés.
// Rappel: si une noisette est incluse dans un plugin non actif elle ne sera pas détectée
// lors du find_all_in_path() puisque le plugin n'est pas dans le path SPIP.
// Ce n'est pas ce cas qui est traité ici.
$noisette_a_garder = true;
$necessite = unserialize($configuration['necessite']);
if (!empty($necessite)) {
foreach ($necessite as $plugin) {
if (!defined('_DIR_PLUGIN_'.strtoupper($plugin))) {
$noisette_a_garder = false;
break;
}
}
}
// Si la noisette est à garder on détermine si elle est nouvelle ou modifiée.
// En mode rechargement forcé toute noisette est considérée comme nouvelle.
// Sinon, la noisette doit être retirée de la base car un plugin qu'elle nécessite a été désactivée:
// => il suffit pour cela de la laisser dans la liste des noisettes obsolètes.
if ($noisette_a_garder) {
if (!$options['md5'] or $options['recharger']) {
// La noisette est soit nouvelle soit on est en mode rechargement forcé:
// => il faut la rajouter dans la table.
$noisettes_nouvelles[] = $configuration;
} else {
// La configuration stockée dans la table a été modifiée et le mode ne force pas le rechargement:
// => il faut mettre à jour la noisette dans la table.
$noisettes_modifiees[] = $configuration;
// => il faut donc la supprimer de la liste des noisettes obsolètes
$noisettes_obsoletes = array_diff($noisettes_obsoletes, array($noisette));
}
}
} else {
// La noisette n'a pas changée et n'a donc pas été réchargée:
// => Il faut donc juste indiquer qu'elle n'est pas obsolète.
$noisettes_obsoletes = array_diff($noisettes_obsoletes, array($noisette));
}
} else {
// Il y a eu une erreur sur lors du rechargement de la noisette.
// => il faut donc ne rien faire pour laisser la noisette dans les obsolètes
continue;
}
}
// Mise à jour du stockage des noisettes si au moins un des 3 tableaux est non vide et que le chargement forcé
// n'est pas demandé:
// -- Suppression des noisettes obsolètes ou de toutes les noisettes si on est en mode rechargement forcé.
// Pour permettre une optimisation du traitement en mode rechargement forcé on passe toujours le mode.
// -- Update des pages modifiées
// -- Insertion des nouvelles pages
if ($recharger
or (!$recharger and ($noisettes_nouvelles or $noisettes_obsoletes or $noisettes_modifiees))) {
$noisettes = array('nouvelles' => $noisettes_nouvelles);
if (!$options['recharger']) {
$noisettes['obsoletes'] = $noisettes_obsoletes;
$noisettes['modifiees'] = $noisettes_modifiees;
}
$retour = ncore_noisette_stocker($service, $noisettes, $options['recharger']);
}
}
return $retour;
}
/**
* Retourne la description complète ou seulement une information précise pour une noisette donnée.
* Les données textuelles peuvent subir une traitement typo si demandé.
*
* @api
*
* @param string $service
* Le service permet de distinguer l'appelant qui peut-être un plugin comme le noiZetier ou
* un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
* La fonction utilisera la fonction de lecture de la description brute d'une noisette, spécifique
* au service, ou à défaut, celle fournie par N-Core.
* @param string $noisette
* Identifiant de la $noisette.
* @param string $information
* Information spécifique à retourner ou vide pour retourner toute la description.
* @param boolean $traiter_typo
* Indique si les données textuelles doivent être retournées brutes ou si elles doivent être traitées
* en utilisant la fonction _T_ou_typo. Par défaut l'indicateur vaut `false`.
* Les champs sérialisés sont eux toujours désérialisés.
*
* @return array|string
* La description complète ou l'information précise demandée pour une noisette donnée. Les champs
* de type tableau sont systématiquement désérialisés et si demandé, les champs textuels peuvent être
* traités avec la fonction _T_ou_typo().
*/
function ncore_noisette_informer($service, $noisette, $information = '', $traiter_typo = false) {
// On indexe le tableau des indicateurs ajax par le service appelant en cas d'appel sur le même hit
// par deux services différents.
static $donnees_typo = array('nom', 'description');
static $description_noisette = array();
// Stocker la description de la noisette si besoin
if (!isset($description_noisette[$service][$noisette])) {
// On charge l'API de N-Core.
// Ce sont ces fonctions qui aiguillent ou pas vers une fonction spécifique du service.
include_spip("ncore/ncore");
// Lecture de toute la configuration de la noisette: les données retournées sont brutes.
$description = ncore_noisette_decrire($service, $noisette);
// Sauvegarde de la description de la page pour une consultation ultérieure dans le même hit.
if ($description) {
// Traitements des champs tableaux sérialisés
$description['contexte'] = unserialize($description['contexte']);
$description['necessite'] = unserialize($description['necessite']);
$description['parametres'] = unserialize($description['parametres']);
// Stockage de la description
$description_noisette[$service][$noisette] = $description;
} else {
$description_noisette[$service][$noisette] = array();
}
}
if ($information) {
if (isset($description_noisette[$service][$noisette][$information])) {
if (in_array($information, $donnees_typo) and $traiter_typo) {
// Traitements de la donnée textuelle
$retour = _T_ou_typo($description_noisette[$service][$noisette][$information]);
} else {
$retour = $description_noisette[$service][$noisette][$information];
}
} else {
$retour = '';
}
} else {
$retour = $description_noisette[$service][$noisette];
// Traitements des données textuels
if ($traiter_typo) {
$retour['nom'] = _T_ou_typo($retour['nom']);
if (isset($retour['description'])) {
$retour['description'] = _T_ou_typo($retour['description']);
}
}
}
return $retour;
}
/**
* Détermine si la noisette spécifiée doit être incluse en AJAX ou pas.
*

221
ncoredata/ncore.php

@ -0,0 +1,221 @@
<?php
/**
* Ce fichier contient les fonctions du service de stockage N-Core pour les types de noisettes et les noisettes.
*
* Chaque fonction, soit aiguille, si elle existe, vers une fonction "homonyme" propre au plugin appelant
* ou à un autre service de stockage, soit déroule sa propre implémentation.
* Ainsi, les plugins externes peuvent, si elle leur convient, utiliser l'implémentation proposée par N-Core
* sans coder la moindre fonction.
*
* @package SPIP\NCORE\DATA
*/
if (!defined('_ECRIRE_INC_VERSION')) {
return;
}
/**
* Stocke les descriptions des types de noisette en distinguant les types de noisette obsolètes, les types de
* noisettes modifiés et les types de noisettes nouveaux.
* Chaque description de type de noisette est un tableau associatif dont tous les index possibles - y compris
* la signature - sont initialisés quelque soit le contenu du fichier YAML.
*
* Le service N-Core stocke les descriptions dans un cache et les signatures dans un autre.
*
* @uses cache_lire()
* @uses cache_ecrire()
*
* @param string $plugin
* Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
* un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
* @param array $types_noisette
* Tableau associatif à 3 entrées fournissant les descriptions des types de noisettes nouveaux, obsolètes
* et modifiés:
* `a_effacer` : liste des identifiants de type de noisette devenus obsolètes.
* `a_changer` : liste des descriptions des types de noisette dont le fichier YAML a été modifié.
* `a_ajouter` : liste des descriptions des nouveaux types de noisette.
* Si $recharger est à `true`, seul l'index `nouvelles` est fourni dans le tableau $types_noisette.
* @param bool $recharger
* Indique si le chargement en cours est forcé ou pas. Cela permet à la fonction N-Core ou au service
* concerné d'optimiser le traitement sachant que seules les types de noisette nouveaux sont fournis.
* @param string $stockage
* Identifiant du service de stockage à utiliser si précisé. Dans ce cas, ni celui du plugin
* ni celui de N-Core ne seront utilisés. En général, cet identifiant est le préfixe d'un plugin
* fournissant le service de stockage souhaité.
*
* @return bool
* `true` si le traitement s'est bien déroulé, `false` sinon.
*/
function ncore_type_noisette_stocker($plugin, $types_noisette, $recharger, $stockage = '') {
$retour = true;
// On cherche le service de stockage à utiliser selon la logique suivante :
// - si le service de stockage est non vide on l'utilise (la fonction doit exister);
// - sinon, on utilise la fonction du plugin appelant si elle existe;
// - et sinon, on utilise la fonction de N-Core.
if (!$stockage) {
$stockage = $plugin;
}
include_spip("ncoredata/${stockage}");
$stocker = "${stockage}_type_noisette_stocker";
if (function_exists($stocker)) {
// On passe le plugin appelant à la fonction car cela permet ainsi de mutualiser les services de stockage.
$retour = $stocker($plugin, $types_noisette, $recharger);
} else {
// Le plugin ne propose pas de fonction propre, on utilise celle de N-Core.
// Les descriptions de types de noisette et les signatures sont stockés dans deux caches distincts.
// -- Les descriptions : on conserve la signature pour chaque description, le tableau est réindexé avec l'identifiant
// de la noisette.
// -- Les signatures : on isole la liste des signatures et on indexe le tableau avec l'identifiant de la noisette.
include_spip('inc/ncore_cache');
if ($recharger) {
// Si le rechargement est forcé, tous les types de noisette sont nouveaux, on peut donc écraser les caches
// existants sans s'en préoccuper.
$descriptions = array_column($types_noisette['a_ajouter'], null, 'noisette');
cache_ecrire($plugin, _NCORE_NOMCACHE_NOISETTE_DESCRIPTION, $descriptions);
$signatures = array_column($types_noisette['a_ajouter'], 'signature', 'noisette');
cache_ecrire($plugin, _NCORE_NOMCACHE_NOISETTE_SIGNATURE, $signatures);
} else {
// On lit les cache existants et on applique les modifications.
$descriptions = cache_lire($plugin, _NCORE_NOMCACHE_NOISETTE_DESCRIPTION);
$signatures = cache_lire($plugin,_NCORE_NOMCACHE_NOISETTE_SIGNATURE);
// On supprime les noisettes obsolètes
if (!empty($types_noisette['a_effacer'])) {
$descriptions_obsoletes = array_column($types_noisette['a_effacer'], null, 'noisette');
$descriptions = array_diff($descriptions, $descriptions_obsoletes);
$signatures_obsoletes = array_column($types_noisette['a_effacer'], 'signature', 'noisette');
$signatures = array_diff($signatures, $signatures_obsoletes);
}
// On remplace les noisettes modifiées et on ajoute les noisettes nouvelles. Cette opération peut-être
// réalisée en une action avec la fonction array_merge.
if (!empty($types_noisette['a_changer']) or !empty($types_noisette['a_ajouter'])) {
$descriptions_modifiees = array_column($types_noisette['a_changer'], null, 'noisette');
$descriptions_nouvelles = array_column($types_noisette['a_ajouter'], null, 'noisette');
$descriptions = array_merge($descriptions, $descriptions_modifiees, $descriptions_nouvelles);
$signatures_modifiees = array_column($types_noisette['a_changer'], 'signature', 'noisette');
$signatures_nouvelles = array_column($types_noisette['a_ajouter'], 'signature', 'noisette');
$signatures = array_merge($signatures, $signatures_modifiees, $signatures_nouvelles);
}
// On recrée les caches.
cache_ecrire($plugin, _NCORE_NOMCACHE_NOISETTE_DESCRIPTION, $descriptions);
cache_ecrire($plugin, _NCORE_NOMCACHE_NOISETTE_SIGNATURE, $signatures);
}
}
return $retour;
}
/**
* Renvoie la description brute d'un type de noisette sans traitement typo ni désérialisation des champs de type
* tableau sérialisé.
*
* Le service N-Core lit la description du type de noisette concerné dans le cache des descriptions.
*
* @uses cache_lire()
*
* @param string $plugin
* Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
* un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
* @param string $type_noisette
* Identifiant du type de noisette.
* @param string $stockage
* Identifiant du service de stockage à utiliser si précisé. Dans ce cas, ni celui du plugin
* ni celui de N-Core ne seront utilisés. En général, cet identifiant est le préfixe d'un plugin
* fournissant le service de stockage souhaité.
*
* @return array
* Tableau de la description du type de noisette. Les champs textuels et les champs de type tableau sérialisé
* sont retournés en l'état.
*/
function ncore_type_noisette_decrire($plugin, $type_noisette, $stockage = '') {
$description = array();
// On cherche le service de stockage à utiliser selon la logique suivante :
// - si le service de stockage est non vide on l'utilise en considérant que la fonction existe forcément;
// - sinon, on utilise la fonction du plugin appelant si elle existe;
// - et sinon, on utilise la fonction de N-Core.
if (!$stockage) {
$stockage = $plugin;
}
include_spip("ncoredata/${stockage}");
$decrire = "${stockage}_type_noisette_decrire";
if (function_exists($decrire)) {
// On passe le plugin appelant à la fonction car cela permet ainsi de mutualiser les services de stockage.
$description = $decrire($plugin, $type_noisette);
} else {
// Le plugin ne propose pas de fonction propre, on utilise celle de N-Core.
// Chargement de toute la configuration du type de noisette en base de données.
// Les données sont renvoyées brutes sans traitement sur les textes ni les tableaux sérialisés.
include_spip('inc/ncore_cache');
$descriptions = cache_lire($plugin, _NCORE_NOMCACHE_NOISETTE_DESCRIPTION);
if (isset($descriptions[$type_noisette])) {
$description = $descriptions[$type_noisette];
}
}
return $description;
}
/**
* Renvoie l'information brute demandée pour l'ensemble des types de noisette utilisés par le plugin appelant.
*
* @uses cache_lire()
*
* @param string $plugin
* Identifiant qui permet de distinguer le module appelant qui peut-être un plugin comme le noiZetier ou
* un script. Pour un plugin, le plus pertinent est d'utiliser le préfixe.
* @param string $information
* Identifiant d'un champ de la description d'un type de noisette ou `signature`.
* Si l'argument est vide ou invalide, la fonction renvoie un tableau vide.
* @param string $stockage
* Identifiant du service de stockage à utiliser si précisé. Dans ce cas, ni celui du plugin ni celui de N-Core
* ne seront utilisés. En général, cet identifiant est le préfixe du plugin fournissant le stockage.
*
* @return array
* Tableau de la forme `[noisette] = information`.
*/
function ncore_type_noisette_lister($plugin, $information, $stockage = '') {
// Initialisation du tableau de sortie
$information_noisettes = array();
// On cherche le service de stockage à utiliser selon la logique suivante :
// - si le service de stockage est non vide on l'utilise en considérant que la fonction existe forcément;
// - sinon, on utilise la fonction du plugin appelant si elle existe;
// - et sinon, on utilise la fonction de N-Core.
if (!$stockage) {
$stockage = $plugin;
}
include_spip("ncoredata/${stockage}");
$lister = "${stockage}_type_noisette_lister";
if (function_exists($lister)) {
// On passe le plugin appelant à la fonction car cela permet ainsi de mutualiser les services de stockage.
$information_noisettes = $lister($plugin, $information);
} else {
// Le plugin ne propose pas de fonction propre, on utilise celle de N-Core.
if ($information) {
include_spip('inc/ncore_cache');
if ($information == 'signature') {
// Les signatures md5 sont sockées dans un fichier cache séparé de celui des descriptions de noisettes.
$information_noisettes = cache_lire($plugin, _NCORE_NOMCACHE_NOISETTE_SIGNATURE);
}
elseif ($descriptions = cache_lire($plugin, _NCORE_NOMCACHE_NOISETTE_DESCRIPTION)) {
// Si $information n'est pas une colonne valide array_column retournera un tableau vide.
$information_noisettes = array_column($descriptions, $information, 'noisette');
}
}
}
return $information_noisettes;
}
Loading…
Cancel
Save