Changeset 93622 in spip-zone for _core_/plugins/revisions/inc/diff.php


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

File:
1 edited

Legend:

Unmodified
Added
Removed
  • _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}
Note: See TracChangeset for help on using the changeset viewer.