Dépôt officiel du core SPIP * Anciennement présent sur svn://trac.rezo.net/spip * Les plugins-dist faisant partie de la distribution SPIP sont présents dans https://git.spip.net/SPIP/[nom du plugin dist] https://www.spip.net
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 

4866 lines
135 KiB

<?php
/***************************************************************************\
* SPIP, Systeme de publication pour l'internet *
* *
* Copyright (c) 2001-2019 *
* Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James *
* *
* Ce programme est un logiciel libre distribue sous licence GNU/GPL. *
* Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne. *
\***************************************************************************/
/**
* Déclaration de filtres pour les squelettes
*
* @package SPIP\Core\Filtres
**/
if (!defined('_ECRIRE_INC_VERSION')) {
return;
}
include_spip('inc/charsets');
include_spip('inc/filtres_mini');
include_spip('inc/filtres_dates');
include_spip('inc/filtres_selecteur_generique');
include_spip('base/objets');
include_spip('public/parametrer'); // charger les fichiers fonctions
/**
* Charger un filtre depuis le php
*
* - on inclue tous les fichiers fonctions des plugins et du skel
* - on appelle chercher_filtre
*
* Pour éviter de perdre le texte si le filtre demandé est introuvable,
* on transmet `filtre_identite_dist` en filtre par défaut.
*
* @uses filtre_identite_dist() Comme fonction par défaut
*
* @param string $fonc Nom du filtre
* @param string $default Filtre par défaut
* @return string Fonction PHP correspondante du filtre
*/
function charger_filtre($fonc, $default = 'filtre_identite_dist') {
include_spip('public/parametrer'); // inclure les fichiers fonctions
return chercher_filtre($fonc, $default);
}
/**
* Retourne le texte tel quel
*
* @param string $texte Texte
* @return string Texte
**/
function filtre_identite_dist($texte) { return $texte; }
/**
* Cherche un filtre
*
* Pour une filtre `F` retourne la première fonction trouvée parmis :
*
* - filtre_F
* - filtre_F_dist
* - F
*
* Peut gérer des appels par des fonctions statiques de classes tel que `Foo::Bar`
*
* En absence de fonction trouvée, retourne la fonction par défaut indiquée.
*
* @param string $fonc
* Nom du filtre
* @param null $default
* Nom du filtre appliqué par défaut si celui demandé n'est pas trouvé
* @return string
* Fonction PHP correspondante du filtre demandé
*/
function chercher_filtre($fonc, $default = null) {
if (!$fonc) {
return $default;
}
// Cas des types mime, sans confondre avec les appels de fonction de classe
// Foo::Bar
// qui peuvent etre avec un namespace : space\Foo::Bar
if (preg_match(',^[\w]+/,', $fonc)) {
$nom = preg_replace(',\W,', '_', $fonc);
$f = chercher_filtre($nom);
// cas du sous-type MIME sans filtre associe, passer au type:
// si filtre_text_plain pas defini, passe a filtre_text
if (!$f and $nom !== $fonc) {
$f = chercher_filtre(preg_replace(',\W.*$,', '', $fonc));
}
return $f;
}
foreach (array('filtre_' . $fonc, 'filtre_' . $fonc . '_dist', $fonc) as $f) {
trouver_filtre_matrice($f); // charge des fichiers spécifiques éventuels
// fonction ou name\space\fonction
if (is_callable($f)) {
return $f;
}
// méthode statique d'une classe Classe::methode ou name\space\Classe::methode
elseif (false === strpos($f, '::') and is_callable(array($f))) {
return $f;
}
}
return $default;
}
/**
* Applique un filtre
*
* Fonction générique qui prend en argument l’objet (texte, etc) à modifier
* et le nom du filtre. Retrouve les arguments du filtre demandé dans les arguments
* transmis à cette fonction, via func_get_args().
*
* @see filtrer() Assez proche
*
* @param mixed $arg
* Texte (le plus souvent) sur lequel appliquer le filtre
* @param string $filtre
* Nom du filtre à appliquer
* @param bool $force
* La fonction doit-elle retourner le texte ou rien si le filtre est absent ?
* @return string
* Texte traité par le filtre si le filtre existe,
* Texte d'origine si le filtre est introuvable et si $force à `true`
* Chaîne vide sinon (filtre introuvable).
**/
function appliquer_filtre($arg, $filtre, $force = null) {
$f = chercher_filtre($filtre);
if (!$f) {
if (!$force) {
return '';
} else {
return $arg;
}
}
$args = func_get_args();
array_shift($args); // enlever $arg
array_shift($args); // enlever $filtre
array_unshift($args, $arg); // remettre $arg
return call_user_func_array($f, $args);
}
/**
* Retourne la version de SPIP
*
* Si l'on retrouve un numéro de révision SVN, il est ajouté entre crochets.
* Si effectivement le SPIP est installé par SVN, 'SVN' est ajouté avant sa révision.
*
* @global spip_version_affichee Contient la version de SPIP
* @uses version_svn_courante() Pour trouver le numéro de révision SVN
*
* @return string
* Version de SPIP
**/
function spip_version() {
$version = $GLOBALS['spip_version_affichee'];
if ($svn_revision = version_svn_courante(_DIR_RACINE)) {
$version .= ($svn_revision < 0 ? ' SVN' : '') . ' [' . abs($svn_revision) . ']';
}
return $version;
}
/**
* Retrouve un numéro de révision SVN d'un répertoire
*
* Mention de la révision SVN courante d'un répertoire
* Retourne un nombre négatif si on est sur .svn, et positif si on utilise svn.revision
*
* @param string $dir Chemin du répertoire
* @return int
*
* - 0 si aucune info trouvée
* - NN (entier) si info trouvée par svn.revision (créé par le générateur de paquet Zip)
* - -NN (entier) si info trouvée par .svn/entries
*
**/
function version_svn_courante($dir) {
if (!$dir) {
$dir = '.';
}
// version installee par paquet ZIP
if (lire_fichier($dir . '/svn.revision', $c)
and preg_match(',Revision: (\d+),', $c, $d)
) {
return intval($d[1]);
}
// version installee par SVN
if (file_exists($dir . '/.svn/wc.db') && class_exists('SQLite3')) {
$db = new SQLite3($dir . '/.svn/wc.db');
$result = $db->query('SELECT changed_revision FROM nodes WHERE local_relpath = "" LIMIT 1');
if ($result) {
$row = $result->fetchArray();
if ($row['changed_revision'] != "") {
return -$row['changed_revision'];
}
}
} else if (lire_fichier($dir . '/.svn/entries', $c)
and (
(preg_match_all(
',committed-rev="([0-9]+)",', $c, $r1, PREG_PATTERN_ORDER)
and $v = max($r1[1])
)
or
(preg_match(',^\d.*dir[\r\n]+(\d+),ms', $c, $r1) # svn >= 1.4
and $v = $r1[1]
))
) {
return -$v;
}
// Bug ou paquet fait main
return 0;
}
// La matrice est necessaire pour ne filtrer _que_ des fonctions definies dans filtres_images
// et laisser passer les fonctions personnelles baptisees image_...
$GLOBALS['spip_matrice']['image_graver'] = true;//'inc/filtres_images_mini.php';
$GLOBALS['spip_matrice']['image_select'] = true;//'inc/filtres_images_mini.php';
$GLOBALS['spip_matrice']['image_reduire'] = true;//'inc/filtres_images_mini.php';
$GLOBALS['spip_matrice']['image_reduire_par'] = true;//'inc/filtres_images_mini.php';
$GLOBALS['spip_matrice']['image_passe_partout'] = true;//'inc/filtres_images_mini.php';
$GLOBALS['spip_matrice']['couleur_html_to_hex'] = 'inc/filtres_images_mini.php';
$GLOBALS['spip_matrice']['couleur_foncer'] = 'inc/filtres_images_mini.php';
$GLOBALS['spip_matrice']['couleur_eclaircir'] = 'inc/filtres_images_mini.php';
// ou pour inclure un script au moment ou l'on cherche le filtre
$GLOBALS['spip_matrice']['filtre_image_dist'] = 'inc/filtres_mime.php';
$GLOBALS['spip_matrice']['filtre_audio_dist'] = 'inc/filtres_mime.php';
$GLOBALS['spip_matrice']['filtre_video_dist'] = 'inc/filtres_mime.php';
$GLOBALS['spip_matrice']['filtre_application_dist'] = 'inc/filtres_mime.php';
$GLOBALS['spip_matrice']['filtre_message_dist'] = 'inc/filtres_mime.php';
$GLOBALS['spip_matrice']['filtre_multipart_dist'] = 'inc/filtres_mime.php';
$GLOBALS['spip_matrice']['filtre_text_dist'] = 'inc/filtres_mime.php';
$GLOBALS['spip_matrice']['filtre_text_csv_dist'] = 'inc/filtres_mime.php';
$GLOBALS['spip_matrice']['filtre_text_html_dist'] = 'inc/filtres_mime.php';
$GLOBALS['spip_matrice']['filtre_audio_x_pn_realaudio'] = 'inc/filtres_mime.php';
/**
* Charge et exécute un filtre (graphique ou non)
*
* Recherche la fonction prévue pour un filtre (qui peut être un filtre graphique `image_*`)
* et l'exécute avec les arguments transmis à la fonction, obtenus avec `func_get_args()`
*
* @api
* @uses image_filtrer() Pour un filtre image
* @uses chercher_filtre() Pour un autre filtre
*
* @param string $filtre
* Nom du filtre à appliquer
* @return string
* Code HTML retourné par le filtre
**/
function filtrer($filtre) {
$tous = func_get_args();
if (trouver_filtre_matrice($filtre) and substr($filtre, 0, 6) == 'image_') {
return image_filtrer($tous);
} elseif ($f = chercher_filtre($filtre)) {
array_shift($tous);
return call_user_func_array($f, $tous);
} else {
// le filtre n'existe pas, on provoque une erreur
$msg = array('zbug_erreur_filtre', array('filtre' => texte_script($filtre)));
erreur_squelette($msg);
return '';
}
}
/**
* Cherche un filtre spécial indiqué dans la globale `spip_matrice`
* et charge le fichier éventuellement associé contenant le filtre.
*
* Les filtres d'images par exemple sont déclarés de la sorte, tel que :
* ```
* $GLOBALS['spip_matrice']['image_reduire'] = true;
* $GLOBALS['spip_matrice']['image_monochrome'] = 'filtres/images_complements.php';
* ```
*
* @param string $filtre
* @return bool true si on trouve le filtre dans la matrice, false sinon.
*/
function trouver_filtre_matrice($filtre) {
if (isset($GLOBALS['spip_matrice'][$filtre]) and is_string($f = $GLOBALS['spip_matrice'][$filtre])) {
find_in_path($f, '', true);
$GLOBALS['spip_matrice'][$filtre] = true;
}
return !empty($GLOBALS['spip_matrice'][$filtre]);
}
/**
* Filtre `set` qui sauve la valeur en entrée dans une variable
*
* La valeur pourra être retrouvée avec `#GET{variable}`.
*
* @example
* `[(#CALCUL|set{toto})]` enregistre le résultat de `#CALCUL`
* dans la variable `toto` et renvoie vide.
* C'est équivalent à `[(#SET{toto, #CALCUL})]` dans ce cas.
* `#GET{toto}` retourne la valeur sauvegardée.
*
* @example
* `[(#CALCUL|set{toto,1})]` enregistre le résultat de `#CALCUL`
* dans la variable toto et renvoie la valeur. Cela permet d'utiliser
* d'autres filtres ensuite. `#GET{toto}` retourne la valeur.
*
* @filtre
* @param array $Pile Pile de données
* @param mixed $val Valeur à sauver
* @param string $key Clé d'enregistrement
* @param bool $continue True pour retourner la valeur
* @return mixed
*/
function filtre_set(&$Pile, $val, $key, $continue = null) {
$Pile['vars'][$key] = $val;
return $continue ? $val : '';
}
/**
* Filtre `setenv` qui enregistre une valeur dans l'environnement du squelette
*
* La valeur pourra être retrouvée avec `#ENV{variable}`.
*
* @example
* `[(#CALCUL|setenv{toto})]` enregistre le résultat de `#CALCUL`
* dans l'environnement toto et renvoie vide.
* `#ENV{toto}` retourne la valeur.
*
* `[(#CALCUL|setenv{toto,1})]` enregistre le résultat de `#CALCUL`
* dans l'environnement toto et renvoie la valeur.
* `#ENV{toto}` retourne la valeur.
*
* @filtre
*
* @param array $Pile
* @param mixed $val Valeur à enregistrer
* @param mixed $key Nom de la variable
* @param null|mixed $continue Si présent, retourne la valeur en sortie
* @return string|mixed Retourne `$val` si `$continue` présent, sinon ''.
*/
function filtre_setenv(&$Pile, $val, $key, $continue = null) {
$Pile[0][$key] = $val;
return $continue ? $val : '';
}
/**
* Filtre `debug` qui affiche un debug de la valeur en entrée
*
* Log la valeur dans `debug.log` et l'affiche si on est webmestre.
*
* @example
* `[(#TRUC|debug)]` affiche et log la valeur de `#TRUC`
* @example
* `[(#TRUC|debug{avant}|calcul|debug{apres}|etc)]`
* affiche la valeur de `#TRUC` avant et après le calcul,
* en précisant "avant" et "apres".
*
* @filtre
* @link http://www.spip.net/5695
* @param mixed $val La valeur à debugguer
* @param mixed|null $key Clé pour s'y retrouver
* @return mixed Retourne la valeur (sans la modifier).
*/
function filtre_debug($val, $key = null) {
$debug = (
is_null($key) ? '' : (var_export($key, true) . " = ")
) . var_export($val, true);
include_spip('inc/autoriser');
if (autoriser('webmestre')) {
echo "<div class='spip_debug'>\n", $debug, "</div>\n";
}
spip_log($debug, 'debug');
return $val;
}
/**
* Exécute un filtre image
*
* Fonction générique d'entrée des filtres images.
* Accepte en entrée :
*
* - un texte complet,
* - un img-log (produit par #LOGO_XX),
* - un tag `<img ...>` complet,
* - un nom de fichier *local* (passer le filtre `|copie_locale` si on veut
* l'appliquer à un document distant).
*
* Applique le filtre demande à chacune des occurrences
*
* @param array $args
* Liste des arguments :
*
* - le premier est le nom du filtre image à appliquer
* - le second est le texte sur lequel on applique le filtre
* - les suivants sont les arguments du filtre image souhaité.
* @return string
* Texte qui a reçu les filtres
**/
function image_filtrer($args) {
$filtre = array_shift($args); # enlever $filtre
$texte = array_shift($args);
if (!strlen($texte)) {
return;
}
find_in_path('filtres_images_mini.php', 'inc/', true);
statut_effacer_images_temporaires(true); // activer la suppression des images temporaires car le compilo finit la chaine par un image_graver
// Cas du nom de fichier local
if (strpos(substr($texte, strlen(_DIR_RACINE)), '..') === false
and !preg_match(',^/|[<>]|\s,S', $texte)
and (
file_exists(preg_replace(',[?].*$,', '', $texte))
or tester_url_absolue($texte)
)
) {
array_unshift($args, "<img src='$texte' />");
$res = call_user_func_array($filtre, $args);
statut_effacer_images_temporaires(false); // desactiver pour les appels hors compilo
return $res;
}
// Cas general : trier toutes les images, avec eventuellement leur <span>
if (preg_match_all(
',(<([a-z]+) [^<>]*spip_documents[^<>]*>)?\s*(<img\s.*>),UimsS',
$texte, $tags, PREG_SET_ORDER)) {
foreach ($tags as $tag) {
$class = extraire_attribut($tag[3], 'class');
if (!$class or
(strpos($class, 'filtre_inactif') == false
// compat historique a virer en 3.2
and strpos($class, 'no_image_filtrer') === false)
) {
array_unshift($args, $tag[3]);
if ($reduit = call_user_func_array($filtre, $args)) {
// En cas de span spip_documents, modifier le style=...width:
if ($tag[1]) {
$w = extraire_attribut($reduit, 'width');
if (!$w and preg_match(",width:\s*(\d+)px,S", extraire_attribut($reduit, 'style'), $regs)) {
$w = $regs[1];
}
if ($w and ($style = extraire_attribut($tag[1], 'style'))) {
$style = preg_replace(",width:\s*\d+px,S", "width:${w}px", $style);
$replace = inserer_attribut($tag[1], 'style', $style);
$texte = str_replace($tag[1], $replace, $texte);
}
}
// traiter aussi un eventuel mouseover
if ($mouseover = extraire_attribut($reduit, 'onmouseover')) {
if (preg_match(",this[.]src=['\"]([^'\"]+)['\"],ims", $mouseover, $match)) {
$srcover = $match[1];
array_shift($args);
array_unshift($args, "<img src='" . $match[1] . "' />");
$srcover_filter = call_user_func_array($filtre, $args);
$srcover_filter = extraire_attribut($srcover_filter, 'src');
$reduit = str_replace($srcover, $srcover_filter, $reduit);
}
}
$texte = str_replace($tag[3], $reduit, $texte);
}
array_shift($args);
}
}
}
statut_effacer_images_temporaires(false); // desactiver pour les appels hors compilo
return $texte;
}
/**
* Retourne les tailles d'une image
*
* Pour les filtres `largeur` et `hauteur`
*
* @param string $img
* Balise HTML `<img ... />` ou chemin de l'image (qui peut être une URL distante).
* @return array
* Liste (hauteur, largeur) en pixels
**/
function taille_image($img) {
static $largeur_img = array(), $hauteur_img = array();
$srcWidth = 0;
$srcHeight = 0;
$logo = extraire_attribut($img, 'src');
if (!$logo) {
$logo = $img;
} else {
$srcWidth = extraire_attribut($img, 'width');
$srcHeight = extraire_attribut($img, 'height');
}
// ne jamais operer directement sur une image distante pour des raisons de perfo
// la copie locale a toutes les chances d'etre la ou de resservir
if (tester_url_absolue($logo)) {
include_spip('inc/distant');
$fichier = copie_locale($logo);
$logo = $fichier ? _DIR_RACINE . $fichier : $logo;
}
if (($p = strpos($logo, '?')) !== false) {
$logo = substr($logo, 0, $p);
}
$srcsize = false;
if (isset($largeur_img[$logo])) {
$srcWidth = $largeur_img[$logo];
}
if (isset($hauteur_img[$logo])) {
$srcHeight = $hauteur_img[$logo];
}
if (!$srcWidth or !$srcHeight) {
if (file_exists($logo)
and $srcsize = @getimagesize($logo)
) {
if (!$srcWidth) {
$largeur_img[$logo] = $srcWidth = $srcsize[0];
}
if (!$srcHeight) {
$hauteur_img[$logo] = $srcHeight = $srcsize[1];
}
}
// $logo peut etre une reference a une image temporaire dont a n'a que le log .src
// on s'y refere, l'image sera reconstruite en temps utile si necessaire
elseif (@file_exists($f = "$logo.src")
and lire_fichier($f, $valeurs)
and $valeurs = unserialize($valeurs)
) {
if (!$srcWidth) {
$largeur_img[$logo] = $srcWidth = $valeurs["largeur_dest"];
}
if (!$srcHeight) {
$hauteur_img[$logo] = $srcHeight = $valeurs["hauteur_dest"];
}
}
}
return array($srcHeight, $srcWidth);
}
/**
* Retourne la largeur d'une image
*
* @filtre
* @link http://www.spip.net/4296
* @uses taille_image()
* @see hauteur()
*
* @param string $img
* Balise HTML `<img ... />` ou chemin de l'image (qui peut être une URL distante).
* @return int|null
* Largeur en pixels, NULL ou 0 si aucune image.
**/
function largeur($img) {
if (!$img) {
return;
}
list($h, $l) = taille_image($img);
return $l;
}
/**
* Retourne la hauteur d'une image
*
* @filtre
* @link http://www.spip.net/4291
* @uses taille_image()
* @see largeur()
*
* @param string $img
* Balise HTML `<img ... />` ou chemin de l'image (qui peut être une URL distante).
* @return int|null
* Hauteur en pixels, NULL ou 0 si aucune image.
**/
function hauteur($img) {
if (!$img) {
return;
}
list($h, $l) = taille_image($img);
return $h;
}
/**
* Échappement des entités HTML avec correction des entités « brutes »
*
* Ces entités peuvent être générées par les butineurs lorsqu'on rentre des
* caractères n'appartenant pas au charset de la page [iso-8859-1 par défaut]
*
* Attention on limite cette correction aux caracteres « hauts » (en fait > 99
* pour aller plus vite que le > 127 qui serait logique), de manière à
* préserver des eéhappements de caractères « bas » (par exemple `[` ou `"`)
* et au cas particulier de `&amp;` qui devient `&amp;amp;` dans les URL
*
* @see corriger_toutes_entites_html()
* @param string $texte
* @return string
**/
function corriger_entites_html($texte) {
if (strpos($texte, '&amp;') === false) {
return $texte;
}
return preg_replace(',&amp;(#[0-9][0-9][0-9]+;|amp;),iS', '&\1', $texte);
}
/**
* Échappement des entités HTML avec correction des entités « brutes » ainsi
* que les `&amp;eacute;` en `&eacute;`
*
* Identique à `corriger_entites_html()` en corrigeant aussi les
* `&amp;eacute;` en `&eacute;`
*
* @see corriger_entites_html()
* @param string $texte
* @return string
**/
function corriger_toutes_entites_html($texte) {
if (strpos($texte, '&amp;') === false) {
return $texte;
}
return preg_replace(',&amp;(#?[a-z0-9]+;),iS', '&\1', $texte);
}
/**
* Échappe les `&` en `&amp;`
*
* @param string $texte
* @return string
**/
function proteger_amp($texte) {
return str_replace('&', '&amp;', $texte);
}
/**
* Échappe en entités HTML certains caractères d'un texte
*
* Traduira un code HTML en transformant en entités HTML les caractères
* en dehors du charset de la page ainsi que les `"`, `<` et `>`.
*
* Ceci permet d’insérer le texte d’une balise dans un `<textarea> </textarea>`
* sans dommages.
*
* @filtre
* @link http://www.spip.net/4280
*
* @uses echappe_html()
* @uses echappe_retour()
* @uses proteger_amp()
* @uses corriger_entites_html()
* @uses corriger_toutes_entites_html()
*
* @param string $texte
* chaine a echapper
* @param bool $tout
* corriger toutes les `&amp;xx;` en `&xx;`
* @param bool $quote
* Échapper aussi les simples quotes en `&#039;`
* @return mixed|string
*/
function entites_html($texte, $tout = false, $quote = true) {
if (!is_string($texte) or !$texte
or strpbrk($texte, "&\"'<>") == false
) {
return $texte;
}
include_spip('inc/texte');
$flags = ($quote ? ENT_QUOTES : ENT_NOQUOTES);
$flags |= ENT_HTML401;
$texte = spip_htmlspecialchars(echappe_retour(echappe_html($texte, '', true), '', 'proteger_amp'), $flags);
if ($tout) {
return corriger_toutes_entites_html($texte);
} else {
return corriger_entites_html($texte);
}
}
/**
* Convertit les caractères spéciaux HTML dans le charset du site.
*
* @exemple
* Si le charset de votre site est `utf-8`, `&eacute;` ou `&#233;`
* sera transformé en `é`
*
* @filtre
* @link http://www.spip.net/5513
*
* @param string $texte
* Texte à convertir
* @return string
* Texte converti
**/
function filtrer_entites($texte) {
if (strpos($texte, '&') === false) {
return $texte;
}
// filtrer
$texte = html2unicode($texte);
// remettre le tout dans le charset cible
$texte = unicode2charset($texte);
// cas particulier des " et ' qu'il faut filtrer aussi
// (on le faisait deja avec un &quot;)
if (strpos($texte, "&#") !== false) {
$texte = str_replace(array("&#039;", "&#39;", "&#034;", "&#34;"), array("'", "'", '"', '"'), $texte);
}
return $texte;
}
if (!function_exists('filtre_filtrer_entites_dist')) {
/**
* Version sécurisée de filtrer_entites
*
* @uses interdire_scripts()
* @uses filtrer_entites()
*
* @param string $t
* @return string
*/
function filtre_filtrer_entites_dist($t) {
include_spip('inc/texte');
return interdire_scripts(filtrer_entites($t));
}
}
/**
* Supprime des caractères illégaux
*
* Remplace les caractères de controle par le caractère `-`
*
* @link http://www.w3.org/TR/REC-xml/#charsets
*
* @param string|array $texte
* @return string|array
**/
function supprimer_caracteres_illegaux($texte) {
static $from = "\x0\x1\x2\x3\x4\x5\x6\x7\x8\xB\xC\xE\xF\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1A\x1B\x1C\x1D\x1E\x1F";
static $to = null;
if (is_array($texte)) {
return array_map('supprimer_caracteres_illegaux', $texte);
}
if (!$to) {
$to = str_repeat('-', strlen($from));
}
return strtr($texte, $from, $to);
}
/**
* Correction de caractères
*
* Supprimer les caracteres windows non conformes et les caracteres de controle illégaux
*
* @param string|array $texte
* @return string|array
**/
function corriger_caracteres($texte) {
$texte = corriger_caracteres_windows($texte);
$texte = supprimer_caracteres_illegaux($texte);
return $texte;
}
/**
* Encode du HTML pour transmission XML notamment dans les flux RSS
*
* Ce filtre transforme les liens en liens absolus, importe les entitées html et échappe les tags html.
*
* @filtre
* @link http://www.spip.net/4287
*
* @param string $texte
* Texte à transformer
* @return string
* Texte encodé pour XML
*/
function texte_backend($texte) {
static $apostrophe = array("&#8217;", "'"); # n'allouer qu'une fois
// si on a des liens ou des images, les passer en absolu
$texte = liens_absolus($texte);
// echapper les tags &gt; &lt;
$texte = preg_replace(',&(gt|lt);,S', '&amp;\1;', $texte);
// importer les &eacute;
$texte = filtrer_entites($texte);
// " -> &quot; et tout ce genre de choses
$u = $GLOBALS['meta']['pcre_u'];
$texte = str_replace("&nbsp;", " ", $texte);
$texte = preg_replace('/\s{2,}/S' . $u, " ", $texte);
// ne pas echapper les sinqle quotes car certains outils de syndication gerent mal
$texte = entites_html($texte, false, false);
// mais bien echapper les double quotes !
$texte = str_replace('"', '&#034;', $texte);
// verifier le charset
$texte = charset2unicode($texte);
// Caracteres problematiques en iso-latin 1
if (isset($GLOBALS['meta']['charset']) and $GLOBALS['meta']['charset'] == 'iso-8859-1') {
$texte = str_replace(chr(156), '&#156;', $texte);
$texte = str_replace(chr(140), '&#140;', $texte);
$texte = str_replace(chr(159), '&#159;', $texte);
}
// l'apostrophe curly pose probleme a certains lecteure de RSS
// et le caractere apostrophe alourdit les squelettes avec PHP
// ==> on les remplace par l'entite HTML
return str_replace($apostrophe, "'", $texte);
}
/**
* Encode et quote du HTML pour transmission XML notamment dans les flux RSS
*
* Comme texte_backend(), mais avec addslashes final pour squelettes avec PHP (rss)
*
* @uses texte_backend()
* @filtre
*
* @param string $texte
* Texte à transformer
* @return string
* Texte encodé et quote pour XML
*/
function texte_backendq($texte) {
return addslashes(texte_backend($texte));
}
/**
* Enlève un numéro préfixant un texte
*
* Supprime `10. ` dans la chaine `10. Titre`
*
* @filtre
* @link http://www.spip.net/4314
* @see recuperer_numero() Pour obtenir le numéro
* @example
* ```
* [<h1>(#TITRE|supprimer_numero)</h1>]
* ```
*
* @param string $texte
* Texte
* @return int|string
* Numéro de titre, sinon chaîne vide
**/
function supprimer_numero($texte) {
return preg_replace(
",^[[:space:]]*([0-9]+)([.)]|" . chr(194) . '?' . chr(176) . ")[[:space:]]+,S",
"", $texte);
}
/**
* Récupère un numéro préfixant un texte
*
* Récupère le numéro `10` dans la chaine `10. Titre`
*
* @filtre
* @link http://www.spip.net/5514
* @see supprimer_numero() Pour supprimer le numéro
* @see balise_RANG_dist() Pour obtenir un numéro de titre
* @example
* ```
* [(#TITRE|recuperer_numero)]
* ```
*
* @param string $texte
* Texte
* @return int|string
* Numéro de titre, sinon chaîne vide
**/
function recuperer_numero($texte) {
if (preg_match(
",^[[:space:]]*([0-9]+)([.)]|" . chr(194) . '?' . chr(176) . ")[[:space:]]+,S",
$texte, $regs)) {
return strval($regs[1]);
} else {
return '';
}
}
/**
* Suppression basique et brutale de tous les tags
*
* Supprime tous les tags `<...>`.
* Utilisé fréquemment pour écrire des RSS.
*
* @filtre
* @link http://www.spip.net/4315
* @example
* ```
* <title>[(#TITRE|supprimer_tags|texte_backend)]</title>
* ```
*
* @note
* Ce filtre supprime aussi les signes inférieurs `<` rencontrés.
*
* @param string $texte
* Texte à échapper
* @param string $rempl
* Inutilisé.
* @return string
* Texte converti
**/
function supprimer_tags($texte, $rempl = "") {
$texte = preg_replace(",<(!--|\w|/|!\[endif|!\[if)[^>]*>,US", $rempl, $texte);
// ne pas oublier un < final non ferme car coupe
$texte = preg_replace(",<(!--|\w|/).*$,US", $rempl, $texte);
// mais qui peut aussi etre un simple signe plus petit que
$texte = str_replace('<', '&lt;', $texte);
return $texte;
}
/**
* Convertit les chevrons de tag en version lisible en HTML
*
* Transforme les chevrons de tag `<...>` en entité HTML.
*
* @filtre
* @link http://www.spip.net/5515
* @example
* ```
* <pre>[(#TEXTE|echapper_tags)]</pre>
* ```
*
* @param string $texte
* Texte à échapper
* @param string $rempl
* Inutilisé.
* @return string
* Texte converti
**/
function echapper_tags($texte, $rempl = "") {
$texte = preg_replace("/<([^>]*)>/", "&lt;\\1&gt;", $texte);
return $texte;
}
/**
* Convertit un texte HTML en texte brut
*
* Enlève les tags d'un code HTML, élimine les doubles espaces.
*
* @filtre
* @link http://www.spip.net/4317
* @example
* ```
* <title>[(#TITRE|textebrut) - ][(#NOM_SITE_SPIP|textebrut)]</title>
* ```
*
* @param string $texte
* Texte à convertir
* @return string
* Texte converti
**/
function textebrut($texte) {
$u = $GLOBALS['meta']['pcre_u'];
$texte = preg_replace('/\s+/S' . $u, " ", $texte);
$texte = preg_replace("/<(p|br)( [^>]*)?" . ">/iS", "\n\n", $texte);
$texte = preg_replace("/^\n+/", "", $texte);
$texte = preg_replace("/\n+$/", "", $texte);
$texte = preg_replace("/\n +/", "\n", $texte);
$texte = supprimer_tags($texte);
$texte = preg_replace("/(&nbsp;| )+/S", " ", $texte);
// nettoyer l'apostrophe curly qui pose probleme a certains rss-readers, lecteurs de mail...
$texte = str_replace("&#8217;", "'", $texte);
return $texte;
}
/**
* Remplace les liens SPIP en liens ouvrant dans une nouvelle fenetre (target=blank)
*
* @filtre
* @link http://www.spip.net/4297
*
* @param string $texte
* Texte avec des liens
* @return string
* Texte avec liens ouvrants
**/
function liens_ouvrants($texte) {
if (preg_match_all(",(<a\s+[^>]*https?://[^>]*class=[\"']spip_(out|url)\b[^>]+>),imsS",
$texte, $liens, PREG_PATTERN_ORDER)) {
foreach ($liens[0] as $a) {
$rel = 'noopener noreferrer ' . extraire_attribut($a, 'rel');
$ablank = inserer_attribut($a, 'rel', $rel);
$ablank = inserer_attribut($ablank, 'target', '_blank');
$texte = str_replace($a, $ablank, $texte);
}
}
return $texte;
}
/**
* Ajouter un attribut rel="nofollow" sur tous les liens d'un texte
*
* @param string $texte
* @return string
*/
function liens_nofollow($texte) {
if (stripos($texte, "<a") === false) {
return $texte;
}
if (preg_match_all(",<a\b[^>]*>,UimsS", $texte, $regs, PREG_PATTERN_ORDER)) {
foreach ($regs[0] as $a) {
$rel = extraire_attribut($a, "rel");
if (strpos($rel, "nofollow") === false) {
$rel = "nofollow" . ($rel ? " $rel" : "");
$anofollow = inserer_attribut($a, "rel", $rel);
$texte = str_replace($a, $anofollow, $texte);
}
}
}
return $texte;
}
/**
* Transforme les sauts de paragraphe HTML `p` en simples passages à la ligne `br`
*
* @filtre
* @link http://www.spip.net/4308
* @example
* ```
* [<div>(#DESCRIPTIF|PtoBR)[(#NOTES|PtoBR)]</div>]
* ```
*
* @param string $texte
* Texte à transformer
* @return string
* Texte sans paraghaphes
**/
function PtoBR($texte) {
$u = $GLOBALS['meta']['pcre_u'];
$texte = preg_replace("@</p>@iS", "\n", $texte);
$texte = preg_replace("@<p\b.*>@UiS", "<br />", $texte);
$texte = preg_replace("@^\s*<br />@S" . $u, "", $texte);
return $texte;
}
/**
* Assure qu'un texte ne vas pas déborder d'un bloc
* par la faute d'un mot trop long (souvent des URLs)
*
* Ne devrait plus être utilisé et fait directement en CSS par un style
* `word-wrap:break-word;`
*
* @note
* Pour assurer la compatibilité du filtre, on encapsule le contenu par
* un `div` ou `span` portant ce style CSS inline.
*
* @filtre
* @link http://www.spip.net/4298
* @link http://www.alsacreations.com/tuto/lire/1038-gerer-debordement-contenu-css.html
* @deprecated Utiliser le style CSS `word-wrap:break-word;`
*
* @param string $texte Texte
* @return string Texte encadré du style CSS
*/
function lignes_longues($texte) {
if (!strlen(trim($texte))) {
return $texte;
}
include_spip('inc/texte');
$tag = preg_match(',</?(' . _BALISES_BLOCS . ')[>[:space:]],iS', $texte) ?
'div' : 'span';
return "<$tag style='word-wrap:break-word;'>$texte</$tag>";
}
/**
* Passe un texte en majuscules, y compris les accents, en HTML
*
* Encadre le texte du style CSS `text-transform: uppercase;`.
* Le cas spécifique du i turc est géré.
*
* @filtre
* @example
* ```
* [(#EXTENSION|majuscules)]
* ```
*
* @param string $texte Texte
* @return string Texte en majuscule
*/
function majuscules($texte) {
if (!strlen($texte)) {
return '';
}
// Cas du turc
if ($GLOBALS['spip_lang'] == 'tr') {
# remplacer hors des tags et des entites
if (preg_match_all(',<[^<>]+>|&[^;]+;,S', $texte, $regs, PREG_SET_ORDER)) {
foreach ($regs as $n => $match) {
$texte = str_replace($match[0], "@@SPIP_TURC$n@@", $texte);
}
}
$texte = str_replace('i', '&#304;', $texte);
if ($regs) {
foreach ($regs as $n => $match) {
$texte = str_replace("@@SPIP_TURC$n@@", $match[0], $texte);
}
}
}
// Cas general
return "<span style='text-transform: uppercase;'>$texte</span>";
}
/**
* Retourne une taille en octets humainement lisible
*
* Tel que "127.4 ko" ou "3.1 Mo"
*
* @example
* - `[(#TAILLE|taille_en_octets)]`
* - `[(#VAL{123456789}|taille_en_octets)]` affiche `117.7 Mo`
*
* @filtre
* @link http://www.spip.net/4316
* @param int $taille
* @return string
**/
function taille_en_octets($taille) {
if (!defined('_KILOBYTE')) {
/**
* Définit le nombre d'octets dans un Kilobyte
*
* @var int
**/
define('_KILOBYTE', 1024);
}
if ($taille < 1) {
return '';
}
if ($taille < _KILOBYTE) {
$taille = _T('taille_octets', array('taille' => $taille));
} elseif ($taille < _KILOBYTE * _KILOBYTE) {
$taille = _T('taille_ko', array('taille' => round($taille / _KILOBYTE, 1)));
} elseif ($taille < _KILOBYTE * _KILOBYTE * _KILOBYTE) {
$taille = _T('taille_mo', array('taille' => round($taille / _KILOBYTE / _KILOBYTE, 1)));
} else {
$taille = _T('taille_go', array('taille' => round($taille / _KILOBYTE / _KILOBYTE / _KILOBYTE, 2)));
}
return $taille;
}
/**
* Rend une chaine utilisable sans dommage comme attribut HTML
*
* @example `<a href="#URL_ARTICLE" title="[(#TITRE|attribut_html)]">#TITRE</a>`
*
* @filtre
* @link http://www.spip.net/4282
* @uses textebrut()
* @uses texte_backend()
*
* @param string $texte
* Texte à mettre en attribut
* @param bool $textebrut
* Passe le texte en texte brut (enlève les balises html) ?
* @return string
* Texte prêt pour être utilisé en attribut HTML
**/
function attribut_html($texte, $textebrut = true) {
$u = $GLOBALS['meta']['pcre_u'];
if ($textebrut) {
$texte = preg_replace(array(",\n,", ",\s(?=\s),msS" . $u), array(" ", ""), textebrut($texte));
}
$texte = texte_backend($texte);
$texte = str_replace(array("'", '"'), array('&#039;', '&#034;'), $texte);
return preg_replace(array("/&(amp;|#38;)/", "/&(?![A-Za-z]{0,4}\w{2,3};|#[0-9]{2,5};)/"), array("&", "&#38;"),
$texte);
}
/**
* Vider les URL nulles
*
* - Vide les URL vides comme `http://` ou `mailto:` (sans rien d'autre)
* - échappe les entités et gère les `&amp;`
*
* @uses entites_html()
*
* @param string $url
* URL à vérifier et échapper
* @param bool $entites
* `true` pour échapper les entités HTML.
* @return string
* URL ou chaîne vide
**/
function vider_url($url, $entites = true) {
# un message pour abs_url
$GLOBALS['mode_abs_url'] = 'url';
$url = trim($url);
$r = ",^(?:" . _PROTOCOLES_STD . '):?/?/?$,iS';
return preg_match($r, $url) ? '' : ($entites ? entites_html($url) : $url);
}
/**
* Maquiller une adresse e-mail
*
* Remplace `@` par 3 caractères aléatoires.
*
* @uses creer_pass_aleatoire()
*
* @param string $texte Adresse email
* @return string Adresse email maquillée
**/
function antispam($texte) {
include_spip('inc/acces');
$masque = creer_pass_aleatoire(3);
return preg_replace("/@/", " $masque ", $texte);
}
/**
* Vérifie un accès à faible sécurité
*
* Vérifie qu'un visiteur peut accéder à la page demandée,
* qui est protégée par une clé, calculée à partir du low_sec de l'auteur,
* et des paramètres le composant l'appel (op, args)
*
* @example
* `[(#ID_AUTEUR|securiser_acces{#ENV{cle}, rss, #ENV{op}, #ENV{args}}|sinon_interdire_acces)]`
*
* @see bouton_spip_rss() pour générer un lien de faible sécurité pour les RSS privés
* @see afficher_low_sec() pour calculer une clé valide
* @uses verifier_low_sec()
*
* @filtre
* @param int $id_auteur
* L'auteur qui demande la page
* @param string $cle
* La clé à tester
* @param string $dir
* Un type d'accès (nom du répertoire dans lequel sont rangés les squelettes demandés, tel que 'rss')
* @param string $op
* Nom de l'opération éventuelle
* @param string $args
* Nom de l'argument calculé
* @return bool
* True si on a le droit d'accès, false sinon.
**/
function securiser_acces($id_auteur, $cle, $dir, $op = '', $args = '') {
include_spip('inc/acces');
if ($op) {
$dir .= " $op $args";
}
return verifier_low_sec($id_auteur, $cle, $dir);
}
/**
* Retourne le second paramètre lorsque
* le premier est considere vide, sinon retourne le premier paramètre.
*
* En php `sinon($a, 'rien')` retourne `$a`, ou `'rien'` si `$a` est vide.
* En filtre SPIP `|sinon{#TEXTE, rien}` : affiche `#TEXTE` ou `rien` si `#TEXTE` est vide,
*
* @filtre
* @see filtre_logique() pour la compilation du filtre dans un squelette
* @link http://www.spip.net/4313
* @note
* L'utilisation de `|sinon` en tant que filtre de squelette
* est directement compilé dans `public/references` par la fonction `filtre_logique()`
*
* @param mixed $texte
* Contenu de reference a tester
* @param mixed $sinon
* Contenu a retourner si le contenu de reference est vide
* @return mixed
* Retourne $texte, sinon $sinon.
**/
function sinon($texte, $sinon = '') {
if ($texte or (!is_array($texte) and strlen($texte))) {
return $texte;
} else {
return $sinon;
}
}
/**
* Filtre `|choixsivide{vide, pas vide}` alias de `|?{si oui, si non}` avec les arguments inversés
*
* @example
* `[(#TEXTE|choixsivide{vide, plein})]` affiche vide si le `#TEXTE`
* est considéré vide par PHP (chaîne vide, false, 0, tableau vide, etc…).
* C'est l'équivalent de `[(#TEXTE|?{plein, vide})]`
*
* @filtre
* @see choixsiegal()
* @link http://www.spip.net/4189
*
* @param mixed $a
* La valeur à tester
* @param mixed $vide
* Ce qui est retourné si `$a` est considéré vide
* @param mixed $pasvide
* Ce qui est retourné sinon
* @return mixed
**/
function choixsivide($a, $vide, $pasvide) {
return $a ? $pasvide : $vide;
}
/**
* Filtre `|choixsiegal{valeur, sioui, sinon}`
*
* @example
* `#LANG_DIR|choixsiegal{ltr,left,right}` retourne `left` si
* `#LANG_DIR` vaut `ltr` et `right` sinon.
*
* @filtre
* @link http://www.spip.net/4148
*
* @param mixed $a1
* La valeur à tester
* @param mixed $a2
* La valeur de comparaison
* @param mixed $v
* Ce qui est retourné si la comparaison est vraie
* @param mixed $f
* Ce qui est retourné sinon
* @return mixed
**/
function choixsiegal($a1, $a2, $v, $f) {
return ($a1 == $a2) ? $v : $f;
}
//
// Export iCal
//
/**
* Adapte un texte pour être inséré dans une valeur d'un export ICAL
*
* Passe le texte en utf8, enlève les sauts de lignes et échappe les virgules.
*
* @example `SUMMARY:[(#TITRE|filtrer_ical)]`
* @filtre
*
* @param string $texte
* @return string
**/
function filtrer_ical($texte) {
#include_spip('inc/charsets');
$texte = html2unicode($texte);
$texte = unicode2charset(charset2unicode($texte, $GLOBALS['meta']['charset'], 1), 'utf-8');
$texte = preg_replace("/\n/", " ", $texte);
$texte = preg_replace("/,/", "\,", $texte);
return $texte;
}
/**
* Transforme les sauts de ligne simples en sauts forcés avec `_ `
*
* Ne modifie pas les sauts de paragraphe (2 sauts consécutifs au moins),
* ou les retours à l'intérieur de modèles ou de certaines balises html.
*
* @note
* Cette fonction pouvait être utilisée pour forcer les alinéas,
* (retours à la ligne sans saut de paragraphe), mais ce traitement
* est maintenant automatique.
* Cf. plugin Textwheel et la constante _AUTOBR
*
* @uses echappe_html()
* @uses echappe_retour()
*
* @param string $texte
* @param string $delim
* Ce par quoi sont remplacés les sauts
* @return string
**/
function post_autobr($texte, $delim = "\n_ ") {
if (!function_exists('echappe_html')) {
include_spip('inc/texte_mini');
}
$texte = str_replace("\r\n", "\r", $texte);
$texte = str_replace("\r", "\n", $texte);
if (preg_match(",\n+$,", $texte, $fin)) {
$texte = substr($texte, 0, -strlen($fin = $fin[0]));
} else {
$fin = '';
}
$texte = echappe_html($texte, '', true);
// echapper les modeles
if (strpos($texte, "<") !== false) {
include_spip('inc/lien');
if (defined('_PREG_MODELE')) {
$preg_modeles = "@" . _PREG_MODELE . "@imsS";
$texte = echappe_html($texte, '', true, $preg_modeles);
}
}
$debut = '';
$suite = $texte;
while ($t = strpos('-' . $suite, "\n", 1)) {
$debut .= substr($suite, 0, $t - 1);
$suite = substr($suite, $t);
$car = substr($suite, 0, 1);
if (($car <> '-') and ($car <> '_') and ($car <> "\n") and ($car <> "|") and ($car <> "}")
and !preg_match(',^\s*(\n|</?(quote|div|dl|dt|dd)|$),S', ($suite))
and !preg_match(',</?(quote|div|dl|dt|dd)> *$,iS', $debut)
) {
$debut .= $delim;
} else {
$debut .= "\n";
}
if (preg_match(",^\n+,", $suite, $regs)) {
$debut .= $regs[0];
$suite = substr($suite, strlen($regs[0]));
}
}
$texte = $debut . $suite;
$texte = echappe_retour($texte);
return $texte . $fin;
}
/**
* Expression régulière pour obtenir le contenu des extraits idiomes `<:module:cle:>`
*
* @var string
*/
define('_EXTRAIRE_IDIOME', '@<:(?:([a-z0-9_]+):)?([a-z0-9_]+):>@isS');
/**
* Extrait une langue des extraits idiomes (`<:module:cle_de_langue:>`)
*
* Retrouve les balises `<:cle_de_langue:>` d'un texte et remplace son contenu
* par l'extrait correspondant à la langue demandée (si possible), sinon dans la
* langue par défaut du site.
*
* Ne pas mettre de span@lang=fr si on est déjà en fr.
*
* @filtre
* @uses inc_traduire_dist()
* @uses code_echappement()
* @uses echappe_retour()
*
* @param string $letexte
* @param string $lang
* Langue à retrouver (si vide, utilise la langue en cours).
* @param array $options Options {
* @type bool $echappe_span
* True pour échapper les balises span (false par défaut)
* @type string $lang_defaut
* Code de langue : permet de définir la langue utilisée par défaut,
* en cas d'absence de traduction dans la langue demandée.
* Par défaut la langue du site.
* Indiquer 'aucune' pour ne pas retourner de texte si la langue
* exacte n'a pas été trouvée.
* }
* @return string
**/
function extraire_idiome($letexte, $lang = null, $options = array()) {
static $traduire = false;
if ($letexte
and preg_match_all(_EXTRAIRE_IDIOME, $letexte, $regs, PREG_SET_ORDER)
) {
if (!$traduire) {
$traduire = charger_fonction('traduire', 'inc');
include_spip('inc/lang');
}
if (!$lang) {
$lang = $GLOBALS['spip_lang'];
}
// Compatibilité avec le prototype de fonction précédente qui utilisait un boolean
if (is_bool($options)) {
$options = array('echappe_span' => $options);
}
if (!isset($options['echappe_span'])) {
$options = array_merge($options, array('echappe_span' => false));
}
foreach ($regs as $reg) {
$cle = ($reg[1] ? $reg[1] . ':' : '') . $reg[2];
$desc = $traduire($cle, $lang, true);
$l = $desc->langue;
// si pas de traduction, on laissera l'écriture de l'idiome entier dans le texte.
if (strlen($desc->texte)) {
$trad = code_echappement($desc->texte, 'idiome', false);
if ($l !== $lang) {
$trad = str_replace("'", '"', inserer_attribut($trad, 'lang', $l));
}
if (lang_dir($l) !== lang_dir($lang)) {
$trad = str_replace("'", '"', inserer_attribut($trad, 'dir', lang_dir($l)));
}
if (!$options['echappe_span']) {
$trad = echappe_retour($trad, 'idiome');
}
$letexte = str_replace($reg[0], $trad, $letexte);
}
}
}
return $letexte;
}
/**
* Expression régulière pour obtenir le contenu des extraits polyglottes `<multi>`
*
* @var string
*/
define('_EXTRAIRE_MULTI', "@<multi>(.*?)</multi>@sS");
/**
* Extrait une langue des extraits polyglottes (`<multi>`)
*
* Retrouve les balises `<multi>` d'un texte et remplace son contenu
* par l'extrait correspondant à la langue demandée.
*
* Si la langue demandée n'est pas trouvée dans le multi, ni une langue
* approchante (exemple `fr` si on demande `fr_TU`), on retourne l'extrait
* correspondant à la langue par défaut (option 'lang_defaut'), qui est
* par défaut la langue du site. Et si l'extrait n'existe toujours pas
* dans cette langue, ça utilisera la première langue utilisée
* dans la balise `<multi>`.
*
* Ne pas mettre de span@lang=fr si on est déjà en fr.
*
* @filtre
* @link http://www.spip.net/5332
*
* @uses extraire_trads()
* @uses approcher_langue()
* @uses lang_typo()
* @uses code_echappement()
* @uses echappe_retour()
*
* @param string $letexte
* @param string $lang
* Langue à retrouver (si vide, utilise la langue en cours).
* @param array $options Options {
* @type bool $echappe_span
* True pour échapper les balises span (false par défaut)
* @type string $lang_defaut
* Code de langue : permet de définir la langue utilisée par défaut,
* en cas d'absence de traduction dans la langue demandée.
* Par défaut la langue du site.
* Indiquer 'aucune' pour ne pas retourner de texte si la langue
* exacte n'a pas été trouvée.
* }
* @return string
**/
function extraire_multi($letexte, $lang = null, $options = array()) {
if ($letexte
and preg_match_all(_EXTRAIRE_MULTI, $letexte, $regs, PREG_SET_ORDER)
) {
if (!$lang) {
$lang = $GLOBALS['spip_lang'];
}
// Compatibilité avec le prototype de fonction précédente qui utilisait un boolean
if (is_bool($options)) {
$options = array('echappe_span' => $options, 'lang_defaut' => _LANGUE_PAR_DEFAUT);
}
if (!isset($options['echappe_span'])) {
$options = array_merge($options, array('echappe_span' => false));
}
if (!isset($options['lang_defaut'])) {
$options = array_merge($options, array('lang_defaut' => _LANGUE_PAR_DEFAUT));
}
include_spip('inc/lang');
foreach ($regs as $reg) {
// chercher la version de la langue courante
$trads = extraire_trads($reg[1]);
if ($l = approcher_langue($trads, $lang)) {
$trad = $trads[$l];
} else {
if ($options['lang_defaut'] == 'aucune') {
$trad = '';
} else {
// langue absente, prendre le fr ou une langue précisée (meme comportement que inc/traduire.php)
// ou la premiere dispo
// mais typographier le texte selon les regles de celle-ci
// Attention aux blocs multi sur plusieurs lignes
if (!$l = approcher_langue($trads, $options['lang_defaut'])) {
$l = key($trads);
}
$trad = $trads[$l];
$typographie = charger_fonction(lang_typo($l), 'typographie');
$trad = $typographie($trad);
// Tester si on echappe en span ou en div
// il ne faut pas echapper en div si propre produit un seul paragraphe
include_spip('inc/texte');
$trad_propre = preg_replace(",(^<p[^>]*>|</p>$),Uims", "", propre($trad));
$mode = preg_match(',</?(' . _BALISES_BLOCS . ')[>[:space:]],iS', $trad_propre) ? 'div' : 'span';
$trad = code_echappement($trad, 'multi', false, $mode);
$trad = str_replace("'", '"', inserer_attribut($trad, 'lang', $l));
if (lang_dir($l) !== lang_dir($lang)) {
$trad = str_replace("'", '"', inserer_attribut($trad, 'dir', lang_dir($l)));
}
if (!$options['echappe_span']) {
$trad = echappe_retour($trad, 'multi');
}
}
}
$letexte = str_replace($reg[0], $trad, $letexte);
}
}
return $letexte;
}
/**
* Convertit le contenu d'une balise `<multi>` en un tableau
*
* Exemple de blocs.
* - `texte par défaut [fr] en français [en] en anglais`
* - `[fr] en français [en] en anglais`
*
* @param string $bloc
* Le contenu intérieur d'un bloc multi
* @return array [code de langue => texte]
* Peut retourner un code de langue vide, lorsqu'un texte par défaut est indiqué.
**/
function extraire_trads($bloc) {
$lang = '';
// ce reg fait planter l'analyse multi s'il y a de l'{italique} dans le champ
// while (preg_match("/^(.*?)[{\[]([a-z_]+)[}\]]/siS", $bloc, $regs)) {
while (preg_match("/^(.*?)[\[]([a-z_]+)[\]]/siS", $bloc, $regs)) {
$texte = trim($regs[1]);
if ($texte or $lang) {
$trads[$lang] = $texte;
}
$bloc = substr($bloc, strlen($regs[0]));
$lang = $regs[2];
}
$trads[$lang] = $bloc;
return $trads;
}
/**
* Calculer l'initiale d'un nom
*
* @param string $nom
* @return string L'initiale en majuscule
*/
function filtre_initiale($nom) {
return spip_substr(trim(strtoupper(extraire_multi($nom))), 0, 1);
}
/**
* Retourne la donnée si c'est la première fois qu'il la voit
*
* Il est possible de gérer différentes "familles" de données avec
* le second paramètre.
*
* @filtre
* @link http://www.spip.net/4320
* @example
* ```
* [(#ID_SECTEUR|unique)]
* [(#ID_SECTEUR|unique{tete})] n'a pas d'incidence sur
* [(#ID_SECTEUR|unique{pied})]
* [(#ID_SECTEUR|unique{pied,1})] affiche le nombre d'éléments.
* Préférer totefois #TOTAL_UNIQUE{pied}
* ```
*
* @todo
* Ameliorations possibles :
*
* 1) si la donnée est grosse, mettre son md5 comme clé
* 2) purger $mem quand on change de squelette (sinon bug inclusions)
*
* @param string $donnee
* Donnée que l'on souhaite unique
* @param string $famille
* Famille de stockage (1 unique donnée par famille)
*
* - _spip_raz_ : (interne) Vide la pile de mémoire et la retourne
* - _spip_set_ : (interne) Affecte la pile de mémoire avec la donnée
* @param bool $cpt
* True pour obtenir le nombre d'éléments différents stockés
* @return string|int|array|null|void
*
* - string : Donnée si c'est la première fois qu'elle est vue
* - void : si la donnée a déjà été vue
* - int : si l'on demande le nombre d'éléments
* - array (interne) : si on dépile
* - null (interne) : si on empile
**/
function unique($donnee, $famille = '', $cpt = false) {
static $mem = array();
// permettre de vider la pile et de la restaurer
// pour le calcul de introduction...
if ($famille == '_spip_raz_') {
$tmp = $mem;
$mem = array();
return $tmp;
} elseif ($famille == '_spip_set_') {
$mem = $donnee;
return;
}
// eviter une notice
if (!isset($mem[$famille])) {
$mem[$famille] = array();
}
if ($cpt) {
return count($mem[$famille]);
}
// eviter une notice
if (!isset($mem[$famille][$donnee])) {
$mem[$famille][$donnee] = 0;
}
if (!($mem[$famille][$donnee]++)) {
return $donnee;
}
}
/**
* Filtre qui alterne des valeurs en fonction d'un compteur
*
* Affiche à tour de rôle et dans l'ordre, un des arguments transmis
* à chaque incrément du compteur.
*
* S'il n'y a qu'un seul argument, et que c'est un tableau,
* l'alternance se fait sur les valeurs du tableau.
*
* Souvent appliqué à l'intérieur d'une boucle, avec le compteur `#COMPTEUR_BOUCLE`
*
* @example
* - `[(#COMPTEUR_BOUCLE|alterner{bleu,vert,rouge})]`
* - `[(#COMPTEUR_BOUCLE|alterner{#LISTE{bleu,vert,rouge}})]`
*
* @filtre
* @link http://www.spip.net/4145
*
* @param int $i
* Le compteur
* @return mixed
* Une des valeurs en fonction du compteur.
**/
function alterner($i) {
// recuperer les arguments (attention fonctions un peu space)
$num = func_num_args();
$args = func_get_args();
if ($num == 2 && is_array($args[1])) {
$args = $args[1];
array_unshift($args, '');
$num = count($args);
}
// renvoyer le i-ieme argument, modulo le nombre d'arguments
return $args[(intval($i) - 1) % ($num - 1) + 1];
}
/**
* Récupérer un attribut d'une balise HTML
*
* la regexp est mortelle : cf. `tests/unit/filtres/extraire_attribut.php`
* Si on a passé un tableau de balises, renvoyer un tableau de résultats
* (dans ce cas l'option `$complet` n'est pas disponible)
*
* @param string|array $balise
* Texte ou liste de textes dont on veut extraire des balises
* @param string $attribut
* Nom de l'attribut désiré
* @param bool $complet
* True pour retourner un tableau avec
* - le texte de la balise
* - l'ensemble des résultats de la regexp ($r)
* @return string|array
* - Texte de l'attribut retourné, ou tableau des texte d'attributs
* (si 1er argument tableau)
* - Tableau complet (si 2e argument)
**/
function extraire_attribut($balise, $attribut, $complet = false) {
if (is_array($balise)) {
array_walk(
$balise,
function(&$a, $key, $t){
$a = extraire_attribut($a, $t);
},
$attribut
);
return $balise;
}
if (preg_match(
',(^.*?<(?:(?>\s*)(?>[\w:.-]+)(?>(?:=(?:"[^"]*"|\'[^\']*\'|[^\'"]\S*))?))*?)(\s+'
. $attribut
. '(?:=\s*("[^"]*"|\'[^\']*\'|[^\'"]\S*))?)()((?:[\s/][^>]*)?>.*),isS',
$balise, $r)) {
if (isset($r[3][0]) and ($r[3][0] == '"' || $r[3][0] == "'")) {
$r[4] = substr($r[3], 1, -1);
$r[3] = $r[3][0];
} elseif ($r[3] !== '') {
$r[4] = $r[3];
$r[3] = '';
} else {
$r[4] = trim($r[2]);
}
$att = $r[4];
if (strpos($att, "&#") !== false) {
$att = str_replace(array("&#039;", "&#39;", "&#034;", "&#34;"), array("'", "'", '"', '"'), $att);
}
$att = filtrer_entites($att);
} else {
$att = null;
}
if ($complet) {
return array($att, $r);
} else {
return $att;
}
}
/**
* Insérer (ou modifier) un attribut html dans une balise
*
* @example
* - `[(#LOGO_ARTICLE|inserer_attribut{class, logo article})]`
* - `[(#LOGO_ARTICLE|inserer_attribut{alt, #TTTRE|attribut_html|couper{60}})]`
* - `[(#FICHIER|image_reduire{40}|inserer_attribut{data-description, #DESCRIPTIF})]`
* Laissera les balises HTML de la valeur (ici `#DESCRIPTIF`) si on n'applique pas le
* filtre `attribut_html` dessus.
*
* @filtre
* @link http://www.spip.net/4294
* @uses attribut_html()
* @uses extraire_attribut()
*
* @param string $balise
* Code html de la balise (ou contenant une balise)
* @param string $attribut
* Nom de l'attribut html à modifier
* @param string $val
* Valeur de l'attribut à appliquer
* @param bool $proteger
* Prépare la valeur en tant qu'attribut de balise (mais conserve les balises html).
* @param bool $vider
* True pour vider l'attribut. Une chaîne vide pour `$val` fera pareil.
* @return string
* Code html modifié
**/
function inserer_attribut($balise, $attribut, $val, $proteger = true, $vider = false) {
// preparer l'attribut
// supprimer les &nbsp; etc mais pas les balises html
// qui ont un sens dans un attribut value d'un input
if ($proteger) {
$val = attribut_html($val, false);
}
// echapper les ' pour eviter tout bug
$val = str_replace("'", "&#039;", $val);
if ($vider and strlen($val) == 0) {
$insert = '';
} else {
$insert = " $attribut='$val'";
}
list($old, $r) = extraire_attribut($balise, $attribut, true);
if ($old !== null) {
// Remplacer l'ancien attribut du meme nom
$balise = $r[1] . $insert . $r[5];
} else {
// preferer une balise " />" (comme <img />)
if (preg_match(',/>,', $balise)) {
$balise = preg_replace(",\s?/>,S", $insert . " />", $balise, 1);
} // sinon une balise <a ...> ... </a>
else {
$balise = preg_replace(",\s?>,S", $insert . ">", $balise, 1);
}
}
return $balise;
}
/**
* Supprime un attribut HTML
*
* @example `[(#LOGO_ARTICLE|vider_attribut{class})]`
*
* @filtre
* @link http://www.spip.net/4142
* @uses inserer_attribut()
* @see extraire_attribut()
*
* @param string $balise Code HTML de l'élément
* @param string $attribut Nom de l'attribut à enlever
* @return string Code HTML sans l'attribut
**/
function vider_attribut($balise, $attribut) {
return inserer_attribut($balise, $attribut, '', false, true);
}
/**
* Un filtre pour déterminer le nom du statut des inscrits
*
* @param void|int $id
* @param string $mode
* @return string
*/
function tester_config($id, $mode = '') {
include_spip('action/inscrire_auteur');
return tester_statut_inscription($mode, $id);
}
//
// Quelques fonctions de calcul arithmetique
//
function floatstr($a) { return str_replace(',','.',(string)floatval($a)); }
function strize($f, $a, $b) { return floatstr($f(floatstr($a),floatstr($b))); }
/**
* Additionne 2 nombres
*
* @filtre
* @link http://www.spip.net/4307
* @see moins()
* @example
* ```
* [(#VAL{28}|plus{14})]
* ```
*
* @param int $a
* @param int $b
* @return int $a+$b
**/
function plus($a, $b) {
return $a + $b;
}
function strplus($a, $b) {return strize('plus', $a, $b);}
/**
* Soustrait 2 nombres
*
* @filtre
* @link http://www.spip.net/4302
* @see plus()
* @example
* ```
* [(#VAL{28}|moins{14})]
* ```
*
* @param int $a
* @param int $b
* @return int $a-$b
**/
function moins($a, $b) {
return $a - $b;
}
function strmoins($a, $b) {return strize('moins', $a, $b);}
/**
* Multiplie 2 nombres
*
* @filtre
* @link http://www.spip.net/4304
* @see div()
* @see modulo()
* @example
* ```
* [(#VAL{28}|mult{14})]
* ```
*
* @param int $a
* @param int $b
* @return int $a*$b
**/
function mult($a, $b) {
return $a * $b;
}
function strmult($a, $b) {return strize('mult', $a, $b);}
/**
* Divise 2 nombres
*
* @filtre
* @link http://www.spip.net/4279
* @see mult()
* @see modulo()
* @example
* ```
* [(#VAL{28}|div{14})]
* ```
*
* @param int $a
* @param int $b
* @return int $a/$b (ou 0 si $b est nul)
**/
function div($a, $b) {
return $b ? $a / $b : 0;
}
function strdiv($a, $b) {return strize('div', $a, $b);}
/**
* Retourne le modulo 2 nombres
*
* @filtre
* @link http://www.spip.net/4301
* @see mult()
* @see div()
* @example
* ```
* [(#VAL{28}|modulo{14})]
* ```
*
* @param int $nb
* @param int $mod
* @param int $add
* @return int ($nb % $mod) + $add
**/
function modulo($nb, $mod, $add = 0) {
return ($mod ? $nb % $mod : 0) + $add;
}
/**
* Vérifie qu'un nom (d'auteur) ne comporte pas d'autres tags que <multi>
* et ceux volontairement spécifiés dans la constante
*
* @param string $nom
* Nom (signature) proposé
* @return bool
* - false si pas conforme,
* - true sinon
**/
function nom_acceptable($nom) {
if (!is_string($nom)) {
return false;
}
if (!defined('_TAGS_NOM_AUTEUR')) {
define('_TAGS_NOM_AUTEUR', '');
}
$tags_acceptes = array_unique(explode(',', 'multi,' . _TAGS_NOM_AUTEUR));
foreach ($tags_acceptes as $tag) {
if (strlen($tag)) {
$remp1[] = '<' . trim($tag) . '>';
$remp1[] = '</' . trim($tag) . '>';
$remp2[] = '\x60' . trim($tag) . '\x61';
$remp2[] = '\x60/' . trim($tag) . '\x61';
}
}
$v_nom = str_replace($remp2, $remp1, supprimer_tags(str_replace($remp1, $remp2, $nom)));
return str_replace('&lt;', '<', $v_nom) == $nom;
}
/**
* Vérifier la conformité d'une ou plusieurs adresses email (suivant RFC 822)
*
* @param string $adresses
* Adresse ou liste d'adresse
* @return bool|string
* - false si pas conforme,
* - la normalisation de la dernière adresse donnée sinon
**/
function email_valide($adresses) {
// eviter d'injecter n'importe quoi dans preg_match
if (!is_string($adresses)) {
return false;
}
// Si c'est un spammeur autant arreter tout de suite
if (preg_match(",[\n\r].*(MIME|multipart|Content-),i", $adresses)) {
spip_log("Tentative d'injection de mail : $adresses");
return false;
}
foreach (explode(',', $adresses) as $v) {
// nettoyer certains formats
// "Marie Toto <Marie@toto.com>"
$adresse = trim(preg_replace(",^[^<>\"]*<([^<>\"]+)>$,i", "\\1", $v));
// RFC 822
if (!preg_match('#^[^()<>@,;:\\"/[:space:]]+(@([-_0-9a-z]+\.)*[-_0-9a-z]+)$#i', $adresse)) {
return false;
}
}
return $adresse;
}
/**
* Permet d'afficher un symbole à côté des liens pointant vers les
* documents attachés d'un article (liens ayant `rel=enclosure`).
*
* @filtre
* @link http://www.spip.net/4134
*
* @param string $tags Texte
* @return string Texte
**/
function afficher_enclosures($tags) {
$s = array();
foreach (extraire_balises($tags, 'a') as $tag) {
if (extraire_attribut($tag, 'rel') == 'enclosure'
and $t = extraire_attribut($tag, 'href')
) {
$s[] = preg_replace(',>[^<]+</a>,S',
'>'
. http_img_pack('attachment-16.png', $t,
'title="' . attribut_html($t) . '"')
. '</a>', $tag);
}
}
return join('&nbsp;', $s);
}
/**
* Filtre des liens HTML `<a>` selon la valeur de leur attribut `rel`
* et ne retourne que ceux là.
*
* @filtre
* @link http://www.spip.net/4187
*
* @param string $tags Texte
* @param string $rels Attribut `rel` à capturer (ou plusieurs séparés par des virgules)
* @return string Liens trouvés
**/
function afficher_tags($tags, $rels = 'tag,directory') {
$s = array();
foreach (extraire_balises($tags, 'a') as $tag) {
$rel = extraire_attribut($tag, 'rel');
if (strstr(",$rels,", ",$rel,")) {
$s[] = $tag;
}
}
return join(', ', $s);
}
/**
* Convertir les médias fournis par un flux RSS (podcasts)
* en liens conformes aux microformats
*
* Passe un `<enclosure url="fichier" length="5588242" type="audio/mpeg"/>`
* au format microformat `<a rel="enclosure" href="fichier" ...>fichier</a>`.
*
* Peut recevoir un `<link` ou un `<media:content` parfois.
*
* Attention : `length="zz"` devient `title="zz"`, pour rester conforme.
*
* @filtre
* @see microformat2enclosure() Pour l'inverse
*
* @param string $e Tag RSS `<enclosure>`
* @return string Tag HTML `<a>` avec microformat.
**/
function enclosure2microformat($e) {
if (!$url = filtrer_entites(extraire_attribut($e, 'url'))) {
$url = filtrer_entites(extraire_attribut($e, 'href'));
}
$type = extraire_attribut($e, 'type');
if (!$length = extraire_attribut($e, 'length')) {
# <media:content : longeur dans fileSize. On tente.
$length = extraire_attribut($e, 'fileSize');
}
$fichier = basename($url);
return '<a rel="enclosure"'
. ($url ? ' href="' . spip_htmlspecialchars($url) . '"' : '')
. ($type ? ' type="' . spip_htmlspecialchars($type) . '"' : '')
. ($length ? ' title="' . spip_htmlspecialchars($length) . '"' : '')
. '>' . $fichier . '</a>';
}
/**
* Convertir les liens conformes aux microformats en médias pour flux RSS,
* par exemple pour les podcasts
*
* Passe un texte ayant des liens avec microformat
* `<a rel="enclosure" href="fichier" ...>fichier</a>`
* au format RSS `<enclosure url="fichier" ... />`.
*
* @filtre
* @see enclosure2microformat() Pour l'inverse
*
* @param string $tags Texte HTML ayant des tag `<a>` avec microformat
* @return string Tags RSS `<enclosure>`.
**/
function microformat2enclosure($tags) {
$enclosures = array();
foreach (extraire_balises($tags, 'a') as $e) {
if (extraire_attribut($e, 'rel') == 'enclosure') {
$url = filtrer_entites(extraire_attribut($e, 'href'));
$type = extraire_attribut($e, 'type');
if (!$length = intval(extraire_attribut($e, 'title'))) {
$length = intval(extraire_attribut($e, 'length'));
} # vieux data
$fichier = basename($url);
$enclosures[] = '<enclosure'
. ($url ? ' url="' . spip_htmlspecialchars($url) . '"' : '')
. ($type ? ' type="' . spip_htmlspecialchars($type) . '"' : '')
. ($length ? ' length="' . $length . '"' : '')
. ' />';
}
}
return join("\n", $enclosures);
}
/**
* Créer les éléments ATOM `<dc:subject>` à partir des tags
*
* Convertit les liens avec attribut `rel="tag"`
* en balise `<dc:subject></dc:subject>` pour les flux RSS au format Atom.
*
* @filtre
*
* @param string $tags Texte
* @return string Tags RSS Atom `<dc:subject>`.
**/
function tags2dcsubject($tags) {
$subjects = '';
foreach (extraire_balises($tags, 'a') as $e) {
if (extraire_attribut($e, rel) == 'tag') {
$subjects .= '<dc:subject>'
. texte_backend(textebrut($e))
. '</dc:subject>' . "\n";
}
}
return $subjects;
}
/**
* Retourne la premiere balise html du type demandé
*
* Retourne le contenu d'une balise jusqu'à la première fermeture rencontrée
* du même type.
* Si on a passe un tableau de textes, retourne un tableau de resultats.
*
* @example `[(#DESCRIPTIF|extraire_balise{img})]`
*
* @filtre
* @link http://www.spip.net/4289
* @see extraire_balises()
* @note
* Attention : les résultats peuvent être incohérents sur des balises imbricables,
* tel que demander à extraire `div` dans le texte `<div> un <div> mot </div> absent </div>`,
* ce qui retournerait `<div> un <div> mot </div>` donc.
*
* @param string|array $texte
* Texte(s) dont on souhaite extraire une balise html
* @param string $tag
* Nom de la balise html à extraire
* @return void|string|array
* - Code html de la balise, sinon rien
* - Tableau de résultats, si tableau en entrée.
**/
function extraire_balise($texte, $tag = 'a') {
if (is_array($texte)) {
array_walk(
$texte,
function(&$a, $key, $t){
$a = extraire_balise($a, $t);
},
$tag
);
return $texte;
}
if (preg_match(
",<$tag\b[^>]*(/>|>.*</$tag\b[^>]*>|>),UimsS",
$texte, $regs)) {
return $regs[0];
}
}
/**
* Extrait toutes les balises html du type demandé
*
* Retourne dans un tableau le contenu de chaque balise jusqu'à la première
* fermeture rencontrée du même type.
* Si on a passe un tableau de textes, retourne un tableau de resultats.
*
* @example `[(#TEXTE|extraire_balises{img}|implode{" - "})]`
*
* @filtre
* @link http://www.spip.net/5618
* @see extraire_balise()
* @note
* Attention : les résultats peuvent être incohérents sur des balises imbricables,
* tel que demander à extraire `div` dans un texte.
*
* @param string|array $texte
* Texte(s) dont on souhaite extraire une balise html
* @param string $tag
* Nom de la balise html à extraire
* @return array
* - Liste des codes html des occurrences de la balise, sinon tableau vide
* - Tableau de résultats, si tableau en entrée.
**/
function extraire_balises($texte, $tag = 'a') {
if (is_array($texte)) {
array_walk(
$texte,
function(&$a, $key, $t){
$a = extraire_balises($a, $t);
},
$tag
);
return $texte;
}
if (preg_match_all(
",<${tag}\b[^>]*(/>|>.*</${tag}\b[^>]*>|>),UimsS",
$texte, $regs, PREG_PATTERN_ORDER)) {
return $regs[0];
} else {
return array();
}
}
/**
* Indique si le premier argument est contenu dans le second
*
* Cette fonction est proche de `in_array()` en PHP avec comme principale
* différence qu'elle ne crée pas d'erreur si le second argument n'est pas
* un tableau (dans ce cas elle tentera de le désérialiser, et sinon retournera
* la valeur par défaut transmise).
*
* @example `[(#VAL{deux}|in_any{#LISTE{un,deux,trois}}|oui) ... ]`
*
* @filtre
* @see filtre_find() Assez proche, avec les arguments valeur et tableau inversés.
*
* @param string $val
* Valeur à chercher dans le tableau
* @param array|string $vals
* Tableau des valeurs. S'il ce n'est pas un tableau qui est transmis,
* la fonction tente de la désérialiser.
* @param string $def
* Valeur par défaut retournée si `$vals` n'est pas un tableau.
* @return string
* - ' ' si la valeur cherchée est dans le tableau
* - '' si la valeur n'est pas dans le tableau
* - `$def` si on n'a pas transmis de tableau
**/
function in_any($val, $vals, $def = '') {
if (!is_array($vals) and $v = unserialize($vals)) {
$vals = $v;
}
return (!is_array($vals) ? $def : (in_array($val, $vals) ? ' ' : ''));
}
/**
* Retourne le résultat d'une expression mathématique simple
*
* N'accepte que les *, + et - (à ameliorer si on l'utilise vraiment).
*
* @filtre
* @example
* ```
* valeur_numerique("3*2") retourne 6
* ```
*
* @param string $expr
* Expression mathématique `nombre operateur nombre` comme `3*2`
* @return int
* Résultat du calcul
**/
function valeur_numerique($expr) {
$a = 0;
if (preg_match(',^[0-9]+(\s*[+*-]\s*[0-9]+)*$,S', trim($expr))) {
eval("\$a = $expr;");
}
return intval($a);
}
/**
* Retourne un calcul de règle de trois
*
* @filtre
* @example
* ```
* [(#VAL{6}|regledetrois{4,3})] retourne 8
* ```
*
* @param int $a
* @param int $b
* @param int $c
* @return int
* Retourne `$a*$b/$c`
**/
function regledetrois($a, $b, $c) {
return round($a * $b / $c);
}
/**
* Crée des tags HTML input hidden pour chaque paramètre et valeur d'une URL
*
* Fournit la suite de Input-Hidden correspondant aux paramètres de
* l'URL donnée en argument, compatible avec les types_urls
*
* @filtre
* @link http://www.spip.net/4286
* @see balise_ACTION_FORMULAIRE()
* Également pour transmettre les actions à un formulaire
* @example
* ```
* [(#ENV{action}|form_hidden)] dans un formulaire
* ```
*
* @param string $action URL
* @return string Suite de champs input hidden
**/
function form_hidden($action) {
$contexte = array();
include_spip('inc/urls');
if ($p = urls_decoder_url($action, '')
and reset($p)
) {
$fond = array_shift($p);
if ($fond != '404') {
$contexte = array_shift($p);
$contexte['page'] = $fond;
$action = preg_replace('/([?]' . preg_quote($fond) . '[^&=]*[0-9]+)(&|$)/', '?&', $action);
}
}
// defaire ce qu'a injecte urls_decoder_url : a revoir en modifiant la signature de urls_decoder_url
if (defined('_DEFINIR_CONTEXTE_TYPE') and _DEFINIR_CONTEXTE_TYPE) {
unset($contexte['type']);
}
if (defined('_DEFINIR_CONTEXTE_TYPE_PAGE') and _DEFINIR_CONTEXTE_TYPE_PAGE) {
unset($contexte['type-page']);
}
// on va remplir un tableau de valeurs en prenant bien soin de ne pas
// ecraser les elements de la forme mots[]=1&mots[]=2
$values = array();
// d'abord avec celles de l'url
if (false !== ($p = strpos($action, '?'))) {
foreach (preg_split('/&(amp;)?/S', substr($action, $p + 1)) as $c) {
$c = explode('=', $c, 2);
$var = array_shift($c);
$val = array_shift($c);
if ($var) {
$val = rawurldecode($val);
$var = rawurldecode($var); // decoder les [] eventuels
if (preg_match(',\[\]$,S', $var)) {
$values[] = array($var, $val);
} else {
if (!isset($values[$var])) {
$values[$var] = array($var, $val);
}
}
}
}
}
// ensuite avec celles du contexte, sans doublonner !
foreach ($contexte as $var => $val) {
if (preg_match(',\[\]$,S', $var)) {
$values[] = array($var, $val);
} else {
if (!isset($values[$var])) {
$values[$var] = array($var, $val);
}
}
}
// puis on rassemble le tout
$hidden = array();
foreach ($values as $value) {
list($var, $val) = $value;
$hidden[] = '<input name="'
. entites_html($var)
. '"'
. (is_null($val)
? ''
: ' value="' . entites_html($val) . '"'
)
. ' type="hidden"' . "\n/>";
}
return join("", $hidden);
}
/**
* Calcule les bornes d'une pagination
*
* @filtre
*
* @param int $courante
* Page courante
* @param int $nombre
* Nombre de pages
* @param int $max
* Nombre d'éléments par page
* @return int[]
* Liste (première page, dernière page).
**/
function filtre_bornes_pagination_dist($courante, $nombre, $max = 10) {
if ($max <= 0 or $max >= $nombre) {
return array(1, $nombre);
}
$premiere = max(1, $courante - floor(($max - 1) / 2));
$derniere = min($nombre, $premiere + $max - 2);
$premiere = $derniere == $nombre ? $derniere - $max + 1 : $premiere;
return array($premiere, $derniere);
}
/**
* Retourne la première valeur d'un tableau
*
* Plus précisément déplace le pointeur du tableau sur la première valeur et la retourne.
*
* @example `[(#LISTE{un,deux,trois}|reset)]` retourne 'un'
*
* @filtre
* @link http://php.net/manual/fr/function.reset.php
* @see filtre_end()
*
* @param array $array
* @return mixed|null|false
* - null si $array n'est pas un tableau,
* - false si le tableau est vide
* - la première valeur du tableau sinon.
**/
function filtre_reset($array) {
return !is_array($array) ? null : reset($array);
}
/**
* Retourne la dernière valeur d'un tableau
*
* Plus précisément déplace le pointeur du tableau sur la dernière valeur et la retourne.
*
* @example `[(#LISTE{un,deux,trois}|end)]` retourne 'trois'
*
* @filtre
* @link http://php.net/manual/fr/function.end.php
* @see filtre_reset()
*
* @param array $array
* @return mixed|null|false
* - null si $array n'est pas un tableau,
* - false si le tableau est vide
* - la dernière valeur du tableau sinon.
**/
function filtre_end($array) {
return !is_array($array) ? null : end($array);
}
/**
* Empile une valeur à la fin d'un tableau
*
* @example `[(#LISTE{un,deux,trois}|push{quatre}|print)]`
*
* @filtre
* @link http://www.spip.net/4571
* @link http://php.net/manual/fr/function.array-push.php
*
* @param array $array
* @param mixed $val
* @return array|string
* - '' si $array n'est pas un tableau ou si echec.
* - le tableau complété de la valeur sinon.
*
**/
function filtre_push($array, $val) {
if (!is_array($array) or !array_push($array, $val)) {
return '';
}
return $array;
}
/**
* Indique si une valeur est contenue dans un tableau
*
* @example `[(#LISTE{un,deux,trois}|find{quatre}|oui) ... ]`
*
* @filtre
* @link http://www.spip.net/4575
* @see in_any() Assez proche, avec les paramètres tableau et valeur inversés.
*
* @param array $array
* @param mixed $val
* @return bool
* - `false` si `$array` n'est pas un tableau
* - `true` si la valeur existe dans le tableau, `false` sinon.
**/
function filtre_find($array, $val) {
return (is_array($array) and in_array($val, $array));
}
/**
* Filtre calculant une pagination, utilisé par la balise `#PAGINATION`
*
* Le filtre cherche le modèle `pagination.html` par défaut, mais peut
* chercher un modèle de pagination particulier avec l'argument `$modele`.
* S'il `$modele='prive'`, le filtre cherchera le modèle `pagination_prive.html`.
*
* @filtre
* @see balise_PAGINATION_dist()
*
* @param int $total
* Nombre total d'éléments
* @param string $nom
* Nom identifiant la pagination
* @param int $position
* Page à afficher (tel que la 3è page)
* @param int $pas
* Nombre d'éléments par page
* @param bool $liste
* - True pour afficher toute la liste des éléments,
* - False pour n'afficher que l'ancre
* @param string $modele
* Nom spécifique du modèle de pagination
* @param string $connect
* Nom du connecteur à la base de données
* @param array $env
* Environnement à transmettre au modèle
* @return string
* Code HTML de la pagination
**/
function filtre_pagination_dist(
$total,
$nom,
$position,
$pas,
$liste = true,
$modele = '',
$connect = '',
$env = array()
) {
static $ancres = array();
if ($pas < 1) {
return '';
}
$ancre = 'pagination' . $nom; // #pagination_articles
$debut = 'debut' . $nom; // 'debut_articles'
// n'afficher l'ancre qu'une fois
if (!isset($ancres[$ancre])) {
$bloc_ancre = $ancres[$ancre] = "<a name='" . $ancre . "' id='" . $ancre . "'></a>";
} else {
$bloc_ancre = '';
}
// liste = false : on ne veut que l'ancre
if (!$liste) {
return $ancres[$ancre];
}
$pagination = array(
'debut' => $debut,
'url' => parametre_url(self(), 'fragment', ''), // nettoyer l'id ahah eventuel
'total' => $total,
'position' => intval($position),
'pas' => $pas,
'nombre_pages' => floor(($total - 1) / $pas) + 1,
'page_courante' => floor(intval($position) / $pas) + 1,
'ancre' => $ancre,
'bloc_ancre' => $bloc_ancre
);
if (is_array($env)) {
$pagination = array_merge($env, $pagination);
}
// Pas de pagination
if ($pagination['nombre_pages'] <= 1) {
return '';
}
if ($modele) {
$modele = '_' . $modele;
}
return recuperer_fond("modeles/pagination$modele", $pagination, array('trim' => true), $connect);
}
/**
* Passer les url relatives à la css d'origine en url absolues
*
* @uses suivre_lien()
*
* @param string $contenu
* Contenu du fichier CSS
* @param string $source
* Chemin du fichier CSS
* @return string
* Contenu avec urls en absolus
**/
function urls_absolues_css($contenu, $source) {
$path = suivre_lien(url_absolue($source), './');
return preg_replace_callback(
",url\s*\(\s*['\"]?([^'\"/#\s][^:]*)['\"]?\s*\),Uims",
function($x) use ($path) {
return "url('" . suivre_lien($path, $x[1]) . "')";
},
$contenu
);
}
/**
* Inverse le code CSS (left <--> right) d'une feuille de style CSS
*
* Récupère le chemin d'une CSS existante et :
*
* 1. regarde si une CSS inversée droite-gauche existe dans le meme répertoire
* 2. sinon la crée (ou la recrée) dans `_DIR_VAR/cache_css/`
*
* Si on lui donne à manger une feuille nommée `*_rtl.css` il va faire l'inverse.
*
* @filtre
* @example
* ```
* [<link rel="stylesheet" href="(#CHEMIN{css/perso.css}|direction_css)" type="text/css" />]
* ```
* @param string $css
* Chemin vers le fichier CSS
* @param string $voulue
* Permet de forcer le sens voulu (en indiquant `ltr`, `rtl` ou un
* code de langue). En absence, prend le sens de la langue en cours.
*
* @return string
* Chemin du fichier CSS inversé
**/
function direction_css($css, $voulue = '') {
if (!preg_match(',(_rtl)?\.css$,i', $css, $r)) {
return $css;
}
// si on a precise le sens voulu en argument, le prendre en compte
if ($voulue = strtolower($voulue)) {
if ($voulue != 'rtl' and $voulue != 'ltr') {
$voulue = lang_dir($voulue);
}
} else {
$voulue = lang_dir();
}
$r = count($r) > 1;
$right = $r ? 'left' : 'right'; // 'right' de la css lue en entree
$dir = $r ? 'rtl' : 'ltr';
$ndir = $r ? 'ltr' : 'rtl';
if ($voulue == $dir) {
return $css;
}
if (
// url absolue
preg_match(",^https?:,i", $css)
// ou qui contient un ?
or (($p = strpos($css, '?')) !== false)
) {
$distant = true;
$cssf = parse_url($css);
$cssf = $cssf['path'] . ($cssf['query'] ? "?" . $cssf['query'] : "");
$cssf = preg_replace(',[?:&=],', "_", $cssf);
} else {
$distant = false;
$cssf = $css;
// 1. regarder d'abord si un fichier avec la bonne direction n'est pas aussi
//propose (rien a faire dans ce cas)
$f = preg_replace(',(_rtl)?\.css$,i', '_' . $ndir . '.css', $css);
if (@file_exists($f)) {
return $f;
}
}
// 2.
$dir_var = sous_repertoire(_DIR_VAR, 'cache-css');
$f = $dir_var
. preg_replace(',.*/(.*?)(_rtl)?\.css,', '\1', $cssf)
. '.' . substr(md5($cssf), 0, 4) . '_' . $ndir . '.css';
// la css peut etre distante (url absolue !)
if ($distant) {
include_spip('inc/distant');
$res = recuperer_url($css);
if (!$res or !$contenu = $res['page']) {
return $css;
}
} else {
if ((@filemtime($f) > @filemtime($css))
and (_VAR_MODE != 'recalcul')
) {
return $f;
}
if (!lire_fichier($css, $contenu)) {
return $css;
}
}
// Inverser la direction gauche-droite en utilisant CSSTidy qui gere aussi les shorthands
include_spip("lib/csstidy/class.csstidy");
$parser = new csstidy();
$parser->set_cfg('optimise_shorthands', 0);
$parser->set_cfg('reverse_left_and_right', true);
</