Changeset 93622 in spip-zone


Ignore:
Timestamp:
Dec 13, 2015, 11:52:51 AM (4 years ago)
Author:
cedric@…
Message:

Indentation et regles de codage selon http://www.spip.net/fr_article3497.html#regles_codage

Location:
_core_/plugins/revisions
Files:
18 edited

Legend:

Unmodified
Added
Removed
  • _core_/plugins/revisions/afficher_diff/champ.php

    r93092 r93622  
    1111\***************************************************************************/
    1212
    13 if (!defined("_ECRIRE_INC_VERSION")) return;
     13if (!defined("_ECRIRE_INC_VERSION")) {
     14        return;
     15}
    1416
    1517include_spip('inc/diff');
     
    1719/**
    1820 * Afficher le diff d'un champ texte generique
     21 *
    1922 * @param string $champ
    2023 * @param string $old
     
    2427 * @return string
    2528 */
    26 function afficher_diff_champ_dist($champ, $old, $new, $format = 'diff'){
     29function afficher_diff_champ_dist($champ, $old, $new, $format = 'diff') {
    2730        // ne pas se compliquer la vie !
    28         if ($old==$new)
    29                 $out = ($format!='complet'?'':$new);
    30         else {
    31                 if($f = charger_fonction($champ,'afficher_diff', true)){
     31        if ($old == $new) {
     32                $out = ($format != 'complet' ? '' : $new);
     33        } else {
     34                if ($f = charger_fonction($champ, 'afficher_diff', true)) {
    3235                        return $f($champ, $old, $new, $format);
    3336                }
    34                
     37
    3538                $diff = new Diff(new DiffTexte);
    3639                $n = preparer_diff($new);
    3740                $o = preparer_diff($old);
    3841
    39                 $out = afficher_diff($diff->comparer($n,$o));
    40                 if ($format == 'diff' OR $format == 'apercu')
     42                $out = afficher_diff($diff->comparer($n, $o));
     43                if ($format == 'diff' OR $format == 'apercu') {
    4144                        $out = afficher_para_modifies($out, ($format == 'apercu'));
     45                }
    4246        }
     47
    4348        return $out;
    4449}
     
    5257 * @return string
    5358 */
    54 function afficher_para_modifies ($texte, $court = false) {
     59function afficher_para_modifies($texte, $court = false) {
    5560        // Limiter la taille de l'affichage
    56         if ($court) $max = 200;
    57         else $max = 2000;
     61        if ($court) {
     62                $max = 200;
     63        } else {
     64                $max = 2000;
     65        }
    5866
    5967        $texte_ret = "";
    60         $paras = explode ("\n",$texte);
     68        $paras = explode("\n", $texte);
    6169        for ($i = 0; $i < count($paras) AND strlen($texte_ret) < $max; $i++) {
    62                 if (strpos($paras[$i], '"diff-')) $texte_ret .= $paras[$i]."\n\n";
     70                if (strpos($paras[$i], '"diff-')) {
     71                        $texte_ret .= $paras[$i] . "\n\n";
     72                }
    6373#               if (strlen($texte_ret) > $max) $texte_ret .= '(...)';
    6474        }
    6575        $texte = $texte_ret;
     76
    6677        return $texte;
    6778}
  • _core_/plugins/revisions/afficher_diff/id_rubrique.php

    r93092 r93622  
    1111\***************************************************************************/
    1212
    13 if (!defined("_ECRIRE_INC_VERSION")) return;
     13if (!defined("_ECRIRE_INC_VERSION")) {
     14        return;
     15}
    1416
    1517include_spip('inc/diff');
     
    2628 * @return string
    2729 */
    28 function afficher_diff_id_rubrique_dist($champ, $old, $new, $format = 'diff'){
     30function afficher_diff_id_rubrique_dist($champ, $old, $new, $format = 'diff') {
    2931        // ne pas se compliquer la vie !
    30         if ($old==$new)
     32        if ($old == $new) {
    3133                $out = _T('info_dans_rubrique')
    32                        . " <b>&#171;&nbsp;".generer_info_entite($new,'rubrique','titre')."&nbsp;&#187;</b>";
    33         else
     34                        . " <b>&#171;&nbsp;" . generer_info_entite($new, 'rubrique', 'titre') . "&nbsp;&#187;</b>";
     35        } else {
    3436                $out = _T('revisions:version_deplace_rubrique',
    35                                                          array('from'=> generer_info_entite($old,'rubrique','titre')
    36                                                                          ,'to'=>generer_info_entite($new,'rubrique','titre')
    37                                                          )
    38                          );
     37                        array(
     38                                'from' => generer_info_entite($old, 'rubrique', 'titre')
     39                        ,
     40                                'to' => generer_info_entite($new, 'rubrique', 'titre')
     41                        )
     42                );
     43        }
     44
    3945        return $out;
    4046}
  • _core_/plugins/revisions/afficher_diff/jointure.php

    r93092 r93622  
    1111\***************************************************************************/
    1212
    13 if (!defined("_ECRIRE_INC_VERSION")) return;
     13if (!defined("_ECRIRE_INC_VERSION")) {
     14        return;
     15}
    1416
    1517include_spip('inc/diff');
     
    1719/**
    1820 * Afficher le diff d'un champ texte generique
     21 *
    1922 * @param string $champ
    2023 * @param string $old
     
    2427 * @return string
    2528 */
    26 function afficher_diff_jointure_dist($champ, $old, $new, $format = 'diff'){
    27         $join = substr($champ,9);
     29function afficher_diff_jointure_dist($champ, $old, $new, $format = 'diff') {
     30        $join = substr($champ, 9);
    2831        $objet = objet_type($join);
    2932
    30         $old = explode(',',$old);
    31         $new = explode(',',$new);
     33        $old = explode(',', $old);
     34        $new = explode(',', $new);
    3235
    3336        $liste = array();
    3437
    3538        // les communs
    36         $intersection = array_intersect($new,$old);
    37         foreach($intersection as $id)
    38                 if ($id=intval(trim($id)))
    39                         $liste[$id] = "<a href='".generer_url_entite($id,$objet)."' title='"._T(objet_info($objet,'texte_objet'))." $id'>".generer_info_entite($id,$objet,'titre')."</a>";
     39        $intersection = array_intersect($new, $old);
     40        foreach ($intersection as $id) {
     41                if ($id = intval(trim($id))) {
     42                        $liste[$id] = "<a href='" . generer_url_entite($id, $objet) . "' title='" . _T(objet_info($objet,
     43                                        'texte_objet')) . " $id'>" . generer_info_entite($id, $objet, 'titre') . "</a>";
     44                }
     45        }
    4046
    4147        // les supprimes
    42         $old = array_diff($old,$intersection);
    43         foreach($old as $id)
    44                 if ($id=intval(trim($id)))
     48        $old = array_diff($old, $intersection);
     49        foreach ($old as $id) {
     50                if ($id = intval(trim($id))) {
    4551                        $liste[$id] = "<span class='diff-supprime'>"
    46                                       . "<a href='".generer_url_entite($id,$objet)."' title='"._T(objet_info($objet,'texte_objet'))." $id'>".generer_info_entite($id,$objet,'titre')."</a>"
    47                                       . "</span>";
     52                                . "<a href='" . generer_url_entite($id, $objet) . "' title='" . _T(objet_info($objet,
     53                                        'texte_objet')) . " $id'>" . generer_info_entite($id, $objet, 'titre') . "</a>"
     54                                . "</span>";
     55                }
     56        }
    4857
    4958        // les ajoutes
    50         $new = array_diff($new,$intersection);
    51         foreach($new as $id)
    52                 if ($id=intval(trim($id)))
     59        $new = array_diff($new, $intersection);
     60        foreach ($new as $id) {
     61                if ($id = intval(trim($id))) {
    5362                        $liste[$id] = "<span class='diff-ajoute'>"
    54                                       . "<a href='".generer_url_entite($id,$objet)."' title='"._T(objet_info($objet,'texte_objet'))." $id'>".generer_info_entite($id,$objet,'titre')."</a>"
    55                                       . "</span>";
     63                                . "<a href='" . generer_url_entite($id, $objet) . "' title='" . _T(objet_info($objet,
     64                                        'texte_objet')) . " $id'>" . generer_info_entite($id, $objet, 'titre') . "</a>"
     65                                . "</span>";
     66                }
     67        }
    5668
    5769        ksort($liste);
    58         $liste = implode(', ',$liste);
     70        $liste = implode(', ', $liste);
     71
    5972        return $liste;
    6073}
  • _core_/plugins/revisions/base/revisions.php

    r89285 r93622  
    1313/**
    1414 * Déclarations relatives à la base de données
    15  * 
     15 *
    1616 * @package SPIP\Revisions\Pipelines
    17 **/
     17 **/
    1818
    19 if (!defined('_ECRIRE_INC_VERSION')) return;
     19if (!defined('_ECRIRE_INC_VERSION')) {
     20        return;
     21}
    2022
    2123/**
     
    2830 *     Déclarations d'interface pour le compilateur
    2931 */
    30 function revisions_declarer_tables_interfaces($interface){
     32function revisions_declarer_tables_interfaces($interface) {
    3133
    32         $interface['table_des_tables']['versions']='versions';
     34        $interface['table_des_tables']['versions'] = 'versions';
    3335
    3436        return $interface;
     
    3739/**
    3840 * Déclaration des jointures génériques
    39  * 
     41 *
    4042 * @pipeline declarer_tables_objets_sql
    4143 * @param array $tables
     
    4446 *     Description complétée des tables
    4547 */
    46 function revisions_declarer_tables_objets_sql($tables){
     48function revisions_declarer_tables_objets_sql($tables) {
    4749
    4850        // jointures sur les mots pour tous les objets
    49         $tables[]['tables_jointures'][]= 'versions';
     51        $tables[]['tables_jointures'][] = 'versions';
    5052
    5153        return $tables;
     
    6264 *     Description complétée des tables
    6365 */
    64 function revisions_declarer_tables_auxiliaires($tables_auxiliaires){
     66function revisions_declarer_tables_auxiliaires($tables_auxiliaires) {
    6567
    66         $spip_versions = array (
    67                 "id_version"    => "bigint(21) DEFAULT 0 NOT NULL",
    68                 "id_objet"              => "bigint(21) DEFAULT 0 NOT NULL",
    69                 "objet"                 => "VARCHAR (25) DEFAULT '' NOT NULL",
    70                 "date"  => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL",
    71                 "id_auteur"     => "VARCHAR(23) DEFAULT '' NOT NULL", # stocke aussi IP(v6)
    72                 "titre_version" => "text DEFAULT '' NOT NULL",
    73                 "permanent"     => "char(3) DEFAULT '' NOT NULL",
    74                 "champs"        => "text DEFAULT '' NOT NULL"
     68        $spip_versions = array(
     69                "id_version" => "bigint(21) DEFAULT 0 NOT NULL",
     70                "id_objet" => "bigint(21) DEFAULT 0 NOT NULL",
     71                "objet" => "VARCHAR (25) DEFAULT '' NOT NULL",
     72                "date" => "datetime DEFAULT '0000-00-00 00:00:00' NOT NULL",
     73                "id_auteur" => "VARCHAR(23) DEFAULT '' NOT NULL", # stocke aussi IP(v6)
     74                "titre_version" => "text DEFAULT '' NOT NULL",
     75                "permanent" => "char(3) DEFAULT '' NOT NULL",
     76                "champs" => "text DEFAULT '' NOT NULL"
    7577        );
    7678
    77         $spip_versions_key = array (
    78                 "PRIMARY KEY"   => "id_version, id_objet, objet",
     79        $spip_versions_key = array(
     80                "PRIMARY KEY" => "id_version, id_objet, objet",
    7981                "KEY id_version" => "id_version",
    8082                "KEY id_objet" => "id_objet",
    81                 "KEY objet" => "objet");
     83                "KEY objet" => "objet"
     84        );
    8285
    8386        $spip_versions_fragments = array(
    84                 "id_fragment"   => "int unsigned DEFAULT '0' NOT NULL",
    85                 "version_min"   => "int unsigned DEFAULT '0' NOT NULL",
    86                 "version_max"   => "int unsigned DEFAULT '0' NOT NULL",
    87                 "id_objet"      => "bigint(21) NOT NULL",
    88                 "objet"                 => "VARCHAR (25) DEFAULT '' NOT NULL",
    89                 "compress"      => "tinyint NOT NULL",
    90                 "fragment"      => "longblob"  # ici c'est VRAIMENT un blob (on y stocke du gzip)
     87                "id_fragment" => "int unsigned DEFAULT '0' NOT NULL",
     88                "version_min" => "int unsigned DEFAULT '0' NOT NULL",
     89                "version_max" => "int unsigned DEFAULT '0' NOT NULL",
     90                "id_objet" => "bigint(21) NOT NULL",
     91                "objet" => "VARCHAR (25) DEFAULT '' NOT NULL",
     92                "compress" => "tinyint NOT NULL",
     93                "fragment" => "longblob"  # ici c'est VRAIMENT un blob (on y stocke du gzip)
    9194        );
    9295
    9396        $spip_versions_fragments_key = array(
    94                 "PRIMARY KEY"   => "id_objet, objet, id_fragment, version_min"
     97                "PRIMARY KEY" => "id_objet, objet, id_fragment, version_min"
    9598        );
    9699
     
    98101        $tables_auxiliaires['spip_versions'] = array(
    99102                'field' => &$spip_versions,
    100                 'key' => &$spip_versions_key);
     103                'key' => &$spip_versions_key
     104        );
    101105
    102106        $tables_auxiliaires['spip_versions_fragments'] = array(
    103107                'field' => &$spip_versions_fragments,
    104                 'key' => &$spip_versions_fragments_key);
     108                'key' => &$spip_versions_fragments_key
     109        );
    105110
    106111        return $tables_auxiliaires;
  • _core_/plugins/revisions/formulaires/configurer_revisions_objets.php

    r89285 r93622  
    1111\***************************************************************************/
    1212
    13 if (!defined("_ECRIRE_INC_VERSION")) return;
     13if (!defined("_ECRIRE_INC_VERSION")) {
     14        return;
     15}
    1416
    15 function formulaires_configurer_revisions_objets_charger_dist(){
    16         if (!$objets = unserialize($GLOBALS['meta']['objets_versions']))
     17function formulaires_configurer_revisions_objets_charger_dist() {
     18        if (!$objets = unserialize($GLOBALS['meta']['objets_versions'])) {
    1719                $objets = array();
     20        }
    1821        $valeurs = array(
    19                 'objets_versions'=>$objets,
     22                'objets_versions' => $objets,
    2023        );
    2124
     
    2326}
    2427
    25 function formulaires_configurer_revisions_objets_traiter_dist(){
     28function formulaires_configurer_revisions_objets_traiter_dist() {
    2629
    2730        include_spip('inc/meta');
    2831        $tables = serialize(_request('objets_versions'));
    29         ecrire_meta('objets_versions',$tables);
     32        ecrire_meta('objets_versions', $tables);
    3033
    31         return array('message_ok'=>_T('config_info_enregistree'));
     34        return array('message_ok' => _T('config_info_enregistree'));
    3235}
    3336
    34 function test_objet_versionable($desc){
     37function test_objet_versionable($desc) {
    3538        if (!$desc['editable']
    3639                OR !isset($desc['champs_versionnes'])
    3740                OR !count($desc['champs_versionnes'])
    38         )
     41        ) {
    3942                return '';
     43        }
    4044
    4145        // regarder si il y a un vrai champ versionne, pas seulement une jointure
    42         foreach ($desc['champs_versionnes'] as $c){
    43                 if (strncmp($c,'jointure_',9)!=0)
     46        foreach ($desc['champs_versionnes'] as $c) {
     47                if (strncmp($c, 'jointure_', 9) != 0) {
    4448                        return ' ';
     49                }
    4550        }
    4651
     
    4853        return '';
    4954}
     55
    5056?>
  • _core_/plugins/revisions/formulaires/reviser.php

    r93092 r93622  
    1111\***************************************************************************/
    1212
    13 if (!defined("_ECRIRE_INC_VERSION")) return;
     13if (!defined("_ECRIRE_INC_VERSION")) {
     14        return;
     15}
    1416
    1517include_spip('base/abstract_sql');
    1618
    17 function trouver_version_inf($objet, $id_objet, $cond = ""){
     19function trouver_version_inf($objet, $id_objet, $cond = "") {
    1820        return sql_getfetsel(
    19                                 'id_version',
    20                                 'spip_versions',
    21                                 ($cond?"$cond AND ":"")."objet=".sql_quote($objet)." AND id_objet=".intval($id_objet),
    22                                 '',
    23                                 'id_version DESC',
    24                                 '0,1'
    25                           );
     21                'id_version',
     22                'spip_versions',
     23                ($cond ? "$cond AND " : "") . "objet=" . sql_quote($objet) . " AND id_objet=" . intval($id_objet),
     24                '',
     25                'id_version DESC',
     26                '0,1'
     27        );
    2628}
    27 function check_version_diff($objet, $id_objet, $id_version, $id_diff, $last_version = 0){
    28         if (!$last_version)
    29                 $last_version = trouver_version_inf($objet,$id_objet);
     29
     30function check_version_diff($objet, $id_objet, $id_version, $id_diff, $last_version = 0) {
     31        if (!$last_version) {
     32                $last_version = trouver_version_inf($objet, $id_objet);
     33        }
    3034
    3135        // si pas de diff possible, on renvoi 0,0
    32         if (!$last_version)
    33                 return array(0,0);
     36        if (!$last_version) {
     37                return array(0, 0);
     38        }
    3439
    35         if ($last_version==1)
    36                 return array(1,0);
     40        if ($last_version == 1) {
     41                return array(1, 0);
     42        }
    3743
    38         $id_version = max($id_version,2);
    39         $id_version = min($id_version,$last_version);
     44        $id_version = max($id_version, 2);
     45        $id_version = min($id_version, $last_version);
    4046
    4147        // verifier id_version
    42         $id_version = trouver_version_inf($objet,$id_objet,"id_version<=".intval($id_version));
     48        $id_version = trouver_version_inf($objet, $id_objet, "id_version<=" . intval($id_version));
    4349
    4450        // si rien trouve on prend la derniere
    45         if (!$id_version)
     51        if (!$id_version) {
    4652                $id_version = $last_version;
     53        }
    4754
    4855        // minorer id_diff en fonction de id_version
    49         $id_diff = min($id_diff,$id_version-1);
     56        $id_diff = min($id_diff, $id_version-1);
    5057        // verifier id_diff
    51         $id_diff = trouver_version_inf($objet,$id_objet,"id_version<=".intval($id_diff));
     58        $id_diff = trouver_version_inf($objet, $id_objet, "id_version<=" . intval($id_diff));
    5259
    53         if (!$id_diff)
    54                 $id_diff = trouver_version_inf($objet,$id_objet,"id_version<".intval($id_version));
     60        if (!$id_diff) {
     61                $id_diff = trouver_version_inf($objet, $id_objet, "id_version<" . intval($id_version));
     62        }
    5563
    5664        // echec, on renvoi ce qu'on peut
    57         if (!$id_diff)
     65        if (!$id_diff) {
    5866                $id_diff = $id_version-1;
     67        }
    5968
    6069        return array($id_version, $id_diff);
    6170}
    6271
    63 function formulaires_reviser_charger_dist($objet, $id_objet, $id_version, $id_diff){
    64         if (!$objets = unserialize($GLOBALS['meta']['objets_versions']))
     72function formulaires_reviser_charger_dist($objet, $id_objet, $id_version, $id_diff) {
     73        if (!$objets = unserialize($GLOBALS['meta']['objets_versions'])) {
    6574                $objets = array();
     75        }
    6676
    67         if (!in_array(table_objet_sql($objet),$objets))
     77        if (!in_array(table_objet_sql($objet), $objets)) {
    6878                return false;
     79        }
    6980
    70         $last_version = trouver_version_inf($objet,$id_objet);
    71         list($id_version,$id_diff) = check_version_diff($objet,$id_objet,$id_version,$id_diff,$last_version);
    72         if (!$id_version)
     81        $last_version = trouver_version_inf($objet, $id_objet);
     82        list($id_version, $id_diff) = check_version_diff($objet, $id_objet, $id_version, $id_diff, $last_version);
     83        if (!$id_version) {
    7384                return false;
    74        
     85        }
     86
    7587        $valeurs = array(
    76                 '_last_version'=>$last_version,
    77                 '_objet'=>$objet,
    78                 '_id_objet'=>$id_objet,
    79                 'id_version'=>$id_version,
    80                 'id_diff'=>$id_diff,
     88                '_last_version' => $last_version,
     89                '_objet' => $objet,
     90                '_id_objet' => $id_objet,
     91                'id_version' => $id_version,
     92                'id_diff' => $id_diff,
    8193        );
    8294
     
    8496}
    8597
    86 function formulaires_reviser_verifier_dist($objet, $id_objet, $id_version, $id_diff){
     98function formulaires_reviser_verifier_dist($objet, $id_objet, $id_version, $id_diff) {
    8799        $erreurs = array();
    88         list($id_version,$id_diff) = check_version_diff($objet,$id_objet,_request('id_version'),_request('id_diff'));
    89         set_request('id_version',$id_version);
    90         set_request('id_diff',$id_diff);
     100        list($id_version, $id_diff) = check_version_diff($objet, $id_objet, _request('id_version'), _request('id_diff'));
     101        set_request('id_version', $id_version);
     102        set_request('id_diff', $id_diff);
     103
    91104        return $erreurs;
    92105}
    93106
    94 function formulaires_reviser_traiter_dist($objet, $id_objet, $id_version, $id_diff){
    95         $res = array('message_ok'=>'','editable'=>true);
     107function formulaires_reviser_traiter_dist($objet, $id_objet, $id_version, $id_diff) {
     108        $res = array('message_ok' => '', 'editable' => true);
    96109
    97110        $id_version = _request('id_version');
    98111        $id_diff = _request('id_diff');
    99112
    100         if (_AJAX)
    101                 $res['message_ok'].="<script type='text/javascript'>if (window.jQuery) jQuery('#wysiwyg.revision').ajaxReload({args:{id_version:$id_version,id_diff:$id_diff},history:true});</script>";
    102         else
    103                 $res['redirect'] = parametre_url(parametre_url(self(),'id_version',$id_version),'id_diff',$id_diff,'&');
     113        if (_AJAX) {
     114                $res['message_ok'] .= "<script type='text/javascript'>if (window.jQuery) jQuery('#wysiwyg.revision').ajaxReload({args:{id_version:$id_version,id_diff:$id_diff},history:true});</script>";
     115        } else {
     116                $res['redirect'] = parametre_url(parametre_url(self(), 'id_version', $id_version), 'id_diff', $id_diff, '&');
     117        }
     118
    104119        return $res;
    105120}
  • _core_/plugins/revisions/genie/optimiser_revisions.php

    r92827 r93622  
    1616 */
    1717
    18 if (!defined('_ECRIRE_INC_VERSION')) return;
     18if (!defined('_ECRIRE_INC_VERSION')) {
     19        return;
     20}
    1921
    2022include_spip('base/abstract_sql');
     
    2224/**
    2325 * Tâche Cron d'optimisation des révisions
    24  * 
     26 *
    2527 * @param int $last
    2628 *     Timestamp de la dernière exécution de cette tâche
     
    3234        optimiser_base_revisions();
    3335        optimiser_tables_revision();
    34        
     36
    3537        return 1;
    3638}
    3739
    3840/**
    39  * Supprimer les révisions des objets disparus 
     41 * Supprimer les révisions des objets disparus
    4042 */
    41 function optimiser_base_revisions(){
     43function optimiser_base_revisions() {
    4244        /**
    4345         * On commence par récupérer la liste des types d'objet ayant au moins une révision
    44          */ 
    45         $objets_revises = sql_select('objet','spip_versions','id_version=1','objet');
    46        
     46         */
     47        $objets_revises = sql_select('objet', 'spip_versions', 'id_version=1', 'objet');
     48
    4749        /**
    4850         * Pour chaque objet, on va contruire un tableau des identifiants disparus
    4951         * On supprimera ensuite les occurences dans spip_versions et spip_versions_fragments
    5052         */
    51         while ($objet = sql_fetch($objets_revises)){
     53        while ($objet = sql_fetch($objets_revises)) {
    5254                $in = array();
    5355                $table = table_objet_sql($objet['objet']);
    5456                $id_table_objet = id_table_objet($objet['objet']);
    5557                $res = sql_select("A.id_objet AS id_objet, A.objet AS objet",
    56                                                         "spip_versions AS A LEFT JOIN $table AS R
    57                                                         ON R.$id_table_objet=A.id_objet AND A.objet=".sql_quote($objet['objet']),
    58                                                         "R.$id_table_objet IS NULL AND A.objet=".sql_quote($objet['objet'])." AND A.id_objet > 0",
    59                                                         "A.id_objet",
    60                                                         "A.id_objet");
     58                        "spip_versions AS A LEFT JOIN $table AS R
     59                                                        ON R.$id_table_objet=A.id_objet AND A.objet=" . sql_quote($objet['objet']),
     60                        "R.$id_table_objet IS NULL AND A.objet=" . sql_quote($objet['objet']) . " AND A.id_objet > 0",
     61                        "A.id_objet",
     62                        "A.id_objet");
    6163
    6264                while ($row = sql_fetch($res)) {
     
    6769                /**
    6870                 * Si on a un array
    69                  * On supprime toute occurence des objets disparus dans : 
     71                 * On supprime toute occurence des objets disparus dans :
    7072                 * -* spip_versions
    7173                 * -* spip_versions_fragments
    7274                 */
    7375                if ($in) {
    74                         foreach(array('spip_versions','spip_versions_fragments') as $table){
    75                                 sql_delete($table,  sql_in('id_objet',array_keys($in)) . " AND objet=".sql_quote($objet['objet']));
     76                        foreach (array('spip_versions', 'spip_versions_fragments') as $table) {
     77                                sql_delete($table, sql_in('id_objet', array_keys($in)) . " AND objet=" . sql_quote($objet['objet']));
    7678                        }
    7779                }
     
    8284 * Optimisation des tables spip_versions et spip_versions_fragments
    8385 */
    84 function optimiser_tables_revision(){
    85         foreach(array('spip_versions','spip_versions_fragments') as $table){
     86function optimiser_tables_revision() {
     87        foreach (array('spip_versions', 'spip_versions_fragments') as $table) {
    8688                spip_log("debut d'optimisation de la table $table");
    87                 if (sql_optimize($table))
     89                if (sql_optimize($table)) {
    8890                        spip_log("fin d'optimisation de la table $table");
    89                 else
     91                } else {
    9092                        spip_log("Pas d'optimiseur necessaire pour $table");
     93                }
    9194        }
    9295}
     96
    9397?>
  • _core_/plugins/revisions/inc/diff.php

    r93105 r93622  
    1515 *
    1616 * @package SPIP\Revisions\Diff
    17 **/
    18 
    19 if (!defined("_ECRIRE_INC_VERSION")) return;
     17 **/
     18
     19if (!defined("_ECRIRE_INC_VERSION")) {
     20        return;
     21}
    2022
    2123
     
    2426
    2527/**
    26  * Calcule un LCS (Longest Common Subsequence) simplifié 
     28 * Calcule un LCS (Longest Common Subsequence) simplifié
    2729 *
    2830 * Chaque chaîne est une permutation de l'autre et on passe en paramètre
     
    3234 * @param array $s
    3335 * @return array
    34 **/
     36 **/
    3537function lcs_opt($s) {
    3638        $n = count($s);
    37         if (!$n) return array();
     39        if (!$n) {
     40                return array();
     41        }
    3842        $paths = array();
    3943        $paths_ymin = array();
     
    4448        $max = 400;
    4549        foreach ($s as $y => $c) {
    46                 if ($max-- < 0) break;  # eviter l'explosion memoire des tres gros diff
     50                if ($max-- < 0) {
     51                        break;
     52                }  # eviter l'explosion memoire des tres gros diff
    4753                for ($len = $max_len; $len > 0; $len--) {
    4854                        if ($paths_ymin[$len] < $y) {
    49                                 $paths_ymin[$len + 1] = $y;
    50                                 $paths[$len + 1] = $paths[$len];
    51                                 $paths[$len + 1][$y] = $c;
     55                                $paths_ymin[$len+1] = $y;
     56                                $paths[$len+1] = $paths[$len];
     57                                $paths[$len+1][$y] = $c;
    5258                                break;
    5359                        }
     
    5763                        $paths[1] = array($y => $c);
    5864                }
    59                 if ($len + 1 > $max_len) $max_len = $len + 1;
    60         }
     65                if ($len+1 > $max_len) {
     66                        $max_len = $len+1;
     67                }
     68        }
     69
    6170        return $paths[$max_len];
    6271}
     
    7180 * @param array $t
    7281 * @return array
    73 **/
     82 **/
    7483function lcs($s, $t) {
    7584        $n = count($s);
    7685        $p = count($t);
    77         if (!$n || !$p) return array(0 => array(), 1 => array());
     86        if (!$n || !$p) {
     87                return array(0 => array(), 1 => array());
     88        }
    7889        $paths = array();
    7990        $paths_ymin = array();
     
    8293
    8394        // Insertion des points
    84         foreach ($t as $y => $c) $t_pos[trim($c)][] = $y;
     95        foreach ($t as $y => $c) {
     96                $t_pos[trim($c)][] = $y;
     97        }
    8598
    8699        foreach ($s as $x => $c) {
    87100                $c = trim($c);
    88                 if (!isset($t_pos[$c])) continue;
     101                if (!isset($t_pos[$c])) {
     102                        continue;
     103                }
    89104                krsort($t_pos[$c]);
    90105                foreach ($t_pos[$c] as $y) {
    91106                        for ($len = $max_len; $len > 0; $len--) {
    92107                                if ($paths_ymin[$len] < $y) {
    93                                         $paths_ymin[$len + 1] = $y;
     108                                        $paths_ymin[$len+1] = $y;
    94109                                        // On construit le resultat sous forme de chaine d'abord,
    95110                                        // car les tableaux de PHP sont dispendieux en taille memoire
    96                                         $paths[$len + 1] = $paths[$len]." $x,$y";
     111                                        $paths[$len+1] = $paths[$len] . " $x,$y";
    97112                                        break;
    98113                                }
    99114                        }
    100                         if ($len + 1 > $max_len) $max_len = $len + 1;
     115                        if ($len+1 > $max_len) {
     116                                $max_len = $len+1;
     117                        }
    101118                        if ($len == 0) {
    102119                                $paths_ymin[1] = $y;
     
    113130                        $v[$y] = $x;
    114131                }
     132
    115133                return array($u, $v);
    116134        }
     135
    117136        return array(0 => array(), 1 => array());
    118137}
     
    122141 *
    123142 * @package SPIP\Revisions\Diff
    124 **/
     143 **/
    125144class Diff {
    126145        /**
    127146         * Objet DiffX d'un texte ou partie de texte
    128          *
    129          * @var Object Objet Diff* (DiffTexte, DiffPara, DiffPhrase) */
     147         *
     148         * @var Object Objet Diff* (DiffTexte, DiffPara, DiffPhrase)
     149         */
    130150        var $diff;
    131151        var $fuzzy;
    132152
    133153        /**
    134          * Constructeur 
     154         * Constructeur
    135155         *
    136          * @param Object $diff    Objet Diff* d'un texte ou morceau de texte
    137         **/
     156         * @param Object $diff Objet Diff* d'un texte ou morceau de texte
     157         **/
    138158        function __construct($diff) {
    139159                $this->diff = $diff;
     
    149169                        $lcs = lcs_opt($trans);
    150170                        $lcs_rev = array_flip($lcs);
    151                 }
    152                 else {
     171                } else {
    153172                        list($trans_rev, $trans) = lcs($paras_old, $paras);
    154173                        $lcs = $trans;
    155174                        $lcs_rev = $trans_rev;
    156175                }
    157        
     176
    158177                reset($paras_old);
    159178                reset($paras);
     
    177196                                if (!isset($i_old)) {
    178197                                        list($i_old, $p_old) = each($paras_old);
    179                                         if (!$p_old) $fin_old = true;
     198                                        if (!$p_old) {
     199                                                $fin_old = true;
     200                                        }
    180201                                }
    181202                                while (!$fin_old && $i_old < $j) {
     
    185206                                        unset($i_old);
    186207                                        list($i_old, $p_old) = each($paras_old);
    187                                         if (!$p_old) $fin_old = true;
     208                                        if (!$p_old) {
     209                                                $fin_old = true;
     210                                        }
    188211                                }
    189212                        }
     
    195218                        if (!isset($i_old)) {
    196219                                list($i_old, $p_old) = each($paras_old);
    197                                 if (!strlen($p_old)) $fin_old = true;
     220                                if (!strlen($p_old)) {
     221                                        $fin_old = true;
     222                                }
    198223                        }
    199224                        while (!$fin_old) {
     
    202227                                }
    203228                                list($i_old, $p_old) = each($paras_old);
    204                                 if (!$p_old) $fin_old = true;
     229                                if (!$p_old) {
     230                                        $fin_old = true;
     231                                }
    205232                        }
    206233                }
     
    210237                        }
    211238                }
     239
    212240                return $this->diff->resultat();
    213241        }
     
    218246 *
    219247 * @package SPIP\Revisions\Diff
    220 **/
     248 **/
    221249class DiffTexte {
    222250        var $r;
    223251
    224252        /**
    225          * Constructeur 
    226         **/
     253         * Constructeur
     254         **/
    227255        function __construct() {
    228256                $this->r = "";
     
    232260        function _diff($p, $p_old) {
    233261                $diff = new Diff(new DiffPara);
     262
    234263                return $diff->comparer($p, $p_old);
    235264        }
     
    241270
    242271        /**
    243          * Découper les paragraphes d'un texte en fragments 
     272         * Découper les paragraphes d'un texte en fragments
    244273         *
    245          * @param string $texte   Texte à fragmenter
     274         * @param string $texte Texte à fragmenter
    246275         * @return string[]       Tableau de fragments (paragraphes)
    247         **/
     276         **/
    248277        function segmenter($texte) {
    249278                return separer_paras($texte);
     
    254283        function ajouter($p) {
    255284                $p = trim($p);
    256                 $this->r .= "\n\n\n<span class=\"diff-para-ajoute\" title=\""._T('revisions:diff_para_ajoute')."\">".$p."</span rem=\"diff-\">";
    257         }
     285                $this->r .= "\n\n\n<span class=\"diff-para-ajoute\" title=\"" . _T('revisions:diff_para_ajoute') . "\">" . $p . "</span rem=\"diff-\">";
     286        }
     287
    258288// http://code.spip.net/@supprimer
    259289        function supprimer($p_old) {
    260290                $p_old = trim($p_old);
    261                 $this->r .= "\n\n\n<span class=\"diff-para-supprime\" title=\""._T('revisions:diff_para_supprime')."\">".$p_old."</span rem=\"diff-\">";
    262         }
     291                $this->r .= "\n\n\n<span class=\"diff-para-supprime\" title=\"" . _T('revisions:diff_para_supprime') . "\">" . $p_old . "</span rem=\"diff-\">";
     292        }
     293
    263294// http://code.spip.net/@deplacer
    264295        function deplacer($p, $p_old) {
    265                 $this->r .= "\n\n\n<span class=\"diff-para-deplace\" title=\""._T('revisions:diff_para_deplace')."\">";
     296                $this->r .= "\n\n\n<span class=\"diff-para-deplace\" title=\"" . _T('revisions:diff_para_deplace') . "\">";
    266297                $this->r .= trim($this->_diff($p, $p_old));
    267298                $this->r .= "</span rem=\"diff-\">";
    268299        }
     300
    269301// http://code.spip.net/@comparer
    270302        function comparer($p, $p_old) {
    271                 $this->r .= "\n\n\n".$this->_diff($p, $p_old);
    272         }
    273        
     303                $this->r .= "\n\n\n" . $this->_diff($p, $p_old);
     304        }
     305
    274306// http://code.spip.net/@resultat
    275307        function resultat() {
     
    282314 *
    283315 * @package SPIP\Revisions\Diff
    284 **/
     316 **/
    285317class DiffPara {
    286318        var $r;
     
    294326        function _diff($p, $p_old) {
    295327                $diff = new Diff(new DiffPhrase);
     328
    296329                return $diff->comparer($p, $p_old);
    297330        }
     
    301334                return true;
    302335        }
     336
    303337// http://code.spip.net/@segmenter
    304338        function segmenter($texte) {
     
    306340                $texte = trim($texte);
    307341                while (preg_match('/[\.!\?\]]+\s*/u', $texte, $regs)) {
    308                         $p = strpos($texte, $regs[0]) + strlen($regs[0]);
     342                        $p = strpos($texte, $regs[0])+strlen($regs[0]);
    309343                        $paras[] = substr($texte, 0, $p);
    310344                        $texte = substr($texte, $p);
    311345                }
    312                 if ($texte) $paras[] = $texte;
     346                if ($texte) {
     347                        $paras[] = $texte;
     348                }
     349
    313350                return $paras;
    314351        }
     
    316353// http://code.spip.net/@ajouter
    317354        function ajouter($p) {
    318                 $this->r .= "<span class=\"diff-ajoute\" title=\""._T('revisions:diff_texte_ajoute')."\">".$p."</span rem=\"diff-\">";
    319         }
     355                $this->r .= "<span class=\"diff-ajoute\" title=\"" . _T('revisions:diff_texte_ajoute') . "\">" . $p . "</span rem=\"diff-\">";
     356        }
     357
    320358// http://code.spip.net/@supprimer
    321359        function supprimer($p_old) {
    322                 $this->r .= "<span class=\"diff-supprime\" title=\""._T('revisions:diff_texte_supprime')."\">".$p_old."</span rem=\"diff-\">";
    323         }
     360                $this->r .= "<span class=\"diff-supprime\" title=\"" . _T('revisions:diff_texte_supprime') . "\">" . $p_old . "</span rem=\"diff-\">";
     361        }
     362
    324363// http://code.spip.net/@deplacer
    325364        function deplacer($p, $p_old) {
    326                 $this->r .= "<span class=\"diff-deplace\" title=\""._T('revisions:diff_texte_deplace')."\">".$this->_diff($p, $p_old)."</span rem=\"diff-\">";
    327         }
     365                $this->r .= "<span class=\"diff-deplace\" title=\"" . _T('revisions:diff_texte_deplace') . "\">" . $this->_diff($p,
     366                                $p_old) . "</span rem=\"diff-\">";
     367        }
     368
    328369// http://code.spip.net/@comparer
    329370        function comparer($p, $p_old) {
    330371                $this->r .= $this->_diff($p, $p_old);
    331372        }
    332        
     373
    333374// http://code.spip.net/@resultat
    334375        function resultat() {
     
    341382 *
    342383 * @package SPIP\Revisions\Diff
    343 **/
     384 **/
    344385class DiffPhrase {
    345386        var $r;
     
    354395                return false;
    355396        }
     397
    356398// http://code.spip.net/@segmenter
    357399        function segmenter($texte) {
    358400                $paras = array();
    359401                if (test_pcre_unicode()) {
    360                         $punct = '([[:punct:]]|'.plage_punct_unicode().')';
     402                        $punct = '([[:punct:]]|' . plage_punct_unicode() . ')';
    361403                        $mode = 'u';
    362                 }
    363                 else {
     404                } else {
    364405                        // Plages de poncutation pour preg_match bugge (ha ha)
    365                         $punct = '([^\w\s\x80-\xFF]|'.plage_punct_unicode().')';
     406                        $punct = '([^\w\s\x80-\xFF]|' . plage_punct_unicode() . ')';
    366407                        $mode = '';
    367408                }
    368                 $preg = '/('.$punct.'+)(\s+|$)|(\s+)('.$punct.'*)/'.$mode;
     409                $preg = '/(' . $punct . '+)(\s+|$)|(\s+)(' . $punct . '*)/' . $mode;
    369410                while (preg_match($preg, $texte, $regs)) {
    370411                        $p = strpos($texte, $regs[0]);
     
    376417                                if ($punct == '[[') {
    377418                                        $avant = substr($texte, 0, $p) . $regs[5] . $punct;
    378                                         $texte = $regs[4] . substr($texte, $p + $l);
    379                                 }
    380                                 else
    381                                 if ($punct == ']]') {
    382                                         $avant = substr($texte, 0, $p) . $regs[5] . $punct;
    383                                         $texte = substr($texte, $p + $l);
    384                                 }
    385                                 // Attacher les raccourcis fermants au mot precedent
    386                                 else
    387                                 if (preg_match(',^[\]}]+$,', $punct)) {
    388                                         $avant = substr($texte, 0, $p) . (isset($regs[5])?$regs[5]:'') . $punct;
    389                                         $texte = $regs[4] . substr($texte, $p + $l);
    390                                 }
    391                                 // Attacher les raccourcis ouvrants au mot suivant
    392                                 else if (isset($regs[5]) && $regs[5] && preg_match(',^[\[{]+$,', $punct)) {
    393                                         $avant = substr($texte, 0, $p) . $regs[5];
    394                                         $texte = $punct . substr($texte, $p + $l);
    395                                 }
    396                                 // Les autres signes de ponctuation sont des mots a part entiere
    397                                 else {
    398                                         $avant = substr($texte, 0, $p);
    399                                         $milieu = $regs[0];
    400                                         $texte = substr($texte, $p + $l);
    401                                 }
    402                         }
    403                         else {
    404                                 $avant = substr($texte, 0, $p + $l);
    405                                 $texte = substr($texte, $p + $l);
    406                         }
    407                         if ($avant) $paras[] = $avant;
    408                         if ($milieu) $paras[] = $milieu;
    409                 }
    410                 if ($texte) $paras[] = $texte;
     419                                        $texte = $regs[4] . substr($texte, $p+$l);
     420                                } else {
     421                                        if ($punct == ']]') {
     422                                                $avant = substr($texte, 0, $p) . $regs[5] . $punct;
     423                                                $texte = substr($texte, $p+$l);
     424                                        } // Attacher les raccourcis fermants au mot precedent
     425                                        else {
     426                                                if (preg_match(',^[\]}]+$,', $punct)) {
     427                                                        $avant = substr($texte, 0, $p) . (isset($regs[5]) ? $regs[5] : '') . $punct;
     428                                                        $texte = $regs[4] . substr($texte, $p+$l);
     429                                                } // Attacher les raccourcis ouvrants au mot suivant
     430                                                else {
     431                                                        if (isset($regs[5]) && $regs[5] && preg_match(',^[\[{]+$,', $punct)) {
     432                                                                $avant = substr($texte, 0, $p) . $regs[5];
     433                                                                $texte = $punct . substr($texte, $p+$l);
     434                                                        } // Les autres signes de ponctuation sont des mots a part entiere
     435                                                        else {
     436                                                                $avant = substr($texte, 0, $p);
     437                                                                $milieu = $regs[0];
     438                                                                $texte = substr($texte, $p+$l);
     439                                                        }
     440                                                }
     441                                        }
     442                                }
     443                        } else {
     444                                $avant = substr($texte, 0, $p+$l);
     445                                $texte = substr($texte, $p+$l);
     446                        }
     447                        if ($avant) {
     448                                $paras[] = $avant;
     449                        }
     450                        if ($milieu) {
     451                                $paras[] = $milieu;
     452                        }
     453                }
     454                if ($texte) {
     455                        $paras[] = $texte;
     456                }
     457
    411458                return $paras;
    412459        }
     
    414461// http://code.spip.net/@ajouter
    415462        function ajouter($p) {
    416                 $this->r .= "<span class=\"diff-ajoute\" title=\""._T('revisions:diff_texte_ajoute')."\">".$p."</span rem=\"diff-\"> ";
    417         }
     463                $this->r .= "<span class=\"diff-ajoute\" title=\"" . _T('revisions:diff_texte_ajoute') . "\">" . $p . "</span rem=\"diff-\"> ";
     464        }
     465
    418466// http://code.spip.net/@supprimer
    419467        function supprimer($p_old) {
    420                 $this->r .= "<span class=\"diff-supprime\" title=\""._T('revisions:diff_texte_supprime')."\">".$p_old."</span rem=\"diff-\"> ";
    421         }
     468                $this->r .= "<span class=\"diff-supprime\" title=\"" . _T('revisions:diff_texte_supprime') . "\">" . $p_old . "</span rem=\"diff-\"> ";
     469        }
     470
    422471// http://code.spip.net/@comparer
    423472        function comparer($p, $p_old) {
     
    437486
    438487        $charset = $GLOBALS['meta']['charset'];
    439         if ($charset == 'utf-8')
     488        if ($charset == 'utf-8') {
    440489                return unicode_to_utf_8(html2unicode($texte));
     490        }
     491
    441492        return unicode_to_utf_8(html2unicode(charset2unicode($texte, $charset, true)));
    442493}
     
    445496function afficher_diff($texte) {
    446497        $charset = $GLOBALS['meta']['charset'];
    447         if ($charset == 'utf-8') return $texte;
     498        if ($charset == 'utf-8') {
     499                return $texte;
     500        }
     501
    448502        return charset2unicode($texte, 'utf-8');
    449503}
  • _core_/plugins/revisions/inc/revisions.php

    r93092 r93622  
    1515 *
    1616 * @package SPIP\Revisions\Fonctions
    17 **/
    18 if (!defined("_ECRIRE_INC_VERSION")) return;
     17 **/
     18if (!defined("_ECRIRE_INC_VERSION")) {
     19        return;
     20}
    1921
    2022$GLOBALS['agregation_versions'] = 10;
    2123
    2224/** Intervalle de temps (en seconde) separant deux révisions par un même auteur */
    23 define('_INTERVALLE_REVISIONS', 600); 
     25define('_INTERVALLE_REVISIONS', 600);
    2426
    2527/**
    26  * Découper les paragraphes d'un texte en fragments 
    27  *
    28  * @param string $texte  Texte à fragmenter
    29  * @param array $paras   Tableau de fragments déjà là
     28 * Découper les paragraphes d'un texte en fragments
     29 *
     30 * @param string $texte Texte à fragmenter
     31 * @param array $paras Tableau de fragments déjà là
    3032 * @return string[]      Tableau de fragments (paragraphes)
    31 **/
     33 **/
    3234function separer_paras($texte, $paras = array()) {
    33         if (!$paras) $paras = array();
     35        if (!$paras) {
     36                $paras = array();
     37        }
    3438        while (preg_match("/(\r\n?){2,}|\n{2,}/", $texte, $regs)) {
    35                 $p = strpos($texte, $regs[0]) + strlen($regs[0]);
     39                $p = strpos($texte, $regs[0])+strlen($regs[0]);
    3640                $paras[] = substr($texte, 0, $p);
    3741                $texte = substr($texte, $p);
    3842        }
    39         if ($texte) $paras[] = $texte;
     43        if ($texte) {
     44                $paras[] = $texte;
     45        }
     46
    4047        return $paras;
    4148}
     
    6471        // Attention a echapper $fragment, binaire potentiellement gz
    6572        return array(
    66                      'id_objet' => intval($id_objet),
    67                          'objet' => $objet,
    68                      'id_fragment' => intval($id_fragment),
    69                      'version_min' => intval($version_min),
    70                      'version_max' => intval($version_max),
    71                      'compress' => $compress,
    72                      'fragment' => $fragment);
     73                'id_objet' => intval($id_objet),
     74                'objet' => $objet,
     75                'id_fragment' => intval($id_fragment),
     76                'version_min' => intval($version_min),
     77                'version_max' => intval($version_max),
     78                'compress' => $compress,
     79                'fragment' => $fragment
     80        );
    7381}
    7482
     
    7684function envoi_replace_fragments($replaces) {
    7785        $desc = $GLOBALS['tables_auxiliaires']['spip_versions_fragments'];
    78         foreach($replaces as $r)
     86        foreach ($replaces as $r) {
    7987                sql_replace('spip_versions_fragments', $r, $desc);
     88        }
    8089}
    8190
     
    8493function envoi_delete_fragments($id_objet, $objet, $deletes) {
    8594        if (count($deletes)) {
    86                 sql_delete("spip_versions_fragments", "id_objet=".intval($id_objet)." AND objet=".sql_quote($objet)." AND ((".  join(") OR (", $deletes)."))");
     95                sql_delete("spip_versions_fragments",
     96                        "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet) . " AND ((" . join(") OR (",
     97                                $deletes) . "))");
    8798        }
    8899}
     
    100111                $nouveau = true;
    101112                // Recuperer la version la plus recente
    102                 $row = sql_fetsel("compress, fragment, version_min, version_max", "spip_versions_fragments", "id_objet=".intval($id_objet)." AND objet=".sql_quote($objet)." AND id_fragment=$id_fragment AND version_min<=$id_version", "", "version_min DESC", "1");
     113                $row = sql_fetsel("compress, fragment, version_min, version_max", "spip_versions_fragments",
     114                        "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet) . " AND id_fragment=$id_fragment AND version_min<=$id_version",
     115                        "", "version_min DESC", "1");
    103116
    104117                if ($row) {
    105118                        $fragment = $row['fragment'];
    106119                        $version_min = $row['version_min'];
    107                         if ($row['compress'] > 0) $fragment = @gzuncompress($fragment);
     120                        if ($row['compress'] > 0) {
     121                                $fragment = @gzuncompress($fragment);
     122                        }
    108123                        $fragment = unserialize($fragment);
    109124                        if (is_array($fragment)) {
     
    117132                        $fragment = array($id_version => $texte);
    118133                        $version_min = $id_version;
    119                 }
    120                 else {
     134                } else {
    121135                        // Ne pas dupliquer les fragments non modifies
    122136                        $modif = true;
    123                         for ($i = $id_version - 1; $i >= $version_min; $i--) {
     137                        for ($i = $id_version-1; $i >= $version_min; $i--) {
    124138                                if (isset($fragment[$i])) {
    125139                                        $modif = ($fragment[$i] != $texte);
     
    127141                                }
    128142                        }
    129                         if ($modif) $fragment[$id_version] = $texte;
     143                        if ($modif) {
     144                                $fragment[$id_version] = $texte;
     145                        }
    130146                }
    131147
    132148                // Preparer l'enregistrement du fragment
    133                 $replaces[] = replace_fragment($id_objet,$objet, $version_min, $id_version, $id_fragment, $fragment);
     149                $replaces[] = replace_fragment($id_objet, $objet, $version_min, $id_version, $id_fragment, $fragment);
    134150        }
    135151
     
    149165
    150166        // D'abord, vider les fragments inutiles
    151         sql_delete("spip_versions_fragments", "id_objet=".intval($id_objet)." AND objet=".sql_quote($objet)." AND version_min>=$version_debut AND version_max<=$version_fin");
     167        sql_delete("spip_versions_fragments",
     168                "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet) . " AND version_min>=$version_debut AND version_max<=$version_fin");
    152169
    153170        // Fragments chevauchant l'ensemble de l'intervalle, s'ils existent
    154         $result = sql_select("id_fragment, compress, fragment, version_min, version_max", "spip_versions_fragments", "id_objet=".intval($id_objet)." AND objet=".sql_quote($objet)." AND version_min<$version_debut AND version_max>$version_fin");
     171        $result = sql_select("id_fragment, compress, fragment, version_min, version_max", "spip_versions_fragments",
     172                "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet) . " AND version_min<$version_debut AND version_max>$version_fin");
    155173
    156174        while ($row = sql_fetch($result)) {
    157175                $id_fragment = $row['id_fragment'];
    158176                $fragment = $row['fragment'];
    159                 if ($row['compress'] > 0) $fragment = gzuncompress($fragment);
     177                if ($row['compress'] > 0) {
     178                        $fragment = gzuncompress($fragment);
     179                }
    160180                $fragment = unserialize($fragment);
    161181                for ($i = $version_fin; $i >= $version_debut; $i--) {
    162182                        if (isset($fragment[$i])) {
    163183                                // Recopier le dernier fragment si implicite
    164                                 if (!isset($fragment[$version_fin + 1]))
    165                                         $fragment[$version_fin + 1] = $fragment[$i];
     184                                if (!isset($fragment[$version_fin+1])) {
     185                                        $fragment[$version_fin+1] = $fragment[$i];
     186                                }
    166187                                unset($fragment[$i]);
    167188                        }
    168189                }
    169190
    170                 $replaces[] = replace_fragment($id_objet,$objet,
     191                $replaces[] = replace_fragment($id_objet, $objet,
    171192                        $row['version_min'], $row['version_max'], $id_fragment, $fragment);
    172193        }
    173194
    174195        // Fragments chevauchant le debut de l'intervalle, s'ils existent
    175         $result = sql_select("id_fragment, compress, fragment, version_min, version_max", "spip_versions_fragments", "id_objet=".intval($id_objet)." AND objet=".sql_quote($objet)." AND version_min<$version_debut AND version_max>=$version_debut AND version_max<=$version_fin");
     196        $result = sql_select("id_fragment, compress, fragment, version_min, version_max", "spip_versions_fragments",
     197                "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet) . " AND version_min<$version_debut AND version_max>=$version_debut AND version_max<=$version_fin");
    176198
    177199        $deb_fragment = array();
     
    181203                $version_min = $row['version_min'];
    182204                $version_max = $row['version_max'];
    183                 if ($row['compress'] > 0) $fragment = gzuncompress($fragment);
     205                if ($row['compress'] > 0) {
     206                        $fragment = gzuncompress($fragment);
     207                }
    184208                $fragment = unserialize($fragment);
    185209                for ($i = $version_debut; $i <= $version_max; $i++) {
    186                         if (isset($fragment[$i])) unset($fragment[$i]);
     210                        if (isset($fragment[$i])) {
     211                                unset($fragment[$i]);
     212                        }
    187213                }
    188214
     
    191217                // Ajuster l'intervalle des versions
    192218                $deb_version_min[$id_fragment] = $version_min;
    193                 $deb_version_max[$id_fragment] = $version_debut - 1;
     219                $deb_version_max[$id_fragment] = $version_debut-1;
    194220        }
    195221
    196222        // Fragments chevauchant la fin de l'intervalle, s'ils existent
    197         $result = sql_select("id_fragment, compress, fragment, version_min, version_max", "spip_versions_fragments", "id_objet=".intval($id_objet)." AND objet=".sql_quote($objet)." AND version_max>$version_fin AND version_min>=$version_debut AND version_min<=$version_fin");
     223        $result = sql_select("id_fragment, compress, fragment, version_min, version_max", "spip_versions_fragments",
     224                "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet) . " AND version_max>$version_fin AND version_min>=$version_debut AND version_min<=$version_fin");
    198225
    199226        while ($row = sql_fetch($result)) {
     
    202229                $version_min = $row['version_min'];
    203230                $version_max = $row['version_max'];
    204                 if ($row['compress'] > 0) $fragment = gzuncompress($fragment);
     231                if ($row['compress'] > 0) {
     232                        $fragment = gzuncompress($fragment);
     233                }
    205234                $fragment = unserialize($fragment);
    206235                for ($i = $version_fin; $i >= $version_min; $i--) {
    207236                        if (isset($fragment[$i])) {
    208237                                // Recopier le dernier fragment si implicite
    209                                 if (!isset($fragment[$version_fin + 1]))
    210                                         $fragment[$version_fin + 1] = $fragment[$i];
     238                                if (!isset($fragment[$version_fin+1])) {
     239                                        $fragment[$version_fin+1] = $fragment[$i];
     240                                }
    211241                                unset($fragment[$i]);
    212242                        }
     
    218248                $agreger = false;
    219249                if (isset($deb_fragment[$id_fragment])) {
    220                         $agreger = (count($deb_fragment[$id_fragment]) + count($fragment) <= $agregation_versions);
     250                        $agreger = (count($deb_fragment[$id_fragment])+count($fragment) <= $agregation_versions);
    221251                        if ($agreger) {
    222                                 $fragment = $deb_fragment[$id_fragment] + $fragment;
     252                                $fragment = $deb_fragment[$id_fragment]+$fragment;
    223253                                $version_min = $deb_version_min[$id_fragment];
    224                         }
    225                         else {
    226                                 $replaces[] = replace_fragment($id_objet,$objet,
     254                        } else {
     255                                $replaces[] = replace_fragment($id_objet, $objet,
    227256                                        $deb_version_min[$id_fragment], $deb_version_max[$id_fragment],
    228257                                        $id_fragment, $deb_fragment[$id_fragment]);
     
    232261                if (!$agreger) {
    233262                        // Ajuster l'intervalle des versions
    234                         $version_min = $version_fin + 1;
     263                        $version_min = $version_fin+1;
    235264                }
    236265                $replaces[] = replace_fragment($id_objet, $objet, $version_min, $version_max, $id_fragment, $fragment);
     
    240269        if (is_array($deb_fragment) && count($deb_fragment) > 0) {
    241270                foreach ($deb_fragment as $id_fragment => $fragment) {
    242                         $replaces[] = replace_fragment($id_objet,$objet,
     271                        $replaces[] = replace_fragment($id_objet, $objet,
    243272                                $deb_version_min[$id_fragment], $deb_version_max[$id_fragment],
    244273                                $id_fragment, $deb_fragment[$id_fragment]);
     
    247276
    248277        envoi_replace_fragments($replaces);
    249         envoi_delete_fragments($id_objet,$objet, $deletes);
     278        envoi_delete_fragments($id_objet, $objet, $deletes);
    250279}
    251280
     
    254283 * Récupérer les fragments d'un objet pour une version demandée
    255284 *
    256  * @param int $id_objet    Identifiant de l'objet
    257  * @param string $objet    Objet
    258  * @param int $id_version  Identifiant de la version
     285 * @param int $id_objet Identifiant de l'objet
     286 * @param string $objet Objet
     287 * @param int $id_version Identifiant de la version
    259288 * @return array           Couples id_fragment => texte
    260289 */
     
    262291        $fragments = array();
    263292
    264         if ($id_version == 0) return array();
     293        if ($id_version == 0) {
     294                return array();
     295        }
    265296
    266297        $result = sql_select(
    267298                "id_fragment, version_min, version_max, compress, fragment",
    268299                "spip_versions_fragments",
    269                 "id_objet=" . intval($id_objet) ." AND objet=".sql_quote($objet)
    270                         ." AND version_min<=$id_version AND version_max>=$id_version");
     300                "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet)
     301                . " AND version_min<=$id_version AND version_max>=$id_version");
    271302
    272303        while ($row = sql_fetch($result)) {
     
    275306                $fragment = $row['fragment'];
    276307                // si le fragment est compressé, tenter de le décompresser, sinon écrire une erreur
    277                 if ($row['compress'] > 0){
     308                if ($row['compress'] > 0) {
    278309                        $fragment_ = @gzuncompress($fragment);
    279                         if (strlen($fragment) && $fragment_===false){
     310                        if (strlen($fragment) && $fragment_ === false) {
    280311                                $fragment = serialize(array($row['version_max'] => "[" . _T('forum_titre_erreur') . $id_fragment . "]"));
    281                         }
    282                         else
    283                          $fragment = $fragment_;
     312                        } else {
     313                                $fragment = $fragment_;
     314                        }
    284315                }
    285316                // tenter dedésérialiser le fragment, sinon écrire une erreur
    286317                $fragment_ = unserialize($fragment);
    287                 if (strlen($fragment) && $fragment_===false){
    288                         $fragment=array($row['version_max']=>"["._T('forum_titre_erreur').$id_fragment."]");
    289                 }
    290                 else
    291                  $fragment = $fragment_;
     318                if (strlen($fragment) && $fragment_ === false) {
     319                        $fragment = array($row['version_max'] => "[" . _T('forum_titre_erreur') . $id_fragment . "]");
     320                } else {
     321                        $fragment = $fragment_;
     322                }
    292323                // on retrouve le fragment le plus près de notre version
    293324                for ($i = $id_version; $i >= $version_min; $i--) {
     
    299330                                ## la situation n'est pas meilleure ni pire qu'avant)
    300331                                if ($GLOBALS['meta']['charset'] == 'utf-8'
    301                                 AND include_spip('inc/charsets')
    302                                 AND !is_utf8($fragment[$i])) {
     332                                        AND include_spip('inc/charsets')
     333                                        AND !is_utf8($fragment[$i])
     334                                ) {
    303335                                        $fragment[$i] = importer_charset($fragment[$i], 'iso-8859-1');
    304336                                }
     
    310342                }
    311343        }
     344
    312345        return $fragments;
    313346}
     
    331364
    332365        // Nettoyage de la ponctuation pour faciliter l'appariement
    333         foreach($src as $key => $val) {
     366        foreach ($src as $key => $val) {
    334367                $t1[$key] = strval(preg_replace("/[[:punct:][:space:]]+/", " ", $val));
    335368        }
    336         foreach($dest as $key => $val) {
     369        foreach ($dest as $key => $val) {
    337370                $t2[$key] = strval(preg_replace("/[[:punct:][:space:]]+/", " ", $val));
    338371        }
    339372
    340373        // Premiere passe : chercher les correspondance exactes
    341         foreach($t1 as $key => $val) $md1[$key] = md5($val);
    342         foreach($t2 as $key => $val) $md2[md5($val)][$key] = $key;
    343         foreach($md1 as $key1 => $h) {
     374        foreach ($t1 as $key => $val) {
     375                $md1[$key] = md5($val);
     376        }
     377        foreach ($t2 as $key => $val) {
     378                $md2[md5($val)][$key] = $key;
     379        }
     380        foreach ($md1 as $key1 => $h) {
    344381                if (isset($md2[$h])) {
    345382                        $key2 = reset($md2[$h]);
     
    356393        if ($flou) {
    357394                // Deuxieme passe : recherche de correlation par test de compressibilite
    358                 foreach($t1 as $key => $val) {
     395                foreach ($t1 as $key => $val) {
    359396                        $l1[$key] = strlen(gzcompress($val));
    360397                }
    361                 foreach($t2 as $key => $val) {
     398                foreach ($t2 as $key => $val) {
    362399                        $l2[$key] = strlen(gzcompress($val));
    363400                }
    364                 foreach($t1 as $key1 => $s1) {
    365                         foreach($t2 as $key2 => $s2) {
    366                                 $r = strlen(gzcompress($s1.$s2));
    367                                 $taux = 1.0 * $r / ($l1[$key1] + $l2[$key2]);
     401                foreach ($t1 as $key1 => $s1) {
     402                        foreach ($t2 as $key2 => $s2) {
     403                                $r = strlen(gzcompress($s1 . $s2));
     404                                $taux = 1.0*$r/($l1[$key1]+$l2[$key2]);
    368405                                if (!isset($gz_min1[$key1]) || !$gz_min1[$key1] || $gz_min1[$key1] > $taux) {
    369406                                        $gz_min1[$key1] = $taux;
    370407                                        $gz_trans1[$key1] = $key2;
    371408                                }
    372                                 if (!isset($gz_min2[$key2]) ||!$gz_min2[$key2] || $gz_min2[$key2] > $taux) {
     409                                if (!isset($gz_min2[$key2]) || !$gz_min2[$key2] || $gz_min2[$key2] > $taux) {
    373410                                        $gz_min2[$key2] = $taux;
    374411                                        $gz_trans2[$key2] = $key1;
     
    379416                // Depouiller les resultats de la deuxieme passe :
    380417                // ne retenir que les correlations reciproques
    381                 foreach($gz_trans1 as $key1 => $key2) {
     418                foreach ($gz_trans1 as $key1 => $key2) {
    382419                        if ($gz_trans2[$key2] == $key1 && $gz_min1[$key1] < 0.9) {
    383420                                $src_dest[$key1] = $key2;
     
    395432 * Récupérer les champs d'un objet, pour une version demandée
    396433 *
    397  * @param int $id_objet    Identifiant de l'objet
    398  * @param string $objet    Objet
    399  * @param int $id_version  Identifiant de la version
     434 * @param int $id_objet Identifiant de l'objet
     435 * @param string $objet Objet
     436 * @param int $id_version Identifiant de la version
    400437 * @return array           Couples champs => textes
    401438 */
    402439function recuperer_version($id_objet, $objet, $id_version) {
    403440
    404         $champs = sql_getfetsel("champs", "spip_versions", "id_objet=" . intval($id_objet) . " AND objet=".sql_quote($objet)." AND id_version=" . intval($id_version));
    405         if (!$champs OR !is_array($champs = unserialize($champs)))
     441        $champs = sql_getfetsel("champs", "spip_versions",
     442                "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet) . " AND id_version=" . intval($id_version));
     443        if (!$champs OR !is_array($champs = unserialize($champs))) {
    406444                return array();
    407         else return reconstuire_version($champs,
    408                          recuperer_fragments($id_objet,$objet, $id_version));
     445        } else {
     446                return reconstuire_version($champs,
     447                        recuperer_fragments($id_objet, $objet, $id_version));
     448        }
    409449}
    410450
     
    415455 * retourne le texte de chaque champ.
    416456 *
    417  * @param array $champs     Couples (champ => liste d'id_fragment).
     457 * @param array $champs Couples (champ => liste d'id_fragment).
    418458 *                          La liste est de la forme "5 32 7 16 8 2"
    419  * @param array $fragments  Couples (id_fragment => texte)
    420  * @param array $res        Couples (champ => texte) déjà connus
     459 * @param array $fragments Couples (id_fragment => texte)
     460 * @param array $res Couples (champ => texte) déjà connus
    421461 * @return array            Couples (champ => texte)
    422462 */
     
    424464
    425465        static $msg;
    426         if (!$msg) $msg = _T('forum_titre_erreur');
     466        if (!$msg) {
     467                $msg = _T('forum_titre_erreur');
     468        }
    427469
    428470        foreach ($champs as $nom => $code) {
     
    437479                }
    438480        }
     481
    439482        return $res;
    440483}
     
    442485// http://code.spip.net/@supprimer_versions
    443486function supprimer_versions($id_objet, $objet, $version_min, $version_max) {
    444         sql_delete("spip_versions", "id_objet=".intval($id_objet)." AND objet=".sql_quote($objet)." AND id_version>=$version_min AND id_version<=$version_max");
    445 
    446         supprimer_fragments($id_objet,$objet, $version_min, $version_max);
     487        sql_delete("spip_versions",
     488                "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet) . " AND id_version>=$version_min AND id_version<=$version_max");
     489
     490        supprimer_fragments($id_objet, $objet, $version_min, $version_max);
    447491}
    448492
     
    459503 *     Auteur apportant les modifications. En absence (session anonyme), utilisera l'IP pour garder une trace.
    460504 * @return int
    461  *     id_version : identifiant de la version 
    462 **/
     505 *     id_version : identifiant de la version
     506 **/
    463507function ajouter_version($id_objet, $objet, $champs, $titre_version = "", $id_auteur = null) {
    464508        $paras = $paras_old = $paras_champ = $fragments = array();
     
    475519        // Detruire les tentatives d'archivages non abouties en 1 heure
    476520        sql_delete('spip_versions', array(
    477                 "id_objet=" . intval($id_objet),
    478                 "objet=" . sql_quote($objet),
    479                 "id_version <= 0",
    480                 "date < DATE_SUB(" . sql_quote(date('Y-m-d H:i:s')) . ", INTERVAL " . _INTERVALLE_REVISIONS . " SECOND)")
     521                        "id_objet=" . intval($id_objet),
     522                        "objet=" . sql_quote($objet),
     523                        "id_version <= 0",
     524                        "date < DATE_SUB(" . sql_quote(date('Y-m-d H:i:s')) . ", INTERVAL " . _INTERVALLE_REVISIONS . " SECOND)"
     525                )
    481526        );
    482527
     
    485530        // et un titre contenant en fait le moment de l'insertion
    486531        list($ms, $sec) = explode(' ', microtime());
    487         $date = $sec . substr($ms,1,4)-20; // SQL ne ramene que 4 chiffres significatifs apres la virgule pour 0.0+titre_version
    488         $datediff = ($sec - mktime(0,0,0,9,1,2007)) * 1000000 + substr($ms,2, strlen($ms)-4);
    489 
    490         $valeurs = array('id_objet' => $id_objet,
    491                          'objet' => $objet,
    492                          'id_version' => (0 - $datediff),
    493                          'date' => date('Y-m-d H:i:s'),
    494                          'id_auteur' => $str_auteur, //  varchar ici!
    495                          'titre_version' => $date);
    496         sql_insertq('spip_versions',  $valeurs);
     532        $date = $sec . substr($ms, 1,
     533                        4)-20; // SQL ne ramene que 4 chiffres significatifs apres la virgule pour 0.0+titre_version
     534        $datediff = ($sec-mktime(0, 0, 0, 9, 1, 2007))*1000000+substr($ms, 2, strlen($ms)-4);
     535
     536        $valeurs = array(
     537                'id_objet' => $id_objet,
     538                'objet' => $objet,
     539                'id_version' => (0-$datediff),
     540                'date' => date('Y-m-d H:i:s'),
     541                'id_auteur' => $str_auteur, //  varchar ici!
     542                'titre_version' => $date
     543        );
     544        sql_insertq('spip_versions', $valeurs);
    497545
    498546        // Eviter les validations entremelees en s'endormant s'il existe
     
    508556#         sleep(15);
    509557        $delai = $sec-10;
    510         while (sql_countsel('spip_versions', "id_objet=".intval($id_objet)." AND objet=".sql_quote($objet)." AND id_version < 0 AND 0.0+titre_version < $date AND titre_version<>".sql_quote($date,'','text')." AND 0.0+titre_version > $delai")) {
    511                 spip_log("version $objet $id_objet :insertion en cours avant $date ($delai)",'revisions');
     558        while (sql_countsel('spip_versions',
     559                "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet) . " AND id_version < 0 AND 0.0+titre_version < $date AND titre_version<>" . sql_quote($date,
     560                        '', 'text') . " AND 0.0+titre_version > $delai")) {
     561                spip_log("version $objet $id_objet :insertion en cours avant $date ($delai)", 'revisions');
    512562                sleep(1);
    513563                $delai++;
     
    515565#   sleep(15);  spip_log("sortie $sec $delai");
    516566        // Determiner le numero du prochain fragment
    517         $next = sql_fetsel("id_fragment", "spip_versions_fragments", "id_objet=".intval($id_objet)." AND objet=".sql_quote($objet), "", "id_fragment DESC", "1");
     567        $next = sql_fetsel("id_fragment", "spip_versions_fragments",
     568                "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet), "", "id_fragment DESC", "1");
    518569
    519570        $onlylock = '';
    520571
    521572        // Examiner la derniere version
    522         $row = sql_fetsel("id_version, champs, id_auteur, date, permanent", "spip_versions", "id_objet=".intval($id_objet)." AND objet=".sql_quote($objet)." AND id_version > 0", '', "id_version DESC", "1"); // le champ id_auteur est un varchar dans cette table
     573        $row = sql_fetsel("id_version, champs, id_auteur, date, permanent", "spip_versions",
     574                "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet) . " AND id_version > 0", '', "id_version DESC",
     575                "1"); // le champ id_auteur est un varchar dans cette table
    523576
    524577        if ($row) {
    525578                $id_version = $row['id_version'];
    526                 $paras_old = recuperer_fragments($id_objet,$objet, $id_version);
     579                $paras_old = recuperer_fragments($id_objet, $objet, $id_version);
    527580                $champs_old = $row['champs'];
    528                 if ($row['id_auteur']!= $str_auteur
    529                   OR $row['permanent']!='non'
    530                   OR strtotime($row['date']) < (time()-_INTERVALLE_REVISIONS)) {
     581                if ($row['id_auteur'] != $str_auteur
     582                        OR $row['permanent'] != 'non'
     583                        OR strtotime($row['date']) < (time()-_INTERVALLE_REVISIONS)
     584                ) {
    531585                        spip_log(strtotime($row['date']), 'revisions');
    532586                        spip_log(time(), 'revisions');
     
    540594                        $onlylock = 're';
    541595                }
    542         } else
     596        } else {
    543597                $id_version = 1;
    544 
    545         $next = !$next ? 1 : ($next['id_fragment'] + 1);
     598        }
     599
     600        $next = !$next ? 1 : ($next['id_fragment']+1);
    546601
    547602        // Generer les nouveaux fragments
     
    557612        if ($n) {
    558613                // Tables d'appariement dans les deux sens
    559                 list(,$trans) = apparier_paras($paras_old, $paras);
     614                list(, $trans) = apparier_paras($paras_old, $paras);
    560615                reset($champs);
    561616                $nom = '';
     
    563618                // eviter une notice PHP au tout debut de la boucle
    564619                // on ajoute ''=>0 en debut de tableau.
    565                 $paras_champ = array($nom=>0) + $paras_champ;
     620                $paras_champ = array($nom => 0)+$paras_champ;
    566621
    567622                for ($i = 0; $i < $n; $i++) {
    568                         while ($i >= $paras_champ[$nom]) list($nom, ) = each($champs);
     623                        while ($i >= $paras_champ[$nom]) {
     624                                list($nom,) = each($champs);
     625                        }
    569626                        // Lier au fragment existant si possible, sinon creer un nouveau fragment
    570627                        $id_fragment = isset($trans[$i]) ? $trans[$i] : $next++;
     
    580637
    581638        // Enregistrer les modifications
    582         ajouter_fragments($id_objet,$objet, $id_version, $fragments);
     639        ajouter_fragments($id_objet, $objet, $id_version, $fragments);
    583640
    584641        // Si l'insertion ne servait que de verrou,
     
    587644
    588645        if (!$onlylock) {
    589                 sql_updateq('spip_versions', array('id_version'=>$id_version, 'date'=>date('Y-m-d H:i:s'), 'champs'=> serialize($codes), 'permanent'=>$permanent, 'titre_version'=> $titre_version), "id_objet=".intval($id_objet)." AND objet=".sql_quote($objet)." AND id_version < 0 AND titre_version='$date'");
     646                sql_updateq('spip_versions', array(
     647                        'id_version' => $id_version,
     648                        'date' => date('Y-m-d H:i:s'),
     649                        'champs' => serialize($codes),
     650                        'permanent' => $permanent,
     651                        'titre_version' => $titre_version
     652                ),
     653                        "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet) . " AND id_version < 0 AND titre_version='$date'");
    590654        } else {
    591                 sql_updateq('spip_versions', array('date'=>date('Y-m-d H:i:s'), 'champs'=>serialize($codes), 'permanent'=>$permanent, 'titre_version'=> $titre_version), "id_objet=".intval($id_objet)." AND objet=".sql_quote($objet)." AND id_version=$id_version");
    592                 sql_delete("spip_versions", "id_objet=".intval($id_objet)." AND objet=".sql_quote($objet)." AND id_version < 0 AND titre_version ='$date'");
    593         }
    594         spip_log($onlylock . "memorise la version $id_version de l'objet $objet $id_objet $titre_version",'revisions');
     655                sql_updateq('spip_versions', array(
     656                        'date' => date('Y-m-d H:i:s'),
     657                        'champs' => serialize($codes),
     658                        'permanent' => $permanent,
     659                        'titre_version' => $titre_version
     660                ), "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet) . " AND id_version=$id_version");
     661                sql_delete("spip_versions",
     662                        "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet) . " AND id_version < 0 AND titre_version ='$date'");
     663        }
     664        spip_log($onlylock . "memorise la version $id_version de l'objet $objet $id_objet $titre_version", 'revisions');
    595665
    596666        return $id_version;
     
    604674        $span_diff = array();
    605675        if (preg_match_all(',<(/)?(span|div) (class|rem)="diff-[^>]*>,', $texte, $regs, PREG_SET_ORDER)) {
    606                 $regs = array_slice($regs,0,500); #limiter la casse s'il y en a trop
     676                $regs = array_slice($regs, 0, 500); #limiter la casse s'il y en a trop
    607677                foreach ($regs as $c => $reg) {
    608                         $texte = str_replace($reg[0], '@@@SPIP_DIFF'.$c.'@@@', $texte);
     678                        $texte = str_replace($reg[0], '@@@SPIP_DIFF' . $c . '@@@', $texte);
    609679                }
    610680        }
     
    639709                foreach ($area as $reg) {
    640710                        $remplace = preg_replace(',@@@SPIP_DIFF[0-9]+@@@,', '**', $reg[0]);
    641                         if ($remplace <> $reg[0])
     711                        if ($remplace <> $reg[0]) {
    642712                                $texte = str_replace($reg[0], $remplace, $texte);
     713                        }
    643714                }
    644715        }
    645716
    646717        // replacer les valeurs des <span> et <div> diff-
    647         if (is_array($regs))
    648         foreach ($regs as $c => $reg) {
    649                 $bal = (!$reg[1]) ? $reg[0] : "</$reg[2]>";
    650                 $texte = str_replace('@@@SPIP_DIFF'.$c.'@@@', $bal, $texte);
    651                 $GLOBALS['les_notes'] = str_replace('@@@SPIP_DIFF'.$c.'@@@', $bal, $GLOBALS['les_notes']);
     718        if (is_array($regs)) {
     719                foreach ($regs as $c => $reg) {
     720                        $bal = (!$reg[1]) ? $reg[0] : "</$reg[2]>";
     721                        $texte = str_replace('@@@SPIP_DIFF' . $c . '@@@', $bal, $texte);
     722                        $GLOBALS['les_notes'] = str_replace('@@@SPIP_DIFF' . $c . '@@@', $bal, $GLOBALS['les_notes']);
     723                }
    652724        }
    653725
     
    655727        // quand le dernier tag est ouvrant le refermer ...
    656728        $reg = end($regs);
    657         if (!$reg[1] AND $reg[2]) $texte.="</$reg[2]>";
     729        if (!$reg[1] AND $reg[2]) {
     730                $texte .= "</$reg[2]>";
     731        }
    658732
    659733        // et interdire_scripts !
     
    666740/**
    667741 * Liste les champs versionnés d'une table objet.
    668  * 
     742 *
    669743 * @param string $table
    670744 *     Nom complet de sa table sql. Exemple 'spip_articles'
     
    675749        $liste_objets_versionnees = is_array(unserialize($GLOBALS['meta']['objets_versions'])) ? unserialize($GLOBALS['meta']['objets_versions']) : array();
    676750
    677         if (!in_array($table,$liste_objets_versionnees))
     751        if (!in_array($table, $liste_objets_versionnees)) {
    678752                return array();
     753        }
    679754
    680755        include_spip('base/objets');
    681         if ($infos=lister_tables_objets_sql($table)
    682           AND isset($infos['champs_versionnes']))
     756        if ($infos = lister_tables_objets_sql($table)
     757                AND isset($infos['champs_versionnes'])
     758        ) {
    683759                return $infos['champs_versionnes'];
     760        }
    684761
    685762        return array();
     
    689766 * Lorsqu'un champ versionée est une jointure, récuperer tous les liens
    690767 * et les mettre sous forme de liste énumérée
    691  * 
     768 *
    692769 * @param string $objet
    693770 * @param string $id_objet
     
    695772 * @return string
    696773 */
    697 function recuperer_valeur_champ_jointure($objet, $id_objet, $jointure){
     774function recuperer_valeur_champ_jointure($objet, $id_objet, $jointure) {
    698775        $objet_joint = objet_type($jointure);
    699776        include_spip('action/editer_liens');
    700777        $v = array();
    701778        if (objet_associable($objet_joint)) {
    702                 $liens = objet_trouver_liens(array($objet_joint=>'*'),array($objet=>$id_objet));
    703                 foreach($liens as $l)
     779                $liens = objet_trouver_liens(array($objet_joint => '*'), array($objet => $id_objet));
     780                foreach ($liens as $l) {
    704781                        $v[] = $l[$objet_joint];
    705         }
    706         elseif(objet_associable($objet)) {
    707                 $liens = objet_trouver_liens(array($objet=>$id_objet),array($objet_joint=>'*'));
    708                 foreach($liens as $l)
     782                }
     783        } elseif (objet_associable($objet)) {
     784                $liens = objet_trouver_liens(array($objet => $id_objet), array($objet_joint => '*'));
     785                foreach ($liens as $l) {
    709786                        $v[] = $l[$objet];
     787                }
    710788        }
    711789        sort($v);
    712         return implode(",",$v);
     790
     791        return implode(",", $v);
    713792}
    714793
    715794/**
    716795 * Créer la première révision d'un objet si nécessaire
    717  * 
     796 *
    718797 * À faire notamment si on vient d'activer l'extension et qu'on fait une modif
    719798 * sur un objet qui était déjà en base, mais non versionné
     
    721800 * La fonction renvoie le numéro de la dernière version de l'objet,
    722801 * et 0 si pas de version pour cet objet
    723  * 
     802 *
    724803 * @param string $table
    725804 * @param string $objet
     
    729808 * @return int
    730809 */
    731 function verifier_premiere_revision($table, $objet, $id_objet, $champs = null, $id_auteur = 0){
     810function verifier_premiere_revision($table, $objet, $id_objet, $champs = null, $id_auteur = 0) {
    732811
    733812        $id_table_objet = id_table_objet($objet);
    734         if (!$champs)
     813        if (!$champs) {
    735814                $champs = liste_champs_versionnes($table);
    736         if (!$champs)
     815        }
     816        if (!$champs) {
    737817                return false;
    738 
    739         if (!$id_version = sql_getfetsel('id_version','spip_versions',"id_objet=".intval($id_objet)." AND objet=".sql_quote($objet),'','id_version DESC','0,1')) {
     818        }
     819
     820        if (!$id_version = sql_getfetsel('id_version', 'spip_versions',
     821                "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet), '', 'id_version DESC', '0,1')
     822        ) {
    740823                // recuperer toutes les valeurs actuelles des champs
    741824                // pour l'objet
    742                 $originaux = sql_fetsel("*", $table, "$id_table_objet=".intval($id_objet));
     825                $originaux = sql_fetsel("*", $table, "$id_table_objet=" . intval($id_objet));
    743826                $premiere = false;
    744827                $champs_originaux = array();
    745828
    746                 foreach($champs as $v){
    747                         if (isset($originaux[$v])){
     829                foreach ($champs as $v) {
     830                        if (isset($originaux[$v])) {
    748831                                $champs_originaux[$v] = $originaux[$v];
    749                         }
    750                         elseif (strncmp($v, 'jointure_', 9) == 0) {
    751                                 $champs_originaux[$v] = recuperer_valeur_champ_jointure($objet,$id_objet,substr($v,9));
     832                        } elseif (strncmp($v, 'jointure_', 9) == 0) {
     833                                $champs_originaux[$v] = recuperer_valeur_champ_jointure($objet, $id_objet, substr($v, 9));
    752834                        }
    753835                        if (isset($champs_originaux[$v]) AND isset($originaux[$v]) AND strlen($originaux[$v])) {
     
    759841                // il faut creer une premiere revision
    760842                if ($premiere) {
    761                         $trouver_table = charger_fonction('trouver_table','base');
     843                        $trouver_table = charger_fonction('trouver_table', 'base');
    762844                        $desc = $trouver_table($table);
    763845
     
    765847
    766848                        $date_modif = "";
    767                         foreach(array('date_modif','maj') as $d){
    768                                 if (!$date_modif AND isset($originaux[$d]) AND $t=strtotime($d))
     849                        foreach (array('date_modif', 'maj') as $d) {
     850                                if (!$date_modif AND isset($originaux[$d]) AND $t = strtotime($d)) {
    769851                                        $date_modif = date("Y-m-d H:i:s", $t-20);
     852                                }
    770853                        }
    771854                        if (!$date_modif
    772                           AND isset($desc['date'])
    773                           AND isset($originaux[$desc['date']])) {
     855                                AND isset($desc['date'])
     856                                AND isset($originaux[$desc['date']])
     857                        ) {
    774858                                $date_modif = $originaux[$desc['date']];
    775                         }
    776                         elseif (!$date_modif)
     859                        } elseif (!$date_modif) {
    777860                                $date_modif = date("Y-m-d H:i:s", time()-20);
    778                                
    779                         if ($id_version = ajouter_version($id_objet, $objet, $champs_originaux, _T('revisions:version_initiale'), $id_auteur))
    780                                 sql_updateq('spip_versions', array('date' => $date_modif), "id_objet=".intval($id_objet)." AND objet=".sql_quote($objet)." AND id_version=$id_version");
    781                 }
    782         }
     861                        }
     862
     863                        if ($id_version = ajouter_version($id_objet, $objet, $champs_originaux, _T('revisions:version_initiale'),
     864                                $id_auteur)
     865                        ) {
     866                                sql_updateq('spip_versions', array('date' => $date_modif),
     867                                        "id_objet=" . intval($id_objet) . " AND objet=" . sql_quote($objet) . " AND id_version=$id_version");
     868                        }
     869                }
     870        }
     871
    783872        return $id_version;
    784873}
     874
    785875?>
  • _core_/plugins/revisions/inc/revisions_autoriser.php

    r93092 r93622  
    1616 *
    1717 * @package SPIP\Revisions\Autorisations
    18 **/
     18 **/
    1919
    20 if (!defined('_ECRIRE_INC_VERSION')) return;
     20if (!defined('_ECRIRE_INC_VERSION')) {
     21        return;
     22}
    2123
    2224/**
    2325 * Fonction du pipeline autoriser. N'a rien à faire.
     26 *
    2427 * @pipeline autoriser
    2528 */
    26 function revisions_autoriser(){}
     29function revisions_autoriser() { }
    2730
    2831/**
    2932 * Autorisation de voir les revisions ?
    30  * 
     33 *
    3134 * Il faut :
    3235 * - des revisions définies pour cet objet
     
    3538 *
    3639 * @param  string $faire Action demandée
    37  * @param  string $type  Type d'objet sur lequel appliquer l'action
    38  * @param  int    $id    Identifiant de l'objet
    39  * @param  array  $qui  Description de l'auteur demandant l'autorisation
    40  * @param  array  $opt  Options de cette autorisation
     40 * @param  string $type Type d'objet sur lequel appliquer l'action
     41 * @param  int $id Identifiant de l'objet
     42 * @param  array $qui Description de l'auteur demandant l'autorisation
     43 * @param  array $opt Options de cette autorisation
    4144 * @return bool          true s'il a le droit, false sinon
    4245 */
     
    4649
    4750        include_spip('inc/revisions');
    48         if (!liste_champs_versionnes($table))
     51        if (!liste_champs_versionnes($table)) {
    4952                return false;
     53        }
    5054
    51         if (!$row = sql_fetsel("*", $table, "$id_table_objet=".intval($id)))
     55        if (!$row = sql_fetsel("*", $table, "$id_table_objet=" . intval($id))) {
    5256                return false;
     57        }
    5358
    5459        return
     
    5964/**
    6065 * Autorisation de voir le menu révisions
    61  * 
     66 *
    6267 * Il faut des révisions activées et présentes.
    6368 *
    6469 * @param  string $faire Action demandée
    65  * @param  string $type  Type d'objet sur lequel appliquer l'action
    66  * @param  int    $id    Identifiant de l'objet
    67  * @param  array  $qui  Description de l'auteur demandant l'autorisation
    68  * @param  array  $opt  Options de cette autorisation
     70 * @param  string $type Type d'objet sur lequel appliquer l'action
     71 * @param  int $id Identifiant de l'objet
     72 * @param  array $qui Description de l'auteur demandant l'autorisation
     73 * @param  array $opt Options de cette autorisation
    6974 * @return bool          true s'il a le droit, false sinon
    7075 */
    71 function autoriser_revisions_menu_dist($faire, $type = '', $id = 0, $qui = NULL, $opt = NULL){
     76function autoriser_revisions_menu_dist($faire, $type = '', $id = 0, $qui = null, $opt = null) {
    7277        // SI pas de revisions sur un objet quelconque.
    7378        // ET pas de version... pas de bouton, c'est inutile...
     
    7681                return false;
    7782        }
     83
    7884        return true;
    7985}
  • _core_/plugins/revisions/inc/revisions_pipeline.php

    r92678 r93622  
    1515 *
    1616 * @package SPIP\Revisions\Pipelines
    17 **/
    18 if (!defined('_ECRIRE_INC_VERSION')) return;
     17 **/
     18if (!defined('_ECRIRE_INC_VERSION')) {
     19        return;
     20}
    1921
    2022
     
    2224 * Ajoute dans le bloc d'info d'un objet un bouton permettant d'aller voir
    2325 * l'historique de ses révisions
    24  * 
    25  * @param array $flux   Données du pipeline
     26 *
     27 * @param array $flux Données du pipeline
    2628 * @return array $flux  Données du pipeline
    2729 */
    28 function revisions_boite_infos($flux){
     30function revisions_boite_infos($flux) {
    2931        $type = $flux['args']['type'];
    3032        if ($id = intval($flux['args']['id'])
    31           AND $tables = unserialize($GLOBALS['meta']['objets_versions'])
    32                 AND in_array(table_objet_sql($type),$tables)
    33           AND autoriser('voirrevisions',$type,$id)
    34           // regarder le numero de revision le plus eleve, et afficher le bouton
    35           // si c'est interessant (id_version>1)
    36           AND sql_countsel('spip_versions', 'id_objet='.intval($id).' AND objet = '.sql_quote($type)) > 1
     33                AND $tables = unserialize($GLOBALS['meta']['objets_versions'])
     34                AND in_array(table_objet_sql($type), $tables)
     35                AND autoriser('voirrevisions', $type, $id)
     36                // regarder le numero de revision le plus eleve, et afficher le bouton
     37                // si c'est interessant (id_version>1)
     38                AND sql_countsel('spip_versions', 'id_objet=' . intval($id) . ' AND objet = ' . sql_quote($type)) > 1
    3739        ) {
    3840                include_spip('inc/presentation');
    39                 $flux['data'] .= icone_horizontale(_T('revisions:info_historique_lien'), generer_url_ecrire('revision',"id_objet=$id&objet=$type"), "revision-24.png");
     41                $flux['data'] .= icone_horizontale(_T('revisions:info_historique_lien'),
     42                        generer_url_ecrire('revision', "id_objet=$id&objet=$type"), "revision-24.png");
    4043        }
    4144
     
    4952 * et sur la page de suivi de l'activité du site
    5053 *
    51  * @param array $flux   Données du pipeline
     54 * @param array $flux Données du pipeline
    5255 * @return array $flux  Données du pipeline
    5356 */
     
    5558        // la bonne page et des objets révisables cochées !
    5659        if (in_array($flux['args']['exec'], array('accueil', 'suivi_edito'))
    57           and unserialize($GLOBALS['meta']['objets_versions'])) {
     60                and unserialize($GLOBALS['meta']['objets_versions'])
     61        ) {
    5862                $contexte = array();
    59                 if ($GLOBALS['visiteur_session']['statut']!=='0minirezo') {
     63                if ($GLOBALS['visiteur_session']['statut'] !== '0minirezo') {
    6064                        $contexte['id_auteur'] = $GLOBALS['visiteur_session']['id_auteur'];
    6165                }
    62                 $flux['data'] .= recuperer_fond('prive/objets/liste/versions',$contexte,array('ajax'=>true));
    63         }
     66                $flux['data'] .= recuperer_fond('prive/objets/liste/versions', $contexte, array('ajax' => true));
     67        }
     68
    6469        return $flux;
    6570}
     
    6772/**
    6873 * Définir les metas de configuration liées aux révisions
    69  * 
     74 *
    7075 * Utilisé par inc/config
    7176 *
    72  * @param array $metas  Liste des métas et leurs valeurs par défaut
     77 * @param array $metas Liste des métas et leurs valeurs par défaut
    7378 * @return array        Liste des métas et leurs valeurs par défaut
    7479 */
    75 function revisions_configurer_liste_metas($metas){
     80function revisions_configurer_liste_metas($metas) {
    7681        // Dorénavant dans les metas on utilisera un array serialisé de types d'objets
    7782        // qui correspondront aux objets versionnés
    78         $metas['objets_versions'] =  '';
     83        $metas['objets_versions'] = '';
    7984
    8085        return $metas;
     
    8489/**
    8590 * Charge les données d'une révision donnée dans le formulaire d'édition d'un objet
    86  * 
    87  * @param array $flux   Données du pipeline
     91 *
     92 * @param array $flux Données du pipeline
    8893 * @return array $flux  Données du pipeline
    8994 */
    90 function revisions_formulaire_charger($flux){
    91         if (strncmp($flux['args']['form'],'editer_',7)==0
    92           AND $id_version = _request('id_version')
    93           AND $objet = substr($flux['args']['form'],7)
    94           AND $id_table_objet = id_table_objet($objet)
    95           AND isset($flux['data'][$id_table_objet])
     95function revisions_formulaire_charger($flux) {
     96        if (strncmp($flux['args']['form'], 'editer_', 7) == 0
     97                AND $id_version = _request('id_version')
     98                AND $objet = substr($flux['args']['form'], 7)
     99                AND $id_table_objet = id_table_objet($objet)
     100                AND isset($flux['data'][$id_table_objet])
    96101                AND $id = intval($flux['data'][$id_table_objet])
    97           AND !$flux['args']['je_suis_poste']){
     102                AND !$flux['args']['je_suis_poste']
     103        ) {
    98104                // ajouter un message convival pour indiquer qu'on a restaure la version
    99                 $flux['data']['message_ok'] = _T('revisions:icone_restaurer_version',array('version'=>$id_version));
    100                 $flux['data']['message_ok'] .= "<br />"._T('revisions:message_valider_recuperer_version');
     105                $flux['data']['message_ok'] = _T('revisions:icone_restaurer_version', array('version' => $id_version));
     106                $flux['data']['message_ok'] .= "<br />" . _T('revisions:message_valider_recuperer_version');
    101107                // recuperer la version
    102108                include_spip('inc/revisions');
    103                 $champs = recuperer_version($id,$objet, $id_version);
    104                 foreach($champs as $champ=>$valeur){
    105                         if (!strncmp($champ,'jointure_',9)==0){
    106                                 if ($champ=='id_rubrique'){
     109                $champs = recuperer_version($id, $objet, $id_version);
     110                foreach ($champs as $champ => $valeur) {
     111                        if (!strncmp($champ, 'jointure_', 9) == 0) {
     112                                if ($champ == 'id_rubrique') {
    107113                                        $flux['data']['id_parent'] = $valeur;
     114                                } else {
     115                                        $flux['data'][$champ] = $valeur;
    108116                                }
    109                                 else
    110                                         $flux['data'][$champ] = $valeur;
    111117                        }
    112118                }
    113119        }
     120
    114121        return $flux;
    115122}
    116 
    117123
    118124
     
    120126 * Sur une insertion en base, lever un flag pour ne pas creer une premiere révision vide
    121127 * dans pre_edition mais attendre la post_edition pour cela
    122  * 
    123  * @param array $x   Données du pipeline
    124  * @return array $x  Données du pipeline
    125  */
    126 function revisions_post_insertion($x){
     128 *
     129 * @param array $x Données du pipeline
     130 * @return array $x  Données du pipeline
     131 */
     132function revisions_post_insertion($x) {
    127133        $table = $x['args']['table'];
    128134        include_spip('inc/revisions');
    129         if  ($champs = liste_champs_versionnes($table)) {
    130                 $GLOBALS['premiere_revision']["$table:".$x['args']['id_objet']] = true;
    131         }
     135        if ($champs = liste_champs_versionnes($table)) {
     136                $GLOBALS['premiere_revision']["$table:" . $x['args']['id_objet']] = true;
     137        }
     138
    132139        return $x;
    133140}
     
    138145 * et la creer sinon avec l'etat actuel de l'objet
    139146 *
    140  * @param array $x   Données du pipeline
     147 * @param array $x Données du pipeline
    141148 * @return array $x  Données du pipeline
    142149 */
     
    144151        // ne rien faire quand on passe ici en controle md5
    145152        if (!isset($x['args']['action'])
    146           OR $x['args']['action']!=='controler'){
     153                OR $x['args']['action'] !== 'controler'
     154        ) {
    147155                $table = $x['args']['table'];
    148156                include_spip('inc/revisions');
    149157                // si flag leve passer son chemin, post_edition le fera (mais baisser le flag en le gardant en memoire tout de meme)
    150                 if (isset($GLOBALS['premiere_revision']["$table:".$x['args']['id_objet']])){
    151                         $GLOBALS['premiere_revision']["$table:".$x['args']['id_objet']] = 0;
    152                 }
    153                 // sinon creer une premiere revision qui date et dont on ne connait pas l'auteur
    154                 elseif  ($versionnes = liste_champs_versionnes($table)) {
     158                if (isset($GLOBALS['premiere_revision']["$table:" . $x['args']['id_objet']])) {
     159                        $GLOBALS['premiere_revision']["$table:" . $x['args']['id_objet']] = 0;
     160                } // sinon creer une premiere revision qui date et dont on ne connait pas l'auteur
     161                elseif ($versionnes = liste_champs_versionnes($table)) {
    155162                        $objet = isset($x['args']['type']) ? $x['args']['type'] : objet_type($table);
    156163                        verifier_premiere_revision($table, $objet, $x['args']['id_objet'], $versionnes, -1);
    157164                }
    158165        }
     166
    159167        return $x;
    160168}
     
    164172 * enregistrer une première révision de l'objet si nécessaire
    165173 *
    166  * @param array $x   Données du pipeline
     174 * @param array $x Données du pipeline
    167175 * @return array $x  Données du pipeline
    168176 */
    169177function revisions_pre_edition_lien($x) {
    170         if (intval($x['args']['id_objet_source'])>0
    171             AND intval($x['args']['id_objet'])>0) {
     178        if (intval($x['args']['id_objet_source']) > 0
     179                AND intval($x['args']['id_objet']) > 0
     180        ) {
    172181                $table = table_objet_sql($x['args']['objet']);
    173182                $id_objet = intval($x['args']['id_objet']);
    174183                include_spip('inc/revisions');
    175                 if (isset($GLOBALS['premiere_revision']["$table:".$id_objet])){
    176                         $GLOBALS['premiere_revision']["$table:".$id_objet] = 0;
    177                 }
    178                 // ex : si le champ jointure_mots est versionnable sur les articles
     184                if (isset($GLOBALS['premiere_revision']["$table:" . $id_objet])) {
     185                        $GLOBALS['premiere_revision']["$table:" . $id_objet] = 0;
     186                } // ex : si le champ jointure_mots est versionnable sur les articles
    179187                elseif ($versionnes = liste_champs_versionnes($table)
    180                         AND in_array($j='jointure_'.table_objet($x['args']['objet_source']),$versionnes)){
    181                         verifier_premiere_revision($table,$x['args']['objet'],$id_objet,$versionnes,-1);
     188                        AND in_array($j = 'jointure_' . table_objet($x['args']['objet_source']), $versionnes)
     189                ) {
     190                        verifier_premiere_revision($table, $x['args']['objet'], $id_objet, $versionnes, -1);
    182191                }
    183192
    184193                $table = table_objet_sql($x['args']['objet_source']);
    185194                $id_objet = $x['args']['id_objet_source'];
    186                 if (isset($GLOBALS['premiere_revision']["$table:".$id_objet])){
    187                         $GLOBALS['premiere_revision']["$table:".$id_objet] = 0;
    188                 }
    189                 // ex : si le champ jointure_articles est versionnable sur les mots
     195                if (isset($GLOBALS['premiere_revision']["$table:" . $id_objet])) {
     196                        $GLOBALS['premiere_revision']["$table:" . $id_objet] = 0;
     197                } // ex : si le champ jointure_articles est versionnable sur les mots
    190198                elseif ($versionnes = liste_champs_versionnes($table)
    191                         AND in_array($j='jointure_'.table_objet($x['args']['objet']),$versionnes)){
    192                         verifier_premiere_revision($table,$x['args']['objet_source'],$id_objet,$versionnes,-1);
     199                        AND in_array($j = 'jointure_' . table_objet($x['args']['objet']), $versionnes)
     200                ) {
     201                        verifier_premiere_revision($table, $x['args']['objet_source'], $id_objet, $versionnes, -1);
    193202                }
    194203        }
     
    200209 * Après modification en base, versionner l'objet
    201210 *
    202  * @param array $x   Données du pipeline
     211 * @param array $x Données du pipeline
    203212 * @return array $x  Données du pipeline
    204213 */
    205214function revisions_post_edition($x) {
    206215        include_spip('inc/revisions');
    207         if (isset($x['args']['table']) and $versionnes = liste_champs_versionnes($x['args']['table'])){
     216        if (isset($x['args']['table']) and $versionnes = liste_champs_versionnes($x['args']['table'])) {
    208217                // Regarder si au moins une des modifs est versionnable
    209218                $champs = array();
     
    212221                include_spip('inc/session');
    213222
    214                 if (isset($GLOBALS['premiere_revision']["$table:".$x['args']['id_objet']])){
    215                         unset($GLOBALS['premiere_revision']["$table:".$x['args']['id_objet']]);
     223                if (isset($GLOBALS['premiere_revision']["$table:" . $x['args']['id_objet']])) {
     224                        unset($GLOBALS['premiere_revision']["$table:" . $x['args']['id_objet']]);
    216225                        // verifier la premiere version : sur une version initiale on attend ici pour la creer
    217226                        // plutot que de creer une version vide+un diff
    218227                        verifier_premiere_revision($table, $objet, $x['args']['id_objet'], $versionnes, session_get('id_auteur'));
    219                 }
    220                 else {
     228                } else {
    221229                        // on versionne les differences
    222230                        foreach ($versionnes as $key) {
     
    227235
    228236                        if (count($champs)) {
    229                                 ajouter_version($x['args']['id_objet'],$objet, $champs, '', session_get('id_auteur'));
     237                                ajouter_version($x['args']['id_objet'], $objet, $champs, '', session_get('id_auteur'));
    230238                        }
    231239                }
     
    239247 * Après modification en base d'un lien, versionner l'objet si nécessaire
    240248 *
    241  * @param array $x   Données du pipeline
     249 * @param array $x Données du pipeline
    242250 * @return array $x  Données du pipeline
    243251 */
     
    256264                )
    257265        */
    258         if (intval($x['args']['id_objet_source'])>0
    259             AND intval($x['args']['id_objet'])>0) {
     266        if (intval($x['args']['id_objet_source']) > 0
     267                AND intval($x['args']['id_objet']) > 0
     268        ) {
    260269
    261270                $table = table_objet_sql($x['args']['objet']);
    262271                $id_objet = $x['args']['id_objet'];
    263272                include_spip('inc/revisions');
    264                 if (isset($GLOBALS['premiere_revision']["$table:".$id_objet])){
    265                         $GLOBALS['premiere_revision']["$table:".$id_objet] = 0;
    266                 }
    267                 // ex : si le champ jointure_mots est versionnable sur les articles
     273                if (isset($GLOBALS['premiere_revision']["$table:" . $id_objet])) {
     274                        $GLOBALS['premiere_revision']["$table:" . $id_objet] = 0;
     275                } // ex : si le champ jointure_mots est versionnable sur les articles
    268276                elseif ($versionnes = liste_champs_versionnes($table)
    269                         AND in_array($j='jointure_'.table_objet($x['args']['objet_source']),$versionnes)){
    270                         $champs = array($j=>recuperer_valeur_champ_jointure($x['args']['objet'],$id_objet,$x['args']['objet_source']));
    271                         ajouter_version($id_objet,$x['args']['objet'], $champs, '', $GLOBALS['visiteur_session']['id_auteur']);
     277                        AND in_array($j = 'jointure_' . table_objet($x['args']['objet_source']), $versionnes)
     278                ) {
     279                        $champs = array(
     280                                $j => recuperer_valeur_champ_jointure($x['args']['objet'], $id_objet, $x['args']['objet_source'])
     281                        );
     282                        ajouter_version($id_objet, $x['args']['objet'], $champs, '', $GLOBALS['visiteur_session']['id_auteur']);
    272283                }
    273284
    274285                $table = table_objet_sql($x['args']['objet_source']);
    275286                $id_objet = $x['args']['id_objet_source'];
    276                 if (isset($GLOBALS['premiere_revision']["$table:".$id_objet])){
    277                         $GLOBALS['premiere_revision']["$table:".$id_objet] = 0;
    278                 }
    279                 // ex : si le champ jointure_articles est versionnable sur les mots
     287                if (isset($GLOBALS['premiere_revision']["$table:" . $id_objet])) {
     288                        $GLOBALS['premiere_revision']["$table:" . $id_objet] = 0;
     289                } // ex : si le champ jointure_articles est versionnable sur les mots
    280290                elseif ($versionnes = liste_champs_versionnes($table)
    281                         AND in_array($j='jointure_'.table_objet($x['args']['objet']),$versionnes)){
    282                         $champs = array($j=>recuperer_valeur_champ_jointure($x['args']['objet_source'],$id_objet,$x['args']['objet']));
    283                         ajouter_version($id_objet,$x['args']['objet_source'], $champs, '', $GLOBALS['visiteur_session']['id_auteur']);
     291                        AND in_array($j = 'jointure_' . table_objet($x['args']['objet']), $versionnes)
     292                ) {
     293                        $champs = array(
     294                                $j => recuperer_valeur_champ_jointure($x['args']['objet_source'], $id_objet, $x['args']['objet'])
     295                        );
     296                        ajouter_version($id_objet, $x['args']['objet_source'], $champs, '', $GLOBALS['visiteur_session']['id_auteur']);
    284297                }
    285298        }
     
    298311 *     Tableau des tâches et leur périodicité en seconde
    299312 */
    300 function revisions_taches_generales_cron($taches_generales){
     313function revisions_taches_generales_cron($taches_generales) {
    301314        $taches_generales['optimiser_revisions'] = 86400;
     315
    302316        return $taches_generales;
    303317}
     318
    304319?>
  • _core_/plugins/revisions/inc/suivi_versions.php

    r93092 r93622  
    1515 *
    1616 * @package SPIP\Revisions\Versions
    17 **/
    18 if (!defined("_ECRIRE_INC_VERSION")) return;
     17 **/
     18if (!defined("_ECRIRE_INC_VERSION")) {
     19        return;
     20}
    1921
    2022include_spip('inc/revisions');
     
    2325/**
    2426 * Afficher un diff correspondant à une révision d'un objet
    25  * 
    26  * @param int $id_objet    Identifiant de l'objet
    27  * @param string $objet    Objet
    28  * @param int $id_version  Identifiant de la version
     27 *
     28 * @param int $id_objet Identifiant de l'objet
     29 * @param string $objet Objet
     30 * @param int $id_version Identifiant de la version
    2931 * @param bool $court
    3032 *     - false : affiche le diff complet
     
    3335 *     Texte HTML du diff.
    3436 */
    35 function revisions_diff ($id_objet, $objet, $id_version, $court = false){
    36         $textes = revision_comparee($id_objet,$objet, $id_version, 'diff');
    37         if (!is_array($textes)) return $textes;
     37function revisions_diff($id_objet, $objet, $id_version, $court = false) {
     38        $textes = revision_comparee($id_objet, $objet, $id_version, 'diff');
     39        if (!is_array($textes)) {
     40                return $textes;
     41        }
    3842        $rev = '';
    3943        $nb = 0;
    4044        foreach ($textes as $var => $t) {
    41                 if ($n=strlen($t)) {
    42                         if ($court)
     45                if ($n = strlen($t)) {
     46                        if ($court) {
    4347                                $nb += $n;
    44                         else {
     48                        } else {
    4549                                $aff = propre_diff($t);
    4650                                if ($GLOBALS['les_notes']) {
    47                                         $aff .= '<p>'.$GLOBALS['les_notes'].'</p>';
     51                                        $aff .= '<p>' . $GLOBALS['les_notes'] . '</p>';
    4852                                        $GLOBALS['les_notes'] = '';
    4953                                }
     
    5256                }
    5357        }
     58
    5459        return $court ? _T('taille_octets', array('taille' => $nb)) : $rev;
    5560}
     
    6267 * récupérer une version qui contient ce champ. On complète alors la liste
    6368 * des champs avec la version du champ trouvée.
    64  * 
    65  * @param string $objet    Objet
    66  * @param int $id_objet    Identifiant de l'objet
    67  * @param int $id_version  Identifiant de la version
    68  * @param string $champ    Le nom du champ à retrouver
    69  * @param array $champs    Liste des champs déjà connus
     69 *
     70 * @param string $objet Objet
     71 * @param int $id_objet Identifiant de l'objet
     72 * @param int $id_version Identifiant de la version
     73 * @param string $champ Le nom du champ à retrouver
     74 * @param array $champs Liste des champs déjà connus
    7075 * @return void
    7176 */
    72 function retrouver_champ_version_objet($objet, $id_objet, $id_version, $champ, &$champs){
    73         if (isset($champs[$champ]))
     77function retrouver_champ_version_objet($objet, $id_objet, $id_version, $champ, &$champs) {
     78        if (isset($champs[$champ])) {
    7479                return;
     80        }
    7581
    7682        // Remonter dans le temps pour trouver le champ en question
     
    7884        $id_ref = $id_version-1;
    7985        $prev = array();
    80         while (!isset($prev[$champ]) AND $id_ref>0) {
    81                 $prev = recuperer_version($id_objet,$objet, $id_ref--);
     86        while (!isset($prev[$champ]) AND $id_ref > 0) {
     87                $prev = recuperer_version($id_objet, $objet, $id_ref--);
    8288        }
    8389        if (isset($prev[$champ])) {
     
    96102 * qui ont été modifiés depuis une version précédente et la version
    97103 * d'id_version, et les retourne.
    98  * 
     104 *
    99105 * La version précédente est par défaut la version juste
    100106 * avant id_version, mais peut être définie via le paramètre id_diff.
     
    102108 * Le retour est plus ou moins locace en fonction du paramètre format.
    103109 *
    104  * @param int $id_objet    Identifiant de l'objet
    105  * @param string $objet    Objet
    106  * @param int $id_version  Identifiant de la version
     110 * @param int $id_objet Identifiant de l'objet
     111 * @param string $objet Objet
     112 * @param int $id_version Identifiant de la version
    107113 * @param string $format
    108114 *     Type de retour
     
    116122 *     Couples (champ => texte)
    117123 */
    118 function revision_comparee($id_objet, $objet, $id_version, $format = 'diff', $id_diff = NULL) {
     124function revision_comparee($id_objet, $objet, $id_version, $format = 'diff', $id_diff = null) {
    119125        include_spip('inc/diff');
    120126
    121127        // chercher le numero de la version precedente
    122128        if (!$id_diff) {
    123                 $id_diff = sql_getfetsel("id_version", "spip_versions", "id_objet=" . intval($id_objet) . " AND id_version < " . intval($id_version)." AND objet=".sql_quote($objet), "", "id_version DESC", "1");
     129                $id_diff = sql_getfetsel("id_version", "spip_versions",
     130                        "id_objet=" . intval($id_objet) . " AND id_version < " . intval($id_version) . " AND objet=" . sql_quote($objet),
     131                        "", "id_version DESC", "1");
    124132        }
    125133
     
    133141                }
    134142
    135                 $old = recuperer_version($id_objet,$objet, $id_diff);
    136                 $new = recuperer_version($id_objet,$objet, $id_version);
     143                $old = recuperer_version($id_objet, $objet, $id_diff);
     144                $new = recuperer_version($id_objet, $objet, $id_version);
    137145
    138146                $textes = array();
     
    152160
    153161                // memoriser les cas les plus courant
    154                 $afficher_diff_champ    = charger_fonction('champ','afficher_diff');
    155                 $afficher_diff_jointure = charger_fonction('jointure','afficher_diff');
     162                $afficher_diff_champ = charger_fonction('champ', 'afficher_diff');
     163                $afficher_diff_jointure = charger_fonction('jointure', 'afficher_diff');
    156164                foreach ($champs as $champ) {
    157165                        // Remonter dans le temps pour trouver le champ en question
    158166                        // pour chaque version
    159                         retrouver_champ_version_objet($objet,$id_objet,$id_version,$champ,$new);
    160                         retrouver_champ_version_objet($objet,$id_objet,$id_diff,$champ,$old);
    161 
    162                         if (!strlen($new[$champ]) && !strlen($old[$champ])) continue;
     167                        retrouver_champ_version_objet($objet, $id_objet, $id_version, $champ, $new);
     168                        retrouver_champ_version_objet($objet, $id_objet, $id_diff, $champ, $old);
     169
     170                        if (!strlen($new[$champ]) && !strlen($old[$champ])) {
     171                                continue;
     172                        }
    163173
    164174                        // si on n'a que le vieux, ou que le nouveau, on ne
    165175                        // l'affiche qu'en mode "complet"
    166                         if ($format == 'complet')
     176                        if ($format == 'complet') {
    167177                                $textes[$champ] = strlen($new[$champ])
    168178                                        ? $new[$champ] : $old[$champ];
     179                        }
    169180
    170181                        // si on a les deux, le diff nous interesse, plus ou moins court
    171182                        if (isset($new[$champ]) AND isset($old[$champ])) {
    172                                 if (!$afficher_diff = charger_fonction($objet."_".$champ,'afficher_diff',true)
    173                                   AND !$afficher_diff = charger_fonction($champ,'afficher_diff',true))
    174                                         $afficher_diff = (strncmp($champ,'jointure_',9)==0?$afficher_diff_jointure:$afficher_diff_champ);
    175 
    176                                 $textes[$champ] = $afficher_diff($champ,$old[$champ],$new[$champ],$format);
     183                                if (!$afficher_diff = charger_fonction($objet . "_" . $champ, 'afficher_diff', true)
     184                                        AND !$afficher_diff = charger_fonction($champ, 'afficher_diff', true)
     185                                ) {
     186                                        $afficher_diff = (strncmp($champ, 'jointure_', 9) == 0 ? $afficher_diff_jointure : $afficher_diff_champ);
     187                                }
     188
     189                                $textes[$champ] = $afficher_diff($champ, $old[$champ], $new[$champ], $format);
    177190                        }
    178191                }
     
    181194        // que donner par defaut ? (par exemple si id_version=1)
    182195        if (!$textes) {
    183                 $textes = recuperer_version($id_objet,$objet, $id_version);
     196                $textes = recuperer_version($id_objet, $objet, $id_version);
    184197        }
    185198
  • _core_/plugins/revisions/prive/objets/contenu/revision_fonctions.php

    r93092 r93622  
    11<?php
    22
    3 if (!defined('_ECRIRE_INC_VERSION')) return;
     3if (!defined('_ECRIRE_INC_VERSION')) {
     4        return;
     5}
    46
    57/**
    68 * Trouver le label d'un champ de révision
    7  * 
     9 *
    810 * Quelques champs ont un label dans dans les chaînes de langue de SPIP
    911 * Pour un champ particulier d'un objet particulier, le pipeline revisions_chercher_label
    1012 * peut être utilisé
    11  * 
     13 *
    1214 * @param string $champ
    13  *              Le nom du champ révisionné
     15 *    Le nom du champ révisionné
    1416 * @param string $objet
    15  *              Le type d'objet révisionné
     17 *    Le type d'objet révisionné
    1618 * @return string $label
    17  *              Le label du champ
     19 *    Le label du champ
    1820 */
    19 function label_champ($champ, $objet = false){
     21function label_champ($champ, $objet = false) {
    2022        $label = "";
    2123        // si jointure: renvoyer le nom des objets joints
    22         if (strncmp($champ,'jointure_',9)==0)
    23                 return _T(objet_info(objet_type(substr($champ,9)),'texte_objets'));
    24        
    25         switch ($champ){
     24        if (strncmp($champ, 'jointure_', 9) == 0) {
     25                return _T(objet_info(objet_type(substr($champ, 9)), 'texte_objets'));
     26        }
     27
     28        switch ($champ) {
    2629                case 'surtitre':
    2730                        $label = "texte_sur_titre";
     
    3942                        $champ = "chapeau";
    4043                default:
    41                         $label = pipeline('revisions_chercher_label',array('args'=>array('champ'=>$champ,'objet'=>$objet),'data' => 'info_'.$champ));
     44                        $label = pipeline('revisions_chercher_label',
     45                                array('args' => array('champ' => $champ, 'objet' => $objet), 'data' => 'info_' . $champ));
    4246                        break;
    4347        }
    44         return $label?_T($label):"";
     48
     49        return $label ? _T($label) : "";
    4550}
    4651
  • _core_/plugins/revisions/prive/objets/liste/versions_fonctions.php

    r53214 r93622  
    11<?php
    22
    3 if (!defined('_ECRIRE_INC_VERSION')) return;
     3if (!defined('_ECRIRE_INC_VERSION')) {
     4        return;
     5}
    46
    57include_spip('inc/puce_statut');
  • _core_/plugins/revisions/prive/rss/revisions_fonctions.php

    r89285 r93622  
    1111\***************************************************************************/
    1212
    13 if (!defined("_ECRIRE_INC_VERSION")) return;
     13if (!defined("_ECRIRE_INC_VERSION")) {
     14        return;
     15}
    1416
    1517include_spip('inc/suivi_versions');
  • _core_/plugins/revisions/prive/squelettes/contenu/revision_fonctions.php

    r53214 r93622  
    11<?php
    22
    3 if (!defined('_ECRIRE_INC_VERSION')) return;
     3if (!defined('_ECRIRE_INC_VERSION')) {
     4        return;
     5}
    46
    57include_spip('inc/revisions');
  • _core_/plugins/revisions/revisions_administrations.php

    r93092 r93622  
    1515 *
    1616 * @package SPIP\Revisions\Installation
    17 **/
    18 
    19 if (!defined('_ECRIRE_INC_VERSION')) return;
     17 **/
     18
     19if (!defined('_ECRIRE_INC_VERSION')) {
     20        return;
     21}
    2022
    2123/**
     
    2527 * @param string $version_cible
    2628 */
    27 function revisions_upgrade($nom_meta_base_version, $version_cible){
     29function revisions_upgrade($nom_meta_base_version, $version_cible) {
    2830        // cas particulier :
    2931        // si plugin pas installe mais que la table existe
    3032        // considerer que c'est un upgrade depuis v 1.0.0
    3133        // pour gerer l'historique des installations SPIP <=2.1
    32         if (!isset($GLOBALS['meta'][$nom_meta_base_version])){
    33                 $trouver_table = charger_fonction('trouver_table','base');
     34        if (!isset($GLOBALS['meta'][$nom_meta_base_version])) {
     35                $trouver_table = charger_fonction('trouver_table', 'base');
    3436                if ($desc = $trouver_table('spip_versions')
    35                   AND isset($desc['exist']) AND $desc['exist']
    36                   AND isset($desc['field']['id_article'])){
    37                         ecrire_meta($nom_meta_base_version,'1.0.0');
     37                        AND isset($desc['exist']) AND $desc['exist']
     38                        AND isset($desc['field']['id_article'])
     39                ) {
     40                        ecrire_meta($nom_meta_base_version, '1.0.0');
    3841                }
    3942                // si pas de table en base, on fera une simple creation de base
     
    4245        $maj = array();
    4346        $maj['create'] = array(
    44                 array('maj_tables',array('spip_versions','spip_versions_fragments')),
     47                array('maj_tables', array('spip_versions', 'spip_versions_fragments')),
    4548                array('revisions_upate_meta'),
    4649        );
     
    4952                // Ajout du champs objet et modification du champs id_article en id_objet
    5053                // sur les 2 tables spip_versions et spip_versions_fragments
    51                 array('sql_alter',"TABLE spip_versions CHANGE id_article id_objet bigint(21) DEFAULT 0 NOT NULL"),
    52                 array('sql_alter',"TABLE spip_versions ADD objet VARCHAR (25) DEFAULT '' NOT NULL AFTER id_objet"),
     54                array('sql_alter', "TABLE spip_versions CHANGE id_article id_objet bigint(21) DEFAULT 0 NOT NULL"),
     55                array('sql_alter', "TABLE spip_versions ADD objet VARCHAR (25) DEFAULT '' NOT NULL AFTER id_objet"),
    5356                // Les id_objet restent les id_articles puisque les révisions n'étaient possibles que sur les articles
    54                 array('sql_updateq',"spip_versions",array('objet'=>'article'),"objet=''"),
     57                array('sql_updateq', "spip_versions", array('objet' => 'article'), "objet=''"),
    5558                // Changement des clefs primaires également
    56                 array('sql_alter',"TABLE spip_versions DROP PRIMARY KEY"),
    57                 array('sql_alter',"TABLE spip_versions ADD PRIMARY KEY (id_version, id_objet, objet)"),
    58 
    59                 array('sql_alter',"TABLE spip_versions_fragments CHANGE id_article id_objet bigint(21) DEFAULT 0 NOT NULL"),
    60                 array('sql_alter',"TABLE spip_versions_fragments ADD objet VARCHAR (25) DEFAULT '' NOT NULL AFTER id_objet"),
     59                array('sql_alter', "TABLE spip_versions DROP PRIMARY KEY"),
     60                array('sql_alter', "TABLE spip_versions ADD PRIMARY KEY (id_version, id_objet, objet)"),
     61
     62                array('sql_alter', "TABLE spip_versions_fragments CHANGE id_article id_objet bigint(21) DEFAULT 0 NOT NULL"),
     63                array('sql_alter', "TABLE spip_versions_fragments ADD objet VARCHAR (25) DEFAULT '' NOT NULL AFTER id_objet"),
    6164                // Les id_objet restent les id_articles puisque les révisions n'étaient possibles que sur les articles
    62                 array('sql_updateq',"spip_versions_fragments",array('objet'=>'article'),"objet=''"),
     65                array('sql_updateq', "spip_versions_fragments", array('objet' => 'article'), "objet=''"),
    6366                // Changement des clefs primaires également
    64                 array('sql_alter',"TABLE spip_versions_fragments DROP PRIMARY KEY"),
    65                 array('sql_alter',"TABLE spip_versions_fragments ADD PRIMARY KEY (id_objet, objet, id_fragment, version_min)"),
     67                array('sql_alter', "TABLE spip_versions_fragments DROP PRIMARY KEY"),
     68                array('sql_alter', "TABLE spip_versions_fragments ADD PRIMARY KEY (id_objet, objet, id_fragment, version_min)"),
    6669                array('revisions_upate_meta'),
    6770        );
    6871        $maj['1.1.2'] = array(
    6972                array('revisions_upate_meta'),
    70                 array('sql_updateq',"spip_versions",array('objet'=>'article'),"objet=''"),
    71                 array('sql_updateq',"spip_versions_fragments",array('objet'=>'article'),"objet=''"),
     73                array('sql_updateq', "spip_versions", array('objet' => 'article'), "objet=''"),
     74                array('sql_updateq', "spip_versions_fragments", array('objet' => 'article'), "objet=''"),
    7275        );
    7376        $maj['1.1.3'] = array(
    74                 array('sql_alter',"TABLE spip_versions DROP KEY id_objet"),
    75                 array('sql_alter',"TABLE spip_versions ADD INDEX id_version (id_version)"),
    76                 array('sql_alter',"TABLE spip_versions ADD INDEX id_objet (id_objet)"),
    77                 array('sql_alter',"TABLE spip_versions ADD INDEX objet (objet)")
     77                array('sql_alter', "TABLE spip_versions DROP KEY id_objet"),
     78                array('sql_alter', "TABLE spip_versions ADD INDEX id_version (id_version)"),
     79                array('sql_alter', "TABLE spip_versions ADD INDEX id_objet (id_objet)"),
     80                array('sql_alter', "TABLE spip_versions ADD INDEX objet (objet)")
    7881        );
    7982        $maj['1.1.4'] = array(
    80                 array('sql_alter',"TABLE spip_versions CHANGE permanent permanent char(3) DEFAULT '' NOT NULL"),
    81                 array('sql_alter',"TABLE spip_versions CHANGE champs champs text DEFAULT '' NOT NULL"),
     83                array('sql_alter', "TABLE spip_versions CHANGE permanent permanent char(3) DEFAULT '' NOT NULL"),
     84                array('sql_alter', "TABLE spip_versions CHANGE champs champs text DEFAULT '' NOT NULL"),
    8285        );
    8386        $maj['1.2.0'] = array(
     
    9194}
    9295
    93 function revisions_uncompress_fragments(){
    94 
    95         $res = sql_select("*","spip_versions_fragments","compress=".intval(1));
    96         while($row = sql_fetch($res)){
     96function revisions_uncompress_fragments() {
     97
     98        $res = sql_select("*", "spip_versions_fragments", "compress=" . intval(1));
     99        while ($row = sql_fetch($res)) {
    97100                $fragment = @gzuncompress($row['fragment']);
    98101
    99102                // si la decompression echoue, on met en base le flag 'corrompu-gz'
    100103                // et au dump le framgment compresse dans un fichier
    101                 if (strlen($row['fragment']) AND $fragment===false){
    102                         $dir_tmp = sous_repertoire(_DIR_TMP,"versions_fragments_corrompus");
    103                         $f = $row['id_fragment']."-".$row['objet']."-".$row['id_objet'];
    104                         spip_log("Fragment gz corrompu $f","maj"._LOG_ERREUR);
    105                         $f = $f."-gz.txt";
    106                         ecrire_fichier($dir_tmp . $f,$row['fragment']);
     104                if (strlen($row['fragment']) AND $fragment === false) {
     105                        $dir_tmp = sous_repertoire(_DIR_TMP, "versions_fragments_corrompus");
     106                        $f = $row['id_fragment'] . "-" . $row['objet'] . "-" . $row['id_objet'];
     107                        spip_log("Fragment gz corrompu $f", "maj" . _LOG_ERREUR);
     108                        $f = $f . "-gz.txt";
     109                        ecrire_fichier($dir_tmp . $f, $row['fragment']);
    107110                        $fragment = "corrompu-gz";
    108111                }
     
    113116                );
    114117
    115                 sql_updateq("spip_versions_fragments",$set,"id_fragment=".intval($row['id_fragment'])." AND id_objet=".intval($row['id_objet'])." AND objet=".sql_quote($row['objet'])." AND version_min=".intval($row['version_min']));
    116                 if (time()>_TIME_OUT) return;
    117         }
    118 
    119         sql_updateq("spip_versions_fragments",array('compress'=>-1));
    120 
    121 }
    122 
    123 function revisions_repair_unserialized_fragments(){
    124         $res = sql_select("*","spip_versions_fragments","compress=".intval(-1));
     118                sql_updateq("spip_versions_fragments", $set,
     119                        "id_fragment=" . intval($row['id_fragment']) . " AND id_objet=" . intval($row['id_objet']) . " AND objet=" . sql_quote($row['objet']) . " AND version_min=" . intval($row['version_min']));
     120                if (time() > _TIME_OUT) {
     121                        return;
     122                }
     123        }
     124
     125        sql_updateq("spip_versions_fragments", array('compress' => -1));
     126
     127}
     128
     129function revisions_repair_unserialized_fragments() {
     130        $res = sql_select("*", "spip_versions_fragments", "compress=" . intval(-1));
    125131        $n = sql_count($res);
    126         spip_log("$n fragments a verifier","maj");
    127         while($row = sql_fetch($res)){
     132        spip_log("$n fragments a verifier", "maj");
     133        while ($row = sql_fetch($res)) {
    128134                $fragment = $row['fragment'];
    129135                $set = array(
     
    132138
    133139                // verifier que le fragment est bien serializable
    134                 if(unserialize($fragment)===false AND strncmp($fragment,"corrompu",8)!==0){
    135                         $dir_tmp = sous_repertoire(_DIR_TMP,"versions_fragments_corrompus");
     140                if (unserialize($fragment) === false AND strncmp($fragment, "corrompu", 8) !== 0) {
     141                        $dir_tmp = sous_repertoire(_DIR_TMP, "versions_fragments_corrompus");
    136142                        $set['fragment'] = revisions_repair_serialise($fragment);
    137                         if (strncmp($set['fragment'],"corrompu",8)==0){
     143                        if (strncmp($set['fragment'], "corrompu", 8) == 0) {
    138144                                $f = $row['id_fragment'] . "-" . $row['objet'] . "-" . $row['id_objet'];
    139145                                spip_log("Fragment serialize corrompu $f", "maj" . _LOG_ERREUR);
     
    142148                        }
    143149                }
    144                 sql_updateq("spip_versions_fragments",$set,$w = "id_fragment=".intval($row['id_fragment'])." AND id_objet=".intval($row['id_objet'])." AND objet=".sql_quote($row['objet'])." AND version_min=".intval($row['version_min']));
     150                sql_updateq("spip_versions_fragments", $set,
     151                        $w = "id_fragment=" . intval($row['id_fragment']) . " AND id_objet=" . intval($row['id_objet']) . " AND objet=" . sql_quote($row['objet']) . " AND version_min=" . intval($row['version_min']));
    145152                #spip_log($w,"maj");
    146153
    147                 if (time()>_TIME_OUT) return;
    148         }
    149 }
    150 
    151 function revisions_repair_serialise($serialize){
    152         if (unserialize($serialize))
     154                if (time() > _TIME_OUT) {
     155                        return;
     156                }
     157        }
     158}
     159
     160function revisions_repair_serialise($serialize) {
     161        if (unserialize($serialize)) {
    153162                return $serialize;
     163        }
    154164
    155165        // verifier les strings
    156         preg_match_all(",s:(\d+):\"(.*)\";(?=}|\w:\d+),Uims",$serialize,$matches,PREG_SET_ORDER);
     166        preg_match_all(",s:(\d+):\"(.*)\";(?=}|\w:\d+),Uims", $serialize, $matches, PREG_SET_ORDER);
    157167        $serialize_repair = $serialize;
    158         foreach($matches as $match){
     168        foreach ($matches as $match) {
    159169                $s = $match[2];
    160170                $l = $match[1];
    161                 if (strlen($s)!==$l){
    162                         if (strlen($s)<$l){
    163                                 $s = str_replace("\r\n","\n",$s);
    164                                 $s = str_replace("\r","\n",$s);
    165                                 $s = str_replace("\n","\r\n",$s);
    166                         }
    167                         if (strlen($s)>$l){
    168                                 $s = str_replace("\r\n","\n",$s);
    169                                 $s = str_replace("\r","\n",$s);
    170                         }
    171                         if (strlen($s)<$l){
    172                                 $s .= str_pad("",$l-strlen($s)," ");
    173                         }
    174                         if (strlen($s)==$l){
    175                                 $s = str_replace($match[2],$s,$match[0]);
    176                                 $serialize_repair = str_replace($match[0],$s,$serialize_repair);
    177                         }
    178                 }
    179         }
    180         if (unserialize($serialize_repair))
     171                if (strlen($s) !== $l) {
     172                        if (strlen($s) < $l) {
     173                                $s = str_replace("\r\n", "\n", $s);
     174                                $s = str_replace("\r", "\n", $s);
     175                                $s = str_replace("\n", "\r\n", $s);
     176                        }
     177                        if (strlen($s) > $l) {
     178                                $s = str_replace("\r\n", "\n", $s);
     179                                $s = str_replace("\r", "\n", $s);
     180                        }
     181                        if (strlen($s) < $l) {
     182                                $s .= str_pad("", $l-strlen($s), " ");
     183                        }
     184                        if (strlen($s) == $l) {
     185                                $s = str_replace($match[2], $s, $match[0]);
     186                                $serialize_repair = str_replace($match[0], $s, $serialize_repair);
     187                        }
     188                }
     189        }
     190        if (unserialize($serialize_repair)) {
    181191                return $serialize_repair;
     192        }
    182193
    183194        // on essaye brutalement
    184195        $serialize_repair = $serialize;
    185         $serialize_repair = str_replace("\r\n","\n",$serialize_repair);
    186         $serialize_repair = str_replace("\r","\n",$serialize_repair);
    187         if (unserialize($serialize_repair))
     196        $serialize_repair = str_replace("\r\n", "\n", $serialize_repair);
     197        $serialize_repair = str_replace("\r", "\n", $serialize_repair);
     198        if (unserialize($serialize_repair)) {
    188199                return $serialize_repair;
    189         $serialize_repair = str_replace("\n","\r\n",$serialize_repair);
    190         if (unserialize($serialize_repair))
     200        }
     201        $serialize_repair = str_replace("\n", "\r\n", $serialize_repair);
     202        if (unserialize($serialize_repair)) {
    191203                return $serialize_repair;
     204        }
    192205
    193206        #echo "Impossible de reparer la chaine :";
     
    195208        #var_dump($matches);
    196209        #die("corrompu-serialize");
    197         return  "corrompu-serialize";
     210        return "corrompu-serialize";
    198211}
    199212
     
    213226/**
    214227 * Mettre a jour la meta des versions
     228 *
    215229 * @return void
    216230 */
    217 function revisions_upate_meta(){
     231function revisions_upate_meta() {
    218232        // Si dans une installation antérieure ou un upgrade, les articles étaient versionnés
    219233        // On crée la meta correspondante
    220234        // mettre les metas par defaut
    221         $config = charger_fonction('config','inc');
     235        $config = charger_fonction('config', 'inc');
    222236        $config();
    223         if (isset($GLOBALS['meta']['articles_versions']) and $GLOBALS['meta']['articles_versions'] == 'oui'){
    224                 ecrire_meta('objets_versions',serialize(array('articles')));
     237        if (isset($GLOBALS['meta']['articles_versions']) and $GLOBALS['meta']['articles_versions'] == 'oui') {
     238                ecrire_meta('objets_versions', serialize(array('articles')));
    225239        }
    226240        effacer_meta('articles_versions');
    227         if (!$versions = unserialize($GLOBALS['meta']['objets_versions']))
     241        if (!$versions = unserialize($GLOBALS['meta']['objets_versions'])) {
    228242                $versions = array();
    229         $versions = array_map('table_objet_sql',$versions);
    230         ecrire_meta('objets_versions',serialize($versions));
     243        }
     244        $versions = array_map('table_objet_sql', $versions);
     245        ecrire_meta('objets_versions', serialize($versions));
    231246}
    232247
  • _core_/plugins/revisions/revisions_ieconfig.php

    r65096 r93622  
    22
    33/**
    4  * Enregistrer les config avec le plugin IEConfig 
     4 * Enregistrer les config avec le plugin IEConfig
    55 *
    66 * @package SPIP\Revisions\Pipelines
    7 **/
    8 if (!defined("_ECRIRE_INC_VERSION")) return;
     7 **/
     8if (!defined("_ECRIRE_INC_VERSION")) {
     9        return;
     10}
    911
    1012/**
     
    1214 *
    1315 * @pipeline ieconfig_metas
    14  * @param array $table  Description des configurations
     16 * @param array $table Description des configurations
    1517 * @return array        Description des configurations
    16 **/
    17 function revisions_ieconfig_metas($table){
     18 **/
     19function revisions_ieconfig_metas($table) {
    1820        $table['revisions']['titre'] = _T('revisions:titre_revisions');
    1921        $table['revisions']['icone'] = 'revision-16.png';
    2022        $table['revisions']['metas_serialize'] = 'objets_versions';
    21        
     23
    2224        return $table;
    2325}
Note: See TracChangeset for help on using the changeset viewer.