1<?php 2 3/** 4 * Utilities for accessing the parser 5 * 6 * @license GPL 2 (http://www.gnu.org/licenses/gpl.html) 7 * @author Harry Fuecks <hfuecks@gmail.com> 8 * @author Andreas Gohr <andi@splitbrain.org> 9 */ 10 11use dokuwiki\Extension\PluginInterface; 12use dokuwiki\Cache\CacheInstructions; 13use dokuwiki\Cache\CacheRenderer; 14use dokuwiki\ChangeLog\PageChangeLog; 15use dokuwiki\Extension\PluginController; 16use dokuwiki\Extension\Event; 17use dokuwiki\Extension\SyntaxPlugin; 18use dokuwiki\Parsing\Parser; 19use dokuwiki\Parsing\ParserMode\Acronym; 20use dokuwiki\Parsing\ParserMode\Camelcaselink; 21use dokuwiki\Parsing\ParserMode\Entity; 22use dokuwiki\Parsing\ParserMode\Formatting; 23use dokuwiki\Parsing\ParserMode\Smiley; 24 25/** 26 * How many pages shall be rendered for getting metadata during one request 27 * at maximum? Note that this limit isn't respected when METADATA_RENDER_UNLIMITED 28 * is passed as render parameter to p_get_metadata. 29 */ 30if (!defined('P_GET_METADATA_RENDER_LIMIT')) define('P_GET_METADATA_RENDER_LIMIT', 5); 31 32/** Don't render metadata even if it is outdated or doesn't exist */ 33define('METADATA_DONT_RENDER', 0); 34/** 35 * Render metadata when the page is really newer or the metadata doesn't exist. 36 * Uses just a simple check, but should work pretty well for loading simple 37 * metadata values like the page title and avoids rendering a lot of pages in 38 * one request. The P_GET_METADATA_RENDER_LIMIT is used in this mode. 39 * Use this if it is unlikely that the metadata value you are requesting 40 * does depend e.g. on pages that are included in the current page using 41 * the include plugin (this is very likely the case for the page title, but 42 * not for relation references). 43 */ 44define('METADATA_RENDER_USING_SIMPLE_CACHE', 1); 45/** 46 * Render metadata using the metadata cache logic. The P_GET_METADATA_RENDER_LIMIT 47 * is used in this mode. Use this mode when you are requesting more complex 48 * metadata. Although this will cause rendering more often it might actually have 49 * the effect that less current metadata is returned as it is more likely than in 50 * the simple cache mode that metadata needs to be rendered for all pages at once 51 * which means that when the metadata for the page is requested that actually needs 52 * to be updated the limit might have been reached already. 53 */ 54define('METADATA_RENDER_USING_CACHE', 2); 55/** 56 * Render metadata without limiting the number of pages for which metadata is 57 * rendered. Use this mode with care, normally it should only be used in places 58 * like the indexer or in cli scripts where the execution time normally isn't 59 * limited. This can be combined with the simple cache using 60 * METADATA_RENDER_USING_CACHE | METADATA_RENDER_UNLIMITED. 61 */ 62define('METADATA_RENDER_UNLIMITED', 4); 63 64/** 65 * Returns the parsed Wikitext in XHTML for the given id and revision. 66 * 67 * If $excuse is true an explanation is returned if the file 68 * wasn't found 69 * 70 * @param string $id page id 71 * @param string|int $rev revision timestamp or empty string 72 * @param bool $excuse 73 * @param string $date_at 74 * 75 * @return null|string 76 * @author Andreas Gohr <andi@splitbrain.org> 77 * 78 */ 79function p_wiki_xhtml($id, $rev = '', $excuse = true, $date_at = '') 80{ 81 $file = wikiFN($id, $rev); 82 $ret = ''; 83 84 //ensure $id is in global $ID (needed for parsing) 85 global $ID; 86 $keep = $ID; 87 $ID = $id; 88 89 if ($rev || $date_at) { 90 if (file_exists($file)) { 91 //no caching on old revisions 92 $ret = p_render('xhtml', p_get_instructions(io_readWikiPage($file, $id, $rev)), $info, $date_at); 93 } elseif ($excuse) { 94 $ret = p_locale_xhtml('norev'); 95 } 96 } elseif (file_exists($file)) { 97 $ret = p_cached_output($file, 'xhtml', $id); 98 } elseif ($excuse) { 99 //check if the page once existed 100 $changelog = new PageChangeLog($id); 101 if ($changelog->hasRevisions()) { 102 $ret = p_locale_xhtml('onceexisted'); 103 } else { 104 $ret = p_locale_xhtml('newpage'); 105 } 106 } 107 108 //restore ID (just in case) 109 $ID = $keep; 110 111 return $ret; 112} 113 114/** 115 * Returns the specified local text in parsed format 116 * 117 * @param string $id page id 118 * @return null|string 119 * @author Andreas Gohr <andi@splitbrain.org> 120 * 121 */ 122function p_locale_xhtml($id) 123{ 124 //fetch parsed locale 125 $data = ['id' => $id, 'html' => '']; 126 127 $event = new Event('PARSER_LOCALE_XHTML', $data); 128 if ($event->advise_before()) { 129 $data['html'] = p_cached_output(localeFN($data['id'])); 130 } 131 $event->advise_after(); 132 133 return $data['html']; 134} 135 136/** 137 * Returns the given file parsed into the requested output format 138 * 139 * @param string $file filename, path to file 140 * @param string $format 141 * @param string $id page id 142 * @return null|string 143 * @author Andreas Gohr <andi@splitbrain.org> 144 * @author Chris Smith <chris@jalakai.co.uk> 145 * 146 */ 147function p_cached_output($file, $format = 'xhtml', $id = '') 148{ 149 global $conf; 150 151 $cache = new CacheRenderer($id, $file, $format); 152 if ($cache->useCache()) { 153 $parsed = $cache->retrieveCache(false); 154 if ($conf['allowdebug'] && $format == 'xhtml') { 155 $parsed .= "\n<!-- cachefile {$cache->cache} used -->\n"; 156 } 157 } else { 158 $parsed = p_render($format, p_cached_instructions($file, false, $id), $info); 159 160 if (!empty($info['cache']) && $cache->storeCache($parsed)) { // storeCache() attempts to save cachefile 161 if ($conf['allowdebug'] && $format == 'xhtml') { 162 $parsed .= "\n<!-- no cachefile used, but created {$cache->cache} -->\n"; 163 } 164 } else { 165 $cache->removeCache(); //try to delete cachefile 166 if ($conf['allowdebug'] && $format == 'xhtml') { 167 $parsed .= "\n<!-- no cachefile used, caching forbidden -->\n"; 168 } 169 } 170 } 171 172 return $parsed; 173} 174 175/** 176 * Returns the render instructions for a file 177 * 178 * Uses and creates a serialized cache file 179 * 180 * @param string $file filename, path to file 181 * @param bool $cacheonly 182 * @param string $id page id 183 * @return array|null 184 * @author Andreas Gohr <andi@splitbrain.org> 185 * 186 */ 187function p_cached_instructions($file, $cacheonly = false, $id = '') 188{ 189 static $run = null; 190 if (is_null($run)) $run = []; 191 192 $cache = new CacheInstructions($id, $file); 193 194 if ($cacheonly || $cache->useCache() || (isset($run[$file]) && !defined('DOKU_UNITTEST'))) { 195 return $cache->retrieveCache(); 196 } elseif (file_exists($file)) { 197 // no cache - do some work 198 $ins = p_get_instructions(io_readWikiPage($file, $id)); 199 if ($cache->storeCache($ins)) { 200 $run[$file] = true; // we won't rebuild these instructions in the same run again 201 } else { 202 msg('Unable to save cache file. Hint: disk full; file permissions; safe_mode setting.', -1); 203 } 204 return $ins; 205 } 206 207 return null; 208} 209 210/** 211 * turns a page into a list of instructions 212 * 213 * @param string $text raw wiki syntax text 214 * @return array a list of instruction arrays 215 * @author Harry Fuecks <hfuecks@gmail.com> 216 * @author Andreas Gohr <andi@splitbrain.org> 217 * 218 */ 219function p_get_instructions($text) 220{ 221 222 $modes = p_get_parsermodes(); 223 224 // Create the parser and handler 225 $Parser = new Parser(new Doku_Handler()); 226 227 //add modes to parser 228 foreach ($modes as $mode) { 229 $Parser->addMode($mode['mode'], $mode['obj']); 230 } 231 232 // Do the parsing 233 Event::createAndTrigger('PARSER_WIKITEXT_PREPROCESS', $text); 234 return $Parser->parse($text); 235} 236 237/** 238 * returns the metadata of a page 239 * 240 * @param string $id The id of the page the metadata should be returned from 241 * @param string $key The key of the metdata value that shall be read (by default everything) 242 * separate hierarchies by " " like "date created" 243 * @param int $render If the page should be rendererd - possible values: 244 * METADATA_DONT_RENDER, METADATA_RENDER_USING_SIMPLE_CACHE, METADATA_RENDER_USING_CACHE 245 * METADATA_RENDER_UNLIMITED (also combined with the previous two options), 246 * default: METADATA_RENDER_USING_CACHE 247 * @return mixed The requested metadata fields 248 * 249 * @author Esther Brunner <esther@kaffeehaus.ch> 250 * @author Michael Hamann <michael@content-space.de> 251 */ 252function p_get_metadata($id, $key = '', $render = METADATA_RENDER_USING_CACHE) 253{ 254 global $ID; 255 static $render_count = 0; 256 // track pages that have already been rendered in order to avoid rendering the same page 257 // again 258 static $rendered_pages = []; 259 260 // cache the current page 261 // Benchmarking shows the current page's metadata is generally the only page metadata 262 // accessed several times. This may catch a few other pages, but that shouldn't be an issue. 263 $cache = ($ID == $id); 264 $meta = p_read_metadata($id, $cache); 265 266 if (!is_numeric($render)) { 267 if ($render) { 268 $render = METADATA_RENDER_USING_SIMPLE_CACHE; 269 } else { 270 $render = METADATA_DONT_RENDER; 271 } 272 } 273 274 // prevent recursive calls in the cache 275 static $recursion = false; 276 if (!$recursion && $render != METADATA_DONT_RENDER && !isset($rendered_pages[$id]) && page_exists($id)) { 277 $recursion = true; 278 279 $cachefile = new CacheRenderer($id, wikiFN($id), 'metadata'); 280 281 $do_render = false; 282 if ($render & METADATA_RENDER_UNLIMITED || $render_count < P_GET_METADATA_RENDER_LIMIT) { 283 if ($render & METADATA_RENDER_USING_SIMPLE_CACHE) { 284 $pagefn = wikiFN($id); 285 $metafn = metaFN($id, '.meta'); 286 if (!file_exists($metafn) || @filemtime($pagefn) > @filemtime($cachefile->cache)) { 287 $do_render = true; 288 } 289 } elseif (!$cachefile->useCache()) { 290 $do_render = true; 291 } 292 } 293 if ($do_render) { 294 if (!defined('DOKU_UNITTEST')) { 295 ++$render_count; 296 $rendered_pages[$id] = true; 297 } 298 $old_meta = $meta; 299 $meta = p_render_metadata($id, $meta); 300 // only update the file when the metadata has been changed 301 if ($meta == $old_meta || p_save_metadata($id, $meta)) { 302 // store a timestamp in order to make sure that the cachefile is touched 303 // this timestamp is also stored when the meta data is still the same 304 $cachefile->storeCache(time()); 305 } else { 306 msg('Unable to save metadata file. Hint: disk full; file permissions; safe_mode setting.', -1); 307 } 308 } 309 310 $recursion = false; 311 } 312 313 $val = $meta['current'] ?? null; 314 315 // filter by $key 316 foreach (preg_split('/\s+/', $key, 2, PREG_SPLIT_NO_EMPTY) as $cur_key) { 317 if (!isset($val[$cur_key])) { 318 return null; 319 } 320 $val = $val[$cur_key]; 321 } 322 return $val; 323} 324 325/** 326 * sets metadata elements of a page 327 * 328 * @see http://www.dokuwiki.org/devel:metadata#functions_to_get_and_set_metadata 329 * 330 * @param string $id is the ID of a wiki page 331 * @param array $data is an array with key ⇒ value pairs to be set in the metadata 332 * @param boolean $render whether or not the page metadata should be generated with the renderer 333 * @param boolean $persistent indicates whether or not the particular metadata value will persist through 334 * the next metadata rendering. 335 * @return boolean true on success 336 * 337 * @author Esther Brunner <esther@kaffeehaus.ch> 338 * @author Michael Hamann <michael@content-space.de> 339 */ 340function p_set_metadata($id, $data, $render = false, $persistent = true) 341{ 342 if (!is_array($data)) return false; 343 344 global $ID, $METADATA_RENDERERS; 345 346 // if there is currently a renderer change the data in the renderer instead 347 if (isset($METADATA_RENDERERS[$id])) { 348 $orig =& $METADATA_RENDERERS[$id]; 349 $meta = $orig; 350 } else { 351 // cache the current page 352 $cache = ($ID == $id); 353 $orig = p_read_metadata($id, $cache); 354 355 // render metadata first? 356 $meta = $render ? p_render_metadata($id, $orig) : $orig; 357 } 358 359 // now add the passed metadata 360 $protected = ['description', 'date', 'contributor']; 361 foreach ($data as $key => $value) { 362 // be careful with sub-arrays of $meta['relation'] 363 if ($key == 'relation') { 364 foreach ($value as $subkey => $subvalue) { 365 if (isset($meta['current'][$key][$subkey]) && is_array($meta['current'][$key][$subkey])) { 366 $meta['current'][$key][$subkey] = array_replace($meta['current'][$key][$subkey], (array)$subvalue); 367 } else { 368 $meta['current'][$key][$subkey] = $subvalue; 369 } 370 if ($persistent) { 371 if (isset($meta['persistent'][$key][$subkey]) && is_array($meta['persistent'][$key][$subkey])) { 372 $meta['persistent'][$key][$subkey] = array_replace( 373 $meta['persistent'][$key][$subkey], 374 (array)$subvalue 375 ); 376 } else { 377 $meta['persistent'][$key][$subkey] = $subvalue; 378 } 379 } 380 } 381 382 // be careful with some senisitive arrays of $meta 383 } elseif (in_array($key, $protected)) { 384 // these keys, must have subkeys - a legitimate value must be an array 385 if (is_array($value)) { 386 $meta['current'][$key] = empty($meta['current'][$key]) ? 387 $value : 388 array_replace((array)$meta['current'][$key], $value); 389 390 if ($persistent) { 391 $meta['persistent'][$key] = empty($meta['persistent'][$key]) ? 392 $value : 393 array_replace((array)$meta['persistent'][$key], $value); 394 } 395 } 396 397 // no special treatment for the rest 398 } else { 399 $meta['current'][$key] = $value; 400 if ($persistent) $meta['persistent'][$key] = $value; 401 } 402 } 403 404 // save only if metadata changed 405 if ($meta == $orig) return true; 406 407 if (isset($METADATA_RENDERERS[$id])) { 408 // set both keys individually as the renderer has references to the individual keys 409 $METADATA_RENDERERS[$id]['current'] = $meta['current']; 410 $METADATA_RENDERERS[$id]['persistent'] = $meta['persistent']; 411 return true; 412 } else { 413 return p_save_metadata($id, $meta); 414 } 415} 416 417/** 418 * Purges the non-persistant part of the meta data 419 * used on page deletion 420 * 421 * @param string $id page id 422 * @return bool success / fail 423 * @author Michael Klier <chi@chimeric.de> 424 * 425 */ 426function p_purge_metadata($id) 427{ 428 $meta = p_read_metadata($id); 429 foreach ($meta['current'] as $key => $value) { 430 if (isset($meta[$key]) && is_array($meta[$key])) { 431 $meta['current'][$key] = []; 432 } else { 433 $meta['current'][$key] = ''; 434 } 435 } 436 return p_save_metadata($id, $meta); 437} 438 439/** 440 * read the metadata from source/cache for $id 441 * (internal use only - called by p_get_metadata & p_set_metadata) 442 * 443 * @param string $id absolute wiki page id 444 * @param bool $cache whether or not to cache metadata in memory 445 * (only use for metadata likely to be accessed several times) 446 * 447 * @return array metadata 448 * @author Christopher Smith <chris@jalakai.co.uk> 449 * 450 */ 451function p_read_metadata($id, $cache = false) 452{ 453 global $cache_metadata; 454 455 if (isset($cache_metadata[(string)$id])) return $cache_metadata[(string)$id]; 456 457 $file = metaFN($id, '.meta'); 458 $meta = file_exists($file) ? 459 unserialize(io_readFile($file, false)) : 460 ['current' => [], 'persistent' => []]; 461 462 if ($cache) { 463 $cache_metadata[(string)$id] = $meta; 464 } 465 466 return $meta; 467} 468 469/** 470 * This is the backend function to save a metadata array to a file 471 * 472 * @param string $id absolute wiki page id 473 * @param array $meta metadata 474 * 475 * @return bool success / fail 476 */ 477function p_save_metadata($id, $meta) 478{ 479 // sync cached copies, including $INFO metadata 480 global $cache_metadata, $INFO; 481 482 if (isset($cache_metadata[$id])) $cache_metadata[$id] = $meta; 483 if (!empty($INFO) && isset($INFO['id']) && ($id == $INFO['id'])) { 484 $INFO['meta'] = $meta['current']; 485 } 486 487 return io_saveFile(metaFN($id, '.meta'), serialize($meta)); 488} 489 490/** 491 * renders the metadata of a page 492 * 493 * @param string $id page id 494 * @param array $orig the original metadata 495 * @return array|null array('current'=> array,'persistent'=> array); 496 * @author Esther Brunner <esther@kaffeehaus.ch> 497 * 498 */ 499function p_render_metadata($id, $orig) 500{ 501 // make sure the correct ID is in global ID 502 global $ID, $METADATA_RENDERERS; 503 504 // avoid recursive rendering processes for the same id 505 if (isset($METADATA_RENDERERS[$id])) { 506 return $orig; 507 } 508 509 // store the original metadata in the global $METADATA_RENDERERS so p_set_metadata can use it 510 $METADATA_RENDERERS[$id] =& $orig; 511 512 $keep = $ID; 513 $ID = $id; 514 515 // add an extra key for the event - to tell event handlers the page whose metadata this is 516 $orig['page'] = $id; 517 $evt = new Event('PARSER_METADATA_RENDER', $orig); 518 if ($evt->advise_before()) { 519 // get instructions 520 $instructions = p_cached_instructions(wikiFN($id), false, $id); 521 if (is_null($instructions)) { 522 $ID = $keep; 523 unset($METADATA_RENDERERS[$id]); 524 return null; // something went wrong with the instructions 525 } 526 527 // set up the renderer 528 $renderer = new Doku_Renderer_metadata(); 529 $renderer->meta =& $orig['current']; 530 $renderer->persistent =& $orig['persistent']; 531 532 // loop through the instructions 533 foreach ($instructions as $instruction) { 534 // execute the callback against the renderer 535 call_user_func_array([&$renderer, $instruction[0]], (array)$instruction[1]); 536 } 537 538 $evt->result = ['current' => &$renderer->meta, 'persistent' => &$renderer->persistent]; 539 } 540 $evt->advise_after(); 541 542 // clean up 543 $ID = $keep; 544 unset($METADATA_RENDERERS[$id]); 545 return $evt->result; 546} 547 548/** 549 * returns all available parser syntax modes in correct order 550 * 551 * @return array[] with for each plugin the array('sort' => sortnumber, 'mode' => mode string, 'obj' => plugin object) 552 * @author Andreas Gohr <andi@splitbrain.org> 553 * 554 */ 555function p_get_parsermodes() 556{ 557 global $conf; 558 559 //reuse old data 560 static $modes = null; 561 if ($modes != null && !defined('DOKU_UNITTEST')) { 562 return $modes; 563 } 564 565 //import parser classes and mode definitions 566 require_once DOKU_INC . 'inc/parser/parser.php'; 567 568 // we now collect all syntax modes and their objects, then they will 569 // be sorted and added to the parser in correct order 570 $modes = []; 571 572 // add syntax plugins 573 $pluginlist = plugin_list('syntax'); 574 if ($pluginlist !== []) { 575 global $PARSER_MODES; 576 foreach ($pluginlist as $p) { 577 /** @var SyntaxPlugin $obj */ 578 $obj = plugin_load('syntax', $p); 579 if (!$obj instanceof PluginInterface) continue; 580 $PARSER_MODES[$obj->getType()][] = "plugin_$p"; //register mode type 581 //add to modes 582 $modes[] = [ 583 'sort' => $obj->getSort(), 584 'mode' => "plugin_$p", 585 'obj' => $obj, 586 ]; 587 unset($obj); //remove the reference 588 } 589 } 590 591 // add default modes 592 $std_modes = [ 593 'listblock', 'preformatted', 'notoc', 'nocache', 'header', 'table', 'linebreak', 'footnote', 'hr', 594 'unformatted', 'code', 'file', 'quote', 'internallink', 'rss', 'media', 'externallink', 595 'emaillink', 'windowssharelink', 'eol' 596 ]; 597 if ($conf['typography']) { 598 $std_modes[] = 'quotes'; 599 $std_modes[] = 'multiplyentity'; 600 } 601 foreach ($std_modes as $m) { 602 $class = 'dokuwiki\\Parsing\\ParserMode\\' . ucfirst($m); 603 $obj = new $class(); 604 $modes[] = ['sort' => $obj->getSort(), 'mode' => $m, 'obj' => $obj]; 605 } 606 607 // add formatting modes 608 $fmt_modes = [ 609 'strong', 'emphasis', 'underline', 'monospace', 'subscript', 'superscript', 'deleted' 610 ]; 611 foreach ($fmt_modes as $m) { 612 $obj = new Formatting($m); 613 $modes[] = [ 614 'sort' => $obj->getSort(), 615 'mode' => $m, 616 'obj' => $obj 617 ]; 618 } 619 620 // add modes which need files 621 $obj = new Smiley(array_keys(getSmileys())); 622 $modes[] = ['sort' => $obj->getSort(), 'mode' => 'smiley', 'obj' => $obj]; 623 $obj = new Acronym(array_keys(getAcronyms())); 624 $modes[] = ['sort' => $obj->getSort(), 'mode' => 'acronym', 'obj' => $obj]; 625 $obj = new Entity(array_keys(getEntities())); 626 $modes[] = ['sort' => $obj->getSort(), 'mode' => 'entity', 'obj' => $obj]; 627 628 // add optional camelcase mode 629 if ($conf['camelcase']) { 630 $obj = new Camelcaselink(); 631 $modes[] = ['sort' => $obj->getSort(), 'mode' => 'camelcaselink', 'obj' => $obj]; 632 } 633 634 //sort modes 635 usort($modes, 'p_sort_modes'); 636 637 return $modes; 638} 639 640/** 641 * Callback function for usort 642 * 643 * @param array $a 644 * @param array $b 645 * @return int $a is lower/equal/higher than $b 646 * @author Andreas Gohr <andi@splitbrain.org> 647 * 648 */ 649function p_sort_modes($a, $b) 650{ 651 return $a['sort'] <=> $b['sort']; 652} 653 654/** 655 * Renders a list of instruction to the specified output mode 656 * 657 * In the $info array is information from the renderer returned 658 * 659 * @param string $mode 660 * @param array|null|false $instructions 661 * @param array $info returns render info like enabled toc and cache 662 * @param string $date_at 663 * @return null|string rendered output 664 * @author Andreas Gohr <andi@splitbrain.org> 665 * 666 * @author Harry Fuecks <hfuecks@gmail.com> 667 */ 668function p_render($mode, $instructions, &$info, $date_at = '') 669{ 670 if (is_null($instructions)) return ''; 671 if ($instructions === false) return ''; 672 673 $Renderer = p_get_renderer($mode); 674 if (is_null($Renderer)) return null; 675 676 $Renderer->reset(); 677 678 if ($date_at) { 679 $Renderer->date_at = $date_at; 680 } 681 682 $Renderer->smileys = getSmileys(); 683 $Renderer->entities = getEntities(); 684 $Renderer->acronyms = getAcronyms(); 685 $Renderer->interwiki = getInterwiki(); 686 687 // Loop through the instructions 688 foreach ($instructions as $instruction) { 689 // Execute the callback against the Renderer 690 if (method_exists($Renderer, $instruction[0])) { 691 call_user_func_array([&$Renderer, $instruction[0]], $instruction[1] ?: []); 692 } 693 } 694 695 //set info array 696 $info = $Renderer->info; 697 698 // Post process and return the output 699 $data = [$mode, & $Renderer->doc]; 700 Event::createAndTrigger('RENDERER_CONTENT_POSTPROCESS', $data); 701 return $Renderer->doc; 702} 703 704/** 705 * Figure out the correct renderer class to use for $mode, 706 * instantiate and return it 707 * 708 * @param string $mode Mode of the renderer to get 709 * @return null|Doku_Renderer The renderer 710 * 711 * @author Christopher Smith <chris@jalakai.co.uk> 712 */ 713function p_get_renderer($mode) 714{ 715 /** @var PluginController $plugin_controller */ 716 global $conf, $plugin_controller; 717 718 $rname = empty($conf['renderer_' . $mode]) ? $mode : $conf['renderer_' . $mode]; 719 $rclass = "Doku_Renderer_$rname"; 720 721 // if requested earlier or a bundled renderer 722 if (class_exists($rclass)) { 723 return new $rclass(); 724 } 725 726 // not bundled, see if its an enabled renderer plugin & when $mode is 'xhtml', the renderer can supply that format. 727 /** @var Doku_Renderer $Renderer */ 728 $Renderer = $plugin_controller->load('renderer', $rname); 729 if ($Renderer && is_a($Renderer, 'Doku_Renderer') && ($mode != 'xhtml' || $mode == $Renderer->getFormat())) { 730 return $Renderer; 731 } 732 733 // there is a configuration error! 734 // not bundled, not a valid enabled plugin, use $mode to try to fallback to a bundled renderer 735 $rclass = "Doku_Renderer_$mode"; 736 if (class_exists($rclass)) { 737 // viewers should see renderered output, so restrict the warning to admins only 738 $msg = "No renderer '$rname' found for mode '$mode', check your plugins"; 739 if ($mode == 'xhtml') { 740 $msg .= " and the 'renderer_xhtml' config setting"; 741 } 742 $msg .= ".<br/>Attempting to fallback to the bundled renderer."; 743 msg($msg, -1, '', '', MSG_ADMINS_ONLY); 744 745 $Renderer = new $rclass(); 746 $Renderer->nocache(); // fallback only (and may include admin alerts), don't cache 747 return $Renderer; 748 } 749 750 // fallback failed, alert the world 751 msg("No renderer '$rname' found for mode '$mode'", -1); 752 return null; 753} 754 755/** 756 * Gets the first heading from a file 757 * 758 * @param string $id dokuwiki page id 759 * @param int $render rerender if first heading not known 760 * default: METADATA_RENDER_USING_SIMPLE_CACHE 761 * Possible values: METADATA_DONT_RENDER, 762 * METADATA_RENDER_USING_SIMPLE_CACHE, 763 * METADATA_RENDER_USING_CACHE, 764 * METADATA_RENDER_UNLIMITED 765 * @return string|null The first heading 766 * 767 * @author Andreas Gohr <andi@splitbrain.org> 768 * @author Michael Hamann <michael@content-space.de> 769 */ 770function p_get_first_heading($id, $render = METADATA_RENDER_USING_SIMPLE_CACHE) 771{ 772 return p_get_metadata(cleanID($id), 'title', $render); 773} 774 775/** 776 * Wrapper for GeSHi Code Highlighter, provides caching of its output 777 * 778 * @param string $code source code to be highlighted 779 * @param string $language language to provide highlighting 780 * @param string $wrapper html element to wrap the returned highlighted text 781 * @return string xhtml code 782 * 783 * @author Christopher Smith <chris@jalakai.co.uk> 784 * @author Andreas Gohr <andi@splitbrain.org> 785 */ 786function p_xhtml_cached_geshi($code, $language, $wrapper = 'pre', array $options = null) 787{ 788 global $conf, $config_cascade, $INPUT; 789 $language = strtolower($language); 790 791 // remove any leading or trailing blank lines 792 $code = preg_replace('/^\s*?\n|\s*?\n$/', '', $code); 793 794 $optionsmd5 = md5(serialize($options)); 795 $cache = getCacheName($language . $code . $optionsmd5, ".code"); 796 $ctime = @filemtime($cache); 797 if ( 798 $ctime && !$INPUT->bool('purge') && 799 $ctime > filemtime(DOKU_INC . 'vendor/composer/installed.json') && // libraries changed 800 $ctime > filemtime(reset($config_cascade['main']['default'])) 801 ) { // dokuwiki changed 802 $highlighted_code = io_readFile($cache, false); 803 } else { 804 $geshi = new GeSHi($code, $language); 805 $geshi->set_encoding('utf-8'); 806 $geshi->enable_classes(); 807 $geshi->set_header_type(GESHI_HEADER_PRE); 808 $geshi->set_link_target($conf['target']['extern']); 809 if ($options !== null) { 810 foreach ($options as $function => $params) { 811 if (is_callable([$geshi, $function])) { 812 $geshi->$function($params); 813 } 814 } 815 } 816 817 // remove GeSHi's wrapper element (we'll replace it with our own later) 818 // we need to use a GeSHi wrapper to avoid <BR> throughout the highlighted text 819 $highlighted_code = trim(preg_replace('!^<pre[^>]*>|</pre>$!', '', $geshi->parse_code()), "\n\r"); 820 io_saveFile($cache, $highlighted_code); 821 } 822 823 // add a wrapper element if required 824 if ($wrapper) { 825 return "<$wrapper class=\"code $language\">$highlighted_code</$wrapper>"; 826 } else { 827 return $highlighted_code; 828 } 829} 830