Browse Source

Une première version complète du plugin.

Reste à voir si on peut traiter de façon plus générique la possibilité d'englober la noisette dans une div pouvant porter des css spécifiques. De cette façon, N-Core pourra proposer des inclusions génériques par liste de noisettes ou conteneur.
svn/root/tags/v0.10.0
eric@smellup.net 4 years ago
parent
commit
ba207b3885
  1. 1
      .gitattributes
  2. 22
      compiler_conteneur.html
  3. 17
      compiler_noisettes.html
  4. 12
      inc/ncore_cache.php
  5. 261
      inc/ncore_compilation.php
  6. 2
      lang/paquet-ncore_fr.php
  7. 38
      ncore/ncore.php
  8. 228
      ncore_fonctions.php
  9. 21090
      pages-sections-composants.pdf
  10. 7
      paquet.xml
  11. 40
      public/noisette_compiler.php

1
.gitattributes vendored

@ -1,3 +1,2 @@
* text=auto !eol
/Guide[!!-~]N[!!-~]-[!!-~]Le[!!-~]plugin[!!-~]N-Core.pdf -text
/pages-sections-composants.pdf -text

22
compiler_conteneur.html

@ -1,22 +0,0 @@
[(#REM) <!-- COMPILER_CONTENEUR
Compile la liste des noisettes d'un conteneur fourni en paramètre de l'inclusion.
@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 array noisettes
Liste des descriptions de noisette à compiler dans l'ordre des rangs
@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é.
-->]
<BOUCLE_compilation_conteneur(DATA){source table, #ENV{noisettes}}{par rang}>
#SET{avec_div, #VALEUR{balise}|=={defaut}|?{#CONFIG{ncore/balise_noisette}, #VALEUR{balise}}}
[[(#GET{avec_div}|oui)<div class="noisette noisette_#NOISETTE[ (#VALEUR{css})]">]
(#NOISETTE_COMPILER{#ENV{plugin}, #ENV{stockage}})
[(#GET{avec_div}|oui)</div>]]
</BOUCLE_compilation_conteneur>

17
compiler_noisettes.html

@ -1,23 +1,24 @@
[(#REM) <!-- COMPILER_NOISETTES
[(#REM) <!-- #COMPILER_NOISETTES
Compile une liste de noisettes fournies en paramètres de l'inclusion. C'est l'appelant qui décide si cette liste
est contenue ou pas dans un conteneur.
Compile une liste de noisettes fournies en paramètres de l'inclusion.
Ce fichier est donné à titre d'exemple : la valeur par défaut de l'utilisation d'une balise div englobante
est donc à gérer par le plugin appelant (constante, configuration...).
@api
@param string $plugin
@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 noisettes
Liste des descriptions de noisette à compiler dans l'ordre des rangs
Liste des descriptions de noisette à compiler dans l'ordre de leur rang.
@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é.
-->]
<BOUCLE_compilation_noisettes(DATA){source table, #ENV{noisettes}}{par rang}>
#SET{avec_div, #VALEUR{balise}|=={defaut}|?{#CONFIG{ncore/balise_noisette}, #VALEUR{balise}}}
<BOUCLE_compilation_noisettes(DATA){source table, #ENV{noisettes, #ARRAY}}{plugin}{par rang_noisette}>
#SET{avec_div, #VALEUR{balise}|=={defaut}|?{oui, #VALEUR{balise}}}
[[(#GET{avec_div}|oui)<div class="noisette noisette_#NOISETTE[ (#VALEUR{css})]">]
(#NOISETTE_COMPILER{#ENV{plugin}, #ENV{stockage}})
(#NOISETTE_COMPILER{#ENV{stockage, ''}})
[(#GET{avec_div}|oui)</div>]]
</BOUCLE_compilation_noisettes>

12
inc/ncore_cache.php

@ -31,19 +31,19 @@ if (!defined('_NCORE_NOMCACHE_TYPE_NOISETTE_DESCRIPTION')) {
*/
define('_NCORE_NOMCACHE_TYPE_NOISETTE_DESCRIPTION', 'type_noisette_descriptions.php');
}
if (!defined('_NCORE_NOMCACHE_NOISETTE_AJAX')) {
if (!defined('_NCORE_NOMCACHE_TYPE_NOISETTE_AJAX')) {
/**
* Cache du paramétrage ajax des noisettes.
* Contient le tableau sérialisé `[noisette] = true/false`.
* Contient le tableau sérialisé `[type_noisette] = true/false`.
*/
define('_NCORE_NOMCACHE_NOISETTE_AJAX', 'noisette_ajax.php');
define('_NCORE_NOMCACHE_TYPE_NOISETTE_AJAX', 'type_noisette_ajax.php');
}
if (!defined('_NCORE_NOMCACHE_NOISETTE_INCLUSION')) {
if (!defined('_NCORE_NOMCACHE_TYPE_NOISETTE_INCLUSION')) {
/**
* Cache du paramétrage d'inclusion dynamique des noisettes.
* Contient le tableau sérialisé `[noisette] = true/false`.
* Contient le tableau sérialisé `[type_noisette] = true/false`.
*/
define('_NCORE_NOMCACHE_NOISETTE_INCLUSION', 'noisette_inclusions.php');
define('_NCORE_NOMCACHE_TYPE_NOISETTE_INCLUSION', 'type_noisette_inclusions.php');
}
if (!defined('_NCORE_NOMCACHE_TYPE_NOISETTE_CONTEXTE')) {
/**

261
inc/ncore_compilation.php

@ -1,261 +0,0 @@
<?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\API\COMPILATION
*/
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;
}
/**
* Détermine si la noisette spécifiée doit être incluse en AJAX ou pas.
*
* @api
* @filtre
*
* @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 les fonctions de lecture de la configuration globale de l'ajax et de
* lecture du paramètre ajax de la noisette, spécifiques au service, ou à défaut, celles fournies par N-Core.
* @param string $noisette
* Identifiant de la $noisette.
*
* @return bool
* `true` si la noisette doit être ajaxée, `false` sinon.
*/
function ncore_noisette_est_ajax($service, $noisette) {
// 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 $est_ajax = array();
if (!isset($est_ajax[$service][$noisette])) {
// On détermine le cache en fonction du service, puis son existence et son contenu.
include_spip('inc/ncore_cache');
$est_ajax[$service] = cache_lire($service, _NCORE_NOMCACHE_NOISETTE_AJAX);
// On doit recalculer le cache.
if (!$est_ajax[$service]
or (_request('var_mode') == 'recalcul')
or (defined('_NO_CACHE') and (_NO_CACHE != 0))) {
// 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");
// On détermine la valeur par défaut de l'ajax des noisettes pour le service appelant.
$defaut_ajax = ncore_noisette_config_ajax($service);
// On repertorie la configuration ajax de toutes les noisettes disponibles et on compare
// avec la valeur par défaut configurée pour le service appelant.
if ($ajax_noisettes = ncore_noisette_lister($service,'ajax')) {
foreach ($ajax_noisettes as $_noisette => $_ajax) {
$est_ajax[$service][$_noisette] = ($_ajax == 'defaut')
? $defaut_ajax
: ($_ajax == 'non' ? false : true);
}
}
// On vérifie que la noisette demandée est bien dans la liste.
// Si non, on la rajoute en utilisant la valeur ajax par défaut afin de toujours renvoyer
// quelque chose.
if (!isset($est_ajax[$service][$noisette])) {
$est_ajax[$service][$noisette] = $defaut_ajax;
}
// In fine, on met à jour le cache
cache_ecrire($service, _NCORE_NOMCACHE_NOISETTE_AJAX, $est_ajax[$service]);
}
}
return $est_ajax[$service][$noisette];
}
/**
* Détermine si la noisette spécifiée doit être incluse dynamiquement ou pas.
*
* @api
* @filtre
*
* @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 les fonctions de lecture du paramètre d'inclusion de la noisette,
* spécifique au service, ou à défaut, celle fournie par N-Core.
* @param string $noisette
* Identifiant de la $noisette.
*
* @return bool
* `true` si la noisette doit être incluse dynamiquement, `false` sinon.
*/
function ncore_noisette_est_dynamique($service, $noisette) {
// 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 $est_dynamique = array();
if (!isset($est_dynamique[$service][$noisette])) {
// On détermine le cache en fonction du service, puis son existence et son contenu.
include_spip('inc/ncore_cache');
$est_dynamique[$service] = cache_lire($service, _NCORE_NOMCACHE_NOISETTE_INCLUSION);
// On doit recalculer le cache.
if (!$est_dynamique[$service]
or (_request('var_mode') == 'recalcul')
or (defined('_NO_CACHE') and (_NO_CACHE != 0))) {
// 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");
// On repertorie la configuration d'inclusion de toutes les noisettes disponibles et on
// détermine si celle-ci est dynamique ou pas.
if ($inclusion_noisettes = ncore_noisette_lister($service,'inclusion')) {
foreach ($inclusion_noisettes as $_noisette => $_inclusion) {
$est_dynamique[$service][$_noisette] = ($_inclusion == 'dynamique') ? true : false;
}
}
// On vérifie que la noisette demandée est bien dans la liste.
// Si non, on la rajoute en utilisant en positionnant l'inclusion dynamique à false.
if (!isset($est_dynamique[$service][$noisette])) {
$est_dynamique[$service][$noisette] = _NCORE_DYNAMIQUE_DEFAUT;
}
// In fine, on met à jour le cache
cache_ecrire($service, _NCORE_NOMCACHE_NOISETTE_INCLUSION, $est_dynamique[$service]);
}
}
return $est_dynamique[$service][$noisette];
}
/**
* Renvoie le contexte de la noisette sous la forme d'un tableau éventuellement vide.
*
* @api
* @filtre
*
* @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 mixed $noisette
* Identifiant de la noisette qui peut prendre soit la forme d'un entier ou d'une chaîne unique, soit la forme
* d'un couple (id conteneur, rang).
* @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
* Le tableau éventuellement vide des éléments de contexte de la noisette.
*/
function noisette_contextualiser($plugin, $noisette, $type_noisette, $environnement, $stockage = '') {
// 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 $contextes_type_noisette = array();
// On initialise le contexte de la noisette a minima.
// -- on transmet toujours l'identifiant de la noisette quel qu'il soit : id_noisette ou couple (id_conteneur, rang).
$contexte = is_array($noisette) ? $noisette : array('id_noisette' => $noisette);
// -- on appelle une fonction de service pour éventuellement compléter le contexte par d'autres variables en fonction
// du plugin.
include_spip('ncore/ncore');
// $contexte = array_merge($contexte, ncore_noisette_contexte_completer($plugin, $noisette, $stockage));
// Récupération du contexte défini pour le type de noisette. Ce contexte est juste une liste de variables non
// valorisées. La valorisation sera faite avec l'environnement.
// -- les contextes sont stockés dans un cache dédié.
if (!isset($contextes_type_noisette[$plugin][$type_noisette])) {
// On vérifie si on doit recalculer le cache le cache ou pas.
include_spip('inc/ncore_cache');
if ((_request('var_mode') == 'recalcul')
or (defined('_NO_CACHE') and (_NO_CACHE != 0))
or (!$contextes_type_noisette[$plugin] = cache_lire($plugin, _NCORE_NOMCACHE_TYPE_NOISETTE_CONTEXTE))) {
// On répertorie la configuration du contexte de toutes les noisettes disponibles et on
// le renvoie le résultat tel quel.
$contextes_type_noisette[$plugin] = ncore_type_noisette_lister($plugin, 'contexte', $stockage);
// On vérifie que le type de noisette demandé est bien dans la liste.
// Si non, on la rajoute en utilisant en positionnant le contexte à tableau vide.
if (!isset($contextes_type_noisette[$plugin][$type_noisette])) {
$contextes_type_noisette[$plugin][$type_noisette] = serialize(array());
}
// In fine, on met à jour le cache
cache_ecrire($plugin, _NCORE_NOMCACHE_TYPE_NOISETTE_CONTEXTE, $contextes_type_noisette[$plugin]);
}
}
// -- on inverse les index et valeurs du tableau de contexte pour obtenir un tableau de type contexte.
$contexte_type_noisette = array_flip(unserialize($contextes_type_noisette[$plugin][$type_noisette]));
// On construit le contexte final en fonction de celui du type de noisette.
// On renvoie systématiquement le contexte minimal déjà initialisé et si le contexte du type de noisette contient:
// - aucun => rien de plus.
// - env ou vide => l'environnement complet également.
// - une liste de variables => on renvoie également l'intersection de cette liste avec l'environnement.
if (!isset($contexte_type_noisette['aucun'])) {
if (isset($contexte_noisette['env'])) {
$contexte = array_merge($environnement, $contexte);
} else {
$contexte = array_merge(array_intersect_key($environnement, $contexte_type_noisette), $contexte);
}
}
return $contexte;
}

2
lang/paquet-ncore_fr.php

@ -8,6 +8,6 @@ if (!defined('_ECRIRE_INC_VERSION')) {
$GLOBALS[$GLOBALS['idx_lang']] = array(
// N
'ncore_description' => 'Framework de gestion de noisettes. Ce plugin fournit les mécanismes permettant de lister et de compiler les noisettes.',
'ncore_description' => 'Framework de gestion de noisettes. Ce plugin fournit les API et les mécanismes permettant de gérer et de compiler les noisettes.',
'ncore_slogan' => 'Un cœur fondant aux noisettes',
);

38
ncore/ncore.php

@ -260,6 +260,44 @@ function ncore_type_noisette_lister($plugin, $information = '', $stockage = '')
return $types_noisettes;
}
/**
* Renvoie la configuration par défaut de l'ajax à appliquer pour la compilation des noisettes.
* Cette information est utilisée si la description YAML d'un type 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.
*
* @package SPIP\NCORE\SERVICE\TYPE_NOISETTE
*
* @uses ncore_chercher_service()
*
* @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.
*
* @return bool
* `true` si par défaut une noisette est insérée en ajax, `false` sinon.
*/
function ncore_type_noisette_initialiser_ajax($plugin) {
// 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.
include_spip('inc/ncore_utils');
if ($configurer = ncore_chercher_service($plugin, 'type_noisette_initialiser_ajax', '')) {
// On passe le plugin appelant à la fonction car cela permet ainsi de mutualiser les services de stockage.
// On autorise la fonction du plugin à retourner autre chose que true ou false si tant est que l'on puisse
// en déduire un booléen (par exemple, 'on' et '' comme le retourne une case à cocher du plugin Saisies).
$defaut_ajax = $configurer($plugin) ? true : false;
} else {
// Le service ne propose pas de fonction propre, on utilise celle de N-Core.
$defaut_ajax = true;
}
return $defaut_ajax;
}
// -----------------------------------------------------------------------
// ----------------------------- NOISETTES -------------------------------

228
ncore_fonctions.php

@ -0,0 +1,228 @@
<?php
/**
* Ce fichier contient les filtres de compilation des noisettes appelés par la balise #COMPILER_NOISETTE.
*
*/
if (!defined('_ECRIRE_INC_VERSION')) {
return;
}
/**
* Détermine si le type de noisette spécifié doit être inclus en AJAX ou pas. Cette fonction gère un cache
* des indicateurs ajax.
*
* @package SPIP\NCORE\API\TYPE_NOISETTE
*
* @api
* @filtre
*
* @uses cache_lire()
* @uses cache_ecrire()
* @uses ncore_type_noisette_lister()
* @uses ncore_type_noisette_initialiser_ajax()
*
* @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 bool
* `true` si la noisette doit être ajaxée, `false` sinon.
*/
function type_noisette_ajaxifier($plugin, $type_noisette, $stockage = '') {
// 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 $est_ajax = array();
if (!isset($est_ajax[$plugin][$type_noisette])) {
include_spip('inc/ncore_cache');
// On vérifie si on doit recalculer le cache ou pas.
if ((_request('var_mode') == 'recalcul')
or (defined('_NO_CACHE') and (_NO_CACHE != 0))
or (!$est_ajax[$plugin] = cache_lire($plugin, _NCORE_NOMCACHE_TYPE_NOISETTE_AJAX))) {
// On charge l'API de N-Core.
include_spip("ncore/ncore");
// On détermine la valeur par défaut de l'ajax des noisettes pour le plugin appelant.
$defaut_ajax = ncore_type_noisette_initialiser_ajax($plugin);
// On répertorie la configuration ajax de toutes les noisettes disponibles et on compare
// avec la valeur par défaut configurée pour le service appelant.
if ($ajax_types_noisette = ncore_type_noisette_lister($plugin,'ajax', $stockage)) {
foreach ($ajax_types_noisette as $_type_noisette => $_ajax) {
$est_ajax[$plugin][$_type_noisette] = ($_ajax == 'defaut')
? $defaut_ajax
: ($_ajax == 'non' ? false : true);
}
}
// On vérifie que la noisette demandée est bien dans la liste.
// Si non, on la rajoute en utilisant la valeur ajax par défaut afin de toujours renvoyer
// quelque chose.
if (!isset($est_ajax[$plugin][$type_noisette])) {
$est_ajax[$plugin][$type_noisette] = $defaut_ajax;
}
// In fine, on met à jour le cache
cache_ecrire($plugin, _NCORE_NOMCACHE_TYPE_NOISETTE_AJAX, $est_ajax[$plugin]);
}
}
return $est_ajax[$plugin][$type_noisette];
}
/**
* Détermine si la noisette spécifiée doit être incluse dynamiquement ou pas. Cette fonction gère un cache
* des indicateurs d'inclusion dynamique.
*
* @package SPIP\NCORE\API\TYPE_NOISETTE
*
* @api
* @filtre
*
* @uses cache_lire()
* @uses cache_ecrire()
* @uses ncore_type_noisette_lister()
*
* @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 bool
* `true` si le type de noisette doit être inclus dynamiquement, `false` sinon.
*/
function type_noisette_dynamiser($plugin, $type_noisette, $stockage = '') {
// 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 $est_dynamique = array();
if (!isset($est_dynamique[$plugin][$type_noisette])) {
include_spip('inc/ncore_cache');
// On doit recalculer le cache ou pas.
if ((_request('var_mode') == 'recalcul')
or (defined('_NO_CACHE') and (_NO_CACHE != 0))
or (!$est_dynamique[$plugin] = cache_lire($type_noisette, _NCORE_NOMCACHE_TYPE_NOISETTE_INCLUSION))) {
// 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");
// On répertorie la configuration d'inclusion de toutes le types noisettes disponibles et on
// détermine si le type demandé est dynamique ou pas.
if ($inclusion_types_noisette = ncore_type_noisette_lister($plugin,'inclusion', $stockage)) {
foreach ($inclusion_types_noisette as $_type_noisette => $_inclusion) {
$est_dynamique[$plugin][$_type_noisette] = ($_inclusion == 'dynamique') ? true : false;
}
}
// On vérifie que le type de noisette demandé est bien dans la liste.
// Si non, on le rajoute en utilisant en positionnant l'inclusion dynamique à false ce qui est le défaut.
if (!isset($est_dynamique[$plugin][$type_noisette])) {
$est_dynamique[$plugin][$type_noisette] = false;
}
// In fine, on met à jour le cache
cache_ecrire($plugin, _NCORE_NOMCACHE_TYPE_NOISETTE_INCLUSION, $est_dynamique[$plugin]);
}
}
return $est_dynamique[$plugin][$type_noisette];
}
/**
* Renvoie le contexte de la noisette sous la forme d'un tableau éventuellement vide. Cette fonction gère un cache
* des contextes génériques des types de noisette disponibles.
*
* @package SPIP\NCORE\API\NOISETTE
*
* @api
* @filtre
*
* @uses cache_lire()
* @uses cache_ecrire()
* @uses ncore_type_noisette_lister()
*
* @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 mixed $noisette
* Tableau des identifiants de la noisette qui peut prendre d'un tableau avec pour index
* id_noisette, id conteneur et rang_noisette, ce qui permet d'utiliser l'un ou l'autre des identifiants.
* @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
* Le tableau éventuellement vide des éléments de contexte de la noisette.
*/
function noisette_contextualiser($plugin, $noisette, $type_noisette, $environnement, $stockage = '') {
// Initialisation du tableau des contexte générique de chaque type de noisette.
static $contextes_type_noisette = array();
// On initialise le contexte de la noisette a minima.
// -- on transmet toujours les identifiants de la noisette id_noisette et couple (id_conteneur, rang) qui sont
// fournis par la balise.
$contexte = $noisette ? $noisette : array();
// Récupération du contexte défini pour le type de noisette. Ce contexte est juste une liste de variables non
// valorisées. La valorisation sera faite avec l'environnement.
// -- les contextes sont stockés dans un cache dédié.
if (!isset($contextes_type_noisette[$plugin][$type_noisette])) {
// On vérifie si on doit recalculer le cache le cache ou pas.
include_spip('inc/ncore_cache');
if ((_request('var_mode') == 'recalcul')
or (defined('_NO_CACHE') and (_NO_CACHE != 0))
or (!$contextes_type_noisette[$plugin] = cache_lire($plugin, _NCORE_NOMCACHE_TYPE_NOISETTE_CONTEXTE))) {
// On répertorie la configuration du contexte de toutes les noisettes disponibles et on
// le renvoie le résultat tel quel.
include_spip('ncore/ncore');
$contextes_type_noisette[$plugin] = ncore_type_noisette_lister($plugin, 'contexte', $stockage);
// On vérifie que le type de noisette demandé est bien dans la liste.
// Si non, on la rajoute en utilisant en positionnant le contexte à tableau vide.
if (!isset($contextes_type_noisette[$plugin][$type_noisette])) {
$contextes_type_noisette[$plugin][$type_noisette] = serialize(array());
}
// In fine, on met à jour le cache
cache_ecrire($plugin, _NCORE_NOMCACHE_TYPE_NOISETTE_CONTEXTE, $contextes_type_noisette[$plugin]);
}
}
// -- on inverse les index et valeurs du tableau de contexte pour obtenir un tableau similaire au contexte.
$contexte_type_noisette = array_flip(unserialize($contextes_type_noisette[$plugin][$type_noisette]));
// On construit le contexte final en fonction de celui du type de noisette.
// On renvoie systématiquement le contexte minimal déjà initialisé et si le contexte du type de noisette contient:
// - aucun => rien de plus.
// - env ou vide => l'environnement complet également.
// - une liste de variables => on renvoie également l'intersection de cette liste avec l'environnement.
if (!isset($contexte_type_noisette['aucun'])) {
if (isset($contexte_noisette['env'])) {
$contexte = array_merge($environnement, $contexte);
} else {
$contexte = array_merge(array_intersect_key($environnement, $contexte_type_noisette), $contexte);
}
}
return $contexte;
}
// Balise #NOISETTE_COMPILER
include_spip('public/noisette_compiler');

21090
pages-sections-composants.pdf

File diff suppressed because one or more lines are too long

7
paquet.xml

@ -1,9 +1,9 @@
<paquet
prefix="Ncore"
prefix="ncore"
categorie="outil"
version="0.2.0"
version="0.3.0"
etat="dev"
compatibilite="[3.2.0-dev;3.2.*]"
compatibilite="[3.2.0;3.2.*]"
logo="ncore_logo-32.png"
>
<nom>N-Core</nom>
@ -14,5 +14,4 @@
<licence lien="http://www.gnu.org/licenses/gpl-3.0.html">GPL 3</licence>
<necessite nom="yaml" compatibilite="[1.5.2;[" />
<necessite nom="saisies" compatibilite="[2.2.3;[" />
</paquet>

40
public/noisette_compiler.php

@ -5,39 +5,43 @@ if (!defined('_ECRIRE_INC_VERSION')) {
return;
}
function balise_NOISETTE_COMPILER_dist($p)
{
// TODO : il faudrait appeler une fonction de service du plugin pour choisir si on passe l'id_noisette ou le couple
// (id_conteneur, rang)
function balise_NOISETTE_COMPILER_dist($p) {
// On passe dans le contexte toujours les deux identifiants d'une noisette, à savoir, l'id_noisette et le couple
// (id_conteneur, rang).
$id_noisette = champ_sql('id_noisette', $p);
$id_conteneur = champ_sql('id_conteneur', $p);
$rang_noisette = champ_sql('rang_noisette', $p);
$noisette = "array(
'id_noisette' => $id_noisette,
'id_conteneur' => $id_conteneur,
'rang_noisette' => $rang_noisette
)";
// On extrait les autres informations de la noisette
$type_noisette = champ_sql('type_noisette', $p);
$parametres = champ_sql('parametres', $p);
$plugin = champ_sql('plugin', $p);
// A-t-on demandé un stockage spécifique
// A-t-on demandé un stockage spécifique en paramètre de la balise ?
$stockage = interprete_argument_balise(1, $p);
$stockage = isset($stockage) ? str_replace('\'', '"', $stockage) : '""';
// si pas de contexte attribuer, on passe tout le contexte que l'on recoit
// sinon, on regarde si 'aucun' ou 'env' est indique :
// si 'aucun' => aucun contexte
// si 'env' => tout le contexte recu.
// $id_noisette est toujours transmis dans l'environnement
$environnement = "array_merge(\$Pile[0],array('id_noisette' => $id_noisette))";
// On récupère l'environnement
$environnement = "\$Pile[0]";
// On prépare le code en fonction du type d'inclusion dynamique ou pas
$inclusion_dynamique = "\"<?php echo recuperer_fond(
'noisettes/\".$type_noisette.\"',
\".var_export(array_merge(unserialize($parametres), noizetier_choisir_contexte($type_noisette, $environnement, $id_noisette)),true).\",
\".var_export(array('ajax'=>($_ajax && noizetier_noisette_ajax($type_noisette))),true).\"
\".var_export(array_merge(unserialize($parametres), noisette_contextualiser($plugin, $noisette, $type_noisette, $environnement, $stockage)),true).\",
\".var_export(array('ajax'=>(type_noisette_ajaxifier($plugin, $type_noisette, $stockage))),true).\"
);?>\"";
$inclusion_statique = "recuperer_fond(
'noisettes/'.$type_noisette,
array_merge(unserialize($parametres), noisette_contextualiser($plugin, $id_noisette, $type_noisette, $environnement, $stockage)),
array('ajax'=>($_ajax && noizetier_noisette_ajax($type_noisette)))
array_merge(unserialize($parametres), noisette_contextualiser($plugin, $noisette, $type_noisette, $environnement, $stockage)),
array('ajax'=>(type_noisette_ajaxifier($plugin, $type_noisette, $stockage)))
)";
$code = "((noizetier_noisette_dynamique($type_noisette)) ? $inclusion_dynamique : $inclusion_statique)";
$code = "((type_noisette_dynamiser($plugin, $type_noisette, $stockage)) ? $inclusion_dynamique : $inclusion_statique)";
$p->code = "((!$id_noisette) ? _T('zbug_champ_hors_motif', array('champ'=>'ID_NOISETTE', 'motif'=>'NOISETTES')) : $code)";
$p->interdire_scripts = false;

Loading…
Cancel
Save