Changeset 53926 in spip-zone


Ignore:
Timestamp:
Nov 1, 2011, 11:39:27 AM (8 years ago)
Author:
esj@…
Message:

langonet version 0.7.0 : en plus de l'évacuation des _L par script Shell, on produit aussi un tel script pour les libellés présents dans un squelette non définis dans une module de langue. Par exemple, soit l'extrait de squelette:

<:Le @article@ sera publi&eacute; prochainement.{article=#ID_ARTICLE}:>
</BOUCLE1>
<div id="content"><h1><:Rien de publi&eacute; &agrave; ce num&eacute;ro.:></h1>
<//B1>

Langonet complétera automatiquement le fichier de langue avec

/*      <LANGONET_DEFINITION_L> */
        'article_sera_publie' => 'Le @article@ sera publi&eacute; prochainement.',
/*      <LANGONET_DEFINITION_L> */
        'rien_de_publie_a_ce_numero' => 'Rien de publi&eacute; &agrave; ce num&eacute;ro.'

et fournira un script Shell dont l'exécution transformera l'extrait ci-dessus en:

<:didacspip:article_sera_publie{article=#ID_ARTICLE}:>
</BOUCLE1>
<div id="content"><h1><:didacspip:rien_de_publie_a_ce_numero:></h1>
<//B1>

Pour ce faire, la RegExp? de Langonet reconnaissant les séquence {{{<:...:>}} a été un peu modifiée pour accepter autre chose que des minuscules et des soulignées (exigés par le compilateur de SPIP). On tient compte également de la présence d'un filtre.

Location:
_plugins_/langonet
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/langonet/formulaires/langonet_verifier.php

    r53562 r53926  
    7272                if ($verification != 'utilisation') {
    7373                        $oublies = array();
    74                         foreach ($resultats['item_non'] as $_item)
    75                                 $oublies[$_item] = ($verification == 'definition') ? '' : $resultats['item_md5'][$_item];
     74                        $_l = ($verification=='fonction_l');
     75                        $all = $resultats[$_l ? "item_non" : 'item_non_mais_nok'];
     76                        foreach ($all as $_item) {
     77                                $oublies[$_item] = @$resultats['item_md5'][$_item]; // indefini si dejo normalise
     78                        }
    7679                        $mode = ($verification == 'definition') ? 'oublie' : 'fonction_l';
    7780                        $corrections = $langonet_corriger($module, $langue, $ou_langue, $langue, $mode, $encodage, $oublies);
     
    306309        }
    307310
    308         if ($verification == 'fonction_l') {
     311        if ($verification == 'fonction_l' OR $verification == 'definition' ) {
    309312                // On cree un fichier de script capable de modifier les fichiers de l'arbo specifiee
    310                 // en remplacant les _L par des _T. Il porte le meme nom que le log avec l'extension .sh
     313                // Il porte le meme nom que le log avec l'extension .sh
    311314                $script = substr($log_fichier, 0, strlen($log_fichier)-4) . '.sh';
    312                 $ok = creer_script_l($resultats, $script);
    313                 if (!$ok) {
    314                         $retour['message_erreur'] .= _T('langonet:message_nok_fichier_script');
    315                         spip_log("echec de creation du fichier $script", "langonet");
    316                         return $retour;
    317                 }
    318                 $resume = 'langonet:message_ok_fichier_log_script';
     315                if ($contenu = creer_script($resultats, $verification)) {
     316                        if (!ecrire_fichier($script, $contenu)) {
     317                                $retour['message_erreur'] .= _T('langonet:message_nok_fichier_script');
     318                                spip_log("echec de creation du fichier $script", "langonet");
     319                                return $retour;
     320                        }
     321                        $resume = 'langonet:message_ok_fichier_log_script';
     322                }
    319323        }
    320324
     
    471475
    472476/**
    473  * Construit un script Shell s'appliquant sur les fichiers contenant _L
     477 * Construit un script Shell
     478 * s'appliquant sur les fichiers contenant les chaines indefinies
    474479 * @param array $resultats
    475  * @param string $langue
    476  * @param string $script
     480 * @param string $verification
    477481 * @return boolean
    478482 */
    479 function creer_script_l($resultats, $script) {
     483function creer_script($resultats, $verification) {
    480484        $ou = $resultats['ou_fichier'];
    481485        $prefixe = ($resultats['module'] == 'spip'
     
    483487                                OR $resultats['module'] == 'public') ? '' : $resultats['module'] . ':' ;
    484488
    485         $sed = array();
    486         foreach ($resultats['fichier_non'] as $index => $val) {
     489        $files = $sed = array();
     490        $_l = ($verification=='fonction_l');
     491        $all = $resultats[$_l ? "fichier_non" : 'fichier_non_mais_nok'];
     492        // Pour chaque item on construit le sed
     493        // et on collecte au passage les fichiers qui le contiennent
     494        foreach ($all as $index => $val) {
     495                foreach($val as $f => $l) $files[$f]= str_replace(_DIR_RACINE . $ou, '', $f);
     496                $fichier = key($val);
    487497                $val = array_shift($val);
    488498                $val = array_shift($val);
    489499                $val = array_shift($val);
    490                 // gestion des backslash imparfaite, mais c'est deja ca
    491                 if (preg_match(_LANGONET_FONCTION_L, $val, $m))
    492                         $occ = str_replace('\\', '.', $m[1]);
    493                 elseif (preg_match(_LANGONET_FONCTION_L2, $val, $m))
    494                         $occ = $m[1];
    495                 else continue;
     500                if ($_l) {
     501                        // gestion des backslash imparfaite, mais c'est deja ca
     502                        if (preg_match(_LANGONET_FONCTION_L, $val, $m))
     503                                $occ = str_replace('\\', '.', $m[1]);
     504                        elseif (preg_match(_LANGONET_FONCTION_L2, $val, $m))
     505                                $occ = $m[1];
     506                        else continue;
     507                } else {
     508                  // si les item n'ont pas que des lettres, normaliser
     509                        $re = strpos($fichier, '.xml') ? _LANGONET_TROUVER_ITEM_X : _LANGONET_TROUVER_ITEM_HP;           
     510                        if (!preg_match($re, $val, $m)) continue;
     511                        if ($m[0][0] !== '<') continue;
     512                        if (preg_match(',^\w+$,', $occ = $m[2])) continue;
     513                }
    496514                // Un item avec $ est intraduisible.
    497515                if (strpos($occ, '$') !== false)  continue;
    498516                $occ = str_replace('%', '\\%', $occ);
    499                 $cite = "s%_L *( *.$occ *.%_T('$prefixe$index'%;";
     517                $cite = $_l ? "s%_L *( *.$occ *.%_T('$prefixe$index'%;" : "s%<:$occ%<:$prefixe$index%;";
    500518                $sed[$cite]=strlen($occ);
    501519        }
    502 
     520        if (!$sed) return '';
    503521        // Trier par ordre decroissant des longueurs des items a remplacer:
    504522        // "truc_x" doit etre traite avant "truc"
    505523        arsort($sed);
    506 
    507         // Lister les fichiers concernes
    508         $files = array();
    509         foreach ($resultats["fichier_non"] as $j) {
    510                 foreach($j as $f => $l) $files[$f]= str_replace(_DIR_RACINE . $ou, '', $f);
    511         }
    512 
    513524        // Creer le texte du script
    514525        $in = _L('executer ce script dans ');
    515         $out = _L("Si correct, rappeler ce script avec 'mv' comme argument pour remplacer _L par _T dans les fichiers.");
    516         $texte = "echo \"$in $ou\"\n" .
     526        $out = _L("Si correct, rappeler ce script avec 'mv' comme argument pour modifier les fichiers.");
     527        return "echo \"$in $ou\"\n" .
    517528                'if [ "$*" == "mv" ]; then comm=mv; else comm=diff; fi' .
    518529                "\nfor i in " .
     
    521532                join("\n", array_keys($sed)) .
    522533                "\n\" \$i > /tmp/\$r\n\$comm /tmp/\$r \$i\ndone\n" .
    523                 "\nif [ \"$*\" != 'mv' ]; then echo \"$out\"; fi";
    524 
    525         $ok = ecrire_fichier($script, $texte);
    526         return $ok;
     534                "\nif [ \"$*\" != 'mv' ]; then echo; echo \"$out\"; fi";
    527535}
    528536
  • _plugins_/langonet/inc/langonet_generer_fichier.php

    r53892 r53926  
    5151
    5252function langonet_generer_couples($module, $var_source, $var_cible, $mode='index', $encodage='utf8', $oublis_inutiles=array()) {
    53 
    5453        if ($encodage == 'utf8') include_spip('inc/langonet_utils');
    5554
    5655        // On recupere les items du fichier de langue si celui ci n'est pas vide
    5756        $source = $GLOBALS[$var_source] ? $GLOBALS[$var_source] : array();
     57
    5858        // Si on demande de generer le fichier corrige
    5959        // alors on fournit la liste des items a ajouter
     
    6262        foreach ($source as $_item => $_valeur) {
    6363                $texte = $GLOBALS[$var_cible][$_item];
    64                 $comm = false;
    65                 if ($GLOBALS[$var_cible][$_item]) {
     64                if ($texte) {
    6665                        $comm = in_array($_item, $oublis_inutiles);
    6766                }
    6867                else {
     68                        $comm = false;
    6969                        if ($mode != 'pas_item') {
    7070                                if ($mode == 'new')
     
    7878                                else if ($mode == 'vide')
    7979                                        $texte = '';
     80                                else if (($mode == 'fonction_l') OR (($mode == 'oublie') AND $_valeur))
     81                                        $texte = array('<LANGONET_DEFINITION_L>', $_valeur, $mode);
    8082                                else if ($mode == 'oublie')
    8183                                        $texte = '<LANGONET_DEFINITION_MANQUANTE>';
    82                                 else if ($mode == 'fonction_l')
    83                                         $texte = array('<LANGONET_DEFINITION_L>', $_valeur, $mode);
    8484                                else
    8585                                        $texte = $_item;
  • _plugins_/langonet/inc/langonet_verifier_items.php

    r52889 r53926  
    33if (!defined('_ECRIRE_INC_VERSION')) return;
    44
    5 // Les REGEXP de recherche de l'item de langue (voir le fichier regexp.txt)
    6 // -- pour les fichiers .html et .php sans detection de _L
    7 define("_LANGONET_TROUVER_ITEM_HP", ",(?:<:|_[TU]\(['\"])(?:([a-z0-9_]+):)?((?:\\$|[\"\']\s*\.\s*\\$*)?[a-z0-9_]+)((?:{(?:[^\|=>]*=[^\|>]*)})?(?:(?:\|[^>]*)?)(?:['\"]\s*\.\s*[^\s]+)?),iS");
     5// Les REGEXP de recherche de l'item de langue
     6// (voir le fichier regexp.txt pour des exemples)
     7
     8// -- pour les fichiers .html et .php
     9// sans detection de _L mais avec variables PHP eventuelles dans l'argument de _T
     10define("_LANGONET_TROUVER_ITEM_HP",
     11        "#" .
     12        "(?:<:|_[TU]\(['\"])" . // designation (<: pour squelette, T|U pour PHP)
     13        "(?:([a-z0-9_]+):)?" .  // nom du module eventuel
     14       "(" . "(?:\\$|[\"\']\s*\.\s*\\$*)?" . // delimiteur ' ou " pour T|U
     15                "[A-Za-z0-9@_&;,.?!\s-]+" . // item nu, pas forcement normalise
     16               ")" .
     17        "(" . "(?:{(?:[^\|=>]*=[^\|>]*)})?" . // argument entre accolades
     18                "(?:(?:\|[^>]*)?)" . // filtre
     19                "(?:['\"]\s*\.\s*[^\s]+)?" . // delimiteur ' ou " pour T|U
     20        ")" .
     21        "#iS"
     22       );
     23
    824// -- pour les fichiers .xml
    925define("_LANGONET_TROUVER_ITEM_X", ",<[a-z0-9_]+>[\n|\t|\s]*([a-z0-9_]+):([a-z0-9_]+)[\n|\t|\s]*</[a-z0-9_]+()>,iS");
    1026
    1127/**
    12  * Vérification de l'utilisation des items de langue
     28 * Verification de l'utilisation des items de langue
    1329 *
    1430 * @param string $rep
     
    3349        // de l'erreur dans $resultats['erreur'].
    3450        // Sinon, cet index n'existe pas
    35         $resultats = array();
     51        $item_md5 = $fichier_non = $resultats = array();
    3652
    3753        // On charge le fichier de langue a verifier
     
    3955        // (evite le mecanisme standard de surcharge SPIP)
    4056        include_spip('inc/traduire');
     57        include_spip('inc/langonet_verifier_l');
    4158        $var_source = "i18n_".$module."_".$langue;
    4259        if (empty($GLOBALS[$var_source])) {
     
    4663
    4764        // On cherche l'ensemble des items utilises dans l'arborescence $ou_fichier
    48         $utilises_brut = array('items' => array(), 'suffixes' => array(), 'modules' => array());
    49         // On ne scanne pas dans les ultimes sous-repertoires charsets/ ,
     65        $utilises = array('items' => array(), 'suffixes' => array(), 'modules' => array());
     66        // On ignore les ultimes sous-repertoires charsets/ ,
    5067        // lang/ , req/ . On ne scanne que les fichiers php, html ou xml
    5168        // (voir le fichier regexp.txt).
    52         foreach (preg_files(_DIR_RACINE.$ou_fichier, '(?<!/charsets|/lang|/req)(/[^/]*\.(html|php|xml|yaml))$') as $_fichier) {
     69        $files = preg_files(_DIR_RACINE.$ou_fichier, '(?<!/charsets|/lang|/req)(/[^/]*\.(html|php|xml|yaml))$');
     70        foreach ($files as $_fichier) {
     71                $re = strpos($_fichier, '.xml') ? _LANGONET_TROUVER_ITEM_X : _LANGONET_TROUVER_ITEM_HP;
    5372                foreach ($contenu = file($_fichier) as $ligne => $texte) {
    54                         if (strpos($_fichier, '.xml')) {
    55                                 $trouver_item = _LANGONET_TROUVER_ITEM_X;
    56                         }
    57                         else {
    58                                 $trouver_item = _LANGONET_TROUVER_ITEM_HP;
    59                         }
    60                         if (preg_match_all($trouver_item, $texte, $matches)) {
     73                        if (preg_match_all($re, $texte,  $m, PREG_SET_ORDER)) {
     74                                foreach ($m as $occ) {
     75                                        $suffixe = preg_replace(',\s*,', '', $occ[2]);
    6176                                // On traite les cas particuliers ou l'item est entierement une expression ou une variable:
    62                                 // on duplique l'item dans le suffixe ce qui est en fait bien le cas
    63                                 // On sauvegarde le matches[2] pour calculer les lignes concernees pus tard
    64                                 $matches[4] = $matches[2];
    65                                 $suffixe = preg_replace(',\s*,', '', $matches[2][0]);
    66                                 if ((substr($suffixe, 0, 1) == "$") OR (substr($suffixe, 0, 2) == "'.") OR (substr($suffixe, 0, 2) == '".')) {
    67                                         $matches[2][0] = str_replace('$', '\$', $suffixe);
    68                                         $utilises_brut['suffixes'] = array_merge($utilises_brut['suffixes'], $matches[2]);
    69                                 }
    70                                 else {
    71                                         $utilises_brut['suffixes'] = array_merge($utilises_brut['suffixes'], $matches[3]);
    72                                 }
    73                                 $utilises_brut['items'] = array_merge($utilises_brut['items'], $matches[2]);
    74                                 $utilises_brut['modules'] = array_merge($utilises_brut['modules'], $matches[1]);
    75                                 // On collecte pour chaque item trouve les lignes et fichiers dans lesquels il est utilise
    76                                 foreach ($matches[4] as $_cle_val => $_item_val) {
    77                                         preg_match("#.{0,8}" . str_replace('$', '\$', $_item_val) . ".{0,20}#is", $texte, $extrait);
    78                                         $item_tous[$matches[2][$_cle_val]][$_fichier][$ligne][] = trim($extrait[0]);
    79                                 }
    80                         }
    81                 }
    82         }
    83 
    84         // On affine le tableau resultant en supprimant les doublons
    85         $utilises = array('items' => array(), 'suffixes' => array(), 'modules' => array());
    86         foreach ($utilises_brut['items'] as $_cle => $_valeur) {
    87                 if (!in_array($_valeur, $utilises['items'])) {
    88                         $utilises['items'][] = $_valeur;
    89                         // Attention ne pas oublier d'exclure le |filtre qui n'est pas un suffixe !!
    90                         $utilises['suffixes'][] = ((!$utilises_brut['suffixes'][$_cle]) OR (substr($utilises_brut['suffixes'][$_cle], 0, 1) == '|' )) ? false : true;
    91                         $utilises['modules'][] = $utilises_brut['modules'][$_cle];
     77                                        if ((substr($suffixe, 0, 1) == "$") OR (substr($suffixe, 0, 2) == "'.") OR (substr($suffixe, 0, 2) == '".')) {
     78                                                $suffixe = str_replace('$', '\$', $suffixe);
     79                                        } else $suffixe = $occ[3];
     80                                        $index = langonet_index_l($occ[2], $utilises['items']);
     81                                        $utilises['items'][$index] = $occ[2];
     82                                        $utilises['modules'][$index] = $occ[1];
     83                                        $item_tous[$index][$_fichier][$ligne][] = trim($occ[0]);
     84                                        // l'item est-il dynamique, hormis tableau d'arguments ou filtre ?
     85                                        // (si oui c'est sale et on pourra pas faire grand chose)
     86                                        $utilises['suffixes'][$index] = ($suffixe AND (strpos('|{', $suffixe[0] !== false)));
     87                                }
     88                        }
    9289                }
    9390        }
     
    113110                                                // L'item est vraiment non defini et c'est une erreur
    114111                                                $item_non[] = $_valeur;
    115                                                 if (is_array($item_tous[$_valeur])) {
    116                                                         $fichier_non[$_valeur] = $item_tous[$_valeur];
     112                                                if (is_array($item_tous[$_cle])) {
     113                                                        $fichier_non[$_cle] = $item_tous[$_cle];
    117114                                                }
    118115                                        }
     
    132129                                                                        }
    133130                                                                        else {
    134                                                                                 $definition_ok = ((($module_trouve[1]=='spip') OR ($module_trouve[1]=='ecrire') OR ($module_trouve[1]=='public')) AND ($utilises['modules'][$_cle] == ''));
     131                                                                                $definition_ok = ((($module_trouve[1]=='spip') OR ($module_trouve[1]=='ecrire') OR ($module_trouve[1]=='public')) AND (!$utilises['modules'][$_cle]));
    135132                                                                        }
    136133                                                                }
     
    139136                                                if ($definition_ok) {
    140137                                                        $item_non_mais[] = $_valeur;
    141                                                         if (is_array($item_tous[$_valeur])) {
    142                                                                 $fichier_non_mais[$_valeur] = $item_tous[$_valeur];
     138                                                        if (is_array($item_tous[$_cle])) {
     139                                                                $fichier_non_mais[$_cle] = $item_tous[$_cle];
    143140                                                        }
    144141                                                        if ($definitions)
     
    146143                                                }
    147144                                                else {
    148                                                         $item_non_mais_nok[] = $_valeur;
    149                                                         if (is_array($item_tous[$_valeur])) {
    150                                                                 $fichier_non_mais_nok[$_valeur] = $item_tous[$_valeur];
     145                                                        $item_non_mais_nok[] = $_cle;
     146                                                        if (is_array($item_tous[$_cle])) {
     147                                                                $fichier_non_mais_nok[$_cle] = $item_tous[$_cle];
     148                                                // Si pas normalise, c'est une auto-definition
     149                                                                if (!preg_match(',^\w+$,', $_valeur)) {
     150                                                                        $item_md5[$_cle] = $_valeur;
     151                                                                }
    151152                                                        }
    152153                                                        if ($definitions)
    153                                                                 $definition_non_mais_nok[$_valeur] = $definitions;
     154                                                                $definition_non_mais_nok[$_cle] = $definitions;
    154155                                                }
    155156                                        }
    156157                                }
    157158                                else {
    158                                         // L'item trouve est utilise dans un contexte variable
     159                                        // L'item est defini dynamiquement (i.e. a l'execution)
    159160                                        // Il ne peut etre trouve directement dans le fichier de
    160                                         // langue, donc on verifie que des items de ce "type"
     161                                        // langue, donc on verifie que des items ressemblant
    161162                                        // existent dans le fichier de langue
    162163                                        $item_trouve = false;
     
    164165                                                if (substr($_item, 0, strlen($_valeur)) == $_valeur) {
    165166                                                        $item_peut_etre[] = $_valeur;
    166                                                         if (is_array($item_tous[$_valeur])) {
    167                                                                 $fichier_peut_etre[$_item] = $item_tous[$_valeur];
     167                                                        if (is_array($item_tous[$_cle])) {
     168                                                                $fichier_peut_etre[$_item] = $item_tous[$_cle];
    168169                                                        }
    169170                                                        $item_trouve = true;
     
    176177                                                $_item = ltrim($_valeur, '\'".\\');
    177178                                                $item_peut_etre[] = $_item;
    178                                                 if (is_array($item_tous[$_valeur])) {
    179                                                         $fichier_peut_etre[$_item] = $item_tous[$_valeur];
     179                                                if (is_array($item_tous[$_cle])) {
     180                                                        $fichier_peut_etre[$_item] = $item_tous[$_cle];
    180181                                                }
    181182                                        }
     
    229230        $resultats['item_peut_etre'] = $item_peut_etre;
    230231        $resultats['fichier_peut_etre'] = $fichier_peut_etre;
     232        $resultats['item_md5'] = $item_md5;
    231233
    232234        return $resultats;
  • _plugins_/langonet/plugin.xml

    r53560 r53926  
    33        <slogan>V&#233;rifier, g&#233;n&#233;rer, rechercher ou afficher les items de langue</slogan>
    44        <auteur>Eric Lupinacci, denisb, kent1</auteur>
    5         <version>0.6.6</version>
     5        <version>0.7.0</version>
    66        <etat>stable</etat>
    77        <licence>GPL 3</licence>
Note: See TracChangeset for help on using the changeset viewer.