Changeset 41208 in spip-zone


Ignore:
Timestamp:
Sep 25, 2010, 11:36:33 PM (11 years ago)
Author:
fil@…
Message:

plein de simplifications du code (on supprime les timers et les debug) ; report de http://core.spip.org/trac/spip/changeset/16329 (bug fix de la langue typo dans l'espace prive) ; integration propre avec memoization

Location:
_plugins_/textwheel
Files:
1 added
7 edited
2 moved

Legend:

Unmodified
Added
Removed
  • _plugins_/textwheel/engine/textwheelruleset.php

    r41198 r41208  
    6767                if (!function_exists('yaml_decode')) {
    6868                        if (function_exists('include_spip'))
    69                                 include_spip('inc/yaml');
     69                                include_spip('inc/yaml-mini');
    7070                        else
    7171                                require_once dirname(__FILE__).'/../inc/yaml.php';
  • _plugins_/textwheel/inc/lien.php

    r41198 r41208  
    1313if (!defined("_ECRIRE_INC_VERSION")) return;
    1414
    15 # Tests TW
    16 require_once _DIR_RESTREINT.'inc/lien.php';
    17 
    1815include_spip('base/abstract_sql');
    1916
     
    2421//
    2522
    26 function inc_lien($lien, $texte='', $class='', $title='', $hlang='', $rel='', $connect=''){
    27         # Tests TW
    28         if (!$GLOBALS['tw']) {
    29                 return inc_lien_dist($lien, $texte, $class, $title, $hlang, $rel, $connect);
    30         }
    31 
     23function inc_lien($lien, $texte='', $class='', $title='', $hlang='', $rel='', $connect='') {
    3224        static $u=null;
    3325        if (!$u) $u=url_de_base();
     
    10092// mais refuser plus d'imbrications ou de mauvaises imbrications
    10193// sinon les crochets ne peuvent plus servir qu'a ce type de raccourci
    102 
    103 define('_RACCOURCI_LIEN_TW', "/\[([^][]*?([[]\w*[]][^][]*)*)->(>?)([^]]*)\]/msS");
     94define('_RACCOURCI_LIEN', "/\[([^][]*?([[]\w*[]][^][]*)*)->(>?)([^]]*)\]/msS");
    10495
    10596// http://doc.spip.org/@expanser_liens
    106 function expanser_liens_tw($texte, $connect='')
    107 {
    108         $debug = _request('var_debug_wheel');
    109 
    110         $texte = pipeline('pre_liens', $texte);
    111 
    112 
    113         if($debug) spip_timer('liensmatch');
    114         tw_expanser_un_lien($connect,'init');
    115 
    116         if (strpos($texte, '->') !== false)
    117                 $texte = preg_replace_callback (_RACCOURCI_LIEN_TW, 'tw_expanser_un_lien',$texte);
    118 
    119         if($debug) $GLOBALS['totaux']['expanser_liens:']['liensmatch'] += spip_timer('liensmatch', true);
     97function expanser_liens($t, $connect='')
     98{
     99
     100        $t = pipeline('pre_liens', $t);
     101
     102        expanser_un_lien($connect,'init');
     103
     104        if (strpos($t, '->') !== false)
     105                $t = preg_replace_callback (_RACCOURCI_LIEN, 'expanser_un_lien',$t);
    120106
    121107        // on passe a traiter_modeles la liste des liens reperes pour lui permettre
    122108        // de remettre le texte d'origine dans les parametres du modele
    123         if($debug) spip_timer('traiter_modeles');
    124         $texte = traiter_modeles($texte, false, false, $connect, tw_expanser_un_lien('','sources'));
    125         if($debug) $GLOBALS['totaux']['expanser_liens:']['traiter_modeles'] += spip_timer('traiter_modeles', true);
    126 
    127         if($debug) spip_timer('corriger_typo');
    128         $texte = corriger_typo($texte);
    129         if($debug) $GLOBALS['totaux']['expanser_liens:']['corriger_typo'] += spip_timer('corriger_typo', true);
    130 
    131         if($debug) spip_timer('reinserts');
    132         $texte = tw_expanser_un_lien($texte,'reinsert');
    133         if($debug) $GLOBALS['totaux']['expanser_liens:']['reinserts'] += spip_timer('reinserts', true);
    134 
    135         return $texte;
    136 }
    137 
    138 
    139 function tw_expanser_un_lien($reg, $quoi='echappe'){
     109        $t = traiter_modeles($t, false, false, $connect, expanser_un_lien('','sources'));
     110
     111        $t = corriger_typo($t);
     112
     113        $t = expanser_un_lien($t,'reinsert');
     114
     115        return $t;
     116}
     117
     118
     119function expanser_un_lien($reg, $quoi='echappe'){
    140120        static $pile = array();
    141121        static $inserts;
     
    160140
    161141                        #$titre=$reg[1];
    162                         list($titre, $bulle, $hlang) = tw_traiter_raccourci_lien_atts($reg[1]);
     142                        list($titre, $bulle, $hlang) = traiter_raccourci_lien_atts($reg[1]);
    163143                        $r = end($reg);
    164144                        // la mise en lien automatique est passee par la a tort !
     
    187167}
    188168
     169// Meme analyse mais pour eliminer les liens
     170// et ne laisser que leur titre, a expliciter si ce n'est fait
     171// http://doc.spip.org/@nettoyer_raccourcis_typo
     172function nettoyer_raccourcis_typo($texte, $connect='')
     173{
     174        $texte = pipeline('nettoyer_raccourcis_typo',$texte);
     175
     176        if (preg_match_all(_RACCOURCI_LIEN, $texte, $regs, PREG_SET_ORDER))
     177                foreach ($regs as $reg) {
     178                        list ($titre,,)= traiter_raccourci_lien_atts($reg[1]);
     179                        if (!$titre) {
     180                                $match = typer_raccourci($reg[count($reg)-1]);
     181                                @list($type,,$id,,,,) = $match;
     182                                if ($type) {
     183                                        $url = generer_url_entite($id,$type,'','',true);
     184                                        if (is_array($url)) list($type, $id) = $url;
     185                                        $titre = traiter_raccourci_titre($id, $type, $connect);
     186                                }
     187                                $titre = $titre ? $titre['titre'] : $match[0];
     188                        }
     189                        $titre = corriger_typo(supprimer_tags($titre));
     190                        $texte = str_replace($reg[0], $titre, $texte);
     191                }
     192
     193        // supprimer les notes
     194        $texte = preg_replace(",[[][[]([^]]|[]][^]])*[]][]],UimsS","",$texte);
     195
     196        // supprimer les codes typos
     197        $texte = str_replace(array('}','{'), '', $texte);
     198
     199        // supprimer les tableaux
     200        $texte = preg_replace(",(^|\r)\|.*\|\r,s", "\r", $texte);
     201
     202        return $texte;
     203}
     204
     205
     206
     207// Repere dans la partie texte d'un raccourci [texte->...]
     208// la langue et la bulle eventuelles
     209
     210define('_RACCOURCI_ATTRIBUTS', '/^(.*?)([|]([^<>]*?))?([{]([a-z_]*)[}])?$/');
    189211
    190212// http://doc.spip.org/@traiter_raccourci_lien_atts
    191 function tw_traiter_raccourci_lien_atts($texte) {
     213function traiter_raccourci_lien_atts($texte) {
    192214
    193215        $bulle = $hlang = '';
     
    229251}
    230252
     253define('_EXTRAIRE_DOMAINE', '/^(?:[^\W_]((?:[^\W_]|-){0,61}[^\W_,])?\.)+[a-z]{2,6}\b/Si');
     254
     255// callback pour la fonction traiter_raccourci_liens()
     256// http://doc.spip.org/@autoliens_callback
     257function traiter_autoliens($r) {
     258        if (count($r)<2) return reset($r);
     259        list($tout, $l) = $r;
     260        if (!$l) return $tout;
     261        // reperer le protocole
     262        if (preg_match(',^(https?):/*,S', $l, $m)) {
     263                $l = substr($l, strlen($m[0]));
     264                $protocol = $m[1];
     265        } else  $protocol = 'http';
     266        // valider le nom de domaine
     267        if (!preg_match(_EXTRAIRE_DOMAINE, $l)) return $tout;
     268        // supprimer les ponctuations a la fin d'une URL
     269        preg_match('/^(.*?)([,.;?]?)$/', $l, $k);
     270        $url = $protocol.'://'.$k[1];
     271        $lien = charger_fonction('lien', 'inc');
     272        $r = $lien($url,'','','','','nofollow') . $k[2];
     273        // si l'original ne contenait pas le 'http:' on le supprime du clic
     274        return $m ? $r : str_replace('>http://', '>', $r);
     275}
     276
     277define('_EXTRAIRE_LIENS', ',' . '\[[^\[\]]*(?:<-|->).*?\]' . '|<a\b.*?</a\b' . '|<\w.*?>' . '|((?:https?:/|www\.)[^"\'\s\[\]\}\)<>]*)' .',imsS');
     278
     279// Les URLs brutes sont converties en <a href='url'>url</a>
     280// http://doc.spip.org/@traiter_raccourci_liens
     281function traiter_raccourci_liens($t) {
     282        return preg_replace_callback(_EXTRAIRE_LIENS, 'traiter_autoliens', $t);
     283}
     284
     285// Fonction pour les champs chapo commencant par =,  redirection qui peut etre:
     286// 1. un raccourci Spip habituel (premier If) [texte->TYPEnnn]
     287// 2. un ultra raccourci TYPEnnn voire nnn (article) (deuxieme If)
     288// 3. une URL std
     289// renvoie une tableau structure comme ci-dessus mais sans calcul d'URL
     290// (cf fusion de sauvegardes)
     291
     292define('_RACCOURCI_CHAPO', '/^(\W*)(\W*)(\w*\d+([?#].*)?)$/');
     293
     294// http://doc.spip.org/@chapo_redirige
     295function chapo_redirige($chapo, $url=false)
     296{
     297        if (!preg_match(_RACCOURCI_LIEN, $chapo, $m))
     298                if (!preg_match(_RACCOURCI_CHAPO, $chapo, $m))
     299                        return $chapo;
     300
     301        return !$url ? $m[3] : traiter_lien_implicite($m[3]);
     302}
     303
     304// Ne pas afficher le chapo si article virtuel
     305// http://doc.spip.org/@nettoyer_chapo
     306function nettoyer_chapo($chapo){
     307        return (substr($chapo,0,1) == "=") ? '' : $chapo;
     308}
     309
     310// http://doc.spip.org/@chapo_redirigetil
     311function chapo_redirigetil($chapo) { return $chapo && $chapo[0] == '=';}
     312
     313// Cherche un lien du type [->raccourci 123]
     314// associe a une fonction generer_url_raccourci() definie explicitement
     315// ou implicitement par le jeu de type_urls courant.
     316//
     317// Valeur retournee selon le parametre $pour:
     318// 'tout' : tableau d'index url,class,titre,lang (vise <a href="U" class='C' hreflang='L'>T</a>)
     319// 'titre': seulement T ci-dessus (i.e. le TITRE ci-dessus ou dans table SQL)
     320// 'url':   seulement U  (i.e. generer_url_RACCOURCI)
     321
     322// http://doc.spip.org/@calculer_url
     323function calculer_url ($ref, $texte='', $pour='url', $connect='') {
     324        $r = traiter_lien_implicite($ref, $texte, $pour, $connect);
     325        return $r ? $r : traiter_lien_explicite($ref, $texte, $pour, $connect);
     326}
     327
     328define('_EXTRAIRE_LIEN', ",^\s*(http:?/?/?|mailto:?)\s*$,iS");
     329
     330// http://doc.spip.org/@traiter_lien_explicite
     331function traiter_lien_explicite ($ref, $texte='', $pour='url', $connect='')
     332{
     333        if (preg_match(_EXTRAIRE_LIEN, $ref))
     334                return ($pour != 'tout') ? '' : array('','','','');
     335
     336        $lien = entites_html(trim($ref));
     337
     338        // Liens explicites
     339        if (!$texte) {
     340                $texte = str_replace('"', '', $lien);
     341                // evite l'affichage de trops longues urls.
     342                // personnalisation possible dans mes_options
     343                $long_url = defined('_MAX_LONG_URL') ? _MAX_LONG_URL : 40;
     344                $coupe_url = defined('_MAX_COUPE_URL') ? _MAX_COUPE_URL : 35;
     345                if (strlen($texte)>$long_url) {
     346                        $texte = substr($texte,0,$coupe_url).'...';
     347                }
     348                $texte = "<html>".quote_amp($texte)."</html>";
     349        }
     350
     351        // petites corrections d'URL
     352        if (preg_match('/^www\.[^@]+$/S',$lien))
     353                $lien = "http://".$lien;
     354        else if (strpos($lien, "@") && email_valide($lien)) {
     355                if (!$texte) $texte = $lien;
     356                $lien = "mailto:".$lien;
     357        }
     358       
     359        if ($pour == 'url') return $lien;
     360
     361        if ($pour == 'titre') return $texte;
     362
     363        return array('url' => $lien, 'titre' => $texte);
     364}
     365
     366// http://doc.spip.org/@traiter_lien_implicite
     367function traiter_lien_implicite ($ref, $texte='', $pour='url', $connect='')
     368{
     369        if (!($match = typer_raccourci($ref))) return false;
     370        @list($type,,$id,,$args,,$ancre) = $match;
     371# attention dans le cas des sites le lien doit pointer non pas sur
     372# la page locale du site, mais directement sur le site lui-meme
     373        if ($type == 'site')
     374                $url = sql_getfetsel('url_site', 'spip_syndic', "id_syndic=$id",'','','','',$connect);
     375        elseif ($type == 'glose') {
     376                if (function_exists($f = 'glossaire_' . $ancre))
     377                  $url = $f($texte, $id);
     378                else $url = glossaire_std($texte);
     379        } else $url = generer_url_entite($id,$type,$args,$ancre,$connect ? $connect : NULL);
     380        if (!$url) return false;
     381        if (is_array($url)) {
     382                @list($type,$id) = $url;
     383                $url = generer_url_entite($id,$type,$args,$ancre,$connect ? $connect : NULL);
     384        }
     385        if ($pour === 'url') return $url;
     386        $r = traiter_raccourci_titre($id, $type, $connect);
     387        if ($r) $r['class'] =  ($type == 'site')?'spip_out':'spip_in';
     388        if ($texte = trim($texte)) $r['titre'] = $texte;
     389        if (!@$r['titre']) $r['titre'] =  _T($type) . " $id";
     390        if ($pour=='titre') return $r['titre'];
     391        $r['url'] = $url;
     392
     393        // dans le cas d'un lien vers un doc, ajouter le type='mime/type'
     394        if ($type == 'document'
     395        AND $mime = sql_getfetsel('mime_type', 'spip_types_documents',
     396                        "extension IN (SELECT extension FROM spip_documents where id_document =".sql_quote($id).")",
     397                        '','','','',$connect)
     398        )
     399                $r['mime'] = $mime;
     400
     401        return $r;
     402}
     403
     404// analyse des raccourcis issus de [TITRE->RACCOURCInnn] et connexes
     405
     406define('_RACCOURCI_URL', '/^\s*(\w*?)\s*(\d+)(\?(.*?))?(#([^\s]*))?\s*$/S');
     407
     408// http://doc.spip.org/@typer_raccourci
     409function typer_raccourci ($lien) {
     410        if (!preg_match(_RACCOURCI_URL, $lien, $match)) return array();
     411        $f = $match[1];
     412        // valeur par defaut et alias historiques
     413        if (!$f) $f = 'article';
     414        else if ($f == 'art') $f = 'article';
     415        else if ($f == 'br') $f = 'breve';
     416        else if ($f == 'rub') $f = 'rubrique';
     417        else if ($f == 'aut') $f = 'auteur';
     418        else if ($f == 'doc' OR $f == 'im' OR $f == 'img' OR $f == 'image' OR $f == 'emb')
     419                $f = 'document';
     420        else if (preg_match('/^br..?ve$/S', $f)) $f = 'breve'; # accents :(
     421        $match[0] = $f;
     422        return $match;
     423}
     424
     425// Retourne le champ textuel associe a une cle primaire, et sa langue
     426function traiter_raccourci_titre($id, $type, $connect=NULL)
     427{
     428        $trouver_table = charger_fonction('trouver_table', 'base');
     429        $desc = $trouver_table(table_objet($type));
     430        if (!($desc AND $s = $desc['titre'])) return array();
     431        $_id = $desc['key']['PRIMARY KEY'];
     432        $r = sql_fetsel($s, $desc['table'], "$_id=$id", '','','','',$connect);
     433        if (!$r) return array();
     434        $r['titre'] = supprimer_numero($r['titre']);
     435        if (!$r['titre']) $r['titre'] = $r['surnom'];
     436        if (!isset($r['lang'])) $r['lang'] = '';
     437        return $r;
     438}
     439
     440// traite les modeles (dans la fonction typo), en remplacant
     441// le raccourci <modeleN|parametres> par la page calculee a
     442// partir du squelette modeles/modele.html
     443// Le nom du modele doit faire au moins trois caracteres (evite <h2>)
     444// Si $doublons==true, on repere les documents sans calculer les modeles
     445// mais on renvoie les params (pour l'indexation par le moteur de recherche)
     446// http://doc.spip.org/@traiter_modeles
     447
     448define('_RACCOURCI_MODELE',
     449         '(<([a-z_-]{3,})' # <modele
     450        .'\s*([0-9]*)\s*' # id
     451        .'([|](?:<[^<>]*>|[^>])*?)?' # |arguments (y compris des tags <...>)
     452        .'\s*/?'.'>)' # fin du modele >
     453        .'\s*(<\/a>)?' # eventuel </a>
     454       );
     455
     456define('_RACCOURCI_MODELE_DEBUT', '@^' . _RACCOURCI_MODELE .'@isS');
     457
     458// http://doc.spip.org/@traiter_modeles
     459function traiter_modeles($texte, $doublons=false, $echap='', $connect='', $liens = null) {
     460        // preserver la compatibilite : true = recherche des documents
     461        if ($doublons===true)
     462                $doublons = array('documents'=>array('doc','emb','img'));
     463        // detecter les modeles (rapide)
     464        if (strpos($texte,"<")!==false AND
     465          preg_match_all('/<[a-z_-]{3,}\s*[0-9|]+/iS', $texte, $matches, PREG_SET_ORDER)) {
     466                include_spip('public/assembler');
     467                foreach ($matches as $match) {
     468                        // Recuperer l'appel complet (y compris un eventuel lien)
     469
     470                        $a = strpos($texte,$match[0]);
     471                        preg_match(_RACCOURCI_MODELE_DEBUT,
     472                        substr($texte, $a), $regs);
     473                        $regs[]=""; // s'assurer qu'il y a toujours un 5e arg, eventuellement vide
     474                        list(,$mod, $type, $id, $params, $fin) = $regs;
     475                        if ($fin AND
     476                        preg_match('/<a\s[^<>]*>\s*$/i',
     477                                        substr($texte, 0, $a), $r)) {
     478                                $lien = array(
     479                                        'href' => extraire_attribut($r[0],'href'),
     480                                        'class' => extraire_attribut($r[0],'class'),
     481                                        'mime' => extraire_attribut($r[0],'type')
     482                                );
     483                                $n = strlen($r[0]);
     484                                $a -= $n;
     485                                $cherche = $n + strlen($regs[0]);
     486                        } else {
     487                                $lien = false;
     488                                $cherche = strlen($mod);
     489                        }
     490
     491                        // calculer le modele
     492                        # hack articles_edit, breves_edit, indexation
     493                        if ($doublons)
     494                                $texte .= preg_replace(',[|][^|=]*,s',' ',$params);
     495                        # version normale
     496                        else {
     497                                // si un tableau de liens a ete passe, reinjecter le contenu d'origine
     498                                // dans les parametres, plutot que les liens echappes
     499                                if (!is_null($liens))
     500                                        $params = str_replace($liens[0], $liens[1], $params);
     501                          $modele = inclure_modele($type, $id, $params, $lien, $connect);
     502                                // en cas d'echec,
     503                                // si l'objet demande a une url,
     504                                // creer un petit encadre vers elle
     505                                if ($modele === false) {
     506                                        if (!$lien)
     507                                                $lien = traiter_lien_implicite("$type$id", '', 'tout', $connect);
     508                                        if ($lien)
     509                                                $modele = '<a href="'
     510                                                  .$lien['url']
     511                                                  .'" class="spip_modele'
     512                                                  . '">'
     513                                                  .sinon($lien['titre'], _T('ecrire:info_sans_titre'))
     514                                                  ."</a>";
     515                                        else {
     516                                                $modele = "";
     517                                                if (test_espace_prive()) {
     518                                                        $modele = entites_html(substr($texte,$a,$cherche));
     519                                                        if (!is_null($liens))
     520                                                                $modele = "<pre>".str_replace($liens[0], $liens[1], $modele)."</pre>";
     521                                                }
     522                                        }
     523                                }
     524                                // le remplacer dans le texte
     525                                if ($modele !== false) {
     526                                        $modele = protege_js_modeles($modele);
     527                                        $rempl = code_echappement($modele, $echap);
     528                                        $texte = substr($texte, 0, $a)
     529                                                . $rempl
     530                                                . substr($texte, $a+$cherche);
     531                                }
     532                        }
     533
     534                        // hack pour tout l'espace prive
     535                        if (((!_DIR_RESTREINT) OR ($doublons)) AND ($id)){
     536                                foreach($doublons?$doublons:array('documents'=>array('doc','emb','img')) as $quoi=>$modeles)
     537                                        if (in_array($type,$modeles))
     538                                                $GLOBALS["doublons_{$quoi}_inclus"][] = $id;
     539                        }
     540                }
     541        }
     542
     543        return $texte;
     544}
     545
     546//
     547// Raccourcis ancre [#ancre<-]
     548//
     549
     550define('_RACCOURCI_ANCRE', "/\[#?([^][]*)<-\]/S");
     551
     552// http://doc.spip.org/@traiter_raccourci_ancre
     553function traiter_raccourci_ancre($letexte)
     554{
     555        if (preg_match_all(_RACCOURCI_ANCRE, $letexte, $m, PREG_SET_ORDER))
     556        foreach ($m as $regs)
     557                $letexte = str_replace($regs[0],
     558                '<a name="'.entites_html($regs[1]).'"></a>', $letexte);
     559        return $letexte;
     560}
     561
     562//
     563// Raccourcis automatiques [?SPIP] vers un glossaire
     564// Wikipedia par defaut, avec ses contraintes techniques
     565// cf. http://fr.wikipedia.org/wiki/Wikip%C3%A9dia:Conventions_sur_les_titres
     566
     567define('_RACCOURCI_GLOSSAIRE', "/\[\?+\s*([^][<>]+)\]/S");
     568define('_RACCOURCI_GLOSES', '/^([^|#{]*\w[^|#{]*)([^#]*)(#([^|{}]*))?(.*)$/S');
     569
     570// http://doc.spip.org/@traiter_raccourci_glossaire
     571function traiter_raccourci_glossaire($texte)
     572{
     573        if (!preg_match_all(_RACCOURCI_GLOSSAIRE,
     574        $texte, $matches, PREG_SET_ORDER))
     575                return $texte;
     576
     577        include_spip('inc/charsets');
     578        $lien = charger_fonction('lien', 'inc');
     579
     580        foreach ($matches as $regs) {
     581        // Eviter les cas particulier genre "[?!?]"
     582        // et isoler le lexeme a gloser de ses accessoires
     583        // (#:url du glossaire, | bulle d'aide, {} hreflang)
     584        // Transformation en pseudo-raccourci pour passer dans inc_lien
     585                if (preg_match(_RACCOURCI_GLOSES, $regs[1], $r)) {
     586                        preg_match('/^(.*?)(\d*)$/', $r[4], $m);
     587                        $_n = intval($m[2]);
     588                        $gloss = $m[1] ? ('#' . $m[1]) : '';
     589                        $t = $r[1] . $r[2] . $r[5];
     590                        list($t, $bulle, $hlang) = traiter_raccourci_lien_atts($t);
     591                        $t = unicode2charset(charset2unicode($t), 'utf-8');
     592                        $ref = $lien("glose$_n$gloss", $t, 'spip_glossaire', $bulle, $hlang);
     593                        $texte = str_replace($regs[0], $ref, $texte);
     594                }
     595        }
     596        return $texte;
     597}
     598
     599// http://doc.spip.org/@glossaire_std
     600function glossaire_std($terme)
     601{
     602        global $url_glossaire_externe;
     603        static $pcre = NULL;
     604
     605        if ($pcre === NULL) {
     606                $pcre = isset($GLOBALS['meta']['pcre_u'])
     607                ? $GLOBALS['meta']['pcre_u']
     608                  : '';
     609                if (strpos($url_glossaire_externe, "%s") === false)
     610                        $url_glossaire_externe .= '%s';
     611        }
     612
     613        $glosateur = str_replace("@lang@",
     614                                $GLOBALS['spip_lang'],
     615                                $GLOBALS['url_glossaire_externe']);
     616
     617        $terme = rawurlencode(preg_replace(',\s+,'.$pcre, '_', $terme));
     618       
     619        return  str_replace("%s", $terme, $glosateur);
     620}
    231621
    232622?>
  • _plugins_/textwheel/inc/texte.php

    r41198 r41208  
    1313if (!defined("_ECRIRE_INC_VERSION")) return;
    1414
    15 # Tests TW : par defaut TW est actif
    16 # passer a false pour basculer sur la version core
    17 $GLOBALS['tw'] = true;
    18 
    1915include_spip('inc/filtres');
    2016include_spip('inc/lang');
    2117include_spip('inc/lien');
    2218
    23 # accepter un mode debug
    24 if (_request('var_debug_wheel'))
    25         $GLOBALS['textWheel'] = 'TextWheelDebug';
    26 else
    27         $GLOBALS['textWheel'] = 'TextWheel';
    28 
    29 require_once _DIR_PLUGIN_TW.'engine/textwheel.php';
    30 $GLOBALS['spip_wheels']['raccourcis'] = array('spip/spip.yaml','spip/spip-paragrapher.yaml');
    31 if (test_espace_prive ())
    32         $GLOBALS['spip_wheels']['raccourcis'][] = 'spip/ecrire.yaml';
    33 
    34 $GLOBALS['spip_wheels']['interdire_scripts'] = array('spip/interdire-scripts.yaml');
    35 $GLOBALS['spip_wheels']['echappe_js'] = array('spip/echappe-js.yaml');
    36 
    37 
    38 class SPIPTextWheelRuleset extends TextWheelRuleSet {
    39         protected function findFile(&$file, $path=''){
    40                 static $default_path;
    41 
    42                 // absolute file path?
    43                 if (file_exists($file))
    44                         return $file;
    45 
    46                 // file include with texwheels, relative to calling ruleset
    47                 if ($path AND file_exists($f = $path.$file))
    48                         return $f;
    49 
    50                 return find_in_path($file,'wheels/');
    51         }
    52 
    53         public static function &loader($ruleset, $callback = '', $class = 'SPIPTextWheelRuleset', $file_cache='') {
    54 
    55                 # memoization
    56                 $key = 'tw-'.md5(serialize($ruleset).$callback.$class);
    57 
    58                 # lecture du cache
    59                 include_spip('inc/memoization');
    60                 if (!_request('var_mode')
    61                 AND $cacheruleset = cache_get($key))
    62                         return $cacheruleset;
    63 
    64                 # calcul de la wheel
    65                 $ruleset = parent::loader($ruleset, $callback, $class);
    66 
    67                 # ecriture du cache
    68                 cache_set($key, $ruleset);
    69 
    70                 return $ruleset;
    71         }
    72 }
    73 
    74 // init du tableau principal des raccourcis
    75 
    76 global $spip_raccourcis_typo, $class_spip_plus, $debut_intertitre, $fin_intertitre, $debut_gras, $fin_gras, $debut_italique, $fin_italique;
    77 
    78 $spip_raccourcis_typo = array(
    79                               array(
    80                 /* 4 */         "/(^|[^{])[{][{][{]/S",
    81                 /* 5 */         "/[}][}][}]($|[^}])/S",
    82                 /* 6 */         "/(( *)\n){2,}(<br\s*\/?".">)?/S",
    83                 /* 7 */         "/[{][{]/S",
    84                 /* 8 */         "/[}][}]/S",
    85                 /* 9 */         "/[{]/S",
    86                 /* 10 */        "/[}]/S",
    87                 /* 11 */        "/(?:<br\s*\/?".">){2,}/S",
    88                 /* 12 */        "/<p>\n*(?:<br\s*\/?".">\n*)*/S",
    89                 /* 13 */        "/<quote>/S",
    90                 /* 14 */        "/<\/quote>/S",
    91                 /* 15 */        "/<\/?intro>/S"
    92                                 ),
    93                               array(
    94                 /* 4 */         "\$1\n\n" . $debut_intertitre,
    95                 /* 5 */         $fin_intertitre ."\n\n\$1",
    96                 /* 6 */         "<p>",
    97                 /* 7 */         $debut_gras,
    98                 /* 8 */         $fin_gras,
    99                 /* 9 */         $debut_italique,
    100                 /* 10 */        $fin_italique,
    101                 /* 11 */        "<p>",
    102                 /* 12 */        "<p>",
    103                 /* 13 */        "<blockquote$class_spip_plus><p>",
    104                 /* 14 */        "</blockquote><p>",
    105                 /* 15 */        ""
    106                                 )
    107 );
     19include_spip('inc/textwheel');
    10820
    10921// Raccourcis dependant du sens de la langue
    110 
    111 function definir_raccourcis_alineas()
    112 {
     22function definir_raccourcis_alineas() {
    11323        global $ligne_horizontale;
    11424        static $alineas = array();
     
    340250
    341251// http://doc.spip.org/@echappe_retour_modeles
    342 function echappe_retour_modeles($letexte, $interdire_scripts=false) {
    343         if ($GLOBALS['tw']) return tw_echappe_retour_modeles($letexte, $interdire_scripts);
    344         return core_echappe_retour_modeles($letexte, $interdire_scripts);
    345 }
    346 
    347 function core_echappe_retour_modeles($letexte, $interdire_scripts=false)
    348 {
     252function echappe_retour_modeles($letexte, $interdire_scripts=false){
    349253        $letexte = echappe_retour($letexte);
    350254
     
    352256        if ($interdire_scripts)
    353257                $letexte = interdire_scripts($letexte,true);
    354 
    355         return trim($letexte);
    356 }
    357 
    358 function tw_echappe_retour_modeles($letexte, $interdire_scripts=false){
    359         $letexte = echappe_retour($letexte);
    360 
    361         // Dans les appels directs hors squelette, securiser aussi ici
    362         if ($interdire_scripts)
    363                 $letexte = tw_interdire_scripts($letexte,true);
    364258
    365259        return trim($letexte);
     
    441335
    442336//
    443 // Les elements de propre()
    444 //
    445 
    446 // afficher joliment les <script>
    447 // http://doc.spip.org/@echappe_js
    448 function echappe_js($t,$class=' class="echappe-js"') {
    449         if ($GLOBALS['tw']) return tw_echappe_js($t,$class);
    450         return core_echappe_js($t,$class);
    451 }
    452 
    453 function core_echappe_js($t,$class=' class="echappe-js"') {
    454         if (preg_match_all(',<script.*?($|</script.),isS', $t, $r, PREG_SET_ORDER))
    455         foreach ($r as $regs)
    456                 $t = str_replace($regs[0],
    457                         "<code$class>".nl2br(htmlspecialchars($regs[0])).'</code>',
    458                         $t);
    459         return $t;
    460 }
    461 
    462 function tw_echappe_js($t) {
     337// echapper les < script ...
     338//
     339function echappe_js($t) {
    463340        static $wheel = null;
     341
    464342        if (!isset($wheel))
    465                 $wheel = new $GLOBALS['textWheel'](
     343                $wheel = new TextWheel(
    466344                        SPIPTextWheelRuleset::loader($GLOBALS['spip_wheels']['echappe_js'])
    467345                );
     
    501379// http://doc.spip.org/@interdire_scripts
    502380function interdire_scripts($arg) {
    503         if ($GLOBALS['tw']) return tw_interdire_scripts($arg);
    504         return core_interdire_scripts($arg);
    505 }
    506 
    507 function core_interdire_scripts($arg) {
    508         // on memorise le resultat sur les arguments non triviaux
    509         static $dejavu = array();
    510 
    511         // Attention, si ce n'est pas une chaine, laisser intact
    512         if (!$arg OR !is_string($arg) OR !strstr($arg, '<')) return $arg;
    513 
    514         if (isset($dejavu[$GLOBALS['filtrer_javascript']][$arg])) return $dejavu[$GLOBALS['filtrer_javascript']][$arg];
    515 
    516         // echapper les tags asp/php
    517         $t = str_replace('<'.'%', '&lt;%', $arg);
    518 
    519         // echapper le php
    520         $t = str_replace('<'.'?', '&lt;?', $t);
    521 
    522         // echapper le < script language=php >
    523         $t = preg_replace(',<(script\b[^>]+\blanguage\b[^\w>]+php\b),UimsS', '&lt;\1', $t);
    524 
    525         // Pour le js, trois modes : parano (-1), prive (0), ok (1)
    526         switch($GLOBALS['filtrer_javascript']) {
    527                 case 0:
    528                         if (!_DIR_RESTREINT)
    529                                 $t = echappe_js($t);
    530                         break;
    531                 case -1:
    532                         $t = echappe_js($t);
    533                         break;
    534         }
    535 
    536         // pas de <base href /> svp !
    537         $t = preg_replace(',<(base\b),iS', '&lt;\1', $t);
    538 
    539         // Reinserer les echappements des modeles
    540         if (defined('_PROTEGE_JS_MODELES'))
    541                 $t = echappe_retour($t,"javascript"._PROTEGE_JS_MODELES);
    542         if (defined('_PROTEGE_PHP_MODELES'))
    543                 $t = echappe_retour($t,"php"._PROTEGE_PHP_MODELES);
    544 
    545         return $dejavu[$GLOBALS['filtrer_javascript']][$arg] = $t;
    546 }
    547 
    548 
    549 // Securite : empecher l'execution de code PHP, en le transformant en joli code
    550 // dans l'espace prive, cette fonction est aussi appelee par propre et typo
    551 // si elles sont appelees en direct
    552 // il ne faut pas desactiver globalement la fonction dans l'espace prive car elle protege
    553 // aussi les balises des squelettes qui ne passent pas forcement par propre ou typo apres
    554 // http://doc.spip.org/@interdire_scripts
    555 function tw_interdire_scripts($arg) {
    556381        static $dejavu = array();
    557382        static $wheel = null;
     
    562387
    563388        if (!isset($wheel)){
    564                 $ruleset = SPIPTextWheelRuleset::loader($GLOBALS['spip_wheels']['interdire_scripts']);
     389                $ruleset = SPIPTextWheelRuleset::loader(
     390                        $GLOBALS['spip_wheels']['interdire_scripts']
     391                );
    565392                // Pour le js, trois modes : parano (-1), prive (0), ok (1)
    566393                // desactiver la regle echappe-js si besoin
     
    568395                        OR ($GLOBALS['filtrer_javascript']==0 AND !test_espace_prive()))
    569396                        $ruleset->addRules (array('securite-js'=>array('disabled'=>true)));
    570                 $wheel = new $GLOBALS['textWheel']($ruleset);
     397                $wheel = new TextWheel($ruleset);
    571398        }
    572399
     
    657484
    658485// http://doc.spip.org/@corriger_typo
    659 function corriger_typo($letexte, $lang='') {
    660         static $typographie = array();
     486function corriger_typo($t, $lang='') {
    661487        // Plus vite !
    662         if (!$letexte) return $letexte;
    663 
    664         $letexte = pipeline('pre_typo', $letexte);
     488        if (!$t) return $t;
     489
     490        $t = pipeline('pre_typo', $t);
    665491
    666492        // Caracteres de controle "illegaux"
    667         $letexte = corriger_caracteres($letexte);
     493        $t = corriger_caracteres($t);
    668494
    669495        // Proteger les caracteres typographiques a l'interieur des tags html
    670         if (preg_match_all(_TYPO_BALISE, $letexte, $regs, PREG_SET_ORDER)) {
     496        if (preg_match_all(_TYPO_BALISE, $t, $regs, PREG_SET_ORDER)) {
    671497                foreach ($regs as $reg) {
    672498                        $insert = $reg[0];
     
    674500                        // par des caracteres "illegaux". (cf corriger_caracteres())
    675501                        $insert = strtr($insert, _TYPO_PROTEGER, _TYPO_PROTECTEUR);
    676                         $letexte = str_replace($reg[0], $insert, $letexte);
     502                        $t = str_replace($reg[0], $insert, $t);
    677503                }
    678504        }
    679505
    680506        // trouver les blocs multi et les traiter a part
    681         $letexte = extraire_multi($e = $letexte, $lang, true);
    682         $e = ($e === $letexte);
     507        $t = extraire_multi($e = $t, $lang, true);
     508        $e = ($e === $t);
    683509
    684510        // Charger & appliquer les fonctions de typographie
    685         if (!isset($typographie[$lang]))
    686                 $typographie[$lang] = charger_fonction(lang_typo($lang), 'typographie');
    687         $letexte = $typographie[$lang]($letexte);
     511        $typographie = charger_fonction(lang_typo($lang), 'typographie');
     512        $letexte = $typographie($letexte);
    688513
    689514        // Les citations en une autre langue, s'il y a lieu
    690         if (!$e) $letexte = echappe_retour($letexte, 'multi');
     515        if (!$e) $t = echappe_retour($t, 'multi');
    691516
    692517        // Retablir les caracteres proteges
    693         $letexte = strtr($letexte, _TYPO_PROTECTEUR, _TYPO_PROTEGER);
     518        $t = strtr($t, _TYPO_PROTECTEUR, _TYPO_PROTEGER);
    694519
    695520        // pipeline
    696         $letexte = pipeline('post_typo', $letexte);
     521        $t = pipeline('post_typo', $t);
    697522
    698523        # un message pour abs_url - on est passe en mode texte
    699524        $GLOBALS['mode_abs_url'] = 'texte';
    700525
    701         return $letexte;
     526        return $t;
    702527}
    703528
     
    1032857
    1033858// Nettoie un texte, traite les raccourcis autre qu'URL, la typo, etc.
    1034 // http://doc.spip.org/@traiter_raccourcis
    1035 function traiter_raccourcis($letexte) {
    1036         if ($GLOBALS['tw']) return tw_traiter_raccourcis($letexte);
    1037         return core_traiter_raccourcis($letexte);
    1038 }
    1039 function core_traiter_raccourcis($letexte) {
    1040 
    1041         // Appeler les fonctions de pre_traitement
    1042         $letexte = pipeline('pre_propre', $letexte);
    1043 
    1044         // Gerer les notes (ne passe pas dans le pipeline)
    1045         $notes = charger_fonction('notes', 'inc');
    1046         list($letexte, $mes_notes) = $notes($letexte);
    1047 
    1048         //
    1049         // Tableaux
    1050         //
    1051 
    1052         // ne pas oublier les tableaux au debut ou a la fin du texte
    1053         $letexte = preg_replace(",^\n?[|],S", "\n\n|", $letexte);
    1054         $letexte = preg_replace(",\n\n+[|],S", "\n\n\n\n|", $letexte);
    1055         $letexte = preg_replace(",[|](\n\n+|\n?$),S", "|\n\n\n\n", $letexte);
    1056 
    1057         if (preg_match_all(',[^|](\n[|].*[|]\n)[^|],UmsS', $letexte,
    1058         $regs, PREG_SET_ORDER))
    1059         foreach ($regs as $t) {
    1060                 $letexte = str_replace($t[1], traiter_tableau($t[1]), $letexte);
    1061         }
    1062 
    1063         $letexte = "\n".trim($letexte);
    1064 
    1065         // les listes
    1066         if (strpos($letexte,"\n-*")!==false OR strpos($letexte,"\n-#")!==false)
    1067                 $letexte = traiter_listes($letexte);
    1068 
    1069         // Proteger les caracteres actifs a l'interieur des tags html
    1070 
    1071         if (preg_match_all(_RACCOURCI_BALISE, $letexte, $regs, PREG_SET_ORDER)) {
    1072                 foreach ($regs as $reg) {
    1073                         $insert = strtr($reg[0], _RACCOURCI_PROTEGER, _RACCOURCI_PROTECTEUR);
    1074                         $letexte = str_replace($reg[0], $insert, $letexte);
    1075                 }
    1076         }
    1077 
    1078         // Traitement des alineas
    1079         list($a,$b) = definir_raccourcis_alineas();
    1080         $letexte = preg_replace($a, $b, $letexte);
    1081         //  Introduction des attributs class_spip* et autres raccourcis
    1082         list($a,$b) = $GLOBALS['spip_raccourcis_typo'];
    1083         $letexte = preg_replace($a, $b, $letexte);
    1084         $letexte = preg_replace('@^\n<br />@S', '', $letexte);
    1085 
    1086         // Retablir les caracteres proteges
    1087         $letexte = strtr($letexte, _RACCOURCI_PROTECTEUR, _RACCOURCI_PROTEGER);
    1088 
    1089         // Fermer les paragraphes ; mais ne pas forcement en creer si un seul
    1090         $letexte = paragrapher($letexte, $GLOBALS['toujours_paragrapher']);
    1091 
    1092         // Appeler les fonctions de post-traitement
    1093         $letexte = pipeline('post_propre', $letexte);
    1094 
    1095         if ($mes_notes) $notes($mes_notes);
    1096 
    1097         return $letexte;
    1098 }
    1099 
    1100 
    1101 function tw_personaliser_raccourcis(&$ruleset){
     859
     860// mais d'abord, une callback de reconfiguration des raccourcis
     861// a partir de globales (est-ce old-style ? on conserve quand meme
     862// par souci de compat ascendante)
     863function personnaliser_raccourcis(&$ruleset){
    1102864        if (isset($GLOBALS['debut_intertitre']) AND $rule=$ruleset->getRule('intertitres')){
    1103865                $rule->replace[0] = preg_replace(',<[^>]*>,Uims',$GLOBALS['debut_intertitre'],$rule->replace[0]);
     
    1126888}
    1127889
    1128 function tw_traiter_raccourcis($letexte) {
     890// http://doc.spip.org/@traiter_raccourcis
     891function traiter_raccourcis($t) {
    1129892        static $wheel;
    1130893        // Appeler les fonctions de pre_traitement
    1131         #$letexte = pipeline('pre_propre', $letexte);
    1132 
    1133         $debug = _request('var_debug_wheel');
    1134 
     894        $t = pipeline('pre_propre', $t);
    1135895
    1136896        if (!isset($wheel)) {
    1137                 if($debug) spip_timer('init');
    1138                 $ruleset = SPIPTextWheelRuleset::loader($GLOBALS['spip_wheels']['raccourcis'],'tw_personaliser_raccourcis');
    1139                 $wheel = new $GLOBALS['textWheel']($ruleset);
    1140 
    1141                 if (_request('var_mode') == 'compile') {
     897                $ruleset = SPIPTextWheelRuleset::loader(
     898                        $GLOBALS['spip_wheels']['raccourcis'],'personnaliser_raccourcis'
     899                );
     900                $wheel = new TextWheel($ruleset);
     901
     902                if (_request('var_mode') == 'wheel'
     903                AND autoriser('debug')) {
    1142904                        echo "<pre>";
    1143905                        echo htmlspecialchars($wheel->compile());
     
    1145907                        ;
    1146908                }
    1147 
    1148                 if($debug) $GLOBALS['totaux']['tw_traiter_raccourcis:']['init'] += spip_timer('init', true);
    1149909        }
    1150910
    1151911        // Gerer les notes (ne passe pas dans le pipeline)
    1152         if($debug) spip_timer('notes');
    1153912        $notes = charger_fonction('notes', 'inc');
    1154         list($letexte, $mes_notes) = $notes($letexte);
    1155         if($debug) $GLOBALS['totaux']['tw_traiter_raccourcis:']['notes'] += spip_timer('notes', true);
    1156 
    1157         if($debug) spip_timer('text');
    1158         $letexte = $wheel->text($letexte);
    1159         if($debug) $GLOBALS['totaux']['tw_traiter_raccourcis:']['text'] += spip_timer('text', true);
     913        list($t, $mes_notes) = $notes($t);
     914
     915        $t = $wheel->text($t);
    1160916
    1161917        // Appeler les fonctions de post-traitement
    1162         if($debug) spip_timer('post_propre');
    1163         $letexte = pipeline('post_propre', $letexte);
    1164         if($debug) $GLOBALS['totaux']['tw_traiter_raccourcis:']['post_propre'] += spip_timer('post_propre', true);
    1165 
    1166         if($debug) spip_timer('mesnotes');
    1167         if ($mes_notes) {
     918        $t = pipeline('post_propre', $t);
     919
     920        if ($mes_notes)
    1168921                $notes($mes_notes);
    1169         }
    1170         if($debug) $GLOBALS['totaux']['tw_traiter_raccourcis:']['mesnotes'] += spip_timer('mesnotes', true);
    1171 
    1172         return $letexte;
     922
     923        return $t;
    1173924}
    1174925
     
    1177928// http://doc.spip.org/@propre
    1178929function propre($t, $connect=null) {
    1179         if ($GLOBALS['tw']) return tw_propre($t,$connect);
    1180         return core_propre($t,$connect);
    1181 }
    1182 
    1183 function core_propre($t, $connect=null) {
    1184930        // les appels directs a cette fonction depuis le php de l'espace
    1185931        // prive etant historiquement ecrits sans argment $connect
     
    1194940        }
    1195941
    1196         return !$t ? strval($t) :
    1197                 echappe_retour_modeles(
    1198                         traiter_raccourcis(
    1199                                 expanser_liens(echappe_html($t),$connect)),$interdire_script);
    1200 }
    1201 
    1202 
    1203 function tw_propre($t, $connect=null) {
    1204 
    1205         // les appels directs a cette fonction depuis le php de l'espace
    1206         // prive etant historiquement ecrits sans argment $connect
    1207         // on utilise la presence de celui-ci pour distinguer les cas
    1208         // ou il faut passer interdire_script explicitement
    1209         // les appels dans les squelettes (de l'espace prive) fournissant un $connect
    1210         // ne seront pas perturbes
    1211         $interdire_script = false;
    1212         if (is_null($connect)){
    1213                 $connect = '';
    1214                 $interdire_script = true;
    1215         }
    1216 
    1217942        if (!$t) return strval($t);
    1218943
    1219         $debug = _request('var_debug_wheel');
    1220 
    1221         if($debug) spip_timer('echappe_html');
    1222944        $t = echappe_html($t);
    1223         if($debug) $GLOBALS['totaux']['echappe_html'] += spip_timer('echappe_html', true);
    1224 
    1225         if($debug) spip_timer('expanser_liens');
    1226         $t = expanser_liens_tw($t,$connect);
    1227         if($debug) $GLOBALS['totaux']['expanser_liens'] += spip_timer('expanser_liens', true);
    1228 
    1229         if($debug) spip_timer('tw_traiter_raccourcis');
    1230         $t = tw_traiter_raccourcis($t);
    1231         if($debug) $GLOBALS['totaux']['tw_traiter_raccourcis'] += spip_timer('tw_traiter_raccourcis', true);
    1232 
    1233         if($debug) spip_timer('tw_echappe_retour_modeles');
    1234         $t = tw_echappe_retour_modeles($t, $interdire_script);
    1235         if($debug) $GLOBALS['totaux']['tw_echappe_retour_modeles'] += spip_timer('tw_echappe_retour_modeles', true);
     945        $t = expanser_liens($t,$connect);
     946        $t = traiter_raccourcis($t);
     947        $t = echappe_retour_modeles($t, $interdire_script);
    1236948
    1237949        return $t;
  • _plugins_/textwheel/plugin.xml

    r41198 r41208  
    44        <icon></icon>
    55        <licence>GNU/GPL</licence>
    6         <version>0.2.0</version>
     6        <version>0.3.0</version>
    77        <etat>test</etat>
    88        <description>Integrer TextWheel dans SPIP</description>
  • _plugins_/textwheel/typographie/en.php

    r41198 r41208  
    1313if (!defined("_ECRIRE_INC_VERSION")) return;
    1414
    15 // Correction typographique francaise
     15// Correction typographique anglaise
    1616
    17 require_once _DIR_RESTREINT.'typographie/en.php';
    18 
    19 function typographie_en($letexte) {
    20 
    21         # version core
    22         if (!$GLOBALS['tw']) {
    23                 return typographie_en_dist($letexte);
    24         }
    25 
    26         $debug = _request('var_debug_wheel');
    27 
     17function typographie_en($t) {
    2818        static $trans;
    2919
     
    4737        $pro = "-\x2-";
    4838
    49         if($debug) spip_timer('trans');
    50         $letexte = str_replace(array_keys($trans), array_values($trans), $letexte);
    51         if($debug) $GLOBALS['totaux']['expanser_liens:']['corriger_typo:']['trans'] += spip_timer('trans', true);
    52 
    53         if($debug) spip_timer('cherche1');
     39        $t = str_replace(array_keys($trans), array_values($trans), $t);
    5440
    5541        /* 2 */
    56         $letexte = preg_replace('/ --?,|(?: %)(?:\W|$)/S', '~$0', $letexte);
     42        $t = preg_replace('/ --?,|(?: %)(?:\W|$)/S', '~$0', $t);
    5743
    5844        /* 4 */
    59         $letexte = preg_replace('/Mr\.? /S', '$0~', $letexte);
     45        $t = preg_replace('/Mr\.? /S', '$0~', $t);
    6046
    61         if($debug) $GLOBALS['totaux']['expanser_liens:']['corriger_typo:']['cherche1'] += spip_timer('cherche1', true);
     47        if (strpos($t, '~') !== false)
     48                $t = preg_replace("/ *~+ */S", "~", $t);
    6249
    63 
    64         if($debug) spip_timer('chercheespaces');
    65         if (strpos($letexte, '~') !== false)
    66                 $letexte = preg_replace("/ *~+ */S", "~", $letexte);
    67         if($debug) $GLOBALS['totaux']['expanser_liens:']['corriger_typo:']['chercheespaces'] += spip_timer('chercheespaces', true);
    68 
    69         if($debug) spip_timer('cherche2');
    70         $letexte = preg_replace("/--([^-]|$)/S", "$pro&mdash;$1", $letexte, -1, $c);
     50        $t = preg_replace("/--([^-]|$)/S", "$pro&mdash;$1", $t, -1, $c);
    7151        if ($c) {
    72                 $letexte = preg_replace("/([-\n])$pro&mdash;/S", "$1--", $letexte);
    73                 $letexte = str_replace($pro, '', $letexte);
     52                $t = preg_replace("/([-\n])$pro&mdash;/S", "$1--", $t);
     53                $t = str_replace($pro, '', $t);
    7454        }
    7555
    76         $letexte = str_replace('~', '&nbsp;', $letexte);
     56        $t = str_replace('~', '&nbsp;', $t);
    7757
    78 
    79         if($debug) $GLOBALS['totaux']['expanser_liens:']['corriger_typo:']['cherche2'] += spip_timer('cherche2', true);
    80 
    81         return $letexte;
     58        return $t;
    8259}
  • _plugins_/textwheel/typographie/fr.php

    r41198 r41208  
    1515// Correction typographique francaise
    1616
    17 require_once _DIR_RESTREINT.'typographie/fr.php';
    18 
    19 function typographie_fr($letexte) {
    20 
    21         # version core
    22         if (!$GLOBALS['tw']) {
    23                 return typographie_fr_dist($letexte);
    24         }
    25 
    26         $debug = _request('var_debug_wheel');
     17function typographie_fr($t) {
    2718
    2819        static $trans;
     
    6051        $pro = "-\x2-";
    6152
    62         if($debug) spip_timer('trans');
    63         $letexte = str_replace(array_keys($trans), array_values($trans), $letexte);
    64         if($debug) $GLOBALS['totaux']['expanser_liens:']['corriger_typo:']['trans'] += spip_timer('trans', true);
     53        $t = str_replace(array_keys($trans), array_values($trans), $t);
    6554
    66         if($debug) spip_timer('cherche1');
    6755        # la typo du ; risque de clasher avec les entites &xxx;
    68         if (strpos($letexte, ';') !== false) {
    69                 $letexte = str_replace(';', '~;', $letexte);
    70                 $letexte = preg_replace(',(&#?[0-9a-z]+)~;,iS', '$1;', $letexte);
     56        if (strpos($t, ';') !== false) {
     57                $t = str_replace(';', '~;', $t);
     58                $t = preg_replace(',(&#?[0-9a-z]+)~;,iS', '$1;', $t);
    7159        }
    7260
    7361        /* 2 */
    74         $letexte = preg_replace('/&#187;| --?,|(?::| %)(?:\W|$)/S', '~$0', $letexte);
     62        $t = preg_replace('/&#187;| --?,|(?::| %)(?:\W|$)/S', '~$0', $t);
    7563
    7664        /* 3 */
    77         $letexte = preg_replace('/[!?][!?\.]*/S', "$pro~$0", $letexte, -1, $c);
     65        $t = preg_replace('/[!?][!?\.]*/S', "$pro~$0", $t, -1, $c);
    7866        if ($c) {
    79                 $letexte = preg_replace("/([\[<\(!\?\.])$pro~/S", '$1', $letexte);
    80                 $letexte = str_replace("$pro", '', $letexte);
     67                $t = preg_replace("/([\[<\(!\?\.])$pro~/S", '$1', $t);
     68                $t = str_replace("$pro", '', $t);
    8169        }
    8270
    8371        /* 4 */
    84         $letexte = preg_replace('/&#171;|M(?:M?\.|mes?|r\.?|&#176;) |[nN]&#176; /S', '$0~', $letexte);
     72        $t = preg_replace('/&#171;|M(?:M?\.|mes?|r\.?|&#176;) |[nN]&#176; /S', '$0~', $t);
    8573
    86         if($debug) $GLOBALS['totaux']['expanser_liens:']['corriger_typo:']['cherche1'] += spip_timer('cherche1', true);
     74        if (strpos($t, '~') !== false)
     75                $t = preg_replace("/ *~+ */S", "~", $t);
    8776
    88 
    89         if($debug) spip_timer('chercheespaces');
    90         if (strpos($letexte, '~') !== false)
    91                 $letexte = preg_replace("/ *~+ */S", "~", $letexte);
    92         if($debug) $GLOBALS['totaux']['expanser_liens:']['corriger_typo:']['chercheespaces'] += spip_timer('chercheespaces', true);
    93 
    94         if($debug) spip_timer('cherche2');
    95         $letexte = preg_replace("/--([^-]|$)/S", "$pro&mdash;$1", $letexte, -1, $c);
     77        $t = preg_replace("/--([^-]|$)/S", "$pro&mdash;$1", $t, -1, $c);
    9678        if ($c) {
    97                 $letexte = preg_replace("/([-\n])$pro&mdash;/S", "$1--", $letexte);
    98                 $letexte = str_replace($pro, '', $letexte);
     79                $t = preg_replace("/([-\n])$pro&mdash;/S", "$1--", $t);
     80                $t = str_replace($pro, '', $t);
    9981        }
    10082
    101         $letexte = preg_replace(',(https?|ftp|mailto)~((://[^"\'\s\[\]\}\)<>]+)~([?]))?,S', '$1$3$4', $letexte);
    102         $letexte = str_replace('~', '&nbsp;', $letexte);
     83        $t = preg_replace(',(https?|ftp|mailto)~((://[^"\'\s\[\]\}\)<>]+)~([?]))?,S', '$1$3$4', $t);
     84        $t = str_replace('~', '&nbsp;', $t);
    10385
    104 
    105         if($debug) $GLOBALS['totaux']['expanser_liens:']['corriger_typo:']['cherche2'] += spip_timer('cherche2', true);
    106 
    107         return $letexte;
     86        return $t;
    10887}
  • _plugins_/textwheel/wheels/spip/interdire-scripts.yaml

    r41198 r41208  
    2222  if_str: "<script"
    2323  type: all
    24   replace: "tw_echappe_js"
     24  replace: "echappe_js"
    2525  is_callback: Y
    2626
Note: See TracChangeset for help on using the changeset viewer.