[ Index ]

PHP Cross Reference of DokuWiki

title

Body

[close]

/inc/ChangeLog/ -> ChangeLog.php (source)

   1  <?php
   2  
   3  namespace dokuwiki\ChangeLog;
   4  
   5  use dokuwiki\Logger;
   6  
   7  /**
   8   * ChangeLog Prototype; methods for handling changelog
   9   */
  10  abstract class ChangeLog
  11  {
  12      use ChangeLogTrait;
  13  
  14      /** @var string */
  15      protected $id;
  16      /** @var false|int */
  17      protected $currentRevision;
  18      /** @var array */
  19      protected $cache = [];
  20  
  21      /**
  22       * Constructor
  23       *
  24       * @param string $id page id
  25       * @param int $chunk_size maximum block size read from file
  26       */
  27      public function __construct($id, $chunk_size = 8192)
  28      {
  29          global $cache_revinfo;
  30  
  31          $this->cache =& $cache_revinfo;
  32          if (!isset($this->cache[$id])) {
  33              $this->cache[$id] = [];
  34          }
  35  
  36          $this->id = $id;
  37          $this->setChunkSize($chunk_size);
  38      }
  39  
  40      /**
  41       * Returns path to current page/media
  42       *
  43       * @param string|int $rev empty string or revision timestamp
  44       * @return string path to file
  45       */
  46      abstract protected function getFilename($rev = '');
  47  
  48      /**
  49       * Returns mode
  50       *
  51       * @return string RevisionInfo::MODE_MEDIA or RevisionInfo::MODE_PAGE
  52       */
  53      abstract protected function getMode();
  54  
  55      /**
  56       * Check whether given revision is the current page
  57       *
  58       * @param int $rev timestamp of current page
  59       * @return bool true if $rev is current revision, otherwise false
  60       */
  61      public function isCurrentRevision($rev)
  62      {
  63          return $rev == $this->currentRevision();
  64      }
  65  
  66      /**
  67       * Checks if the revision is last revision
  68       *
  69       * @param int $rev revision timestamp
  70       * @return bool true if $rev is last revision, otherwise false
  71       */
  72      public function isLastRevision($rev = null)
  73      {
  74          return $rev === $this->lastRevision();
  75      }
  76  
  77      /**
  78       * Return the current revision identifier
  79       *
  80       * The "current" revision means current version of the page or media file. It is either
  81       * identical with or newer than the "last" revision, that depends on whether the file
  82       * has modified, created or deleted outside of DokuWiki.
  83       * The value of identifier can be determined by timestamp as far as the file exists,
  84       * otherwise it must be assigned larger than any other revisions to keep them sortable.
  85       *
  86       * @return int|false revision timestamp
  87       */
  88      public function currentRevision()
  89      {
  90          if (!isset($this->currentRevision)) {
  91              // set ChangeLog::currentRevision property
  92              $this->getCurrentRevisionInfo();
  93          }
  94          return $this->currentRevision;
  95      }
  96  
  97      /**
  98       * Return the last revision identifier, date value of the last entry of the changelog
  99       *
 100       * @return int|false revision timestamp
 101       */
 102      public function lastRevision()
 103      {
 104          $revs = $this->getRevisions(-1, 1);
 105          return empty($revs) ? false : $revs[0];
 106      }
 107  
 108      /**
 109       * Parses a changelog line into its components and save revision info to the cache pool
 110       *
 111       * @param string $value changelog line
 112       * @return array|bool parsed line or false
 113       */
 114      protected function parseAndCacheLogLine($value)
 115      {
 116          $info = static::parseLogLine($value);
 117          if (is_array($info)) {
 118              $info['mode'] = $this->getMode();
 119              $this->cache[$this->id][$info['date']] ??= $info;
 120              return $info;
 121          }
 122          return false;
 123      }
 124  
 125      /**
 126       * Get the changelog information for a specific revision (timestamp)
 127       *
 128       * Adjacent changelog lines are optimistically parsed and cached to speed up
 129       * consecutive calls to getRevisionInfo. For large changelog files, only the chunk
 130       * containing the requested changelog line is read.
 131       *
 132       * @param int $rev revision timestamp
 133       * @param bool $retrieveCurrentRevInfo allows to skip for getting other revision info in the
 134       *                                     getCurrentRevisionInfo() where $currentRevision is not yet determined
 135       * @return bool|array false or array with entries:
 136       *      - date:  unix timestamp
 137       *      - ip:    IPv4 address (127.0.0.1)
 138       *      - type:  log line type
 139       *      - id:    page id
 140       *      - user:  user name
 141       *      - sum:   edit summary (or action reason)
 142       *      - extra: extra data (varies by line type)
 143       *      - sizechange: change of filesize
 144       *    additional:
 145       *      - mode: page or media
 146       *
 147       * @author Ben Coburn <btcoburn@silicodon.net>
 148       * @author Kate Arzamastseva <pshns@ukr.net>
 149       */
 150      public function getRevisionInfo($rev, $retrieveCurrentRevInfo = true)
 151      {
 152          $rev = max(0, $rev);
 153          if (!$rev) return false;
 154  
 155          //ensure the external edits are cached as well
 156          if (!isset($this->currentRevision) && $retrieveCurrentRevInfo) {
 157              $this->getCurrentRevisionInfo();
 158          }
 159  
 160          // check if it's already in the memory cache
 161          if (isset($this->cache[$this->id][$rev])) {
 162              return $this->cache[$this->id][$rev];
 163          }
 164  
 165          //read lines from changelog
 166          [$fp, $lines] = $this->readloglines($rev);
 167          if ($fp) {
 168              fclose($fp);
 169          }
 170          if (empty($lines)) return false;
 171  
 172          // parse and cache changelog lines
 173          foreach ($lines as $line) {
 174              $this->parseAndCacheLogLine($line);
 175          }
 176  
 177          return $this->cache[$this->id][$rev] ?? false;
 178      }
 179  
 180      /**
 181       * Return a list of page revisions numbers
 182       *
 183       * Does not guarantee that the revision exists in the attic,
 184       * only that a line with the date exists in the changelog.
 185       * By default the current revision is skipped.
 186       *
 187       * The current revision is automatically skipped when the page exists.
 188       * See $INFO['meta']['last_change'] for the current revision.
 189       * A negative $first let read the current revision too.
 190       *
 191       * For efficiency, the log lines are parsed and cached for later
 192       * calls to getRevisionInfo. Large changelog files are read
 193       * backwards in chunks until the requested number of changelog
 194       * lines are received.
 195       *
 196       * @param int $first skip the first n changelog lines
 197       * @param int $num number of revisions to return
 198       * @return array with the revision timestamps
 199       *
 200       * @author Ben Coburn <btcoburn@silicodon.net>
 201       * @author Kate Arzamastseva <pshns@ukr.net>
 202       */
 203      public function getRevisions($first, $num)
 204      {
 205          $revs = [];
 206          $lines = [];
 207          $count = 0;
 208  
 209          $logfile = $this->getChangelogFilename();
 210          if (!file_exists($logfile)) return $revs;
 211  
 212          $num = max($num, 0);
 213          if ($num == 0) {
 214              return $revs;
 215          }
 216  
 217          if ($first < 0) {
 218              $first = 0;
 219          } else {
 220              $fileLastMod = $this->getFilename();
 221              if (file_exists($fileLastMod) && $this->isLastRevision(filemtime($fileLastMod))) {
 222                  // skip last revision if the page exists
 223                  $first = max($first + 1, 0);
 224              }
 225          }
 226  
 227          if (filesize($logfile) < $this->chunk_size || $this->chunk_size == 0) {
 228              // read whole file
 229              $lines = file($logfile);
 230              if ($lines === false) {
 231                  return $revs;
 232              }
 233          } else {
 234              // read chunks backwards
 235              $fp = fopen($logfile, 'rb'); // "file pointer"
 236              if ($fp === false) {
 237                  return $revs;
 238              }
 239              fseek($fp, 0, SEEK_END);
 240              $tail = ftell($fp);
 241  
 242              // chunk backwards
 243              $finger = max($tail - $this->chunk_size, 0);
 244              while ($count < $num + $first) {
 245                  $nl = $this->getNewlinepointer($fp, $finger);
 246  
 247                  // was the chunk big enough? if not, take another bite
 248                  if ($nl > 0 && $tail <= $nl) {
 249                      $finger = max($finger - $this->chunk_size, 0);
 250                      continue;
 251                  } else {
 252                      $finger = $nl;
 253                  }
 254  
 255                  // read chunk
 256                  $chunk = '';
 257                  $read_size = max($tail - $finger, 0); // found chunk size
 258                  $got = 0;
 259                  while ($got < $read_size && !feof($fp)) {
 260                      $tmp = @fread($fp, max(min($this->chunk_size, $read_size - $got), 0));
 261                      if ($tmp === false) {
 262                          break;
 263                      } //error state
 264                      $got += strlen($tmp);
 265                      $chunk .= $tmp;
 266                  }
 267                  $tmp = explode("\n", $chunk);
 268                  array_pop($tmp); // remove trailing newline
 269  
 270                  // combine with previous chunk
 271                  $count += count($tmp);
 272                  $lines = [...$tmp, ...$lines];
 273  
 274                  // next chunk
 275                  if ($finger == 0) {
 276                      break;
 277                  } else { // already read all the lines
 278                      $tail = $finger;
 279                      $finger = max($tail - $this->chunk_size, 0);
 280                  }
 281              }
 282              fclose($fp);
 283          }
 284  
 285          // skip parsing extra lines
 286          $num = max(min(count($lines) - $first, $num), 0);
 287          if ($first > 0 && $num > 0) {
 288              $lines = array_slice($lines, max(count($lines) - $first - $num, 0), $num);
 289          } elseif ($first > 0 && $num == 0) {
 290              $lines = array_slice($lines, 0, max(count($lines) - $first, 0));
 291          } elseif ($first == 0 && $num > 0) {
 292              $lines = array_slice($lines, max(count($lines) - $num, 0));
 293          }
 294  
 295          // handle lines in reverse order
 296          for ($i = count($lines) - 1; $i >= 0; $i--) {
 297              $info = $this->parseAndCacheLogLine($lines[$i]);
 298              if (is_array($info)) {
 299                  $revs[] = $info['date'];
 300              }
 301          }
 302  
 303          return $revs;
 304      }
 305  
 306      /**
 307       * Get the nth revision left or right-hand side  for a specific page id and revision (timestamp)
 308       *
 309       * For large changelog files, only the chunk containing the
 310       * reference revision $rev is read and sometimes a next chunk.
 311       *
 312       * Adjacent changelog lines are optimistically parsed and cached to speed up
 313       * consecutive calls to getRevisionInfo.
 314       *
 315       * @param int $rev revision timestamp used as start date
 316       *    (doesn't need to be exact revision number)
 317       * @param int $direction give position of returned revision with respect to $rev;
 318            positive=next, negative=prev
 319       * @return bool|int
 320       *      timestamp of the requested revision
 321       *      otherwise false
 322       */
 323      public function getRelativeRevision($rev, $direction)
 324      {
 325          $rev = max($rev, 0);
 326          $direction = (int)$direction;
 327  
 328          //no direction given or last rev, so no follow-up
 329          if (!$direction || ($direction > 0 && $this->isCurrentRevision($rev))) {
 330              return false;
 331          }
 332  
 333          //get lines from changelog
 334          [$fp, $lines, $head, $tail, $eof] = $this->readloglines($rev);
 335          if (empty($lines)) return false;
 336  
 337          // look for revisions later/earlier than $rev, when founded count till the wanted revision is reached
 338          // also parse and cache changelog lines for getRevisionInfo().
 339          $revCounter = 0;
 340          $relativeRev = false;
 341          $checkOtherChunk = true; //always runs once
 342          while (!$relativeRev && $checkOtherChunk) {
 343              $info = [];
 344              //parse in normal or reverse order
 345              $count = count($lines);
 346              if ($direction > 0) {
 347                  $start = 0;
 348                  $step = 1;
 349              } else {
 350                  $start = $count - 1;
 351                  $step = -1;
 352              }
 353              for ($i = $start; $i >= 0 && $i < $count; $i += $step) {
 354                  $info = $this->parseAndCacheLogLine($lines[$i]);
 355                  if (is_array($info)) {
 356                      //look for revs older/earlier then reference $rev and select $direction-th one
 357                      if (($direction > 0 && $info['date'] > $rev) || ($direction < 0 && $info['date'] < $rev)) {
 358                          $revCounter++;
 359                          if ($revCounter == abs($direction)) {
 360                              $relativeRev = $info['date'];
 361                          }
 362                      }
 363                  }
 364              }
 365  
 366              //true when $rev is found, but not the wanted follow-up.
 367              $checkOtherChunk = $fp
 368                  && ($info['date'] == $rev || ($revCounter > 0 && !$relativeRev))
 369                  && (!($tail == $eof && $direction > 0) && !($head == 0 && $direction < 0));
 370  
 371              if ($checkOtherChunk) {
 372                  [$lines, $head, $tail] = $this->readAdjacentChunk($fp, $head, $tail, $direction);
 373  
 374                  if (empty($lines)) break;
 375              }
 376          }
 377          if ($fp) {
 378              fclose($fp);
 379          }
 380  
 381          return $relativeRev;
 382      }
 383  
 384      /**
 385       * Returns revisions around rev1 and rev2
 386       * When available it returns $max entries for each revision
 387       *
 388       * @param int $rev1 oldest revision timestamp
 389       * @param int $rev2 newest revision timestamp (0 looks up last revision)
 390       * @param int $max maximum number of revisions returned
 391       * @return array with two arrays with revisions surrounding rev1 respectively rev2
 392       */
 393      public function getRevisionsAround($rev1, $rev2, $max = 50)
 394      {
 395          $max = (int) (abs($max) / 2) * 2 + 1;
 396          $rev1 = max($rev1, 0);
 397          $rev2 = max($rev2, 0);
 398  
 399          if ($rev2) {
 400              if ($rev2 < $rev1) {
 401                  $rev = $rev2;
 402                  $rev2 = $rev1;
 403                  $rev1 = $rev;
 404              }
 405          } else {
 406              //empty right side means a removed page. Look up last revision.
 407              $rev2 = $this->currentRevision();
 408          }
 409          //collect revisions around rev2
 410          [$revs2, $allRevs, $fp, $lines, $head, $tail] = $this->retrieveRevisionsAround($rev2, $max);
 411  
 412          if (empty($revs2)) return [[], []];
 413  
 414          //collect revisions around rev1
 415          $index = array_search($rev1, $allRevs);
 416          if ($index === false) {
 417              //no overlapping revisions
 418              [$revs1, , , , , ] = $this->retrieveRevisionsAround($rev1, $max);
 419              if (empty($revs1)) $revs1 = [];
 420          } else {
 421              //revisions overlaps, reuse revisions around rev2
 422              $lastRev = array_pop($allRevs); //keep last entry that could be external edit
 423              $revs1 = $allRevs;
 424              while ($head > 0) {
 425                  for ($i = count($lines) - 1; $i >= 0; $i--) {
 426                      $info = $this->parseAndCacheLogLine($lines[$i]);
 427                      if (is_array($info)) {
 428                          $revs1[] = $info['date'];
 429                          $index++;
 430  
 431                          if ($index > (int) ($max / 2)) {
 432                              break 2;
 433                          }
 434                      }
 435                  }
 436  
 437                  [$lines, $head, $tail] = $this->readAdjacentChunk($fp, $head, $tail, -1);
 438              }
 439              sort($revs1);
 440              $revs1[] = $lastRev; //push back last entry
 441  
 442              //return wanted selection
 443              $revs1 = array_slice($revs1, max($index - (int) ($max / 2), 0), $max);
 444          }
 445  
 446          return [array_reverse($revs1), array_reverse($revs2)];
 447      }
 448  
 449      /**
 450       * Return an existing revision for a specific date which is
 451       * the current one or younger or equal then the date
 452       *
 453       * @param number $date_at timestamp
 454       * @return string revision ('' for current)
 455       */
 456      public function getLastRevisionAt($date_at)
 457      {
 458          $fileLastMod = $this->getFilename();
 459          //requested date_at(timestamp) younger or equal then modified_time($this->id) => load current
 460          if (file_exists($fileLastMod) && $date_at >= @filemtime($fileLastMod)) {
 461              return '';
 462          } elseif ($rev = $this->getRelativeRevision($date_at + 1, -1)) {
 463              //+1 to get also the requested date revision
 464              return $rev;
 465          } else {
 466              return false;
 467          }
 468      }
 469  
 470      /**
 471       * Collect the $max revisions near to the timestamp $rev
 472       *
 473       * Ideally, half of retrieved timestamps are older than $rev, another half are newer.
 474       * The returned array $requestedRevs may not contain the reference timestamp $rev
 475       * when it does not match any revision value recorded in changelog.
 476       *
 477       * @param int $rev revision timestamp
 478       * @param int $max maximum number of revisions to be returned
 479       * @return bool|array
 480       *     return array with entries:
 481       *       - $requestedRevs: array of with $max revision timestamps
 482       *       - $revs: all parsed revision timestamps
 483       *       - $fp: file pointer only defined for chuck reading, needs closing.
 484       *       - $lines: non-parsed changelog lines before the parsed revisions
 485       *       - $head: position of first read changelog line
 486       *       - $lastTail: position of end of last read changelog line
 487       *     otherwise false
 488       */
 489      protected function retrieveRevisionsAround($rev, $max)
 490      {
 491          $revs = [];
 492          $afterCount = 0;
 493          $beforeCount = 0;
 494  
 495          //get lines from changelog
 496          [$fp, $lines, $startHead, $startTail, $eof] = $this->readloglines($rev);
 497          if (empty($lines)) return false;
 498  
 499          //parse changelog lines in chunk, and read forward more chunks until $max/2 is reached
 500          $head = $startHead;
 501          $tail = $startTail;
 502          while (count($lines) > 0) {
 503              foreach ($lines as $line) {
 504                  $info = $this->parseAndCacheLogLine($line);
 505                  if (is_array($info)) {
 506                      $revs[] = $info['date'];
 507                      if ($info['date'] >= $rev) {
 508                          //count revs after reference $rev
 509                          $afterCount++;
 510                          if ($afterCount == 1) {
 511                              $beforeCount = count($revs);
 512                          }
 513                      }
 514                      //enough revs after reference $rev?
 515                      if ($afterCount > (int) ($max / 2)) {
 516                          break 2;
 517                      }
 518                  }
 519              }
 520              //retrieve next chunk
 521              [$lines, $head, $tail] = $this->readAdjacentChunk($fp, $head, $tail, 1);
 522          }
 523          $lastTail = $tail;
 524  
 525          // add a possible revision of external edit, create or deletion
 526          if (
 527              $lastTail == $eof && $afterCount <= (int) ($max / 2) &&
 528              count($revs) && !$this->isCurrentRevision($revs[count($revs) - 1])
 529          ) {
 530              $revs[] = $this->currentRevision;
 531              $afterCount++;
 532          }
 533  
 534          if ($afterCount == 0) {
 535              //given timestamp $rev is newer than the most recent line in chunk
 536              return false; //FIXME: or proceed to collect older revisions?
 537          }
 538  
 539          //read more chunks backward until $max/2 is reached and total number of revs is equal to $max
 540          $lines = [];
 541          $i = 0;
 542          $head = $startHead;
 543          $tail = $startTail;
 544          while ($head > 0) {
 545              [$lines, $head, $tail] = $this->readAdjacentChunk($fp, $head, $tail, -1);
 546  
 547              for ($i = count($lines) - 1; $i >= 0; $i--) {
 548                  $info = $this->parseAndCacheLogLine($lines[$i]);
 549                  if (is_array($info)) {
 550                      $revs[] = $info['date'];
 551                      $beforeCount++;
 552                      //enough revs before reference $rev?
 553                      if ($beforeCount > max((int) ($max / 2), $max - $afterCount)) {
 554                          break 2;
 555                      }
 556                  }
 557              }
 558          }
 559          //keep only non-parsed lines
 560          $lines = array_slice($lines, 0, $i);
 561  
 562          sort($revs);
 563  
 564          //trunk desired selection
 565          $requestedRevs = array_slice($revs, -$max, $max);
 566  
 567          return [$requestedRevs, $revs, $fp, $lines, $head, $lastTail];
 568      }
 569  
 570      /**
 571       * Get the current revision information, considering external edit, create or deletion
 572       *
 573       * When the file has not modified since its last revision, the information of the last
 574       * change that had already recorded in the changelog is returned as current change info.
 575       * Otherwise, the change information since the last revision caused outside DokuWiki
 576       * should be returned, which is referred as "external revision".
 577       *
 578       * The change date of the file can be determined by timestamp as far as the file exists,
 579       * however this is not possible when the file has already deleted outside of DokuWiki.
 580       * In such case we assign 1 sec before current time() for the external deletion.
 581       * As a result, the value of current revision identifier may change each time because:
 582       *   1) the file has again modified outside of DokuWiki, or
 583       *   2) the value is essentially volatile for deleted but once existed files.
 584       *
 585       * @return bool|array false when page had never existed or array with entries:
 586       *      - date:  revision identifier (timestamp or last revision +1)
 587       *      - ip:    IPv4 address (127.0.0.1)
 588       *      - type:  log line type
 589       *      - id:    id of page or media
 590       *      - user:  user name
 591       *      - sum:   edit summary (or action reason)
 592       *      - extra: extra data (varies by line type)
 593       *      - sizechange: change of filesize
 594       *      - timestamp: unix timestamp or false (key set only for external edit occurred)
 595       *   additional:
 596       *      - mode:  page or media
 597       *
 598       * @author  Satoshi Sahara <sahara.satoshi@gmail.com>
 599       */
 600      public function getCurrentRevisionInfo()
 601      {
 602          global $lang;
 603  
 604          if (isset($this->currentRevision)) {
 605              return $this->getRevisionInfo($this->currentRevision);
 606          }
 607  
 608          // get revision id from the item file timestamp and changelog
 609          $fileLastMod = $this->getFilename();
 610          $fileRev = @filemtime($fileLastMod); // false when the file not exist
 611          $lastRev = $this->lastRevision();    // false when no changelog
 612  
 613          if (!$fileRev && !$lastRev) {                // has never existed
 614              $this->currentRevision = false;
 615              return false;
 616          } elseif ($fileRev === $lastRev) {           // not external edit
 617              $this->currentRevision = $lastRev;
 618              return $this->getRevisionInfo($lastRev);
 619          }
 620  
 621          if (!$fileRev && $lastRev) {                 // item file does not exist
 622              // check consistency against changelog
 623              $revInfo = $this->getRevisionInfo($lastRev, false);
 624              if ($revInfo['type'] == DOKU_CHANGE_TYPE_DELETE) {
 625                  $this->currentRevision = $lastRev;
 626                  return $revInfo;
 627              }
 628  
 629              // externally deleted, set revision date as late as possible
 630              $revInfo = [
 631                  'date' => max($lastRev + 1, time() - 1), // 1 sec before now or new page save
 632                  'ip'   => '127.0.0.1',
 633                  'type' => DOKU_CHANGE_TYPE_DELETE,
 634                  'id'   => $this->id,
 635                  'user' => '',
 636                  'sum'  => $lang['deleted'] . ' - ' . $lang['external_edit'] . ' (' . $lang['unknowndate'] . ')',
 637                  'extra' => '',
 638                  'sizechange' => -io_getSizeFile($this->getFilename($lastRev)),
 639                  'timestamp' => false,
 640                  'mode' => $this->getMode()
 641              ];
 642          } else {                                     // item file exists, with timestamp $fileRev
 643              // here, file timestamp $fileRev is different with last revision timestamp $lastRev in changelog
 644              $isJustCreated = $lastRev === false || (
 645                      $fileRev > $lastRev &&
 646                      $this->getRevisionInfo($lastRev, false)['type'] == DOKU_CHANGE_TYPE_DELETE
 647              );
 648              $filesize_new = filesize($this->getFilename());
 649              $filesize_old = $isJustCreated ? 0 : io_getSizeFile($this->getFilename($lastRev));
 650              $sizechange = $filesize_new - $filesize_old;
 651  
 652              if ($isJustCreated) {
 653                  $timestamp = $fileRev;
 654                  $sum = $lang['created'] . ' - ' . $lang['external_edit'];
 655              } elseif ($fileRev > $lastRev) {
 656                  $timestamp = $fileRev;
 657                  $sum = $lang['external_edit'];
 658              } else {
 659                  // $fileRev is older than $lastRev, that is erroneous/incorrect occurrence.
 660                  $msg = "Warning: current file modification time is older than last revision date";
 661                  $details = 'File revision: ' . $fileRev . ' ' . dformat($fileRev, "%Y-%m-%d %H:%M:%S") . "\n"
 662                            . 'Last revision: ' . $lastRev . ' ' . dformat($lastRev, "%Y-%m-%d %H:%M:%S");
 663                  Logger::error($msg, $details, $this->getFilename());
 664                  $timestamp = false;
 665                  $sum = $lang['external_edit'] . ' (' . $lang['unknowndate'] . ')';
 666              }
 667  
 668              // externally created or edited
 669              $revInfo = [
 670                  'date' => $timestamp ?: $lastRev + 1,
 671                  'ip'   => '127.0.0.1',
 672                  'type' => $isJustCreated ? DOKU_CHANGE_TYPE_CREATE : DOKU_CHANGE_TYPE_EDIT,
 673                  'id'   => $this->id,
 674                  'user' => '',
 675                  'sum'  => $sum,
 676                  'extra' => '',
 677                  'sizechange' => $sizechange,
 678                  'timestamp' => $timestamp,
 679                  'mode' => $this->getMode()
 680              ];
 681          }
 682  
 683          // cache current revision information of external edition
 684          $this->currentRevision = $revInfo['date'];
 685          $this->cache[$this->id][$this->currentRevision] = $revInfo;
 686          return $this->getRevisionInfo($this->currentRevision);
 687      }
 688  
 689      /**
 690       * Mechanism to trace no-actual external current revision
 691       * @param int $rev
 692       */
 693      public function traceCurrentRevision($rev)
 694      {
 695          if ($rev > $this->lastRevision()) {
 696              $rev = $this->currentRevision();
 697          }
 698          return $rev;
 699      }
 700  }