includes/svncommon.php

   1 <?php
   2 /*=====================================================================*\
   3 || ###################################################################
   4 || # ViewSVN [#]version[#]
   5 || # Copyright ©2002-[#]year[#] Iris Studios, Inc.
   6 || #
   7 || # This program is free software; you can redistribute it and/or modify
   8 || # it under the terms of the GNU General Public License as published by
   9 || # the Free Software Foundation; version [#]gpl[#] of the License.
  10 || #
  11 || # This program is distributed in the hope that it will be useful, but
  12 || # WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13 || # or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
  14 || # more details.
  15 || #
  16 || # You should have received a copy of the GNU General Public License along
  17 || # with this program; if not, write to the Free Software Foundation, Inc.,
  18 || # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
  19 || ###################################################################
  20 \*=====================================================================*/
  21
  22 /**
  23 * Common functions that aren't Xquery-related and advanced query systems
  24 *
  25 * @package      ViewSVN
  26 */
  27
  28 /**
  29 * Interacts with the command line subsystem to
  30 * access SVN information
  31 *
  32 * @package      ViewSVN
  33 * @version      $Id$
  34 */
  35 class SVNCommon
  36 {
  37         /**
  38         * Path to the SVN binary
  39         * @var  string
  40         */
  41         var $svnpath;
  42
  43         /**
  44         * Constructor
  45         */
  46         function SVNLib()
  47         {
  48                 global $viewsvn;
  49         }
  50
  51         /**
  52         * Prepares data for output
  53         *
  54         * @access       public
  55         *
  56         * @param        string  Standard data
  57         *
  58         * @return       string  Output-ready data
  59         */
  60         function format($string)
  61         {
  62                 // convert entities
  63                 $string = htmlspecialchars($string);
  64
  65                 // tabs to 5 spaces
  66                 $string = str_replace("\t", '     ', $string);
  67
  68                 // spaces to nbsp
  69                 if (true)
  70                 {
  71                         $string = preg_replace('#( +)#e', '$this->format_spaces("\1")', $string);
  72                 }
  73                 // no word wrap
  74                 else
  75                 {
  76                         $string = str_replace(' ', '&nbsp;', $string);
  77                 }
  78
  79                 // convert advanced diff
  80                 $string = str_replace(array('{@+' . '+}', '{@-' . '-}'), array('<span class="diff_add_bit">', '<span class="diff_del_bit">'), $string);
  81                 $string = str_replace(array('{/@+' . '+}', '{/@-' . '-}'), '</span>', $string);
  82
  83                 // nl2br
  84                 $string = nl2br($string);
  85
  86                 return $string;
  87         }
  88
  89         /**
  90         * Formats a SVN log message
  91         *
  92         * @access       public
  93         *
  94         * @param        string  Unformatted log message
  95         *
  96         * @return       string  Output-ready log message
  97         */
  98         function format_log_message($message)
  99         {
 100                 global $viewsvn;
 101
 102                 $message = $viewsvn->entity_encode($message);
 103
 104                 $message = preg_replace('#r([0-9]+)#e', '"<a href=\"" . $viewsvn->path . "/" . $viewsvn->paths->out("diff.php" . $viewsvn->paths->fetch_rev_str(true, "\1", 0), $viewsvn->paths->fetch_repos($viewsvn->paths->parse()) . "/") . "\">r\1</a>"', $message);
 105
 106                 $list = false;
 107                 $lines = explode("\n", $message);
 108                 $message = '';
 109                 foreach ($lines AS $line)
 110                 {
 111                         if (preg_match('#^\s*?(\*|\-)\s?(.*)#', $line, $matches))
 112                         {
 113                                 if ($list)
 114                                 {
 115                                         $message .= '<li>' . $matches[2] . '</li>';
 116                                 }
 117                                 else
 118                                 {
 119                                         $message .= '<ul class="list">';
 120                                         $message .= '<li>' . $matches[2] . '</li>';
 121                                 }
 122                                 $list = true;
 123                         }
 124                         else
 125                         {
 126                                 if ($list)
 127                                 {
 128                                         $message .= '</ul>';
 129                                         $message .= $line;
 130                                 }
 131                                 else
 132                                 {
 133                                         $message .= $line;
 134                                         $message .= '<br />';
 135                                 }
 136                                 $list = false;
 137                         }
 138
 139                         $message .= "\n";
 140                 }
 141
 142                 if ($list)
 143                 {
 144                         $message .= '</ul>';
 145                 }
 146
 147                 $message = preg_replace('#(<br />)*$#', '', $message);
 148
 149                 return $message;
 150         }
 151
 152         // ###################################################################
 153         /**
 154         * Parses a date from Xquery XML outut
 155         *
 156         * @access       public
 157         *
 158         * @param        string  Date string
 159         *
 160         * @return       string  Formatted and readable date string
 161         */
 162         function format_date_string($string)
 163         {
 164                 // 2005-01-23T20:42:53.703057Z
 165                 return preg_replace('#(....)\-(..)\-(..)T(..):(..):(..).(.*)Z#e', 'gmdate("r", mktime(\4, \5, \6, \2, \3, \1))', $string);
 166         }
 167
 168         /**
 169         * Counts the spaces and replaces two or more ones
 170         *
 171         * @access       private
 172         *
 173         * @param        string  Spaced string
 174         *
 175         * @return       string  &nbsp;'d string
 176         */
 177         function format_spaces($thestring)
 178         {
 179                 if (strlen($thestring) >= 2)
 180                 {
 181                         $thestring = str_replace(' ', '&nbsp;', $thestring);
 182                 }
 183
 184                 return $thestring;
 185         }
 186
 187         /**
 188         * Prints the file changed list
 189         *
 190         * @access       public
 191         *
 192         * @public       array   List of file changes
 193         * @public       string  The repository
 194         * @public       integer Current revision
 195         *
 196         * @return       string  Processed HTML
 197         */
 198         function construct_file_changes($changes, $repos, $revision)
 199         {
 200                 global $viewsvn;
 201
 202                 $files = '';
 203
 204                 foreach ($changes AS $file)
 205                 {
 206                         switch ($file['action'])
 207                         {
 208                                 case 'A':
 209                                         $class = 'file_add';
 210                                         $tooltip = $viewsvn->lang->string('Added');
 211                                         break;
 212                                 case 'D':
 213                                         $class = 'file_delete';
 214                                         $tooltip = $viewsvn->lang->string('Deleted');
 215                                         break;
 216                                 case 'M':
 217                                         $class = 'file_modify';
 218                                         $tooltip = $viewsvn->lang->string('Modified');
 219                                         break;
 220                                 case 'R':
 221                                         $class = 'file_replace';
 222                                         $tooltip = $viewsvn->lang->string('Replaced');
 223                                         break;
 224                         }
 225
 226                         $show['from'] = (bool)$file['from'];
 227
 228                         if ($file['from'])
 229                         {
 230                                 $class = 'file_move';
 231                                 $tooltip = 'Moved/Copied';
 232                                 preg_match('#(.*):([0-9]+)#', $file['from'], $matches);
 233                                 $link['from'] = $viewsvn->paths->out('view.php' . $viewsvn->paths->fetch_rev_str(false, $matches[2]), $repos . $matches[1]);
 234                         }
 235
 236                         $link['file'] = $viewsvn->paths->out('view.php' . $viewsvn->paths->fetch_rev_str(false, $revision), $repos . $file['file']);
 237
 238                         eval('$files .= "' . $viewsvn->template->fetch('file_change') . '";');
 239                 }
 240
 241                 return $files;
 242         }
 243 }
 244
 245 /**
 246 * Annotation/blame system; constructs an array
 247 * that is ready for output
 248 *
 249 * @package      ViewSVN
 250 * @version      $Id$
 251 */
 252 class SVNBlame
 253 {
 254         /**
 255         * Array of blame information
 256         * @var  array
 257         */
 258         var $blame = array();
 259
 260         /**
 261         * Raw "svn blame" output
 262         * @var  array
 263         */
 264         var $rawoutput;
 265
 266         /**
 267         * Constructor: create blame and store data
 268         *
 269         * @param        string  Repository
 270         * @param        string  Path
 271         * @param        integer Revision
 272         */
 273         function SVNBlame($repos, $path, $revision)
 274         {
 275                 global $viewsvn;
 276
 277                 $this->rawoutput = $viewsvn->svn->blame($repos, $path, $revision);
 278                 $this->process();
 279         }
 280
 281         /**
 282         * Returns blame for display
 283         *
 284         * @access       public
 285         *
 286         * @return       array   Blame data
 287         */
 288         function fetch()
 289         {
 290                 return $this->blame;
 291         }
 292
 293         /**
 294         * Parses the blame data
 295         *
 296         * @access       private
 297         */
 298         function process()
 299         {
 300                 $lineno = 1;
 301
 302                 foreach ($this->rawoutput AS $line)
 303                 {
 304                         if (preg_match('#^\s+([0-9]+)\s+([\w\.\-_]+)\s(.*)$#', $line, $matches))
 305                         {
 306                                 $this->blame[] = array(
 307                                         'rev'           => $matches[1],
 308                                         'author'        => $matches[2],
 309                                         'line'          => $matches[3],
 310                                         'lineno'        => $lineno++
 311                                 );
 312                         }
 313                         // a blank line
 314                         else if (preg_match('#^\s+([0-9]+)\s+([\w\.\-_]+)$#', $line, $matches))
 315                         {
 316                                 $this->blame[] = array(
 317                                         'rev'           => $matches[1],
 318                                         'author'        => $matches[2],
 319                                         'line'          => '',
 320                                         'lineno'        => $lineno++
 321                                 );
 322                         }
 323                 }
 324         }
 325 }
 326
 327 /**
 328 * Log management system; creates a complex list
 329 * of SVN log information
 330 *
 331 * @package      ViewSVN
 332 * @version      $Id$
 333 */
 334 class SVNLog
 335 {
 336         /**
 337         * Array of logs
 338         * @var  array
 339         */
 340         var $logs = array();
 341
 342         /**
 343         * Raw "svn log" output
 344         * @var  array
 345         */
 346         var $rawoutput;
 347
 348         /**
 349         * Constructor: create log store for the given file
 350         *
 351         * @param        string  Repository
 352         * @param        string  Path
 353         * @param        integer Lower revision
 354         * @param        integer Higher revision
 355         */
 356         function SVNLog($repos, $path, $lorev, $hirev)
 357         {
 358                 global $viewsvn;
 359
 360                 $this->rawoutput = $viewsvn->svn->log($repos, $path, $lorev, $hirev);
 361                 $this->process();
 362         }
 363
 364         /**
 365         * Returns logs for display
 366         *
 367         * @access       public
 368         *
 369         * @return       array   Log data
 370         */
 371         function fetch()
 372         {
 373                 return $this->logs;
 374         }
 375
 376         /**
 377         * Splits up the raw output into a usable log
 378         *
 379         * @access       private
 380         */
 381         function process()
 382         {
 383                 $lastrev = 0;
 384
 385                 for ($i = 1; $i <= count($this->rawoutput) - 1; $i++)
 386                 {
 387                         $line = $this->rawoutput["$i"];
 388
 389                         if (preg_match('#^r([0-9]*) \| (.*?) \| (....-..-.. ..:..:..) ([0-9\-]*) \((.*?)\) \| ([0-9]*) lines?$#', $line, $matches))
 390                         {
 391                                 if (isset($this->logs["$lastrev"]))
 392                                 {
 393                                         $this->logs["$lastrev"]['message'] = $this->strip_last_line($this->logs["$lastrev"]['message']);
 394                                 }
 395
 396                                 $this->logs["$matches[1]"] = array(
 397                                         'rev'           => $matches[1],
 398                                         'author'        => $matches[2],
 399                                         'date'          => $matches[3],
 400                                         'timezone'      => $matches[4],
 401                                         'lines'         => $matches[6],
 402                                         'message'       => ''
 403                                 );
 404
 405                                 $lastrev = $matches[1];
 406                         }
 407                         else if (preg_match('#^\s+([ADMR])\s(.*)#', $line, $matches))
 408                         {
 409                                 if (preg_match('#(.*) \(from (.*?)\)$#', $matches[2], $amatches))
 410                                 {
 411                                         $matches[2] = $amatches[1];
 412                                 }
 413
 414                                 $this->logs["$lastrev"]['files'][] = array(
 415                                         'action'        => $matches[1],
 416                                         'file'          => trim($matches[2]),
 417                                         'from'          => (isset($amatches[2]) ? $amatches[2] : '')
 418                                 );
 419                         }
 420                         else
 421                         {
 422                                 if (trim($line) != 'Changed paths:')
 423                                 {
 424                                         $this->logs["$lastrev"]['message'] .= $line . "\n";
 425                                 }
 426                         }
 427                 }
 428
 429                 if (isset($this->logs["$lastrev"]))
 430                 {
 431                         $this->logs["$lastrev"]['message'] = $this->strip_last_line($this->logs["$lastrev"]['message']);
 432                 }
 433         }
 434
 435         /**
 436         * Trims the last dash line off a message
 437         *
 438         * @access       private
 439         *
 440         * @param        string  Message with annoying-ass line
 441         *
 442         * @return       string  Clean string
 443         */
 444         function strip_last_line($string)
 445         {
 446                 return trim(preg_replace("#\n(.*?)\n$#", '', $string));
 447         }
 448 }
 449
 450 /**
 451 * Diff system; constructs a diff array that
 452 * is ready for output
 453 *
 454 * @package      ViewSVN
 455 */
 456 class SVNDiff
 457 {
 458         /**
 459         * Array of diff information
 460         * @var  array
 461         */
 462         var $diff = array();
 463
 464         /**
 465         * Raw "svn diff" output
 466         * @var  array
 467         */
 468         var $rawoutput;
 469
 470         /**
 471         * Constructor: create and store diff data
 472         *
 473         * @param        string  Repository
 474         * @param        string  Path
 475         * @param        integer Lower revision
 476         * @param        integer Higher revision
 477         */
 478         function SVNDiff($repos, $path, $lorev, $hirev)
 479         {
 480                 global $viewsvn;
 481
 482                 $this->rawoutput = $viewsvn->svn->diff($repos, $path, $lorev, $hirev);
 483                 $this->process();
 484         }
 485
 486         /**
 487         * Returns diffs for display
 488         *
 489         * @access       public
 490         *
 491         * @return       array   Diff data
 492         */
 493         function fetch()
 494         {
 495                 return $this->diff;
 496         }
 497
 498         /**
 499         * Processes and prepares diff data
 500         *
 501         * @access       private
 502         */
 503         function process()
 504         {
 505                 global $viewsvn;
 506
 507                 $chunk = 0;
 508                 $indexcounter = null;
 509                 $curprop = '';
 510
 511                 $delstack = array();
 512
 513                 foreach ($this->rawoutput AS $line)
 514                 {
 515                         if (preg_match('#^@@ \-([0-9]*),([0-9]*) \+([0-9]*),([0-9]*) @@$#', $line, $bits))
 516                         {
 517                                 $property = false;
 518                                 $delstack = array();
 519                                 $this->diff["$index"][ ++$chunk ]['hunk'] = array('old' => array('line' => $bits[1], 'count' => $bits[2]), 'new' => array('line' => $bits[3], 'count' => $bits[4]));
 520                                 $lines['old'] = $this->diff["$index"]["$chunk"]['hunk']['old']['line'] - 1;
 521                                 $lines['new'] = $this->diff["$index"]["$chunk"]['hunk']['new']['line'] - 1;
 522                                 continue;
 523                         }
 524                         else if (preg_match('#^Property changes on: (.*?)$#', $line, $bits))
 525                         {
 526                                 $property = true;
 527                                 $index = $bits[1];
 528                                 $this->diff["$index"]['props'] = array();
 529                                 continue;
 530                         }
 531
 532                         if ($indexcounter <= 3 AND $indexcounter !== null)
 533                         {
 534                                 $indexcounter++;
 535                                 continue;
 536                         }
 537                         else if ($indexcounter == 3)
 538                         {
 539                                 $indexcounter = null;
 540                                 continue;
 541                         }
 542
 543                         if (preg_match('#^([\+\- ])(.*)#', $line, $matches) AND !$property)
 544                         {
 545                                 $act = $matches[1];
 546                                 $content = $matches[2];
 547
 548                                 if ($act == ' ')
 549                                 {
 550                                         $this->diff["$index"]["$chunk"][] = array(
 551                                                 'line'          => $content,
 552                                                 'act'           => '',
 553                                                 'oldlineno'     => ++$lines['old'],
 554                                                 'newlineno'     => ++$lines['new']
 555                                         );
 556
 557                                         $delstack = array();
 558                                 }
 559                                 else if ($act == '+')
 560                                 {
 561                                         // potential line delta
 562                                         if (count($delstack) > 0)
 563                                         {
 564                                                 $lastline = array_shift($delstack);
 565
 566                                                 if ($delta = @$this->fetch_diff_extent($lastline['line'], $content))
 567                                                 {
 568                                                         if (strlen($lastline['line']) > ($delta['start'] - $delta['end']))
 569                                                         {
 570                                                                 $end = strlen($lastline['line']) + $delta['end'];
 571                                                                 $viewsvn->debug("RM delta- = " . $end);
 572                                                                 $change = '{@-' . '-}' . substr($lastline['line'], $delta['start'], $end - $delta['start']) . '{/@-' . '-}';
 573                                                                 $this->diff["$index"]["$chunk"]["$lastline[INDEX]"]['line'] = substr($lastline['line'], 0, $delta['start']) . $change . substr($lastline['line'], $end);
 574                                                         }
 575
 576                                                         if (strlen($content) > $delta['start'] - $delta['end'])
 577                                                         {
 578                                                                 $end = strlen($content) + $delta['end'];
 579                                                                 $viewsvn->debug("MK delta+ = " . $end);
 580                                                                 $change = '{@+' . '+}' . substr($content, $delta['start'], $end - $delta['start']) . '{/@+' . '+}';
 581                                                                 $content = substr($content, 0, $delta['start']) . $change . substr($content, $end);
 582                                                         }
 583                                                 }
 584                                         }
 585
 586                                         $this->diff["$index"]["$chunk"][] = array(
 587                                                 'line'          => $content,
 588                                                 'act'           => '+',
 589                                                 'oldlineno'     => '',
 590                                                 'newlineno'     => ++$lines['new']
 591                                         );
 592                                 }
 593                                 else if ($act == '-')
 594                                 {
 595                                         $this->diff["$index"]["$chunk"][] = $thearray = array(
 596                                                 'line'          => $content,
 597                                                 'act'           => '-',
 598                                                 'oldlineno'     => ++$lines['old'],
 599                                                 'newlineno'     => ''
 600                                         );
 601
 602                                         $key = count($this->diff["$index"]["$chunk"]) - 2;
 603                                         $thearray['INDEX'] = $key;
 604
 605                                         array_push($delstack, $thearray);
 606                                 }
 607                         }
 608                         // whitespace lines
 609                         else
 610                         {
 611                                 if (preg_match('#^Index: (.*?)$#', $line, $matches))
 612                                 {
 613                                         $index = $matches[1];
 614                                         $indexcounter = 1;
 615                                         $chunk = 0;
 616                                         continue;
 617                                 }
 618
 619                                 if ($property)
 620                                 {
 621                                         if (preg_match('#^__*_$#', trim($line)))
 622                                         {
 623                                                 $viewsvn->debug("skipping: $line");
 624                                                 continue;
 625                                         }
 626
 627                                         if (preg_match('#Name: (.*?)$#', $line, $matches))
 628                                         {
 629                                                 $curprop = $matches[1];
 630                                                 $viewsvn->debug("prop: $curprop");
 631                                                 continue;
 632                                         }
 633                                         else
 634                                         {
 635                                                 if (preg_match('#^\s+?\+(.*)#', $line, $matches))
 636                                                 {
 637                                                         $mode = 'add';
 638                                                         $this->diff["$index"]['props']["$curprop"]['add'] .= $matches[1];
 639                                                 }
 640                                                 else if (preg_match('#^\s+?\-(.*)#', $line, $matches))
 641                                                 {
 642                                                         $mode = 'del';
 643                                                         $this->diff["$index"]['props']["$curprop"]['del'] .= $matches[1];
 644                                                 }
 645                                                 else if (!preg_match('#^\s+[\+\- ](.*)#', $line) AND trim($line) != '')
 646                                                 {
 647                                                         $this->diff["$index"]['props']["$curprop"]["$mode"] .= "\n" . $line;
 648                                                 }
 649                                                 continue;
 650                                         }
 651                                 }
 652
 653                                 $this->diff["$index"]["$chunk"][] = array(
 654                                         'line'          => '',
 655                                         'act'           => '',
 656                                         'oldlineno'     => ++$lines['old'],
 657                                         'newlineno'     => ++$lines['new']
 658                                 );
 659
 660                                 $delstack = array();
 661                         }
 662                 }
 663         }
 664
 665         /**
 666         * Returns the amount of change that occured
 667         * between two lines
 668         *
 669         * @access       private
 670         *
 671         * @param        string  Old line
 672         * @param        string  New line
 673         *
 674         * @return       array   Difference of positions
 675         */
 676         function fetch_diff_extent($old, $new)
 677         {
 678                 global $viewsvn;
 679
 680                 $start = 0;
 681                 $min = min(strlen($old), strlen($new));
 682
 683                 $viewsvn->debug("min1 = $min");
 684
 685                 while ($start < $min AND $old["$start"] == $new["$start"])
 686                 {
 687                         $start++;
 688                 }
 689
 690                 $end = -1;
 691                 $min = $min - $start;
 692
 693                 $viewsvn->debug("min2 = $min");
 694
 695                 $viewsvn->debug("checking: " . $old[ strlen($old) + $end ] . ' ==  ' . $new[ strlen($new) + $end ]);
 696
 697                 while (-$end <= $min AND $old[ strlen($old) + $end ] == $new[ strlen($new) + $end ])
 698                 {
 699                         $end--;
 700                 }
 701
 702                 return array('start' => $start, 'end' => $end + 1);
 703         }
 704 }
 705
 706 /*=====================================================================*\
 707 || ###################################################################
 708 || # $HeadURL$
 709 || # $Id$
 710 || ###################################################################
 711 \*=====================================================================*/
 712 ?>