include/VCS/RCS.php

   1 <?php
   2 /*
   3  * Copyright (C) 2003-2004 Polytechnique.org
   4  * http://opensource.polytechnique.org/
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21
  22 require_once 'VCS/Spool.php';
  23 // dependency on PEAR
  24 require_once 'System.php';
  25
  26 /** This class handles Diogenes RCS operations.
  27  */
  28 class Diogenes_VCS_RCS extends Diogenes_VCS_Spool {
  29   /** Absolute directory location for the barrel's RCS files. */
  30   var $rcsdir;
  31
  32   /** The username */
  33   var $login;
  34   /** The constructor.
  35    *
  36    * @param caller
  37    * @param alias
  38    * @param login the current user's login
  39    * @param init should create this module?
  40    */
  41   function Diogenes_VCS_RCS(&$caller,$alias,$login,$init = false) {
  42     global $globals;
  43     $this->Diogenes_VCS_Spool($caller,$alias);
  44     $this->rcsdir = "{$globals->rcsroot}/$alias";
  45     $this->login = $login;
  46
  47     // if we were asked to, created directories
  48     if ($init) {
  49       if (!is_dir($this->rcsdir))
  50         mkdir($this->rcsdir, 0700);
  51       if (!is_dir($this->datadir))
  52         mkdir($this->datadir, 0700);
  53     }
  54
  55     // check RCS directory
  56     if (!is_dir($this->rcsdir) || !is_writable($this->rcsdir))
  57       $this->kill("'{$this->rcsdir}' is not a writable directory");
  58
  59     // check spool directory
  60     if (!is_dir($this->datadir) || !is_writable($this->datadir))
  61       $this->kill("'{$this->datadir}' is not a writable directory");
  62   }
  63
  64
  65   /** Return the path of an RCS "item" (file or directory).
  66   *
  67   * @param parent parent directory (optional)
  68   * @param entry the item
  69   */
  70   function rcsPath($parent="",$entry="") {
  71     $this->checkPath($parent,$entry);
  72     return $this->rcsdir.($parent ? "/$parent": "") . ($entry ? "/$entry" : "");
  73   }
  74
  75
  76   /** Return the path of an RCS file (something,v).
  77   *
  78   * @param dir parent directory
  79   * @param file the RCS entry
  80   */
  81   function rcsFile($dir,$file) {
  82     return $this->rcsPath($dir,$file).",v";
  83   }
  84
  85
  86   /** Check whether a file is registered in RCS.
  87    *
  88    * @param dir parent directory
  89    * @param file the RCS entry
  90    */
  91   function checkFile($dir, $file) {
  92     return is_file($this->rcsFile($dir, $file));
  93   }
  94
  95
  96   /** Perform sanity check on an RCS directory
  97    *  and the corresponding checkout in the spool
  98    *
  99    * @param dir
 100    */
 101   function checkDir($dir) {
 102     return is_dir($this->rcsPath($dir))
 103         && is_writable($this->rcsPath($dir))
 104         && is_dir($this->spoolPath($dir))
 105         && is_writable($this->spoolPath($dir));
 106   }
 107
 108
 109   /** Do a checkout of an RCS item to a given location.
 110   *
 111   * @param dir parent directory
 112   * @param file the RCS entry
 113   * @param rev the revision to check out
 114   * @param output the directory to which we want to perform the checkout
 115   */
 116   function checkout($dir,$file,$rev,$output)
 117   {
 118     $this->info("RCS : checkout out $file ($rev)..");
 119     $rfile = $this->rcsFile($dir,$file);
 120     if ($this->cmdExec("co -q -r".escapeshellarg($rev)." ".escapeshellarg($rfile)." ".escapeshellarg("$output/$file")))
 121     {
 122       $this->info("RCS : Error, checkout failed!");
 123       $this->info($this->cmdStatus());
 124       return;
 125     }
 126     return "$output/$file";
 127   }
 128
 129
 130   /** Commit an RCS item. Returns true for succes, false for an error.
 131   *
 132   * @param dir parent directory
 133   * @param file the RCS entry
 134   * @param content the contents of the new revision
 135   * @param message the log message for this revision
 136   */
 137   function commit($dir,$file,$content,$message="")
 138   {
 139     $this->info("RCS : checking in '$file'..");
 140
 141     // check directories
 142     if (!$this->checkDir($dir)) {
 143         // error
 144         $this->info("RCS : Error, RCS sanity check for '$dir' failed!");
 145         return false;
 146     }
 147
 148     // log commit attempt
 149     $this->log("rcs_commit","{$this->alias}:$dir/$file:$message");
 150
 151     $sfile = $this->spoolPath($dir,$file);
 152     $rfile = $this->rcsFile($dir,$file);
 153
 154     // if the RCS file does not exist, create it
 155     if (!file_exists($rfile)) {
 156       if ($this->cmdExec("echo '' | rcs -q -i ".escapeshellarg($rfile)))
 157       {
 158         // error
 159         $this->info("RCS : Error, could not initialise RCS file '$rfile'!");
 160         $this->info($this->cmdStatus());
 161         return false;
 162       }
 163     }
 164
 165     // lock the spool file
 166     if ($this->cmdExec("co -q -l ".escapeshellarg($rfile)." ".escapeshellarg($sfile)))
 167     {
 168         // error
 169         $this->info("RCS : Error, could not get RCS lock on file '$file'!");
 170         $this->info($this->cmdStatus());
 171         return false;
 172     }
 173     if ($fp = fopen($sfile,"w")) {
 174       fwrite($fp,$content);
 175       fclose($fp);
 176
 177       if ($this->cmdExec("ci -q -w".escapeshellarg($this->login). ($message ? " -m".escapeshellarg($message) : "").
 178              " ". escapeshellarg($sfile). " ". escapeshellarg($rfile)))
 179       {
 180         // error
 181         $this->info("RCS : Error, checkin failed!");
 182         $this->info($this->cmdStatus());
 183         return false;
 184       }
 185
 186       if ($this->cmdExec("co -q ".escapeshellarg($rfile)." ".escapeshellarg($sfile)))
 187       {
 188         // error
 189         $this->info("RCS : Error, checkout after checkin failed!");
 190         $this->info($this->cmdStatus());
 191         return false;
 192       }
 193     }
 194     return true;
 195   }
 196
 197
 198
 199  /** Make a copy of an RCS item to a given location.
 200   *
 201   * @param sdir the source directory
 202   * @param sfile the source RCS entry
 203   * @param ddir the destination directory
 204   * @param dfile the destination RCS entry
 205   */
 206   function copy($sdir,$sfile,$ddir,$dfile)
 207   {
 208     $this->info("RCS : copying '$sfile' to '$ddir/$dfile'..");
 209
 210     $spath = $this->spoolPath($sdir, $sfile);
 211     if (!is_file($spath)) {
 212       $this->info("Error: source file '$spath' does not exist!");
 213       return false;
 214     }
 215     if (!$this->checkDir($ddir))
 216     {
 217       $this->info("Error: directory '$ddir' does not exist!");
 218       return false;
 219     }
 220     if ($this->checkFile($ddir, $dfile))
 221     {
 222       $this->info("Error: file '$dfile' already exists in '$ddir'!");
 223       return false;
 224     }
 225     return $this->commit($ddir,$dfile,
 226                         file_get_contents($spath),
 227                         "copied from '$ddir/$sfile'");
 228   }
 229
 230
 231   /** Delete an RCS file and its corresponding spool entry.
 232   *
 233   * @param dir parent directory
 234   * @param file the RCS entry
 235   */
 236   function del($dir,$file) {
 237     $this->info("RCS : deleting '$file'..");
 238     $this->log("rcs_delete","{$this->alias}:$dir/$file");
 239     @unlink($this->spoolPath($dir,$file));
 240     @unlink($this->rcsFile($dir,$file));
 241   }
 242
 243
 244   /** Retrieve differences between two version of a file.
 245    *
 246    * @param dir parent directory
 247    * @param file the RCS entry
 248    * @param r1 the first revision
 249    * @param r2 the second revision
 250    */
 251   function diff($dir,$file,$r1,$r2)
 252   {
 253     $rfile = $this->rcsFile($dir,$file);
 254     $this->info("RCS : diffing '$file' ($r1 to $r2)..");
 255     $this->cmdExec("rcsdiff  -r".escapeshellarg($r1). " -r".escapeshellarg($r2)." ".escapeshellarg($rfile));
 256     return $this->cmd_output;
 257   }
 258
 259
 260   /** Converts a Word document to HTML and commits the resulting
 261    *  HTML and images.
 262    *
 263    * @param dir
 264    * @param htmlfile
 265    * @param wordfile
 266    */
 267   function importWordFile($dir,$htmlfile,$wordfile)
 268   {
 269     global $globals;
 270
 271     if (!$globals->word_import) {
 272       $this->info("Error : support for word import is disabled!");
 273       return false;
 274     }
 275
 276     $func = "importWordFile_{$globals->word_import}";
 277
 278     if (!method_exists($this, $func))
 279     {
 280       $this->info("Error : the utility '$globals->word_import' is not supported!");
 281       return false;
 282     }
 283
 284     return $this->$func($dir, $htmlfile, $wordfile);
 285   }
 286
 287
 288   /** Converts a Word document to HTML using wvHtml and commits the resulting
 289    *  HTML and images.
 290    *
 291    * @param dir
 292    * @param htmlfile
 293    * @param wordfile
 294    */
 295   function importWordFile_wvHtml($dir,$htmlfile,$wordfile)
 296   {
 297     $tmphtmlfile = "importWord.html";
 298     if (($tmpdir = System::mktemp('-d')) == false) {
 299       $this->info("Error : could not create temporary directory!");
 300       return false;
 301     }
 302
 303     if ($this->cmdExec("wvHtml --targetdir=".escapeshellarg($tmpdir).
 304            " --charset=iso-8859-15 ".
 305            escapeshellarg($wordfile)." ".escapeshellarg($tmphtmlfile)))
 306     {
 307       $this->info("Error : wvHtml returned an error!");
 308       $this->info($this->cmdStatus());
 309       return false;
 310     }
 311
 312     if (!$dh = opendir($tmpdir)) {
 313       $this->info("Error : could not find temporary directory '$tmpdir'!");
 314       return false;
 315     }
 316
 317     // process the files generated by wvHtml
 318     $ok = true;
 319     while (($myentry = readdir($dh)) != false) {
 320       if (is_file($myfile = "$tmpdir/$myentry")) {
 321         if ($myentry == $tmphtmlfile) {
 322           $ok = $ok &&
 323           $this->commit($dir,$htmlfile,
 324                         $this->importHtmlString(file_get_contents($myfile)),
 325                         "Word file import");
 326         } else {
 327           $ok = $ok &&
 328           $this->commit($dir,$myentry,file_get_contents($myfile),
 329                         "Word file import");
 330         }
 331       }
 332     }
 333     closedir($dh);
 334
 335     return $ok;
 336   }
 337
 338
 339   /** Returns raw log entries for an RCS item.
 340    *
 341    * @param dir parent directory
 342    * @param file the RCS entry
 343    */
 344   function logEntries($dir,$file) {
 345     $rfile = $this->rcsFile($dir,$file);
 346     $this->cmdExec("rlog ".escapeshellarg($rfile));
 347     return $this->cmd_output;
 348   }
 349
 350
 351   /** Parse the log entries for an RCS item into an array.
 352    *
 353    * @param dir parent directory
 354    * @param file the RCS entry
 355    */
 356    function logParse($dir,$file)
 357    {
 358     // get the log, drop last 2 lines
 359     $lines = $this->logEntries($dir,$file);
 360     array_pop($lines);
 361     array_pop($lines);
 362
 363     // split into revision, drop first block
 364     $revs = split("----------------------------\n", implode("\n",$lines));
 365     array_shift($revs);
 366
 367     // parse info about the revisions
 368     $revinfo = array();
 369     foreach ($revs as $rev) {
 370       $myrev = array();
 371       $lines = explode("\n",$rev);
 372       preg_match("/^revision (.+)$/",array_shift($lines),$res);
 373       $myrev['rev'] = $res[1];
 374       preg_match("/^date: ([^;]+);  author: ([^;]+); .*$/",array_shift($lines),$res);
 375       $myrev['date'] = $res[1];
 376       $myrev['author'] = $res[2];
 377       $myrev['log'] = implode("\n",$lines);
 378       array_push($revinfo,$myrev);
 379     }
 380     return $revinfo;
 381   }
 382
 383
 384  /** Move an RCS item to a given location.
 385   *
 386   * @param sdir the source directory
 387   * @param sfile the source RCS entry
 388   * @param ddir the destination directory
 389   * @param dfile the destination RCS entry
 390   */
 391   function move($sdir,$sfile,$ddir,$dfile)
 392   {
 393     $this->info("RCS : moving '$sfile' to '$ddir/$dfile'..");
 394
 395
 396     // check source files
 397     $spath = $this->spoolPath($sdir, $sfile);
 398     $srpath = $this->rcsFile($sdir, $sfile);
 399
 400     if (!is_file($spath)) {
 401       $this->info("Error: source file '$spath' does not exist!");
 402       return false;
 403     }
 404
 405     if (!is_file($srpath)) {
 406       $this->info("Error: source RCS file '$srpath' does not exist!");
 407       return false;
 408     }
 409
 410     // check destination
 411     $dpath = $this->spoolPath($ddir, $dfile);
 412     $drpath = $this->rcsFile($ddir, $dfile);
 413
 414     if (!$this->checkDir($ddir))
 415     {
 416       $this->info("Error: directory '$ddir' does not exist!");
 417       return false;
 418     }
 419
 420     if (file_exists($dpath)) {
 421       $this->info("Error: file '$dfile' already exists in '$ddir'!");
 422       return false;
 423     }
 424
 425     if (file_exists($drpath)) {
 426       $this->info("Error: file '".basename($drpath)."' already exists in '$ddir'!");
 427       return false;
 428     }
 429
 430     if (!rename($spath, $dpath))
 431     {
 432       $this->info("Error: failed to move '".basename($spath)."' to '".basename($dpath)."' in '$ddir'!");
 433       return false;
 434     }
 435
 436     if (!rename($srpath, $drpath))
 437     {
 438       $this->info("Error: failed to move '".basename($srpath)."' to '".basename($drpath)."' in '$ddir'!");
 439       return false;
 440     }
 441
 442
 443     //$this->log("rcs_move","{$this->alias}:$dir/$file");
 444
 445     return true;
 446   }
 447
 448
 449   /** Add a new RCS-managed directory.
 450    *
 451    * @param parent the parent directory
 452    * @param dir the directory to add
 453    */
 454   function newdir($parent,$dir)
 455   {
 456     @mkdir($this->rcsPath($parent,$dir),0700);
 457     @mkdir($this->spoolPath($parent,$dir),0700);
 458   }
 459
 460
 461   /** Retrieve differences between two version of a file and prepare for output.
 462    *
 463    * @param dir parent directory
 464    * @param file the RCS entry
 465    * @param r1 the first revision
 466    * @param r2 the second revision
 467    */
 468   function dispDiff($dir,$file,$r1,$r2)
 469   {
 470     $lns = "[0-9]+|[0-9]+,[0-9]+";
 471
 472     // get diff, strip any leading comments
 473     $lines = $this->diff($dir,$file,$r1,$r2);
 474     $line = "";
 475     while (!preg_match("/^($lns)([acd])($lns)/",$line))
 476       $line = array_shift($lines);
 477     array_unshift($lines,$line);
 478     $raw = implode("\n",$lines);
 479
 480     $blocks = preg_split("/($lns)([acd])($lns)\n/",$raw,-1,PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY);
 481     $out = array();
 482
 483     $lold = array_shift($blocks);
 484     while ($lold!='')
 485     {
 486       $type = array_shift($blocks);
 487       $lnew = array_shift($blocks);
 488       $diff = array_shift($blocks);
 489
 490       switch ($type) {
 491       case 'c':
 492         list($a,$b) = split("---\n",$diff,2);
 493         break;
 494       case 'a':
 495         $a = "";
 496         $b = $diff;
 497         break;
 498       case 'd':
 499         $a = $diff;
 500         $b = "";
 501         break;
 502       }
 503       array_push($out,array($lold,$type,$lnew,$a,$b));
 504       $lold = array_shift($blocks);
 505     }
 506     //array_push($out,array($type,$a,$b));
 507     return $out;
 508   }
 509
 510
 511   /** Return an RCS-managed directory.
 512    *
 513    * @param dir the directory
 514    * @param loc the visible location for the directory
 515    * @param canedit can we edit files in this directory?
 516    */
 517   function dispDir($dir,$loc,$canedit) {
 518     $entries = array();
 519
 520     if ($pdir = @opendir($this->rcsPath($dir))) {
 521       while ( ($file = readdir($pdir)) !== false) {
 522         if ( ($file != ".") && ($file != "..") )
 523         {
 524           $entry = $this->dispEntry($dir,$loc,$file,$canedit);
 525           if (!empty($entry))
 526             array_push($entries, $entry);
 527         }
 528       }
 529       closedir($pdir);
 530     }
 531     return $entries;
 532   }
 533
 534
 535   /** Returns an RCS "item" (file or directory).
 536   *
 537   * @param dir parent directory
 538   * @param loc visible location for parent directory
 539   * @param file the RCS "item"
 540   * @param canedit can we edit files this entry?
 541   */
 542   function dispEntry($dir,$loc,$file,$canedit) {
 543     global $globals;
 544
 545     $view = $edit = $del = $size = $rev = "";
 546
 547     $myitem = $this->rcsPath($dir,$file);
 548
 549     // check the RCS entry exists
 550     if (!file_exists($myitem)) {
 551       $this->info("RCS entry '$myitem' does not exist!");
 552       return;
 553     }
 554
 555     if (is_dir($myitem))
 556     {
 557     // this is a directory, this should not happen!
 558       $this->info("Unexpected directory in RCS, skipping : '$myitem'");
 559       return;
 560     }
 561     else if (substr($file,-2) == ",v")
 562     {
 563     // this is an RCS file
 564       $file = substr($file,0,-2);
 565
 566       // check we have a working copy of this item
 567       $spoolitem = $this->spoolPath($dir,$file);
 568       if (!is_file($spoolitem))
 569       {
 570         $this->info("Could not find working copy '$spoolitem'!");
 571         $size = "";
 572         $icon = "";
 573       } else {
 574         $size = $this->dispSize(filesize($spoolitem));
 575         $icon = $globals->icons->get_mime_icon($spoolitem);
 576       }
 577
 578       // revision info
 579       $myrev = array_shift($tmparr = $this->logParse($dir,$file));
 580
 581       return array(
 582         "icon" => $icon,
 583         "file" => $file,
 584         "rev" => array($myrev['rev'],$rev),
 585         "date" => $myrev['date'],
 586         "author" => $myrev['author'],
 587         "size" => $size
 588       );
 589
 590     }
 591     else
 592     {
 593       $this->info("Unknown RCS entry type : '$myitem'");
 594       return;
 595     }
 596
 597   }
 598
 599
 600   /** Format a file size for display.
 601   *
 602   * @param size the size, in bytes
 603   */
 604   function dispSize($size)
 605   {
 606     if ($size < 1000)
 607       return "$size B";
 608     else if ($size < 1000000)
 609       return floor($size/1000)." kB";
 610     else
 611       return floor($size/1000000)." MB";
 612   }
 613
 614 }
 615
 616 ?>