lib/WikiDB.php

   1 <?php //-*-php-*-
   2 rcs_id('$Id: WikiDB.php,v 1.142 2006-06-10 11:55:58 rurban Exp $');
   3
   4 require_once('lib/PageType.php');
   5
   6 /**
   7  * The classes in the file define the interface to the
   8  * page database.
   9  *
  10  * @package WikiDB
  11  * @author Geoffrey T. Dairiki <dairiki@dairiki.org>
  12  *         Reini Urban
  13  */
  14
  15 /**
  16  * Force the creation of a new revision.
  17  * @see WikiDB_Page::createRevision()
  18  */
  19 if (!defined('WIKIDB_FORCE_CREATE'))
  20     define('WIKIDB_FORCE_CREATE', -1);
  21
  22 /**
  23  * Abstract base class for the database used by PhpWiki.
  24  *
  25  * A <tt>WikiDB</tt> is a container for <tt>WikiDB_Page</tt>s which in
  26  * turn contain <tt>WikiDB_PageRevision</tt>s.
  27  *
  28  * Conceptually a <tt>WikiDB</tt> contains all possible
  29  * <tt>WikiDB_Page</tt>s, whether they have been initialized or not.
  30  * Since all possible pages are already contained in a WikiDB, a call
  31  * to WikiDB::getPage() will never fail (barring bugs and
  32  * e.g. filesystem or SQL database problems.)
  33  *
  34  * Also each <tt>WikiDB_Page</tt> always contains at least one
  35  * <tt>WikiDB_PageRevision</tt>: the default content (e.g. "Describe
  36  * [PageName] here.").  This default content has a version number of
  37  * zero.
  38  *
  39  * <tt>WikiDB_PageRevision</tt>s have read-only semantics. One can
  40  * only create new revisions or delete old ones --- one can not modify
  41  * an existing revision.
  42  */
  43 class WikiDB {
  44     /**
  45      * Open a WikiDB database.
  46      *
  47      * This is a static member function. This function inspects its
  48      * arguments to determine the proper subclass of WikiDB to
  49      * instantiate, and then it instantiates it.
  50      *
  51      * @access public
  52      *
  53      * @param hash $dbparams Database configuration parameters.
  54      * Some pertinent paramters are:
  55      * <dl>
  56      * <dt> dbtype
  57      * <dd> The back-end type.  Current supported types are:
  58      *   <dl>
  59      *   <dt> SQL
  60      *     <dd> Generic SQL backend based on the PEAR/DB database abstraction
  61      *       library. (More stable and conservative)
  62      *   <dt> ADODB
  63      *     <dd> Another generic SQL backend. (More current features are tested here. Much faster)
  64      *   <dt> dba
  65      *     <dd> Dba based backend. The default and by far the fastest.
  66      *   <dt> cvs
  67      *     <dd>
  68      *   <dt> file
  69      *     <dd> flat files
  70      *   </dl>
  71      *
  72      * <dt> dsn
  73      * <dd> (Used by the SQL and ADODB backends.)
  74      *      The DSN specifying which database to connect to.
  75      *
  76      * <dt> prefix
  77      * <dd> Prefix to be prepended to database tables (and file names).
  78      *
  79      * <dt> directory
  80      * <dd> (Used by the dba backend.)
  81      *      Which directory db files reside in.
  82      *
  83      * <dt> timeout
  84      * <dd> Used only by the dba backend so far.
  85      *      And: When optimizing mysql it closes timed out mysql processes.
  86      *      otherwise only used for dba: Timeout in seconds for opening (and
  87      *      obtaining lock) on the dbm file.
  88      *
  89      * <dt> dba_handler
  90      * <dd> (Used by the dba backend.)
  91      *
  92      *      Which dba handler to use. Good choices are probably either
  93      *      'gdbm' or 'db2'.
  94      * </dl>
  95      *
  96      * @return WikiDB A WikiDB object.
  97      **/
  98     function open ($dbparams) {
  99         $dbtype = $dbparams{'dbtype'};
 100         include_once("lib/WikiDB/$dbtype.php");
 101
 102         $class = 'WikiDB_' . $dbtype;
 103         return new $class ($dbparams);
 104     }
 105
 106
 107     /**
 108      * Constructor.
 109      *
 110      * @access private
 111      * @see open()
 112      */
 113     function WikiDB (&$backend, $dbparams) {
 114         $this->_backend = &$backend;
 115         // don't do the following with the auth_dsn!
 116         if (isset($dbparams['auth_dsn'])) return;
 117
 118         $this->_cache = new WikiDB_cache($backend);
 119         if (!empty($GLOBALS['request'])) $GLOBALS['request']->_dbi = $this;
 120
 121         // If the database doesn't yet have a timestamp, initialize it now.
 122         if ($this->get('_timestamp') === false)
 123             $this->touch();
 124
 125         //FIXME: devel checking.
 126         //$this->_backend->check();
 127     }
 128
 129     /**
 130      * Close database connection.
 131      *
 132      * The database may no longer be used after it is closed.
 133      *
 134      * Closing a WikiDB invalidates all <tt>WikiDB_Page</tt>s,
 135      * <tt>WikiDB_PageRevision</tt>s and <tt>WikiDB_PageIterator</tt>s
 136      * which have been obtained from it.
 137      *
 138      * @access public
 139      */
 140     function close () {
 141         $this->_backend->close();
 142         $this->_cache->close();
 143     }
 144
 145     /**
 146      * Get a WikiDB_Page from a WikiDB.
 147      *
 148      * A {@link WikiDB} consists of the (infinite) set of all possible pages,
 149      * therefore this method never fails.
 150      *
 151      * @access public
 152      * @param string $pagename Which page to get.
 153      * @return WikiDB_Page The requested WikiDB_Page.
 154      */
 155     function getPage($pagename) {
 156         static $error_displayed = false;
 157         $pagename = (string) $pagename;
 158         if (DEBUG) {
 159             if ($pagename === '') {
 160                 if ($error_displayed) return false;
 161                 $error_displayed = true;
 162                 if (function_exists("xdebug_get_function_stack"))
 163                     var_dump(xdebug_get_function_stack());
 164                 trigger_error("empty pagename", E_USER_WARNING);
 165                 return false;
 166             }
 167         } else {
 168             assert($pagename != '');
 169         }
 170         return new WikiDB_Page($this, $pagename);
 171     }
 172
 173     /**
 174      * Determine whether page exists (in non-default form).
 175      *
 176      * <pre>
 177      *   $is_page = $dbi->isWikiPage($pagename);
 178      * </pre>
 179      * is equivalent to
 180      * <pre>
 181      *   $page = $dbi->getPage($pagename);
 182      *   $current = $page->getCurrentRevision();
 183      *   $is_page = ! $current->hasDefaultContents();
 184      * </pre>
 185      * however isWikiPage may be implemented in a more efficient
 186      * manner in certain back-ends.
 187      *
 188      * @access public
 189      *
 190      * @param string $pagename string Which page to check.
 191      *
 192      * @return boolean True if the page actually exists with
 193      * non-default contents in the WikiDataBase.
 194      */
 195     function isWikiPage ($pagename) {
 196         $page = $this->getPage($pagename);
 197         return $page->exists();
 198     }
 199
 200     /**
 201      * Delete page from the WikiDB.
 202      *
 203      * Deletes the page from the WikiDB with the possibility to revert and diff.
 204      * //Also resets all page meta-data to the default values.
 205      *
 206      * Note: purgePage() effectively destroys all revisions of the page from the WikiDB.
 207      *
 208      * @access public
 209      *
 210      * @param string $pagename Name of page to delete.
 211      */
 212     function deletePage($pagename) {
 213         // don't create empty revisions of already purged pages.
 214         if ($this->_backend->get_latest_version($pagename))
 215             $result = $this->_cache->delete_page($pagename);
 216         else
 217             $result = -1;
 218
 219         /* Generate notification emails? */
 220         if (! $this->isWikiPage($pagename) and !isa($GLOBALS['request'],'MockRequest')) {
 221             $notify = $this->get('notify');
 222             if (!empty($notify) and is_array($notify)) {
 223                 global $request;
 224                 //TODO: deferr it (quite a massive load if you remove some pages).
 225                 //TODO: notification class which catches all changes,
 226                 //  and decides at the end of the request what to mail.
 227                 //  (type, page, who, what, users, emails)
 228                 // could be used for PageModeration and RSS2 Cloud xml-rpc also.
 229                 $page = new WikiDB_Page($this, $pagename);
 230                 list($emails, $userids) = $page->getPageChangeEmails($notify);
 231                 if (!empty($emails)) {
 232                     $from = $request->_user->getId() . '@' .  $request->get('REMOTE_HOST');
 233                     $editedby = sprintf(_("Removed by: %s"), $from);
 234                     $emails = join(',', $emails);
 235                     $subject = sprintf(_("Page removed %s"), urlencode($pagename));
 236                     if (mail("<undisclosed-recipients>","[".WIKI_NAME."] ".$subject,
 237                              $subject."\n".
 238                              $editedby."\n\n".
 239                              "Deleted $pagename",
 240                              "From: $from\r\nBcc: $emails"))
 241                         trigger_error(sprintf(_("PageChange Notification of %s sent to %s"),
 242                                               $pagename, join(',',$userids)), E_USER_NOTICE);
 243                     else
 244                         trigger_error(sprintf(_("PageChange Notification Error: Couldn't send %s to %s"),
 245                                               $pagename, join(',',$userids)), E_USER_WARNING);
 246                 }
 247             }
 248         }
 249
 250         //How to create a RecentChanges entry with explaining summary? Dynamically
 251         /*
 252         $page = $this->getPage($pagename);
 253         $current = $page->getCurrentRevision();
 254         $meta = $current->_data;
 255         $version = $current->getVersion();
 256         $meta['summary'] = _("removed");
 257         $page->save($current->getPackedContent(), $version + 1, $meta);
 258         */
 259         return $result;
 260     }
 261
 262     /**
 263      * Completely remove the page from the WikiDB, without undo possibility.
 264      */
 265     function purgePage($pagename) {
 266         $result = $this->_cache->purge_page($pagename);
 267         $this->deletePage($pagename); // just for the notification
 268         return $result;
 269     }
 270
 271     /**
 272      * Retrieve all pages.
 273      *
 274      * Gets the set of all pages with non-default contents.
 275      *
 276      * @access public
 277      *
 278      * @param boolean $include_defaulted Normally pages whose most
 279      * recent revision has empty content are considered to be
 280      * non-existant. Unless $include_defaulted is set to true, those
 281      * pages will not be returned.
 282      *
 283      * @return WikiDB_PageIterator A WikiDB_PageIterator which contains all pages
 284      *     in the WikiDB which have non-default contents.
 285      */
 286     function getAllPages($include_empty=false, $sortby=false, $limit=false,
 287                          $exclude=false)
 288     {
 289         // HACK: memory_limit=8M will fail on too large pagesets. old php on unix only!
 290         if (USECACHE) {
 291             $mem = ini_get("memory_limit");
 292             if ($mem and !$limit and !isWindows() and !check_php_version(4,3)) {
 293                 $limit = 450;
 294                 $GLOBALS['request']->setArg('limit', $limit);
 295                 $GLOBALS['request']->setArg('paging', 'auto');
 296             }
 297         }
 298         $result = $this->_backend->get_all_pages($include_empty, $sortby, $limit,
 299                                                  $exclude);
 300         return new WikiDB_PageIterator($this, $result,
 301                                        array('include_empty' => $include_empty,
 302                                              'exclude' => $exclude,
 303                                              'limit' => $limit));
 304     }
 305
 306     /**
 307      * $include_empty = true: include also empty pages
 308      * exclude: comma-seperated list pagenames: TBD: array of pagenames
 309      */
 310     function numPages($include_empty=false, $exclude='') {
 311         if (method_exists($this->_backend, 'numPages'))
 312             // FIXME: currently are all args ignored.
 313             $count = $this->_backend->numPages($include_empty, $exclude);
 314         else {
 315             // FIXME: exclude ignored.
 316             $iter = $this->getAllPages($include_empty, false, false, $exclude);
 317             $count = $iter->count();
 318             $iter->free();
 319         }
 320         return (int)$count;
 321     }
 322
 323     /**
 324      * Title search.
 325      *
 326      * Search for pages containing (or not containing) certain words
 327      * in their names.
 328      *
 329      * Pages are returned in alphabetical order whenever it is
 330      * practical to do so.
 331      *
 332      * FIXME: clarify $search syntax. provide glob=>TextSearchQuery converters
 333      *
 334      * @access public
 335      * @param TextSearchQuery $search A TextSearchQuery object
 336      * @return WikiDB_PageIterator A WikiDB_PageIterator containing the matching pages.
 337      * @see TextSearchQuery
 338      */
 339     function titleSearch($search, $sortby='pagename', $limit=false, $exclude=false) {
 340         $result = $this->_backend->text_search($search, false, $sortby, $limit, $exclude);
 341         return new WikiDB_PageIterator($this, $result,
 342                                        array('exclude' => $exclude,
 343                                              'limit' => $limit));
 344     }
 345
 346     /**
 347      * Full text search.
 348      *
 349      * Search for pages containing (or not containing) certain words
 350      * in their entire text (this includes the page content and the
 351      * page name).
 352      *
 353      * Pages are returned in alphabetical order whenever it is
 354      * practical to do so.
 355      *
 356      * @access public
 357      *
 358      * @param TextSearchQuery $search A TextSearchQuery object.
 359      * @return WikiDB_PageIterator A WikiDB_PageIterator containing the matching pages.
 360      * @see TextSearchQuery
 361      */
 362     function fullSearch($search, $sortby='pagename', $limit=false, $exclude=false) {
 363         $result = $this->_backend->text_search($search, true, $sortby, $limit, $exclude);
 364         return new WikiDB_PageIterator($this, $result,
 365                                        array('exclude' => $exclude,
 366                                              'limit'   => $limit,
 367                                              'stoplisted' => $result->stoplisted
 368                                              ));
 369     }
 370
 371     /**
 372      * Find the pages with the greatest hit counts.
 373      *
 374      * Pages are returned in reverse order by hit count.
 375      *
 376      * @access public
 377      *
 378      * @param integer $limit The maximum number of pages to return.
 379      * Set $limit to zero to return all pages.  If $limit < 0, pages will
 380      * be sorted in decreasing order of popularity.
 381      *
 382      * @return WikiDB_PageIterator A WikiDB_PageIterator containing the matching
 383      * pages.
 384      */
 385     function mostPopular($limit = 20, $sortby = '-hits') {
 386         $result = $this->_backend->most_popular($limit, $sortby);
 387         return new WikiDB_PageIterator($this, $result);
 388     }
 389
 390     /**
 391      * Find recent page revisions.
 392      *
 393      * Revisions are returned in reverse order by creation time.
 394      *
 395      * @access public
 396      *
 397      * @param hash $params This hash is used to specify various optional
 398      *   parameters:
 399      * <dl>
 400      * <dt> limit
 401      *    <dd> (integer) At most this many revisions will be returned.
 402      * <dt> since
 403      *    <dd> (integer) Only revisions since this time (unix-timestamp) will be returned.
 404      * <dt> include_minor_revisions
 405      *    <dd> (boolean) Also include minor revisions.  (Default is not to.)
 406      * <dt> exclude_major_revisions
 407      *    <dd> (boolean) Don't include non-minor revisions.
 408      *         (Exclude_major_revisions implies include_minor_revisions.)
 409      * <dt> include_all_revisions
 410      *    <dd> (boolean) Return all matching revisions for each page.
 411      *         Normally only the most recent matching revision is returned
 412      *         for each page.
 413      * </dl>
 414      *
 415      * @return WikiDB_PageRevisionIterator A WikiDB_PageRevisionIterator containing the
 416      * matching revisions.
 417      */
 418     function mostRecent($params = false) {
 419         $result = $this->_backend->most_recent($params);
 420         return new WikiDB_PageRevisionIterator($this, $result);
 421     }
 422
 423     /**
 424      * @access public
 425      *
 426      * @return Iterator A generic iterator containing rows of (duplicate) pagename, wantedfrom.
 427      */
 428     function wantedPages($exclude_from='', $exclude='', $sortby=false, $limit=false) {
 429         return $this->_backend->wanted_pages($exclude_from, $exclude, $sortby, $limit);
 430         //return new WikiDB_PageIterator($this, $result);
 431     }
 432
 433     /**
 434      * @access public
 435      *
 436      * @return array rows of pagenames.
 437      */
 438     function listRelations() {
 439         if (method_exists($this->_backend, "list_relations"))
 440             return $this->_backend->list_relations();
 441         $iter = $this->getAllPages(false, false, false, $exclude);
 442         while ($page = $iter->next()) {
 443             $reliter = $page->getRelations();
 444             $names = array();
 445             while ($rel = $reliter->next()) {
 446                 $names[] = $rel->getName();
 447             }
 448             $relations = array_merge($relations, $names);
 449             $reliter->free();
 450         }
 451         $iter->free();
 452         return $relations;
 453     }
 454
 455     /**
 456      * Call the appropriate backend method.
 457      *
 458      * @access public
 459      * @param string $from Page to rename
 460      * @param string $to   New name
 461      * @param boolean $updateWikiLinks If the text in all pages should be replaced.
 462      * @return boolean     true or false
 463      */
 464     function renamePage($from, $to, $updateWikiLinks = false) {
 465         assert(is_string($from) && $from != '');
 466         assert(is_string($to) && $to != '');
 467         $result = false;
 468         if (method_exists($this->_backend, 'rename_page')) {
 469             $oldpage = $this->getPage($from);
 470             $newpage = $this->getPage($to);
 471             //update all WikiLinks in existing pages
 472             //non-atomic! i.e. if rename fails the links are not undone
 473             if ($updateWikiLinks) {
 474                 require_once('lib/plugin/WikiAdminSearchReplace.php');
 475                 $links = $oldpage->getBackLinks();
 476                 while ($linked_page = $links->next()) {
 477                     WikiPlugin_WikiAdminSearchReplace::replaceHelper($this,
 478                                                                      $linked_page->getName(),
 479                                                                      $from, $to);
 480                 }
 481                 $links = $newpage->getBackLinks();
 482                 while ($linked_page = $links->next()) {
 483                     WikiPlugin_WikiAdminSearchReplace::replaceHelper($this,
 484                                                                      $linked_page->getName(),
 485                                                                      $from, $to);
 486                 }
 487             }
 488             if ($oldpage->exists() and ! $newpage->exists()) {
 489                 if ($result = $this->_backend->rename_page($from, $to)) {
 490                     //create a RecentChanges entry with explaining summary
 491                     $page = $this->getPage($to);
 492                     $current = $page->getCurrentRevision();
 493                     $meta = $current->_data;
 494                     $version = $current->getVersion();
 495                     $meta['summary'] = sprintf(_("renamed from %s"), $from);
 496                     $page->save($current->getPackedContent(), $version + 1, $meta);
 497                 }
 498             } elseif (!$oldpage->getCurrentRevision(false) and !$newpage->exists()) {
 499                 // if a version 0 exists try it also.
 500                 $result = $this->_backend->rename_page($from, $to);
 501             }
 502         } else {
 503             trigger_error(_("WikiDB::renamePage() not yet implemented for this backend"),
 504                           E_USER_WARNING);
 505         }
 506         /* Generate notification emails? */
 507         if ($result and !isa($GLOBALS['request'], 'MockRequest')) {
 508             $notify = $this->get('notify');
 509             if (!empty($notify) and is_array($notify)) {
 510                 list($emails, $userids) = $oldpage->getPageChangeEmails($notify);
 511                 if (!empty($emails)) {
 512                     $oldpage->sendPageRenameNotification($to, $meta, $emails, $userids);
 513                 }
 514             }
 515         }
 516         return $result;
 517     }
 518
 519     /** Get timestamp when database was last modified.
 520      *
 521      * @return string A string consisting of two integers,
 522      * separated by a space.  The first is the time in
 523      * unix timestamp format, the second is a modification
 524      * count for the database.
 525      *
 526      * The idea is that you can cast the return value to an
 527      * int to get a timestamp, or you can use the string value
 528      * as a good hash for the entire database.
 529      */
 530     function getTimestamp() {
 531         $ts = $this->get('_timestamp');
 532         return sprintf("%d %d", $ts[0], $ts[1]);
 533     }
 534
 535     /**
 536      * Update the database timestamp.
 537      *
 538      */
 539     function touch() {
 540         $ts = $this->get('_timestamp');
 541         $this->set('_timestamp', array(time(), $ts[1] + 1));
 542     }
 543
 544
 545     /**
 546      * Access WikiDB global meta-data.
 547      *
 548      * NOTE: this is currently implemented in a hackish and
 549      * not very efficient manner.
 550      *
 551      * @access public
 552      *
 553      * @param string $key Which meta data to get.
 554      * Some reserved meta-data keys are:
 555      * <dl>
 556      * <dt>'_timestamp' <dd> Data used by getTimestamp().
 557      * </dl>
 558      *
 559      * @return scalar The requested value, or false if the requested data
 560      * is not set.
 561      */
 562     function get($key) {
 563         if (!$key || $key[0] == '%')
 564             return false;
 565         /*
 566          * Hack Alert: We can use any page (existing or not) to store
 567          * this data (as long as we always use the same one.)
 568          */
 569         $gd = $this->getPage('global_data');
 570         $data = $gd->get('__global');
 571
 572         if ($data && isset($data[$key]))
 573             return $data[$key];
 574         else
 575             return false;
 576     }
 577
 578     /**
 579      * Set global meta-data.
 580      *
 581      * NOTE: this is currently implemented in a hackish and
 582      * not very efficient manner.
 583      *
 584      * @see get
 585      * @access public
 586      *
 587      * @param string $key  Meta-data key to set.
 588      * @param string $newval  New value.
 589      */
 590     function set($key, $newval) {
 591         if (!$key || $key[0] == '%')
 592             return;
 593
 594         $gd = $this->getPage('global_data');
 595         $data = $gd->get('__global');
 596         if ($data === false)
 597             $data = array();
 598
 599         if (empty($newval))
 600             unset($data[$key]);
 601         else
 602             $data[$key] = $newval;
 603
 604         $gd->set('__global', $data);
 605     }
 606
 607     /* TODO: these are really backend methods */
 608
 609     // SQL result: for simple select or create/update queries
 610     // returns the database specific resource type
 611     function genericSqlQuery($sql, $args=false) {
 612         if (function_exists('debug_backtrace')) { // >= 4.3.0
 613             echo "<pre>", printSimpleTrace(debug_backtrace()), "</pre>\n";
 614         }
 615         trigger_error("no SQL database", E_USER_ERROR);
 616         return false;
 617     }
 618
 619     // SQL iter: for simple select or create/update queries
 620     // returns the generic iterator object (count,next)
 621     function genericSqlIter($sql, $field_list = NULL) {
 622         if (function_exists('debug_backtrace')) { // >= 4.3.0
 623             echo "<pre>", printSimpleTrace(debug_backtrace()), "</pre>\n";
 624         }
 625         trigger_error("no SQL database", E_USER_ERROR);
 626         return false;
 627     }
 628
 629     // see backend upstream methods
 630     // ADODB adds surrounding quotes, SQL not yet!
 631     function quote ($s) {
 632         return $s;
 633     }
 634
 635     function isOpen () {
 636         global $request;
 637         if (!$request->_dbi) return false;
 638         else return false; /* so far only needed for sql so false it.
 639                             later we have to check dba also */
 640     }
 641
 642     function getParam($param) {
 643         global $DBParams;
 644         if (isset($DBParams[$param])) return $DBParams[$param];
 645         elseif ($param == 'prefix') return '';
 646         else return false;
 647     }
 648
 649     function getAuthParam($param) {
 650         global $DBAuthParams;
 651         if (isset($DBAuthParams[$param])) return $DBAuthParams[$param];
 652         elseif ($param == 'USER_AUTH_ORDER') return $GLOBALS['USER_AUTH_ORDER'];
 653         elseif ($param == 'USER_AUTH_POLICY') return $GLOBALS['USER_AUTH_POLICY'];
 654         else return false;
 655     }
 656 };
 657
 658
 659 /**
 660  * An abstract base class which representing a wiki-page within a
 661  * WikiDB.
 662  *
 663  * A WikiDB_Page contains a number (at least one) of
 664  * WikiDB_PageRevisions.
 665  */
 666 class WikiDB_Page
 667 {
 668     function WikiDB_Page(&$wikidb, $pagename) {
 669         $this->_wikidb = &$wikidb;
 670         $this->_pagename = $pagename;
 671         if (DEBUG) {
 672             if (!(is_string($pagename) and $pagename != '')) {
 673                 if (function_exists("xdebug_get_function_stack")) {
 674                     echo "xdebug_get_function_stack(): "; var_dump(xdebug_get_function_stack());
 675                 } elseif (function_exists("debug_backtrace")) { // >= 4.3.0
 676                     printSimpleTrace(debug_backtrace());
 677                 }
 678                 trigger_error("empty pagename", E_USER_WARNING);
 679                 return false;
 680             }
 681         } else {
 682             assert(is_string($pagename) and $pagename != '');
 683         }
 684     }
 685
 686     /**
 687      * Get the name of the wiki page.
 688      *
 689      * @access public
 690      *
 691      * @return string The page name.
 692      */
 693     function getName() {
 694         return $this->_pagename;
 695     }
 696
 697     // To reduce the memory footprint for larger sets of pagelists,
 698     // we don't cache the content (only true or false) and
 699     // we purge the pagedata (_cached_html) also
 700     function exists() {
 701         if (isset($this->_wikidb->_cache->_id_cache[$this->_pagename])) return true;
 702         $current = $this->getCurrentRevision(false);
 703         if (!$current) return false;
 704         return ! $current->hasDefaultContents();
 705     }
 706
 707     /**
 708      * Delete an old revision of a WikiDB_Page.
 709      *
 710      * Deletes the specified revision of the page.
 711      * It is a fatal error to attempt to delete the current revision.
 712      *
 713      * @access public
 714      *
 715      * @param integer $version Which revision to delete.  (You can also
 716      *  use a WikiDB_PageRevision object here.)
 717      */
 718     function deleteRevision($version) {
 719         $backend = &$this->_wikidb->_backend;
 720         $cache = &$this->_wikidb->_cache;
 721         $pagename = &$this->_pagename;
 722
 723         $version = $this->_coerce_to_version($version);
 724         if ($version == 0)
 725             return;
 726
 727         $backend->lock(array('page','version'));
 728         $latestversion = $cache->get_latest_version($pagename);
 729         if ($latestversion && ($version == $latestversion)) {
 730             $backend->unlock(array('page','version'));
 731             trigger_error(sprintf("Attempt to delete most recent revision of '%s'",
 732                                   $pagename), E_USER_ERROR);
 733             return;
 734         }
 735
 736         $cache->delete_versiondata($pagename, $version);
 737         $backend->unlock(array('page','version'));
 738     }
 739
 740     /*
 741      * Delete a revision, or possibly merge it with a previous
 742      * revision.
 743      *
 744      * The idea is this:
 745      * Suppose an author make a (major) edit to a page.  Shortly
 746      * after that the same author makes a minor edit (e.g. to fix
 747      * spelling mistakes he just made.)
 748      *
 749      * Now some time later, where cleaning out old saved revisions,
 750      * and would like to delete his minor revision (since there's
 751      * really no point in keeping minor revisions around for a long
 752      * time.)
 753      *
 754      * Note that the text after the minor revision probably represents
 755      * what the author intended to write better than the text after
 756      * the preceding major edit.
 757      *
 758      * So what we really want to do is merge the minor edit with the
 759      * preceding edit.
 760      *
 761      * We will only do this when:
 762      * <ul>
 763      * <li>The revision being deleted is a minor one, and
 764      * <li>It has the same author as the immediately preceding revision.
 765      * </ul>
 766      */
 767     function mergeRevision($version) {
 768         $backend = &$this->_wikidb->_backend;
 769         $cache = &$this->_wikidb->_cache;
 770         $pagename = &$this->_pagename;
 771
 772         $version = $this->_coerce_to_version($version);
 773         if ($version == 0)
 774             return;
 775
 776         $backend->lock(array('version'));
 777         $latestversion = $cache->get_latest_version($pagename);
 778         if ($latestversion && $version == $latestversion) {
 779             $backend->unlock(array('version'));
 780             trigger_error(sprintf("Attempt to merge most recent revision of '%s'",
 781                                   $pagename), E_USER_ERROR);
 782             return;
 783         }
 784
 785         $versiondata = $cache->get_versiondata($pagename, $version, true);
 786         if (!$versiondata) {
 787             // Not there? ... we're done!
 788             $backend->unlock(array('version'));
 789             return;
 790         }
 791
 792         if ($versiondata['is_minor_edit']) {
 793             $previous = $backend->get_previous_version($pagename, $version);
 794             if ($previous) {
 795                 $prevdata = $cache->get_versiondata($pagename, $previous);
 796                 if ($prevdata['author_id'] == $versiondata['author_id']) {
 797                     // This is a minor revision, previous version is
 798                     // by the same author. We will merge the
 799                     // revisions.
 800                     $cache->update_versiondata($pagename, $previous,
 801                                                array('%content' => $versiondata['%content'],
 802                                                      '_supplanted' => $versiondata['_supplanted']));
 803                 }
 804             }
 805         }
 806
 807         $cache->delete_versiondata($pagename, $version);
 808         $backend->unlock(array('version'));
 809     }
 810
 811
 812     /**
 813      * Create a new revision of a {@link WikiDB_Page}.
 814      *
 815      * @access public
 816      *
 817      * @param int $version Version number for new revision.
 818      * To ensure proper serialization of edits, $version must be
 819      * exactly one higher than the current latest version.
 820      * (You can defeat this check by setting $version to
 821      * {@link WIKIDB_FORCE_CREATE} --- not usually recommended.)
 822      *
 823      * @param string $content Contents of new revision.
 824      *
 825      * @param hash $metadata Metadata for new revision.
 826      * All values in the hash should be scalars (strings or integers).
 827      *
 828      * @param hash $links List of linkto=>pagename, relation=>pagename which this page links to.
 829      *
 830      * @return WikiDB_PageRevision  Returns the new WikiDB_PageRevision object. If
 831      * $version was incorrect, returns false
 832      */
 833     function createRevision($version, &$content, $metadata, $links) {
 834         $backend = &$this->_wikidb->_backend;
 835         $cache = &$this->_wikidb->_cache;
 836         $pagename = &$this->_pagename;
 837         $cache->invalidate_cache($pagename);
 838
 839         $backend->lock(array('version','page','recent','link','nonempty'));
 840
 841         $latestversion = $backend->get_latest_version($pagename);
 842         $newversion = ($latestversion ? $latestversion : 0) + 1;
 843         assert($newversion >= 1);
 844
 845         if ($version != WIKIDB_FORCE_CREATE and $version != $newversion) {
 846             $backend->unlock(array('version','page','recent','link','nonempty'));
 847             return false;
 848         }
 849
 850         $data = $metadata;
 851
 852         foreach ($data as $key => $val) {
 853             if (empty($val) || $key[0] == '_' || $key[0] == '%')
 854                 unset($data[$key]);
 855         }
 856
 857         assert(!empty($data['author']));
 858         if (empty($data['author_id']))
 859             @$data['author_id'] = $data['author'];
 860
 861         if (empty($data['mtime']))
 862             $data['mtime'] = time();
 863
 864         if ($latestversion and $version != WIKIDB_FORCE_CREATE) {
 865             // Ensure mtimes are monotonic.
 866             $pdata = $cache->get_versiondata($pagename, $latestversion);
 867             if ($data['mtime'] < $pdata['mtime']) {
 868                 trigger_error(sprintf(_("%s: Date of new revision is %s"),
 869                                       $pagename,"'non-monotonic'"),
 870                               E_USER_NOTICE);
 871                 $data['orig_mtime'] = $data['mtime'];
 872                 $data['mtime'] = $pdata['mtime'];
 873             }
 874
 875             // FIXME: use (possibly user specified) 'mtime' time or
 876             // time()?
 877             $cache->update_versiondata($pagename, $latestversion,
 878                                        array('_supplanted' => $data['mtime']));
 879         }
 880
 881         $data['%content'] = &$content;
 882
 883         $cache->set_versiondata($pagename, $newversion, $data);
 884
 885         //$cache->update_pagedata($pagename, array(':latestversion' => $newversion,
 886         //':deleted' => empty($content)));
 887
 888         $backend->set_links($pagename, $links);
 889
 890         $backend->unlock(array('version','page','recent','link','nonempty'));
 891
 892         return new WikiDB_PageRevision($this->_wikidb, $pagename, $newversion,
 893                                        $data);
 894     }
 895
 896     /** A higher-level interface to createRevision.
 897      *
 898      * This takes care of computing the links, and storing
 899      * a cached version of the transformed wiki-text.
 900      *
 901      * @param string $wikitext  The page content.
 902      *
 903      * @param int $version Version number for new revision.
 904      * To ensure proper serialization of edits, $version must be
 905      * exactly one higher than the current latest version.
 906      * (You can defeat this check by setting $version to
 907      * {@link WIKIDB_FORCE_CREATE} --- not usually recommended.)
 908      *
 909      * @param hash $meta  Meta-data for new revision.
 910      */
 911     function save($wikitext, $version, $meta) {
 912         $formatted = new TransformedText($this, $wikitext, $meta);
 913         $type = $formatted->getType();
 914         $meta['pagetype'] = $type->getName();
 915         $links = $formatted->getWikiPageLinks(); // linkto => relation
 916
 917         $backend = &$this->_wikidb->_backend;
 918         $newrevision = $this->createRevision($version, $wikitext, $meta, $links);
 919         if ($newrevision and !WIKIDB_NOCACHE_MARKUP)
 920             $this->set('_cached_html', $formatted->pack());
 921
 922         // FIXME: probably should have some global state information
 923         // in the backend to control when to optimize.
 924         //
 925         // We're doing this here rather than in createRevision because
 926         // postgresql can't optimize while locked.
 927         if ((DEBUG & _DEBUG_SQL)
 928             or (DATABASE_OPTIMISE_FREQUENCY > 0 and
 929                 (time() % DATABASE_OPTIMISE_FREQUENCY == 0))) {
 930             if ($backend->optimize()) {
 931                 if (DEBUG)
 932                     trigger_error(_("Optimizing database"), E_USER_NOTICE);
 933             }
 934         }
 935
 936         /* Generate notification emails? */
 937         if (isa($newrevision, 'WikiDB_PageRevision')) {
 938             // Save didn't fail because of concurrent updates.
 939             $notify = $this->_wikidb->get('notify');
 940             if (!empty($notify) and is_array($notify) and !isa($GLOBALS['request'],'MockRequest')) {
 941                 list($emails, $userids) = $this->getPageChangeEmails($notify);
 942                 if (!empty($emails)) {
 943                     $this->sendPageChangeNotification($wikitext, $version, $meta, $emails, $userids);
 944                 }
 945             }
 946             $newrevision->_transformedContent = $formatted;
 947         }
 948
 949         return $newrevision;
 950     }
 951
 952     function getPageChangeEmails($notify) {
 953         $emails = array(); $userids = array();
 954         foreach ($notify as $page => $users) {
 955             if (glob_match($page, $this->_pagename)) {
 956                 foreach ($users as $userid => $user) {
 957                     if (!$user) { // handle the case for ModeratePage: no prefs, just userid's.
 958                         global $request;
 959                         $u = $request->getUser();
 960                         if ($u->UserName() == $userid) {
 961                             $prefs = $u->getPreferences();
 962                         } else {
 963                             // not current user
 964                             if (ENABLE_USER_NEW) {
 965                                 $u = WikiUser($userid);
 966                                 $u->getPreferences();
 967                                 $prefs = &$u->_prefs;
 968                             } else {
 969                                 $u = new WikiUser($GLOBALS['request'], $userid);
 970                                 $prefs = $u->getPreferences();
 971                             }
 972                         }
 973                         $emails[] = $prefs->get('email');
 974                         $userids[] = $userid;
 975                     } else {
 976                       if (!empty($user['verified']) and !empty($user['email'])) {
 977                         $emails[]  = $user['email'];
 978                         $userids[] = $userid;
 979                       } elseif (!empty($user['email'])) {
 980                         global $request;
 981                         // do a dynamic emailVerified check update
 982                         $u = $request->getUser();
 983                         if ($u->UserName() == $userid) {
 984                             if ($request->_prefs->get('emailVerified')) {
 985                                 $emails[] = $user['email'];
 986                                 $userids[] = $userid;
 987                                 $notify[$page][$userid]['verified'] = 1;
 988                                 $request->_dbi->set('notify', $notify);
 989                             }
 990                         } else {
 991                             // not current user
 992                             if (ENABLE_USER_NEW) {
 993                                 $u = WikiUser($userid);
 994                                 $u->getPreferences();
 995                                 $prefs = &$u->_prefs;
 996                             } else {
 997                                 $u = new WikiUser($GLOBALS['request'], $userid);
 998                                 $prefs = $u->getPreferences();
 999                             }
1000                             if ($prefs->get('emailVerified')) {
1001                                 $emails[] = $user['email'];
1002                                 $userids[] = $userid;
1003                                 $notify[$page][$userid]['verified'] = 1;
1004                                 $request->_dbi->set('notify', $notify);
1005                             }
1006                         }
1007                         // ignore verification
1008                         /*
1009                         if (DEBUG) {
1010                             if (!in_array($user['email'],$emails))
1011                                 $emails[] = $user['email'];
1012                         }
1013                         */
1014                     }
1015                   }
1016                 }
1017             }
1018         }
1019         $emails = array_unique($emails);
1020         $userids = array_unique($userids);
1021         return array($emails, $userids);
1022     }
1023
1024     /**
1025      * Send udiff for a changed page to multiple users.
1026      * See rename and remove methods also
1027      */
1028     function sendPageChangeNotification(&$wikitext, $version, $meta, $emails, $userids) {
1029         global $request;
1030         if (@is_array($request->_deferredPageChangeNotification)) {
1031             // collapse multiple changes (loaddir) into one email
1032             $request->_deferredPageChangeNotification[]
1033                 = array($this->_pagename, $emails, $userids);
1034             return;
1035         }
1036         $backend = &$this->_wikidb->_backend;
1037         //$backend = &$request->_dbi->_backend;
1038         $subject = _("Page change").' '.urlencode($this->_pagename);
1039         $previous = $backend->get_previous_version($this->_pagename, $version);
1040         if (!isset($meta['mtime'])) $meta['mtime'] = time();
1041         if ($previous) {
1042             $difflink = WikiURL($this->_pagename, array('action'=>'diff'), true);
1043             $cache = &$this->_wikidb->_cache;
1044             //$cache = &$request->_dbi->_cache;
1045             $this_content = explode("\n", $wikitext);
1046             $prevdata = $cache->get_versiondata($this->_pagename, $previous, true);
1047             if (empty($prevdata['%content']))
1048                 $prevdata = $backend->get_versiondata($this->_pagename, $previous, true);
1049             $other_content = explode("\n", $prevdata['%content']);
1050
1051             include_once("lib/difflib.php");
1052             $diff2 = new Diff($other_content, $this_content);
1053             //$context_lines = max(4, count($other_content) + 1,
1054             //                     count($this_content) + 1);
1055             $fmt = new UnifiedDiffFormatter(/*$context_lines*/);
1056             $content  = $this->_pagename . " " . $previous . " " .
1057                 Iso8601DateTime($prevdata['mtime']) . "\n";
1058             $content .= $this->_pagename . " " . $version . " " .
1059                 Iso8601DateTime($meta['mtime']) . "\n";
1060             $content .= $fmt->format($diff2);
1061
1062         } else {
1063             $difflink = WikiURL($this->_pagename,array(),true);
1064             $content = $this->_pagename . " " . $version . " " .
1065                 Iso8601DateTime($meta['mtime']) . "\n";
1066             $content .= _("New page");
1067         }
1068         $from = $request->_user->getId() . '@' .  $request->get('REMOTE_HOST');
1069         $editedby = sprintf(_("Edited by: %s"), $from);
1070         $emails = join(',',$emails);
1071         if (mail("<undisclosed-recipients>",
1072                  "[".WIKI_NAME."] ".$subject,
1073                  $subject."\n". $editedby."\n". $difflink."\n\n". $content,
1074                  "From: $from\r\nBcc: $emails"))
1075             trigger_error(sprintf(_("PageChange Notification of %s sent to %s"),
1076                                   $this->_pagename, join(',',$userids)), E_USER_NOTICE);
1077         else
1078             trigger_error(sprintf(_("PageChange Notification Error: Couldn't send %s to %s"),
1079                                   $this->_pagename, join(',',$userids)), E_USER_WARNING);
1080     }
1081
1082     /** support mass rename / remove (not yet tested)
1083      */
1084     function sendPageRenameNotification($to, &$meta, $emails, $userids) {
1085         global $request;
1086         if (@is_array($request->_deferredPageRenameNotification)) {
1087             $request->_deferredPageRenameNotification[] = array($this->_pagename,
1088                                                                 $to, $meta, $emails, $userids);
1089         } else {
1090             $oldname = $this->_pagename;
1091             $from = $request->_user->getId() . '@' .  $request->get('REMOTE_HOST');
1092             $editedby = sprintf(_("Edited by: %s"), $from);
1093             $emails = join(',',$emails);
1094             $subject = sprintf(_("Page rename %s to %s"), urlencode($oldname), urlencode($to));
1095             $link = WikiURL($to, true);
1096             if (mail("<undisclosed-recipients>",
1097                      "[".WIKI_NAME."] ".$subject,
1098                      $subject."\n".$editedby."\n".$link."\n\n"."Renamed $from to $to",
1099                      "From: $from\r\nBcc: $emails"))
1100                 trigger_error(sprintf(_("PageChange Notification of %s sent to %s"),
1101                                       $oldname, join(',',$userids)), E_USER_NOTICE);
1102             else
1103                 trigger_error(sprintf(_("PageChange Notification Error: Couldn't send %s to %s"),
1104                                       $oldname, join(',',$userids)), E_USER_WARNING);
1105         }
1106     }
1107
1108     /**
1109      * Get the most recent revision of a page.
1110      *
1111      * @access public
1112      *
1113      * @return WikiDB_PageRevision The current WikiDB_PageRevision object.
1114      */
1115     function getCurrentRevision ($need_content = true) {
1116         $backend = &$this->_wikidb->_backend;
1117         $cache = &$this->_wikidb->_cache;
1118         $pagename = &$this->_pagename;
1119
1120         // Prevent deadlock in case of memory exhausted errors
1121         // Pure selection doesn't really need locking here.
1122         //   sf.net bug#927395
1123         // I know it would be better to lock, but with lots of pages this deadlock is more
1124         // severe than occasionally get not the latest revision.
1125         // In spirit to wikiwiki: read fast, edit slower.
1126         //$backend->lock();
1127         $version = $cache->get_latest_version($pagename);
1128         // getRevision gets the content also!
1129         $revision = $this->getRevision($version, $need_content);
1130         //$backend->unlock();
1131         assert($revision);
1132         return $revision;
1133     }
1134
1135     /**
1136      * Get a specific revision of a WikiDB_Page.
1137      *
1138      * @access public
1139      *
1140      * @param integer $version  Which revision to get.
1141      *
1142      * @return WikiDB_PageRevision The requested WikiDB_PageRevision object, or
1143      * false if the requested revision does not exist in the {@link WikiDB}.
1144      * Note that version zero of any page always exists.
1145      */
1146     function getRevision ($version, $need_content=true) {
1147         $cache = &$this->_wikidb->_cache;
1148         $pagename = &$this->_pagename;
1149
1150         if (! $version or $version == -1) // 0 or false
1151             return new WikiDB_PageRevision($this->_wikidb, $pagename, 0);
1152
1153         assert($version > 0);
1154         $vdata = $cache->get_versiondata($pagename, $version, $need_content);
1155         if (!$vdata) {
1156             return new WikiDB_PageRevision($this->_wikidb, $pagename, 0);
1157         }
1158         return new WikiDB_PageRevision($this->_wikidb, $pagename, $version,
1159                                        $vdata);
1160     }
1161
1162     /**
1163      * Get previous page revision.
1164      *
1165      * This method find the most recent revision before a specified
1166      * version.
1167      *
1168      * @access public
1169      *
1170      * @param integer $version  Find most recent revision before this version.
1171      *  You can also use a WikiDB_PageRevision object to specify the $version.
1172      *
1173      * @return WikiDB_PageRevision The requested WikiDB_PageRevision object, or false if the
1174      * requested revision does not exist in the {@link WikiDB}.  Note that
1175      * unless $version is greater than zero, a revision (perhaps version zero,
1176      * the default revision) will always be found.
1177      */
1178     function getRevisionBefore ($version=false, $need_content=true) {
1179         $backend = &$this->_wikidb->_backend;
1180         $pagename = &$this->_pagename;
1181         if ($version === false)
1182             $version = $this->_wikidb->_cache->get_latest_version($pagename);
1183         else
1184             $version = $this->_coerce_to_version($version);
1185
1186         if ($version == 0)
1187             return false;
1188         //$backend->lock();
1189         $previous = $backend->get_previous_version($pagename, $version);
1190         $revision = $this->getRevision($previous, $need_content);
1191         //$backend->unlock();
1192         assert($revision);
1193         return $revision;
1194     }
1195
1196     /**
1197      * Get all revisions of the WikiDB_Page.
1198      *
1199      * This does not include the version zero (default) revision in the
1200      * returned revision set.
1201      *
1202      * @return WikiDB_PageRevisionIterator A
1203      *   WikiDB_PageRevisionIterator containing all revisions of this
1204      *   WikiDB_Page in reverse order by version number.
1205      */
1206     function getAllRevisions() {
1207         $backend = &$this->_wikidb->_backend;
1208         $revs = $backend->get_all_revisions($this->_pagename);
1209         return new WikiDB_PageRevisionIterator($this->_wikidb, $revs);
1210     }
1211
1212     /**
1213      * Find pages which link to or are linked from a page.
1214      * relations: $backend->get_links is responsible to add the relation to the pagehash
1215      * as 'linkrelation' key as pagename. See WikiDB_PageIterator::next
1216      *   if (isset($next['linkrelation']))
1217      *
1218      * @access public
1219      *
1220      * @param boolean $reversed Which links to find: true for backlinks (default).
1221      *
1222      * @return WikiDB_PageIterator A WikiDB_PageIterator containing
1223      * all matching pages.
1224      */
1225     function getLinks ($reversed = true, $include_empty=false, $sortby=false,
1226                        $limit=false, $exclude=false, $want_relations=false)
1227     {
1228         $backend = &$this->_wikidb->_backend;
1229         $result =  $backend->get_links($this->_pagename, $reversed,
1230                                        $include_empty, $sortby, $limit, $exclude,
1231                                        $want_relations);
1232         return new WikiDB_PageIterator($this->_wikidb, $result,
1233                                        array('include_empty' => $include_empty,
1234                                              'sortby'        => $sortby,
1235                                              'limit'         => $limit,
1236                                              'exclude'       => $exclude,
1237                                              'want_relations'=> $want_relations));
1238     }
1239
1240     /**
1241      * All Links from other pages to this page.
1242      */
1243     function getBackLinks($include_empty=false, $sortby=false, $limit=false, $exclude=false,
1244                           $want_relations=false)
1245     {
1246         return $this->getLinks(true, $include_empty, $sortby, $limit, $exclude);
1247     }
1248     /**
1249      * Forward Links: All Links from this page to other pages.
1250      */
1251     function getPageLinks($include_empty=false, $sortby=false, $limit=false, $exclude=false,
1252                           $want_relations=false)
1253     {
1254         return $this->getLinks(false, $include_empty, $sortby, $limit, $exclude);
1255     }
1256     /**
1257      * Relations: All links from this page to other pages with relation <> 0.
1258      * Like isa:=page
1259      */
1260     function getRelations($sortby=false, $limit=false, $exclude=false) {
1261         $backend = &$this->_wikidb->_backend;
1262         $result =  $backend->get_links($this->_pagename, false, true,
1263                                        $sortby, $limit, $exclude,
1264                                        true);
1265         // we do not care for the linked page versiondata, just the pagename and relationname
1266         return new WikiDB_PageIterator($this->_wikidb, $result,
1267                                        array('include_empty' => true,
1268                                              'sortby'        => $sortby,
1269                                              'limit'         => $limit,
1270                                              'exclude'       => $exclude,
1271                                              'want_relations'=> true));
1272     }
1273
1274     /**
1275      * possibly faster link existance check. not yet accelerated.
1276      */
1277     function existLink($link, $reversed=false) {
1278         $backend = &$this->_wikidb->_backend;
1279         if (method_exists($backend,'exists_link'))
1280             return $backend->exists_link($this->_pagename, $link, $reversed);
1281         //$cache = &$this->_wikidb->_cache;
1282         // TODO: check cache if it is possible
1283         $iter = $this->getLinks($reversed, false);
1284         while ($page = $iter->next()) {
1285             if ($page->getName() == $link)
1286                 return $page;
1287         }
1288         $iter->free();
1289         return false;
1290     }
1291
1292     /* Semantic relations are links with the relation pointing to another page,
1293        the so called "RDF Triple".
1294        [San Diego] is%20a::city
1295        => "At the page San Diego there is a relation link of 'is a' to the page 'city'."
1296      */
1297
1298     /* Semantic attributes for a page.
1299        [San Diego] population:=1,305,736
1300        Attributes are links with the relation pointing to another page.
1301     */
1302
1303     /**
1304      * Access WikiDB_Page non version-specific meta-data.
1305      *
1306      * @access public
1307      *
1308      * @param string $key Which meta data to get.
1309      * Some reserved meta-data keys are:
1310      * <dl>
1311      * <dt>'date'  <dd> Created as unixtime
1312      * <dt>'locked'<dd> Is page locked? 'yes' or 'no'
1313      * <dt>'hits'  <dd> Page hit counter.
1314      * <dt>'_cached_html' <dd> Transformed CachedMarkup object, serialized + optionally gzipped.
1315      *                         In SQL stored now in an extra column.
1316      * Optional data:
1317      * <dt>'pref'  <dd> Users preferences, stored only in homepages.
1318      * <dt>'owner' <dd> Default: first author_id. We might add a group with a dot here:
1319      *                  E.g. "owner.users"
1320      * <dt>'perm'  <dd> Permission flag to authorize read/write/execution of
1321      *                  page-headers and content.
1322      + <dt>'moderation'<dd> ModeratedPage data
1323      * <dt>'score' <dd> Page score (not yet implement, do we need?)
1324      * </dl>
1325      *
1326      * @return scalar The requested value, or false if the requested data
1327      * is not set.
1328      */
1329     function get($key) {
1330         $cache = &$this->_wikidb->_cache;
1331         $backend = &$this->_wikidb->_backend;
1332         if (!$key || $key[0] == '%')
1333             return false;
1334         // several new SQL backends optimize this.
1335         if (!WIKIDB_NOCACHE_MARKUP
1336             and $key == '_cached_html'
1337             and method_exists($backend, 'get_cached_html'))
1338         {
1339             return $backend->get_cached_html($this->_pagename);
1340         }
1341         $data = $cache->get_pagedata($this->_pagename);
1342         return isset($data[$key]) ? $data[$key] : false;
1343     }
1344
1345     /**
1346      * Get all the page meta-data as a hash.
1347      *
1348      * @return hash The page meta-data.
1349      */
1350     function getMetaData() {
1351         $cache = &$this->_wikidb->_cache;
1352         $data = $cache->get_pagedata($this->_pagename);
1353         $meta = array();
1354         foreach ($data as $key => $val) {
1355             if (/*!empty($val) &&*/ $key[0] != '%')
1356                 $meta[$key] = $val;
1357         }
1358         return $meta;
1359     }
1360
1361     /**
1362      * Set page meta-data.
1363      *
1364      * @see get
1365      * @access public
1366      *
1367      * @param string $key  Meta-data key to set.
1368      * @param string $newval  New value.
1369      */
1370     function set($key, $newval) {
1371         $cache = &$this->_wikidb->_cache;
1372         $backend = &$this->_wikidb->_backend;
1373         $pagename = &$this->_pagename;
1374
1375         assert($key && $key[0] != '%');
1376
1377         // several new SQL backends optimize this.
1378         if (!WIKIDB_NOCACHE_MARKUP
1379             and $key == '_cached_html'
1380             and method_exists($backend, 'set_cached_html'))
1381         {
1382             return $backend->set_cached_html($pagename, $newval);
1383         }
1384
1385         $data = $cache->get_pagedata($pagename);
1386
1387         if (!empty($newval)) {
1388             if (!empty($data[$key]) && $data[$key] == $newval)
1389                 return;         // values identical, skip update.
1390         }
1391         else {
1392             if (empty($data[$key]))
1393                 return;         // values identical, skip update.
1394         }
1395
1396         $cache->update_pagedata($pagename, array($key => $newval));
1397     }
1398
1399     /**
1400      * Increase page hit count.
1401      *
1402      * FIXME: IS this needed?  Probably not.
1403      *
1404      * This is a convenience function.
1405      * <pre> $page->increaseHitCount(); </pre>
1406      * is functionally identical to
1407      * <pre> $page->set('hits',$page->get('hits')+1); </pre>
1408      * but less expensive (ignores the pagadata string)
1409      *
1410      * Note that this method may be implemented in more efficient ways
1411      * in certain backends.
1412      *
1413      * @access public
1414      */
1415     function increaseHitCount() {
1416         if (method_exists($this->_wikidb->_backend, 'increaseHitCount'))
1417             $this->_wikidb->_backend->increaseHitCount($this->_pagename);
1418         else {
1419             @$newhits = $this->get('hits') + 1;
1420             $this->set('hits', $newhits);
1421         }
1422     }
1423
1424     /**
1425      * Return a string representation of the WikiDB_Page
1426      *
1427      * This is really only for debugging.
1428      *
1429      * @access public
1430      *
1431      * @return string Printable representation of the WikiDB_Page.
1432      */
1433     function asString () {
1434         ob_start();
1435         printf("[%s:%s\n", get_class($this), $this->getName());
1436         print_r($this->getMetaData());
1437         echo "]\n";
1438         $strval = ob_get_contents();
1439         ob_end_clean();
1440         return $strval;
1441     }
1442
1443
1444     /**
1445      * @access private
1446      * @param integer_or_object $version_or_pagerevision
1447      * Takes either the version number (and int) or a WikiDB_PageRevision
1448      * object.
1449      * @return integer The version number.
1450      */
1451     function _coerce_to_version($version_or_pagerevision) {
1452         if (method_exists($version_or_pagerevision, "getContent"))
1453             $version = $version_or_pagerevision->getVersion();
1454         else
1455             $version = (int) $version_or_pagerevision;
1456
1457         assert($version >= 0);
1458         return $version;
1459     }
1460
1461     function isUserPage ($include_empty = true) {
1462         if (!$include_empty and !$this->exists()) return false;
1463         return $this->get('pref') ? true : false;
1464     }
1465
1466     // May be empty. Either the stored owner (/Chown), or the first authorized author
1467     function getOwner() {
1468         if ($owner = $this->get('owner'))
1469             return ($owner == "The PhpWiki programming team") ? ADMIN_USER : $owner;
1470         // check all revisions forwards for the first author_id
1471         $backend = &$this->_wikidb->_backend;
1472         $pagename = &$this->_pagename;
1473         $latestversion = $backend->get_latest_version($pagename);
1474         for ($v=1; $v <= $latestversion; $v++) {
1475             $rev = $this->getRevision($v,false);
1476             if ($rev and $owner = $rev->get('author_id')) {
1477                 return ($owner == "The PhpWiki programming team") ? ADMIN_USER : $owner;
1478             }
1479         }
1480         return '';
1481     }
1482
1483     // The authenticated author of the first revision or empty if not authenticated then.
1484     function getCreator() {
1485         if ($current = $this->getRevision(1,false)) return $current->get('author_id');
1486         else return '';
1487     }
1488
1489     // The authenticated author of the current revision.
1490     function getAuthor() {
1491         if ($current = $this->getCurrentRevision(false)) return $current->get('author_id');
1492         else return '';
1493     }
1494
1495 };
1496
1497 /**
1498  * This class represents a specific revision of a WikiDB_Page within
1499  * a WikiDB.
1500  *
1501  * A WikiDB_PageRevision has read-only semantics. You may only create
1502  * new revisions (and delete old ones) --- you cannot modify existing
1503  * revisions.
1504  */
1505 class WikiDB_PageRevision
1506 {
1507     //var $_transformedContent = false; // set by WikiDB_Page::save()
1508
1509     function WikiDB_PageRevision(&$wikidb, $pagename, $version, $versiondata = false) {
1510         $this->_wikidb = &$wikidb;
1511         $this->_pagename = $pagename;
1512         $this->_version = $version;
1513         $this->_data = $versiondata ? $versiondata : array();
1514         $this->_transformedContent = false; // set by WikiDB_Page::save()
1515     }
1516
1517     /**
1518      * Get the WikiDB_Page which this revision belongs to.
1519      *
1520      * @access public
1521      *
1522      * @return WikiDB_Page The WikiDB_Page which this revision belongs to.
1523      */
1524     function getPage() {
1525         return new WikiDB_Page($this->_wikidb, $this->_pagename);
1526     }
1527
1528     /**
1529      * Get the version number of this revision.
1530      *
1531      * @access public
1532      *
1533      * @return integer The version number of this revision.
1534      */
1535     function getVersion() {
1536         return $this->_version;
1537     }
1538
1539     /**
1540      * Determine whether this revision has defaulted content.
1541      *
1542      * The default revision (version 0) of each page, as well as any
1543      * pages which are created with empty content have their content
1544      * defaulted to something like:
1545      * <pre>
1546      *   Describe [ThisPage] here.
1547      * </pre>
1548      *
1549      * @access public
1550      *
1551      * @return boolean Returns true if the page has default content.
1552      */
1553     function hasDefaultContents() {
1554         $data = &$this->_data;
1555         return empty($data['%content']); // FIXME: what if it's the number 0? <>'' or === false
1556     }
1557
1558     /**
1559      * Get the content as an array of lines.
1560      *
1561      * @access public
1562      *
1563      * @return array An array of lines.
1564      * The lines should contain no trailing white space.
1565      */
1566     function getContent() {
1567         return explode("\n", $this->getPackedContent());
1568     }
1569
1570    /**
1571      * Get the pagename of the revision.
1572      *
1573      * @access public
1574      *
1575      * @return string pagename.
1576      */
1577     function getPageName() {
1578         return $this->_pagename;
1579     }
1580     function getName() {
1581         return $this->_pagename;
1582     }
1583
1584     /**
1585      * Determine whether revision is the latest.
1586      *
1587      * @access public
1588      *
1589      * @return boolean True iff the revision is the latest (most recent) one.
1590      */
1591     function isCurrent() {
1592         if (!isset($this->_iscurrent)) {
1593             $page = $this->getPage();
1594             $current = $page->getCurrentRevision(false);
1595             $this->_iscurrent = $this->getVersion() == $current->getVersion();
1596         }
1597         return $this->_iscurrent;
1598     }
1599
1600     /**
1601      * Get the transformed content of a page.
1602      *
1603      * @param string $pagetype  Override the page-type of the revision.
1604      *
1605      * @return object An XmlContent-like object containing the page transformed
1606      * contents.
1607      */
1608     function getTransformedContent($pagetype_override=false) {
1609         $backend = &$this->_wikidb->_backend;
1610
1611         if ($pagetype_override) {
1612             // Figure out the normal page-type for this page.
1613             $type = PageType::GetPageType($this->get('pagetype'));
1614             if ($type->getName() == $pagetype_override)
1615                 $pagetype_override = false; // Not really an override...
1616         }
1617
1618         if ($pagetype_override) {
1619             // Overriden page type, don't cache (or check cache).
1620             return new TransformedText($this->getPage(),
1621                                        $this->getPackedContent(),
1622                                        $this->getMetaData(),
1623                                        $pagetype_override);
1624         }
1625
1626         $possibly_cache_results = true;
1627
1628         if (!USECACHE or WIKIDB_NOCACHE_MARKUP) {
1629             if (WIKIDB_NOCACHE_MARKUP == 'purge') {
1630                 // flush cache for this page.
1631                 $page = $this->getPage();
1632                 $page->set('_cached_html', ''); // ignored with !USECACHE
1633             }
1634             $possibly_cache_results = false;
1635         }
1636         elseif (USECACHE and !$this->_transformedContent) {
1637             //$backend->lock();
1638             if ($this->isCurrent()) {
1639                 $page = $this->getPage();
1640                 $this->_transformedContent = TransformedText::unpack($page->get('_cached_html'));
1641             }
1642             else {
1643                 $possibly_cache_results = false;
1644             }
1645             //$backend->unlock();
1646         }
1647
1648         if (!$this->_transformedContent) {
1649             $this->_transformedContent
1650                 = new TransformedText($this->getPage(),
1651                                       $this->getPackedContent(),
1652                                       $this->getMetaData());
1653
1654             if ($possibly_cache_results and !WIKIDB_NOCACHE_MARKUP) {
1655                 // If we're still the current version, cache the transfomed page.
1656                 //$backend->lock();
1657                 if ($this->isCurrent()) {
1658                     $page->set('_cached_html', $this->_transformedContent->pack());
1659                 }
1660                 //$backend->unlock();
1661             }
1662         }
1663
1664         return $this->_transformedContent;
1665     }
1666
1667     /**
1668      * Get the content as a string.
1669      *
1670      * @access public
1671      *
1672      * @return string The page content.
1673      * Lines are separated by new-lines.
1674      */
1675     function getPackedContent() {
1676         $data = &$this->_data;
1677
1678
1679         if (empty($data['%content'])) {
1680             include_once('lib/InlineParser.php');
1681
1682             // A feature similar to taglines at http://www.wlug.org.nz/
1683             // Lib from http://www.aasted.org/quote/
1684             if (defined('FORTUNE_DIR')
1685                 and is_dir(FORTUNE_DIR)
1686                 and in_array($GLOBALS['request']->getArg('action'),
1687                              array('create','edit')))
1688             {
1689                 include_once("lib/fortune.php");
1690                 $fortune = new Fortune();
1691                 $quote = str_replace("\n<br>","\n", $fortune->quoteFromDir(FORTUNE_DIR));
1692                 return sprintf("<verbatim>\n%s</verbatim>\n\n"._("Describe %s here."),
1693                                $quote, "[" . WikiEscape($this->_pagename) . "]");
1694             }
1695             // Replace empty content with default value.
1696             return sprintf(_("Describe %s here."),
1697                            "[" . WikiEscape($this->_pagename) . "]");
1698         }
1699
1700         // There is (non-default) content.
1701         assert($this->_version > 0);
1702
1703         if (!is_string($data['%content'])) {
1704             // Content was not provided to us at init time.
1705             // (This is allowed because for some backends, fetching
1706             // the content may be expensive, and often is not wanted
1707             // by the user.)
1708             //
1709             // In any case, now we need to get it.
1710             $data['%content'] = $this->_get_content();
1711             assert(is_string($data['%content']));
1712         }
1713
1714         return $data['%content'];
1715     }
1716
1717     function _get_content() {
1718         $cache = &$this->_wikidb->_cache;
1719         $pagename = $this->_pagename;
1720         $version = $this->_version;
1721
1722         assert($version > 0);
1723
1724         $newdata = $cache->get_versiondata($pagename, $version, true);
1725         if ($newdata) {
1726             assert(is_string($newdata['%content']));
1727             return $newdata['%content'];
1728         }
1729         else {
1730             // else revision has been deleted... What to do?
1731             return __sprintf("Oops! Revision %s of %s seems to have been deleted!",
1732                              $version, $pagename);
1733         }
1734     }
1735
1736     /**
1737      * Get meta-data for this revision.
1738      *
1739      *
1740      * @access public
1741      *
1742      * @param string $key Which meta-data to access.
1743      *
1744      * Some reserved revision meta-data keys are:
1745      * <dl>
1746      * <dt> 'mtime' <dd> Time this revision was created (seconds since midnight Jan 1, 1970.)
1747      *        The 'mtime' meta-value is normally set automatically by the database
1748      *        backend, but it may be specified explicitly when creating a new revision.
1749      * <dt> orig_mtime
1750      *  <dd> To ensure consistency of RecentChanges, the mtimes of the versions
1751      *       of a page must be monotonically increasing.  If an attempt is
1752      *       made to create a new revision with an mtime less than that of
1753      *       the preceeding revision, the new revisions timestamp is force
1754      *       to be equal to that of the preceeding revision.  In that case,
1755      *       the originally requested mtime is preserved in 'orig_mtime'.
1756      * <dt> '_supplanted' <dd> Time this revision ceased to be the most recent.
1757      *        This meta-value is <em>always</em> automatically maintained by the database
1758      *        backend.  (It is set from the 'mtime' meta-value of the superceding
1759      *        revision.)  '_supplanted' has a value of 'false' for the current revision.
1760      *
1761      * FIXME: this could be refactored:
1762      * <dt> author
1763      *  <dd> Author of the page (as he should be reported in, e.g. RecentChanges.)
1764      * <dt> author_id
1765      *  <dd> Authenticated author of a page.  This is used to identify
1766      *       the distinctness of authors when cleaning old revisions from
1767      *       the database.
1768      * <dt> 'is_minor_edit' <dd> Set if change was marked as a minor revision by the author.
1769      * <dt> 'summary' <dd> Short change summary entered by page author.
1770      * </dl>
1771      *
1772      * Meta-data keys must be valid C identifers (they have to start with a letter
1773      * or underscore, and can contain only alphanumerics and underscores.)
1774      *
1775      * @return string The requested value, or false if the requested value
1776      * is not defined.
1777      */
1778     function get($key) {
1779         if (!$key || $key[0] == '%')
1780             return false;
1781         $data = &$this->_data;
1782         return isset($data[$key]) ? $data[$key] : false;
1783     }
1784
1785     /**
1786      * Get all the revision page meta-data as a hash.
1787      *
1788      * @return hash The revision meta-data.
1789      */
1790     function getMetaData() {
1791         $meta = array();
1792         foreach ($this->_data as $key => $val) {
1793             if (!empty($val) && $key[0] != '%')
1794                 $meta[$key] = $val;
1795         }
1796         return $meta;
1797     }
1798
1799
1800     /**
1801      * Return a string representation of the revision.
1802      *
1803      * This is really only for debugging.
1804      *
1805      * @access public
1806      *
1807      * @return string Printable representation of the WikiDB_Page.
1808      */
1809     function asString () {
1810         ob_start();
1811         printf("[%s:%d\n", get_class($this), $this->get('version'));
1812         print_r($this->_data);
1813         echo $this->getPackedContent() . "\n]\n";
1814         $strval = ob_get_contents();
1815         ob_end_clean();
1816         return $strval;
1817     }
1818 };
1819
1820
1821 /**
1822  * Class representing a sequence of WikiDB_Pages.
1823  * TODO: Enhance to php5 iterators
1824  * TODO:
1825  *   apply filters for options like 'sortby', 'limit', 'exclude'
1826  *   for simple queries like titleSearch, where the backend is not ready yet.
1827  */
1828 class WikiDB_PageIterator
1829 {
1830     function WikiDB_PageIterator(&$wikidb, &$iter, $options=false) {
1831         $this->_iter = $iter; // a WikiDB_backend_iterator
1832         $this->_wikidb = &$wikidb;
1833         $this->_options = $options;
1834     }
1835
1836     function count () {
1837         return $this->_iter->count();
1838     }
1839
1840     /**
1841      * Get next WikiDB_Page in sequence.
1842      *
1843      * @access public
1844      *
1845      * @return WikiDB_Page The next WikiDB_Page in the sequence.
1846      */
1847     function next () {
1848         if ( ! ($next = $this->_iter->next()) )
1849             return false;
1850
1851         $pagename = &$next['pagename'];
1852         if (!is_string($pagename)) { // Bug #1327912 fixed by Joachim Lous
1853             $pagename = strval($pagename);
1854         }
1855         if (!$pagename) {
1856             trigger_error('empty pagename in WikiDB_PageIterator::next()', E_USER_WARNING);
1857             var_dump($next);
1858             return false;
1859         }
1860         // There's always hits, but we cache only if more
1861         // (well not with file, cvs and dba)
1862         if (isset($next['pagedata']) and count($next['pagedata']) > 1) {
1863             $this->_wikidb->_cache->cache_data($next);
1864         // cache existing page id's since we iterate over all links in GleanDescription
1865         // and need them later for LinkExistingWord
1866         } elseif ($this->_options and array_key_exists('include_empty', $this->_options)
1867                   and !$this->_options['include_empty'] and isset($next['id'])) {
1868             $this->_wikidb->_cache->_id_cache[$next['pagename']] = $next['id'];
1869         }
1870         $page = new WikiDB_Page($this->_wikidb, $pagename);
1871         if (isset($next['linkrelation']))
1872             $page->set('linkrelation', $next['linkrelation']);
1873         return $page;
1874     }
1875
1876     /**
1877      * Release resources held by this iterator.
1878      *
1879      * The iterator may not be used after free() is called.
1880      *
1881      * There is no need to call free(), if next() has returned false.
1882      * (I.e. if you iterate through all the pages in the sequence,
1883      * you do not need to call free() --- you only need to call it
1884      * if you stop before the end of the iterator is reached.)
1885      *
1886      * @access public
1887      */
1888     function free() {
1889         $this->_iter->free();
1890     }
1891
1892     function asArray() {
1893         $result = array();
1894         while ($page = $this->next())
1895             $result[] = $page;
1896         //$this->reset();
1897         return $result;
1898     }
1899
1900     /**
1901      * Apply filters for options like 'sortby', 'limit', 'exclude'
1902      * for simple queries like titleSearch, where the backend is not ready yet.
1903      * Since iteration is usually destructive for SQL results,
1904      * we have to generate a copy.
1905      */
1906     function applyFilters($options = false) {
1907         if (!$options) $options = $this->_options;
1908         if (isset($options['sortby'])) {
1909             $array = array();
1910             /* this is destructive */
1911             while ($page = $this->next())
1912                 $result[] = $page->getName();
1913             $this->_doSort($array, $options['sortby']);
1914         }
1915         /* the rest is not destructive.
1916          * reconstruct a new iterator
1917          */
1918         $pagenames = array(); $i = 0;
1919         if (isset($options['limit']))
1920             $limit = $options['limit'];
1921         else
1922             $limit = 0;
1923         if (isset($options['exclude']))
1924             $exclude = $options['exclude'];
1925         if (is_string($exclude) and !is_array($exclude))
1926             $exclude = PageList::explodePageList($exclude, false, false, $limit);
1927         foreach($array as $pagename) {
1928             if ($limit and $i++ > $limit)
1929                 return new WikiDB_Array_PageIterator($pagenames);
1930             if (!empty($exclude) and !in_array($pagename, $exclude))
1931                 $pagenames[] = $pagename;
1932             elseif (empty($exclude))
1933                 $pagenames[] = $pagename;
1934         }
1935         return new WikiDB_Array_PageIterator($pagenames);
1936     }
1937
1938     /* pagename only */
1939     function _doSort(&$array, $sortby) {
1940         $sortby = PageList::sortby($sortby, 'init');
1941         if ($sortby == '+pagename')
1942             sort($array, SORT_STRING);
1943         elseif ($sortby == '-pagename')
1944             rsort($array, SORT_STRING);
1945         reset($array);
1946     }
1947
1948 };
1949
1950 /**
1951  * A class which represents a sequence of WikiDB_PageRevisions.
1952  * TODO: Enhance to php5 iterators
1953  */
1954 class WikiDB_PageRevisionIterator
1955 {
1956     function WikiDB_PageRevisionIterator(&$wikidb, &$revisions, $options=false) {
1957         $this->_revisions = $revisions;
1958         $this->_wikidb = &$wikidb;
1959         $this->_options = $options;
1960     }
1961
1962     function count () {
1963         return $this->_revisions->count();
1964     }
1965
1966     /**
1967      * Get next WikiDB_PageRevision in sequence.
1968      *
1969      * @access public
1970      *
1971      * @return WikiDB_PageRevision
1972      * The next WikiDB_PageRevision in the sequence.
1973      */
1974     function next () {
1975         if ( ! ($next = $this->_revisions->next()) )
1976             return false;
1977
1978         //$this->_wikidb->_cache->cache_data($next);
1979
1980         $pagename = $next['pagename'];
1981         $version = $next['version'];
1982         $versiondata = $next['versiondata'];
1983         if (DEBUG) {
1984             if (!(is_string($pagename) and $pagename != '')) {
1985                 trigger_error("empty pagename",E_USER_WARNING);
1986                 return false;
1987             }
1988         } else assert(is_string($pagename) and $pagename != '');
1989         if (DEBUG) {
1990             if (!is_array($versiondata)) {
1991                 trigger_error("empty versiondata",E_USER_WARNING);
1992                 return false;
1993             }
1994         } else assert(is_array($versiondata));
1995         if (DEBUG) {
1996             if (!($version > 0)) {
1997                 trigger_error("invalid version",E_USER_WARNING);
1998                 return false;
1999             }
2000         } else assert($version > 0);
2001
2002         return new WikiDB_PageRevision($this->_wikidb, $pagename, $version,
2003                                        $versiondata);
2004     }
2005
2006     /**
2007      * Release resources held by this iterator.
2008      *
2009      * The iterator may not be used after free() is called.
2010      *
2011      * There is no need to call free(), if next() has returned false.
2012      * (I.e. if you iterate through all the revisions in the sequence,
2013      * you do not need to call free() --- you only need to call it
2014      * if you stop before the end of the iterator is reached.)
2015      *
2016      * @access public
2017      */
2018     function free() {
2019         $this->_revisions->free();
2020     }
2021
2022     function asArray() {
2023         $result = array();
2024         while ($rev = $this->next())
2025             $result[] = $rev;
2026         $this->free();
2027         return $result;
2028     }
2029 };
2030
2031 /** pseudo iterator
2032  */
2033 class WikiDB_Array_PageIterator
2034 {
2035     function WikiDB_Array_PageIterator($pagenames) {
2036         global $request;
2037         $this->_dbi = $request->getDbh();
2038         $this->_pages = $pagenames;
2039         reset($this->_pages);
2040     }
2041     function next() {
2042         $c =& current($this->_pages);
2043         next($this->_pages);
2044         return $c !== false ? $this->_dbi->getPage($c) : false;
2045     }
2046     function count() {
2047         return count($this->_pages);
2048     }
2049     function free() {}
2050     function asArray() {
2051         reset($this->_pages);
2052         return $this->_pages;
2053     }
2054 }
2055
2056 class WikiDB_Array_generic_iter
2057 {
2058     function WikiDB_Array_generic_iter($result) {
2059         // $result may be either an array or a query result
2060         if (is_array($result)) {
2061             $this->_array = $result;
2062         } elseif (is_object($result)) {
2063             $this->_array = $result->asArray();
2064         } else {
2065             $this->_array = array();
2066         }
2067         if (!empty($this->_array))
2068             reset($this->_array);
2069     }
2070     function next() {
2071         $c =& current($this->_array);
2072         next($this->_array);
2073         return $c !== false ? $c : false;
2074     }
2075     function count() {
2076         return count($this->_array);
2077     }
2078     function free() {}
2079     function asArray() {
2080         if (!empty($this->_array))
2081             reset($this->_array);
2082         return $this->_array;
2083     }
2084 }
2085
2086 /**
2087  * Data cache used by WikiDB.
2088  *
2089  * FIXME: Maybe rename this to caching_backend (or some such).
2090  *
2091  * @access private
2092  */
2093 class WikiDB_cache
2094 {
2095     // FIXME: beautify versiondata cache.  Cache only limited data?
2096
2097     function WikiDB_cache (&$backend) {
2098         $this->_backend = &$backend;
2099
2100         $this->_pagedata_cache = array();
2101         $this->_versiondata_cache = array();
2102         array_push ($this->_versiondata_cache, array());
2103         $this->_glv_cache = array();
2104         $this->_id_cache = array(); // formerly ->_dbi->_iwpcache (nonempty pages => id)
2105     }
2106
2107     function close() {
2108         $this->_pagedata_cache = array();
2109         $this->_versiondata_cache = array();
2110         $this->_glv_cache = array();
2111         $this->_id_cache = array();
2112     }
2113
2114     function get_pagedata($pagename) {
2115         assert(is_string($pagename) && $pagename != '');
2116         if (USECACHE) {
2117             $cache = &$this->_pagedata_cache;
2118             if (!isset($cache[$pagename]) || !is_array($cache[$pagename])) {
2119                 $cache[$pagename] = $this->_backend->get_pagedata($pagename);
2120                 if (empty($cache[$pagename]))
2121                     $cache[$pagename] = array();
2122             }
2123             return $cache[$pagename];
2124         } else {
2125             return $this->_backend->get_pagedata($pagename);
2126         }
2127     }
2128
2129     function update_pagedata($pagename, $newdata) {
2130         assert(is_string($pagename) && $pagename != '');
2131
2132         $this->_backend->update_pagedata($pagename, $newdata);
2133
2134         if (USECACHE) {
2135             if (!empty($this->_pagedata_cache[$pagename])
2136                 and is_array($this->_pagedata_cache[$pagename]))
2137             {
2138                 $cachedata = &$this->_pagedata_cache[$pagename];
2139                 foreach($newdata as $key => $val)
2140                     $cachedata[$key] = $val;
2141             } else
2142                 $this->_pagedata_cache[$pagename] = $newdata;
2143         }
2144     }
2145
2146     function invalidate_cache($pagename) {
2147         unset ($this->_pagedata_cache[$pagename]);
2148         unset ($this->_versiondata_cache[$pagename]);
2149         unset ($this->_glv_cache[$pagename]);
2150         unset ($this->_id_cache[$pagename]);
2151         //unset ($this->_backend->_page_data);
2152     }
2153
2154     function delete_page($pagename) {
2155         $result = $this->_backend->delete_page($pagename);
2156         $this->invalidate_cache($pagename);
2157         return $result;
2158     }
2159
2160     function purge_page($pagename) {
2161         $result = $this->_backend->purge_page($pagename);
2162         $this->invalidate_cache($pagename);
2163         return $result;
2164     }
2165
2166     // FIXME: ugly and wrong. may overwrite full cache with partial cache
2167     function cache_data($data) {
2168         ;
2169         //if (isset($data['pagedata']))
2170         //    $this->_pagedata_cache[$data['pagename']] = $data['pagedata'];
2171     }
2172
2173     function get_versiondata($pagename, $version, $need_content = false) {
2174         //  FIXME: Seriously ugly hackage
2175         $readdata = false;
2176         if (USECACHE) {   //temporary - for debugging
2177             assert(is_string($pagename) && $pagename != '');
2178             // There is a bug here somewhere which results in an assertion failure at line 105
2179             // of ArchiveCleaner.php  It goes away if we use the next line.
2180             //$need_content = true;
2181             $nc = $need_content ? '1':'0';
2182             $cache = &$this->_versiondata_cache;
2183             if (!isset($cache[$pagename][$version][$nc])
2184                 || !(is_array ($cache[$pagename]))
2185                 || !(is_array ($cache[$pagename][$version])))
2186             {
2187                 $cache[$pagename][$version][$nc] =
2188                     $this->_backend->get_versiondata($pagename, $version, $need_content);
2189                 $readdata = true;
2190                 // If we have retrieved all data, we may as well set the cache for
2191                 // $need_content = false
2192                 if ($need_content){
2193                     $cache[$pagename][$version]['0'] =& $cache[$pagename][$version]['1'];
2194                 }
2195             }
2196             $vdata = $cache[$pagename][$version][$nc];
2197         } else {
2198             $vdata = $this->_backend->get_versiondata($pagename, $version, $need_content);
2199             $readdata = true;
2200         }
2201         if ($readdata && $vdata && !empty($vdata['%pagedata'])) {
2202             $this->_pagedata_cache[$pagename] =& $vdata['%pagedata'];
2203         }
2204         return $vdata;
2205     }
2206
2207     function set_versiondata($pagename, $version, $data) {
2208         //unset($this->_versiondata_cache[$pagename][$version]);
2209
2210         $new = $this->_backend->set_versiondata($pagename, $version, $data);
2211         // Update the cache
2212         $this->_versiondata_cache[$pagename][$version]['1'] = $data;
2213         $this->_versiondata_cache[$pagename][$version]['0'] = $data;
2214         // Is this necessary?
2215         unset($this->_glv_cache[$pagename]);
2216     }
2217
2218     function update_versiondata($pagename, $version, $data) {
2219         $new = $this->_backend->update_versiondata($pagename, $version, $data);
2220         // Update the cache
2221         $this->_versiondata_cache[$pagename][$version]['1'] = $data;
2222         // FIXME: hack
2223         $this->_versiondata_cache[$pagename][$version]['0'] = $data;
2224         // Is this necessary?
2225         unset($this->_glv_cache[$pagename]);
2226     }
2227
2228     function delete_versiondata($pagename, $version) {
2229         $new = $this->_backend->delete_versiondata($pagename, $version);
2230         if (isset($this->_versiondata_cache[$pagename][$version]))
2231             unset ($this->_versiondata_cache[$pagename][$version]);
2232         // dirty latest version cache only if latest version gets deleted
2233         if (isset($this->_glv_cache[$pagename]) and $this->_glv_cache[$pagename] == $version)
2234             unset ($this->_glv_cache[$pagename]);
2235     }
2236
2237     function get_latest_version($pagename)  {
2238         if (USECACHE) {
2239             assert (is_string($pagename) && $pagename != '');
2240             $cache = &$this->_glv_cache;
2241             if (!isset($cache[$pagename])) {
2242                 $cache[$pagename] = $this->_backend->get_latest_version($pagename);
2243                 if (empty($cache[$pagename]))
2244                     $cache[$pagename] = 0;
2245             }
2246             return $cache[$pagename];
2247         } else {
2248             return $this->_backend->get_latest_version($pagename);
2249         }
2250     }
2251 };
2252
2253 function _sql_debuglog($msg, $newline=true, $shutdown=false) {
2254     static $fp = false;
2255     static $i = 0;
2256     if (!$fp) {
2257         $stamp = strftime("%y%m%d-%H%M%S");
2258         $fp = fopen("/tmp/sql-$stamp.log", "a");
2259         register_shutdown_function("_sql_debuglog_shutdown_function");
2260     } elseif ($shutdown) {
2261         fclose($fp);
2262         return;
2263     }
2264     if ($newline) fputs($fp, "[$i++] $msg");
2265     else fwrite($fp, $msg);
2266 }
2267
2268 function _sql_debuglog_shutdown_function() {
2269     _sql_debuglog('',false,true);
2270 }
2271
2272 // $Log: not supported by cvs2svn $
2273 // Revision 1.141  2006/04/17 17:28:21  rurban
2274 // honor getWikiPageLinks change linkto=>relation
2275 //
2276 // Revision 1.140  2006/03/19 14:23:51  rurban
2277 // sf.net patch #1377011 by Matt Brown: add DATABASE_OPTIMISE_FREQUENCY
2278 //
2279 // Revision 1.139  2006/01/12 16:38:07  rurban
2280 // add page method listRelations()
2281 // fix bug #1327912 numeric pagenames can break plugins (Joachim Lous)
2282 //
2283 // Revision 1.138  2005/11/14 22:27:07  rurban
2284 // add linkrelation support
2285 //   getPageLinks returns now an array of hashes
2286 // pass stoplist through iterator
2287 //
2288 // Revision 1.137  2005/10/12 06:16:18  rurban
2289 // better From header
2290 //
2291 // Revision 1.136  2005/10/03 16:14:57  rurban
2292 // improve description
2293 //
2294 // Revision 1.135  2005/09/11 14:19:44  rurban
2295 // enable LIMIT support for fulltext search
2296 //
2297 // Revision 1.134  2005/09/10 21:28:10  rurban
2298 // applyFilters hack to use filters after methods, which do not support them (titleSearch)
2299 //
2300 // Revision 1.133  2005/08/27 09:39:10  rurban
2301 // dumphtml when not at admin page: dump the current or given page
2302 //
2303 // Revision 1.132  2005/08/07 10:10:07  rurban
2304 // clean whole version cache
2305 //
2306 // Revision 1.131  2005/04/23 11:30:12  rurban
2307 // allow emtpy WikiDB::getRevisionBefore(), for simplier templates (revert)
2308 //
2309 // Revision 1.130  2005/04/06 06:19:30  rurban
2310 // Revert the previous wrong bugfix #1175761: USECACHE was mixed with WIKIDB_NOCACHE_MARKUP.
2311 // Fix WIKIDB_NOCACHE_MARKUP in main (always set it) and clarify it in WikiDB
2312 //
2313 // Revision 1.129  2005/04/06 05:50:29  rurban
2314 // honor !USECACHE for _cached_html, fixes #1175761
2315 //
2316 // Revision 1.128  2005/04/01 16:11:42  rurban
2317 // just whitespace
2318 //
2319 // Revision 1.127  2005/02/18 20:43:40  uckelman
2320 // WikiDB::genericWarnings() is no longer used.
2321 //
2322 // Revision 1.126  2005/02/04 17:58:06  rurban
2323 // minor versioncache improvement. part 2/3 of Charles Corrigan cache patch. not sure about the 0/1 issue
2324 //
2325 // Revision 1.125  2005/02/03 05:08:39  rurban
2326 // ref fix by Charles Corrigan
2327 //
2328 // Revision 1.124  2005/01/29 20:43:32  rurban
2329 // protect against empty request: on some occasion this happens
2330 //
2331 // Revision 1.123  2005/01/25 06:58:21  rurban
2332 // reformatting
2333 //
2334 // Revision 1.122  2005/01/20 10:18:17  rurban
2335 // reformatting
2336 //
2337 // Revision 1.121  2005/01/04 20:25:01  rurban
2338 // remove old [%pagedata][_cached_html] code
2339 //
2340 // Revision 1.120  2004/12/23 14:12:31  rurban
2341 // dont email on unittest
2342 //
2343 // Revision 1.119  2004/12/20 16:05:00  rurban
2344 // gettext msg unification
2345 //
2346 // Revision 1.118  2004/12/13 13:22:57  rurban
2347 // new BlogArchives plugin for the new blog theme. enable default box method
2348 // for all plugins. Minor search improvement.
2349 //
2350 // Revision 1.117  2004/12/13 08:15:09  rurban
2351 // false is wrong. null might be better but lets play safe.
2352 //
2353 // Revision 1.116  2004/12/10 22:15:00  rurban
2354 // fix $page->get('_cached_html)
2355 // refactor upgrade db helper _convert_cached_html() to be able to call them from WikiAdminUtils also.
2356 // support 2nd genericSqlQuery param (bind huge arg)
2357 //
2358 // Revision 1.115  2004/12/10 02:45:27  rurban
2359 // SQL optimization:
2360 //   put _cached_html from pagedata into a new seperate blob, not huge serialized string.
2361 //   it is only rarelely needed: for current page only, if-not-modified
2362 //   but was extracted for every simple page iteration.
2363 //
2364 // Revision 1.114  2004/12/09 22:24:44  rurban
2365 // optimize on _DEBUG_SQL only. but now again on every 50th request, not just save.
2366 //
2367 // Revision 1.113  2004/12/06 19:49:55  rurban
2368 // enable action=remove which is undoable and seeable in RecentChanges: ADODB ony for now.
2369 // renamed delete_page to purge_page.
2370 // enable action=edit&version=-1 to force creation of a new version.
2371 // added BABYCART_PATH config
2372 // fixed magiqc in adodb.inc.php
2373 // and some more docs
2374 //
2375 // Revision 1.112  2004/11/30 17:45:53  rurban
2376 // exists_links backend implementation
2377 //
2378 // Revision 1.111  2004/11/28 20:39:43  rurban
2379 // deactivate pagecache overwrite: it is wrong
2380 //
2381 // Revision 1.110  2004/11/26 18:39:01  rurban
2382 // new regex search parser and SQL backends (90% complete, glob and pcre backends missing)
2383 //
2384 // Revision 1.109  2004/11/25 17:20:50  rurban
2385 // and again a couple of more native db args: backlinks
2386 //
2387 // Revision 1.108  2004/11/23 13:35:31  rurban
2388 // add case_exact search
2389 //
2390 // Revision 1.107  2004/11/21 11:59:16  rurban
2391 // remove final \n to be ob_cache independent
2392 //
2393 // Revision 1.106  2004/11/20 17:35:56  rurban
2394 // improved WantedPages SQL backends
2395 // PageList::sortby new 3rd arg valid_fields (override db fields)
2396 // WantedPages sql pager inexact for performance reasons:
2397 //   assume 3 wantedfrom per page, to be correct, no getTotal()
2398 // support exclude argument for get_all_pages, new _sql_set()
2399 //
2400 // Revision 1.105  2004/11/20 09:16:27  rurban
2401 // Fix bad-style Cut&Paste programming errors, detected by Charles Corrigan.
2402 //
2403 // Revision 1.104  2004/11/19 19:22:03  rurban
2404 // ModeratePage part1: change status
2405 //
2406 // Revision 1.103  2004/11/16 17:29:04  rurban
2407 // fix remove notification error
2408 // fix creation + update id_cache update
2409 //
2410 // Revision 1.102  2004/11/11 18:31:26  rurban
2411 // add simple backtrace on such general failures to get at least an idea where
2412 //
2413 // Revision 1.101  2004/11/10 19:32:22  rurban
2414 // * optimize increaseHitCount, esp. for mysql.
2415 // * prepend dirs to the include_path (phpwiki_dir for faster searches)
2416 // * Pear_DB version logic (awful but needed)
2417 // * fix broken ADODB quote
2418 // * _extract_page_data simplification
2419 //
2420 // Revision 1.100  2004/11/10 15:29:20  rurban
2421 // * requires newer Pear_DB (as the internal one): quote() uses now escapeSimple for strings
2422 // * ACCESS_LOG_SQL: fix cause request not yet initialized
2423 // * WikiDB: moved SQL specific methods upwards
2424 // * new Pear_DB quoting: same as ADODB and as newer Pear_DB.
2425 //   fixes all around: WikiGroup, WikiUserNew SQL methods, SQL logging
2426 //
2427 // Revision 1.99  2004/11/09 17:11:05  rurban
2428 // * revert to the wikidb ref passing. there's no memory abuse there.
2429 // * use new wikidb->_cache->_id_cache[] instead of wikidb->_iwpcache, to effectively
2430 //   store page ids with getPageLinks (GleanDescription) of all existing pages, which
2431 //   are also needed at the rendering for linkExistingWikiWord().
2432 //   pass options to pageiterator.
2433 //   use this cache also for _get_pageid()
2434 //   This saves about 8 SELECT count per page (num all pagelinks).
2435 // * fix passing of all page fields to the pageiterator.
2436 // * fix overlarge session data which got broken with the latest ACCESS_LOG_SQL changes
2437 //
2438 // Revision 1.98  2004/11/07 18:34:29  rurban
2439 // more logging fixes
2440 //
2441 // Revision 1.97  2004/11/07 16:02:51  rurban
2442 // new sql access log (for spam prevention), and restructured access log class
2443 // dbh->quote (generic)
2444 // pear_db: mysql specific parts seperated (using replace)
2445 //
2446 // Revision 1.96  2004/11/05 22:32:15  rurban
2447 // encode the subject to be 7-bit safe
2448 //
2449 // Revision 1.95  2004/11/05 20:53:35  rurban
2450 // login cleanup: better debug msg on failing login,
2451 // checked password less immediate login (bogo or anon),
2452 // checked olduser pref session error,
2453 // better PersonalPage without password warning on minimal password length=0
2454 //   (which is default now)
2455 //
2456 // Revision 1.94  2004/11/01 10:43:56  rurban
2457 // seperate PassUser methods into seperate dir (memory usage)
2458 // fix WikiUser (old) overlarge data session
2459 // remove wikidb arg from various page class methods, use global ->_dbi instead
2460 // ...
2461 //
2462 // Revision 1.93  2004/10/14 17:17:57  rurban
2463 // remove dbi WikiDB_Page param: use global request object instead. (memory)
2464 // allow most_popular sortby arguments
2465 //
2466 // Revision 1.92  2004/10/05 17:00:04  rurban
2467 // support paging for simple lists
2468 // fix RatingDb sql backend.
2469 // remove pages from AllPages (this is ListPages then)
2470 //
2471 // Revision 1.91  2004/10/04 23:41:19  rurban
2472 // delete notify: fix, @unset syntax error
2473 //
2474 // Revision 1.90  2004/09/28 12:50:22  rurban
2475 // https://sourceforge.net/forum/forum.php?thread_id=1150924&forum_id=18929
2476 //
2477 // Revision 1.89  2004/09/26 10:54:42  rurban
2478 // silence deferred check
2479 //
2480 // Revision 1.88  2004/09/25 18:16:40  rurban
2481 // unset more unneeded _cached_html. (Guess this should fix sf.net now)
2482 //
2483 // Revision 1.87  2004/09/25 16:25:40  rurban
2484 // notify on rename and remove (to be improved)
2485 //
2486 // Revision 1.86  2004/09/23 18:52:06  rurban
2487 // only fortune at create
2488 //
2489 // Revision 1.85  2004/09/16 08:00:51  rurban
2490 // just some comments
2491 //
2492 // Revision 1.84  2004/09/14 10:34:30  rurban
2493 // fix TransformedText call to use refs
2494 //
2495 // Revision 1.83  2004/09/08 13:38:00  rurban
2496 // improve loadfile stability by using markup=2 as default for undefined markup-style.
2497 // use more refs for huge objects.
2498 // fix debug=static issue in WikiPluginCached
2499 //
2500 // Revision 1.82  2004/09/06 12:08:49  rurban
2501 // memory_limit on unix workaround
2502 // VisualWiki: default autosize image
2503 //
2504 // Revision 1.81  2004/09/06 08:28:00  rurban
2505 // rename genericQuery to genericSqlQuery
2506 //
2507 // Revision 1.80  2004/07/09 13:05:34  rurban
2508 // just aesthetics
2509 //
2510 // Revision 1.79  2004/07/09 10:06:49  rurban
2511 // Use backend specific sortby and sortable_columns method, to be able to
2512 // select between native (Db backend) and custom (PageList) sorting.
2513 // Fixed PageList::AddPageList (missed the first)
2514 // Added the author/creator.. name to AllPagesBy...
2515 //   display no pages if none matched.
2516 // Improved dba and file sortby().
2517 // Use &$request reference
2518 //
2519 // Revision 1.78  2004/07/08 21:32:35  rurban
2520 // Prevent from more warnings, minor db and sort optimizations
2521 //
2522 // Revision 1.77  2004/07/08 19:04:42  rurban
2523 // more unittest fixes (file backend, metadata RatingsDb)
2524 //
2525 // Revision 1.76  2004/07/08 17:31:43  rurban
2526 // improve numPages for file (fixing AllPagesTest)
2527 //
2528 // Revision 1.75  2004/07/05 13:56:22  rurban
2529 // sqlite autoincrement fix
2530 //
2531 // Revision 1.74  2004/07/03 16:51:05  rurban
2532 // optional DBADMIN_USER:DBADMIN_PASSWD for action=upgrade (if no ALTER permission)
2533 // added atomic mysql REPLACE for PearDB as in ADODB
2534 // fixed _lock_tables typo links => link
2535 // fixes unserialize ADODB bug in line 180
2536 //
2537 // Revision 1.73  2004/06/29 08:52:22  rurban
2538 // Use ...version() $need_content argument in WikiDB also:
2539 // To reduce the memory footprint for larger sets of pagelists,
2540 // we don't cache the content (only true or false) and
2541 // we purge the pagedata (_cached_html) also.
2542 // _cached_html is only cached for the current pagename.
2543 // => Vastly improved page existance check, ACL check, ...
2544 //
2545 // Now only PagedList info=content or size needs the whole content, esp. if sortable.
2546 //
2547 // Revision 1.72  2004/06/25 14:15:08  rurban
2548 // reduce memory footprint by caching only requested pagedate content (improving most page iterators)
2549 //
2550 // Revision 1.71  2004/06/21 16:22:30  rurban
2551 // add DEFAULT_DUMP_DIR and HTML_DUMP_DIR constants, for easier cmdline dumps,
2552 // fixed dumping buttons locally (images/buttons/),
2553 // support pages arg for dumphtml,
2554 // optional directory arg for dumpserial + dumphtml,
2555 // fix a AllPages warning,
2556 // show dump warnings/errors on DEBUG,
2557 // don't warn just ignore on wikilens pagelist columns, if not loaded.
2558 // RateIt pagelist column is called "rating", not "ratingwidget" (Dan?)
2559 //
2560 // Revision 1.70  2004/06/18 14:39:31  rurban
2561 // actually check USECACHE
2562 //
2563 // Revision 1.69  2004/06/13 15:33:20  rurban
2564 // new support for arguments owner, author, creator in most relevant
2565 // PageList plugins. in WikiAdmin* via preSelectS()
2566 //
2567 // Revision 1.68  2004/06/08 21:03:20  rurban
2568 // updated RssParser for XmlParser quirks (store parser object params in globals)
2569 //
2570 // Revision 1.67  2004/06/07 19:12:49  rurban
2571 // fixed rename version=0, bug #966284
2572 //
2573 // Revision 1.66  2004/06/07 18:57:27  rurban
2574 // fix rename: Change pagename in all linked pages
2575 //
2576 // Revision 1.65  2004/06/04 20:32:53  rurban
2577 // Several locale related improvements suggested by Pierrick Meignen
2578 // LDAP fix by John Cole
2579 // reanable admin check without ENABLE_PAGEPERM in the admin plugins
2580 //
2581 // Revision 1.64  2004/06/04 16:50:00  rurban
2582 // add random quotes to empty pages
2583 //
2584 // Revision 1.63  2004/06/04 11:58:38  rurban
2585 // added USE_TAGLINES
2586 //
2587 // Revision 1.62  2004/06/03 22:24:41  rurban
2588 // reenable admin check on !ENABLE_PAGEPERM, honor s=Wildcard arg, fix warning after Remove
2589 //
2590 // Revision 1.61  2004/06/02 17:13:48  rurban
2591 // fix getRevisionBefore assertion
2592 //
2593 // Revision 1.60  2004/05/28 10:09:58  rurban
2594 // fix bug #962117, incorrect init of auth_dsn
2595 //
2596 // Revision 1.59  2004/05/27 17:49:05  rurban
2597 // renamed DB_Session to DbSession (in CVS also)
2598 // added WikiDB->getParam and WikiDB->getAuthParam method to get rid of globals
2599 // remove leading slash in error message
2600 // added force_unlock parameter to File_Passwd (no return on stale locks)
2601 // fixed adodb session AffectedRows
2602 // added FileFinder helpers to unify local filenames and DATA_PATH names
2603 // editpage.php: new edit toolbar javascript on ENABLE_EDIT_TOOLBAR
2604 //
2605 // Revision 1.58  2004/05/18 13:59:14  rurban
2606 // rename simpleQuery to genericQuery
2607 //
2608 // Revision 1.57  2004/05/16 22:07:35  rurban
2609 // check more config-default and predefined constants
2610 // various PagePerm fixes:
2611 //   fix default PagePerms, esp. edit and view for Bogo and Password users
2612 //   implemented Creator and Owner
2613 //   BOGOUSERS renamed to BOGOUSER
2614 // fixed syntax errors in signin.tmpl
2615 //
2616 // Revision 1.56  2004/05/15 22:54:49  rurban
2617 // fixed important WikiDB bug with DEBUG > 0: wrong assertion
2618 // improved SetAcl (works) and PagePerms, some WikiGroup helpers.
2619 //
2620 // Revision 1.55  2004/05/12 19:27:47  rurban
2621 // revert wrong inline optimization.
2622 //
2623 // Revision 1.54  2004/05/12 10:49:55  rurban
2624 // require_once fix for those libs which are loaded before FileFinder and
2625 //   its automatic include_path fix, and where require_once doesn't grok
2626 //   dirname(__FILE__) != './lib'
2627 // upgrade fix with PearDB
2628 // navbar.tmpl: remove spaces for IE &nbsp; button alignment
2629 //
2630 // Revision 1.53  2004/05/08 14:06:12  rurban
2631 // new support for inlined image attributes: [image.jpg size=50x30 align=right]
2632 // minor stability and portability fixes
2633 //
2634 // Revision 1.52  2004/05/06 19:26:16  rurban
2635 // improve stability, trying to find the InlineParser endless loop on sf.net
2636 //
2637 // remove end-of-zip comments to fix sf.net bug #777278 and probably #859628
2638 //
2639 // Revision 1.51  2004/05/06 17:30:37  rurban
2640 // CategoryGroup: oops, dos2unix eol
2641 // improved phpwiki_version:
2642 //   pre -= .0001 (1.3.10pre: 1030.099)
2643 //   -p1 += .001 (1.3.9-p1: 1030.091)
2644 // improved InstallTable for mysql and generic SQL versions and all newer tables so far.
2645 // abstracted more ADODB/PearDB methods for action=upgrade stuff:
2646 //   backend->backendType(), backend->database(),
2647 //   backend->listOfFields(),
2648 //   backend->listOfTables(),
2649 //
2650 // Revision 1.50  2004/05/04 22:34:25  rurban
2651 // more pdf support
2652 //
2653 // Revision 1.49  2004/05/03 11:16:40  rurban
2654 // fixed sendPageChangeNotification
2655 // subject rewording
2656 //
2657 // Revision 1.48  2004/04/29 23:03:54  rurban
2658 // fixed sf.net bug #940996
2659 //
2660 // Revision 1.47  2004/04/29 19:39:44  rurban
2661 // special support for formatted plugins (one-liners)
2662 //   like <small><plugin BlaBla ></small>
2663 // iter->asArray() helper for PopularNearby
2664 // db_session for older php's (no &func() allowed)
2665 //
2666 // Revision 1.46  2004/04/26 20:44:34  rurban
2667 // locking table specific for better databases
2668 //
2669 // Revision 1.45  2004/04/20 00:06:03  rurban
2670 // themable paging support
2671 //
2672 // Revision 1.44  2004/04/19 18:27:45  rurban
2673 // Prevent from some PHP5 warnings (ref args, no :: object init)
2674 //   php5 runs now through, just one wrong XmlElement object init missing
2675 // Removed unneccesary UpgradeUser lines
2676 // Changed WikiLink to omit version if current (RecentChanges)
2677 //
2678 // Revision 1.43  2004/04/18 01:34:20  rurban
2679 // protect most_popular from sortby=mtime
2680 //
2681 // Revision 1.42  2004/04/18 01:11:51  rurban
2682 // more numeric pagename fixes.
2683 // fixed action=upload with merge conflict warnings.
2684 // charset changed from constant to global (dynamic utf-8 switching)
2685 //
2686
2687 // Local Variables:
2688 // mode: php
2689 // tab-width: 8
2690 // c-basic-offset: 4
2691 // c-hanging-comment-ender-p: nil
2692 // indent-tabs-mode: nil
2693 // End:
2694 ?>