summaryrefslogtreecommitdiff
path: root/platform/www/inc/parserutils.php
diff options
context:
space:
mode:
Diffstat (limited to 'platform/www/inc/parserutils.php')
-rw-r--r--platform/www/inc/parserutils.php809
1 files changed, 809 insertions, 0 deletions
diff --git a/platform/www/inc/parserutils.php b/platform/www/inc/parserutils.php
new file mode 100644
index 0000000..846be54
--- /dev/null
+++ b/platform/www/inc/parserutils.php
@@ -0,0 +1,809 @@
+<?php
+/**
+ * Utilities for accessing the parser
+ *
+ * @license GPL 2 (http://www.gnu.org/licenses/gpl.html)
+ * @author Harry Fuecks <hfuecks@gmail.com>
+ * @author Andreas Gohr <andi@splitbrain.org>
+ */
+
+use dokuwiki\Cache\CacheInstructions;
+use dokuwiki\Cache\CacheRenderer;
+use dokuwiki\ChangeLog\PageChangeLog;
+use dokuwiki\Extension\PluginController;
+use dokuwiki\Extension\Event;
+use dokuwiki\Parsing\Parser;
+
+/**
+ * How many pages shall be rendered for getting metadata during one request
+ * at maximum? Note that this limit isn't respected when METADATA_RENDER_UNLIMITED
+ * is passed as render parameter to p_get_metadata.
+ */
+if (!defined('P_GET_METADATA_RENDER_LIMIT')) define('P_GET_METADATA_RENDER_LIMIT', 5);
+
+/** Don't render metadata even if it is outdated or doesn't exist */
+define('METADATA_DONT_RENDER', 0);
+/**
+ * Render metadata when the page is really newer or the metadata doesn't exist.
+ * Uses just a simple check, but should work pretty well for loading simple
+ * metadata values like the page title and avoids rendering a lot of pages in
+ * one request. The P_GET_METADATA_RENDER_LIMIT is used in this mode.
+ * Use this if it is unlikely that the metadata value you are requesting
+ * does depend e.g. on pages that are included in the current page using
+ * the include plugin (this is very likely the case for the page title, but
+ * not for relation references).
+ */
+define('METADATA_RENDER_USING_SIMPLE_CACHE', 1);
+/**
+ * Render metadata using the metadata cache logic. The P_GET_METADATA_RENDER_LIMIT
+ * is used in this mode. Use this mode when you are requesting more complex
+ * metadata. Although this will cause rendering more often it might actually have
+ * the effect that less current metadata is returned as it is more likely than in
+ * the simple cache mode that metadata needs to be rendered for all pages at once
+ * which means that when the metadata for the page is requested that actually needs
+ * to be updated the limit might have been reached already.
+ */
+define('METADATA_RENDER_USING_CACHE', 2);
+/**
+ * Render metadata without limiting the number of pages for which metadata is
+ * rendered. Use this mode with care, normally it should only be used in places
+ * like the indexer or in cli scripts where the execution time normally isn't
+ * limited. This can be combined with the simple cache using
+ * METADATA_RENDER_USING_CACHE | METADATA_RENDER_UNLIMITED.
+ */
+define('METADATA_RENDER_UNLIMITED', 4);
+
+/**
+ * Returns the parsed Wikitext in XHTML for the given id and revision.
+ *
+ * If $excuse is true an explanation is returned if the file
+ * wasn't found
+ *
+ * @author Andreas Gohr <andi@splitbrain.org>
+ *
+ * @param string $id page id
+ * @param string|int $rev revision timestamp or empty string
+ * @param bool $excuse
+ * @param string $date_at
+ *
+ * @return null|string
+ */
+function p_wiki_xhtml($id, $rev='', $excuse=true,$date_at=''){
+ $file = wikiFN($id,$rev);
+ $ret = '';
+
+ //ensure $id is in global $ID (needed for parsing)
+ global $ID;
+ $keep = $ID;
+ $ID = $id;
+
+ if($rev || $date_at){
+ if(file_exists($file)){
+ //no caching on old revisions
+ $ret = p_render('xhtml',p_get_instructions(io_readWikiPage($file,$id,$rev)),$info,$date_at);
+ }elseif($excuse){
+ $ret = p_locale_xhtml('norev');
+ }
+ }else{
+ if(file_exists($file)){
+ $ret = p_cached_output($file,'xhtml',$id);
+ }elseif($excuse){
+ //check if the page once existed
+ $changelog = new PageChangeLog($id);
+ if($changelog->hasRevisions()) {
+ $ret = p_locale_xhtml('onceexisted');
+ } else {
+ $ret = p_locale_xhtml('newpage');
+ }
+ }
+ }
+
+ //restore ID (just in case)
+ $ID = $keep;
+
+ return $ret;
+}
+
+/**
+ * Returns the specified local text in parsed format
+ *
+ * @author Andreas Gohr <andi@splitbrain.org>
+ *
+ * @param string $id page id
+ * @return null|string
+ */
+function p_locale_xhtml($id){
+ //fetch parsed locale
+ $html = p_cached_output(localeFN($id));
+ return $html;
+}
+
+/**
+ * Returns the given file parsed into the requested output format
+ *
+ * @author Andreas Gohr <andi@splitbrain.org>
+ * @author Chris Smith <chris@jalakai.co.uk>
+ *
+ * @param string $file filename, path to file
+ * @param string $format
+ * @param string $id page id
+ * @return null|string
+ */
+function p_cached_output($file, $format='xhtml', $id='') {
+ global $conf;
+
+ $cache = new CacheRenderer($id, $file, $format);
+ if ($cache->useCache()) {
+ $parsed = $cache->retrieveCache(false);
+ if($conf['allowdebug'] && $format=='xhtml') {
+ $parsed .= "\n<!-- cachefile {$cache->cache} used -->\n";
+ }
+ } else {
+ $parsed = p_render($format, p_cached_instructions($file,false,$id), $info);
+
+ if ($info['cache'] && $cache->storeCache($parsed)) { // storeCache() attempts to save cachefile
+ if($conf['allowdebug'] && $format=='xhtml') {
+ $parsed .= "\n<!-- no cachefile used, but created {$cache->cache} -->\n";
+ }
+ }else{
+ $cache->removeCache(); //try to delete cachefile
+ if($conf['allowdebug'] && $format=='xhtml') {
+ $parsed .= "\n<!-- no cachefile used, caching forbidden -->\n";
+ }
+ }
+ }
+
+ return $parsed;
+}
+
+/**
+ * Returns the render instructions for a file
+ *
+ * Uses and creates a serialized cache file
+ *
+ * @author Andreas Gohr <andi@splitbrain.org>
+ *
+ * @param string $file filename, path to file
+ * @param bool $cacheonly
+ * @param string $id page id
+ * @return array|null
+ */
+function p_cached_instructions($file,$cacheonly=false,$id='') {
+ static $run = null;
+ if(is_null($run)) $run = array();
+
+ $cache = new CacheInstructions($id, $file);
+
+ if ($cacheonly || $cache->useCache() || (isset($run[$file]) && !defined('DOKU_UNITTEST'))) {
+ return $cache->retrieveCache();
+ } else if (file_exists($file)) {
+ // no cache - do some work
+ $ins = p_get_instructions(io_readWikiPage($file,$id));
+ if ($cache->storeCache($ins)) {
+ $run[$file] = true; // we won't rebuild these instructions in the same run again
+ } else {
+ msg('Unable to save cache file. Hint: disk full; file permissions; safe_mode setting.',-1);
+ }
+ return $ins;
+ }
+
+ return null;
+}
+
+/**
+ * turns a page into a list of instructions
+ *
+ * @author Harry Fuecks <hfuecks@gmail.com>
+ * @author Andreas Gohr <andi@splitbrain.org>
+ *
+ * @param string $text raw wiki syntax text
+ * @return array a list of instruction arrays
+ */
+function p_get_instructions($text){
+
+ $modes = p_get_parsermodes();
+
+ // Create the parser and handler
+ $Parser = new Parser(new Doku_Handler());
+
+ //add modes to parser
+ foreach($modes as $mode){
+ $Parser->addMode($mode['mode'],$mode['obj']);
+ }
+
+ // Do the parsing
+ Event::createAndTrigger('PARSER_WIKITEXT_PREPROCESS', $text);
+ $p = $Parser->parse($text);
+ // dbg($p);
+ return $p;
+}
+
+/**
+ * returns the metadata of a page
+ *
+ * @param string $id The id of the page the metadata should be returned from
+ * @param string $key The key of the metdata value that shall be read (by default everything)
+ * separate hierarchies by " " like "date created"
+ * @param int $render If the page should be rendererd - possible values:
+ * METADATA_DONT_RENDER, METADATA_RENDER_USING_SIMPLE_CACHE, METADATA_RENDER_USING_CACHE
+ * METADATA_RENDER_UNLIMITED (also combined with the previous two options),
+ * default: METADATA_RENDER_USING_CACHE
+ * @return mixed The requested metadata fields
+ *
+ * @author Esther Brunner <esther@kaffeehaus.ch>
+ * @author Michael Hamann <michael@content-space.de>
+ */
+function p_get_metadata($id, $key='', $render=METADATA_RENDER_USING_CACHE){
+ global $ID;
+ static $render_count = 0;
+ // track pages that have already been rendered in order to avoid rendering the same page
+ // again
+ static $rendered_pages = array();
+
+ // cache the current page
+ // Benchmarking shows the current page's metadata is generally the only page metadata
+ // accessed several times. This may catch a few other pages, but that shouldn't be an issue.
+ $cache = ($ID == $id);
+ $meta = p_read_metadata($id, $cache);
+
+ if (!is_numeric($render)) {
+ if ($render) {
+ $render = METADATA_RENDER_USING_SIMPLE_CACHE;
+ } else {
+ $render = METADATA_DONT_RENDER;
+ }
+ }
+
+ // prevent recursive calls in the cache
+ static $recursion = false;
+ if (!$recursion && $render != METADATA_DONT_RENDER && !isset($rendered_pages[$id])&& page_exists($id)){
+ $recursion = true;
+
+ $cachefile = new CacheRenderer($id, wikiFN($id), 'metadata');
+
+ $do_render = false;
+ if ($render & METADATA_RENDER_UNLIMITED || $render_count < P_GET_METADATA_RENDER_LIMIT) {
+ if ($render & METADATA_RENDER_USING_SIMPLE_CACHE) {
+ $pagefn = wikiFN($id);
+ $metafn = metaFN($id, '.meta');
+ if (!file_exists($metafn) || @filemtime($pagefn) > @filemtime($cachefile->cache)) {
+ $do_render = true;
+ }
+ } elseif (!$cachefile->useCache()){
+ $do_render = true;
+ }
+ }
+ if ($do_render) {
+ if (!defined('DOKU_UNITTEST')) {
+ ++$render_count;
+ $rendered_pages[$id] = true;
+ }
+ $old_meta = $meta;
+ $meta = p_render_metadata($id, $meta);
+ // only update the file when the metadata has been changed
+ if ($meta == $old_meta || p_save_metadata($id, $meta)) {
+ // store a timestamp in order to make sure that the cachefile is touched
+ // this timestamp is also stored when the meta data is still the same
+ $cachefile->storeCache(time());
+ } else {
+ msg('Unable to save metadata file. Hint: disk full; file permissions; safe_mode setting.',-1);
+ }
+ }
+
+ $recursion = false;
+ }
+
+ $val = $meta['current'];
+
+ // filter by $key
+ foreach(preg_split('/\s+/', $key, 2, PREG_SPLIT_NO_EMPTY) as $cur_key) {
+ if (!isset($val[$cur_key])) {
+ return null;
+ }
+ $val = $val[$cur_key];
+ }
+ return $val;
+}
+
+/**
+ * sets metadata elements of a page
+ *
+ * @see http://www.dokuwiki.org/devel:metadata#functions_to_get_and_set_metadata
+ *
+ * @param string $id is the ID of a wiki page
+ * @param array $data is an array with key ⇒ value pairs to be set in the metadata
+ * @param boolean $render whether or not the page metadata should be generated with the renderer
+ * @param boolean $persistent indicates whether or not the particular metadata value will persist through
+ * the next metadata rendering.
+ * @return boolean true on success
+ *
+ * @author Esther Brunner <esther@kaffeehaus.ch>
+ * @author Michael Hamann <michael@content-space.de>
+ */
+function p_set_metadata($id, $data, $render=false, $persistent=true){
+ if (!is_array($data)) return false;
+
+ global $ID, $METADATA_RENDERERS;
+
+ // if there is currently a renderer change the data in the renderer instead
+ if (isset($METADATA_RENDERERS[$id])) {
+ $orig =& $METADATA_RENDERERS[$id];
+ $meta = $orig;
+ } else {
+ // cache the current page
+ $cache = ($ID == $id);
+ $orig = p_read_metadata($id, $cache);
+
+ // render metadata first?
+ $meta = $render ? p_render_metadata($id, $orig) : $orig;
+ }
+
+ // now add the passed metadata
+ $protected = array('description', 'date', 'contributor');
+ foreach ($data as $key => $value){
+
+ // be careful with sub-arrays of $meta['relation']
+ if ($key == 'relation'){
+
+ foreach ($value as $subkey => $subvalue){
+ if(isset($meta['current'][$key][$subkey]) && is_array($meta['current'][$key][$subkey])) {
+ $meta['current'][$key][$subkey] = array_replace($meta['current'][$key][$subkey], (array)$subvalue);
+ } else {
+ $meta['current'][$key][$subkey] = $subvalue;
+ }
+ if($persistent) {
+ if(isset($meta['persistent'][$key][$subkey]) && is_array($meta['persistent'][$key][$subkey])) {
+ $meta['persistent'][$key][$subkey] = array_replace(
+ $meta['persistent'][$key][$subkey],
+ (array) $subvalue
+ );
+ } else {
+ $meta['persistent'][$key][$subkey] = $subvalue;
+ }
+ }
+ }
+
+ // be careful with some senisitive arrays of $meta
+ } elseif (in_array($key, $protected)){
+
+ // these keys, must have subkeys - a legitimate value must be an array
+ if (is_array($value)) {
+ $meta['current'][$key] = !empty($meta['current'][$key]) ?
+ array_replace((array)$meta['current'][$key],$value) :
+ $value;
+
+ if ($persistent) {
+ $meta['persistent'][$key] = !empty($meta['persistent'][$key]) ?
+ array_replace((array)$meta['persistent'][$key],$value) :
+ $value;
+ }
+ }
+
+ // no special treatment for the rest
+ } else {
+ $meta['current'][$key] = $value;
+ if ($persistent) $meta['persistent'][$key] = $value;
+ }
+ }
+
+ // save only if metadata changed
+ if ($meta == $orig) return true;
+
+ if (isset($METADATA_RENDERERS[$id])) {
+ // set both keys individually as the renderer has references to the individual keys
+ $METADATA_RENDERERS[$id]['current'] = $meta['current'];
+ $METADATA_RENDERERS[$id]['persistent'] = $meta['persistent'];
+ return true;
+ } else {
+ return p_save_metadata($id, $meta);
+ }
+}
+
+/**
+ * Purges the non-persistant part of the meta data
+ * used on page deletion
+ *
+ * @author Michael Klier <chi@chimeric.de>
+ *
+ * @param string $id page id
+ * @return bool success / fail
+ */
+function p_purge_metadata($id) {
+ $meta = p_read_metadata($id);
+ foreach($meta['current'] as $key => $value) {
+ if(is_array($meta[$key])) {
+ $meta['current'][$key] = array();
+ } else {
+ $meta['current'][$key] = '';
+ }
+
+ }
+ return p_save_metadata($id, $meta);
+}
+
+/**
+ * read the metadata from source/cache for $id
+ * (internal use only - called by p_get_metadata & p_set_metadata)
+ *
+ * @author Christopher Smith <chris@jalakai.co.uk>
+ *
+ * @param string $id absolute wiki page id
+ * @param bool $cache whether or not to cache metadata in memory
+ * (only use for metadata likely to be accessed several times)
+ *
+ * @return array metadata
+ */
+function p_read_metadata($id,$cache=false) {
+ global $cache_metadata;
+
+ if (isset($cache_metadata[(string)$id])) return $cache_metadata[(string)$id];
+
+ $file = metaFN($id, '.meta');
+ $meta = file_exists($file) ?
+ unserialize(io_readFile($file, false)) :
+ array('current'=>array(),'persistent'=>array());
+
+ if ($cache) {
+ $cache_metadata[(string)$id] = $meta;
+ }
+
+ return $meta;
+}
+
+/**
+ * This is the backend function to save a metadata array to a file
+ *
+ * @param string $id absolute wiki page id
+ * @param array $meta metadata
+ *
+ * @return bool success / fail
+ */
+function p_save_metadata($id, $meta) {
+ // sync cached copies, including $INFO metadata
+ global $cache_metadata, $INFO;
+
+ if (isset($cache_metadata[$id])) $cache_metadata[$id] = $meta;
+ if (!empty($INFO) && ($id == $INFO['id'])) { $INFO['meta'] = $meta['current']; }
+
+ return io_saveFile(metaFN($id, '.meta'), serialize($meta));
+}
+
+/**
+ * renders the metadata of a page
+ *
+ * @author Esther Brunner <esther@kaffeehaus.ch>
+ *
+ * @param string $id page id
+ * @param array $orig the original metadata
+ * @return array|null array('current'=> array,'persistent'=> array);
+ */
+function p_render_metadata($id, $orig){
+ // make sure the correct ID is in global ID
+ global $ID, $METADATA_RENDERERS;
+
+ // avoid recursive rendering processes for the same id
+ if (isset($METADATA_RENDERERS[$id])) {
+ return $orig;
+ }
+
+ // store the original metadata in the global $METADATA_RENDERERS so p_set_metadata can use it
+ $METADATA_RENDERERS[$id] =& $orig;
+
+ $keep = $ID;
+ $ID = $id;
+
+ // add an extra key for the event - to tell event handlers the page whose metadata this is
+ $orig['page'] = $id;
+ $evt = new Event('PARSER_METADATA_RENDER', $orig);
+ if ($evt->advise_before()) {
+
+ // get instructions
+ $instructions = p_cached_instructions(wikiFN($id),false,$id);
+ if(is_null($instructions)){
+ $ID = $keep;
+ unset($METADATA_RENDERERS[$id]);
+ return null; // something went wrong with the instructions
+ }
+
+ // set up the renderer
+ $renderer = new Doku_Renderer_metadata();
+ $renderer->meta =& $orig['current'];
+ $renderer->persistent =& $orig['persistent'];
+
+ // loop through the instructions
+ foreach ($instructions as $instruction){
+ // execute the callback against the renderer
+ call_user_func_array(array(&$renderer, $instruction[0]), (array) $instruction[1]);
+ }
+
+ $evt->result = array('current'=>&$renderer->meta,'persistent'=>&$renderer->persistent);
+ }
+ $evt->advise_after();
+
+ // clean up
+ $ID = $keep;
+ unset($METADATA_RENDERERS[$id]);
+ return $evt->result;
+}
+
+/**
+ * returns all available parser syntax modes in correct order
+ *
+ * @author Andreas Gohr <andi@splitbrain.org>
+ *
+ * @return array[] with for each plugin the array('sort' => sortnumber, 'mode' => mode string, 'obj' => plugin object)
+ */
+function p_get_parsermodes(){
+ global $conf;
+
+ //reuse old data
+ static $modes = null;
+ if($modes != null && !defined('DOKU_UNITTEST')){
+ return $modes;
+ }
+
+ //import parser classes and mode definitions
+ require_once DOKU_INC . 'inc/parser/parser.php';
+
+ // we now collect all syntax modes and their objects, then they will
+ // be sorted and added to the parser in correct order
+ $modes = array();
+
+ // add syntax plugins
+ $pluginlist = plugin_list('syntax');
+ if(count($pluginlist)){
+ global $PARSER_MODES;
+ $obj = null;
+ foreach($pluginlist as $p){
+ /** @var \dokuwiki\Extension\SyntaxPlugin $obj */
+ if(!$obj = plugin_load('syntax',$p)) continue; //attempt to load plugin into $obj
+ $PARSER_MODES[$obj->getType()][] = "plugin_$p"; //register mode type
+ //add to modes
+ $modes[] = array(
+ 'sort' => $obj->getSort(),
+ 'mode' => "plugin_$p",
+ 'obj' => $obj,
+ );
+ unset($obj); //remove the reference
+ }
+ }
+
+ // add default modes
+ $std_modes = array('listblock','preformatted','notoc','nocache',
+ 'header','table','linebreak','footnote','hr',
+ 'unformatted','php','html','code','file','quote',
+ 'internallink','rss','media','externallink',
+ 'emaillink','windowssharelink','eol');
+ if($conf['typography']){
+ $std_modes[] = 'quotes';
+ $std_modes[] = 'multiplyentity';
+ }
+ foreach($std_modes as $m){
+ $class = 'dokuwiki\\Parsing\\ParserMode\\'.ucfirst($m);
+ $obj = new $class();
+ $modes[] = array(
+ 'sort' => $obj->getSort(),
+ 'mode' => $m,
+ 'obj' => $obj
+ );
+ }
+
+ // add formatting modes
+ $fmt_modes = array('strong','emphasis','underline','monospace',
+ 'subscript','superscript','deleted');
+ foreach($fmt_modes as $m){
+ $obj = new \dokuwiki\Parsing\ParserMode\Formatting($m);
+ $modes[] = array(
+ 'sort' => $obj->getSort(),
+ 'mode' => $m,
+ 'obj' => $obj
+ );
+ }
+
+ // add modes which need files
+ $obj = new \dokuwiki\Parsing\ParserMode\Smiley(array_keys(getSmileys()));
+ $modes[] = array('sort' => $obj->getSort(), 'mode' => 'smiley','obj' => $obj );
+ $obj = new \dokuwiki\Parsing\ParserMode\Acronym(array_keys(getAcronyms()));
+ $modes[] = array('sort' => $obj->getSort(), 'mode' => 'acronym','obj' => $obj );
+ $obj = new \dokuwiki\Parsing\ParserMode\Entity(array_keys(getEntities()));
+ $modes[] = array('sort' => $obj->getSort(), 'mode' => 'entity','obj' => $obj );
+
+ // add optional camelcase mode
+ if($conf['camelcase']){
+ $obj = new \dokuwiki\Parsing\ParserMode\Camelcaselink();
+ $modes[] = array('sort' => $obj->getSort(), 'mode' => 'camelcaselink','obj' => $obj );
+ }
+
+ //sort modes
+ usort($modes,'p_sort_modes');
+
+ return $modes;
+}
+
+/**
+ * Callback function for usort
+ *
+ * @author Andreas Gohr <andi@splitbrain.org>
+ *
+ * @param array $a
+ * @param array $b
+ * @return int $a is lower/equal/higher than $b
+ */
+function p_sort_modes($a, $b){
+ if($a['sort'] == $b['sort']) return 0;
+ return ($a['sort'] < $b['sort']) ? -1 : 1;
+}
+
+/**
+ * Renders a list of instruction to the specified output mode
+ *
+ * In the $info array is information from the renderer returned
+ *
+ * @author Harry Fuecks <hfuecks@gmail.com>
+ * @author Andreas Gohr <andi@splitbrain.org>
+ *
+ * @param string $mode
+ * @param array|null|false $instructions
+ * @param array $info returns render info like enabled toc and cache
+ * @param string $date_at
+ * @return null|string rendered output
+ */
+function p_render($mode,$instructions,&$info,$date_at=''){
+ if(is_null($instructions)) return '';
+ if($instructions === false) return '';
+
+ $Renderer = p_get_renderer($mode);
+ if (is_null($Renderer)) return null;
+
+ $Renderer->reset();
+
+ if($date_at) {
+ $Renderer->date_at = $date_at;
+ }
+
+ $Renderer->smileys = getSmileys();
+ $Renderer->entities = getEntities();
+ $Renderer->acronyms = getAcronyms();
+ $Renderer->interwiki = getInterwiki();
+
+ // Loop through the instructions
+ foreach ( $instructions as $instruction ) {
+ // Execute the callback against the Renderer
+ if(method_exists($Renderer, $instruction[0])){
+ call_user_func_array(array(&$Renderer, $instruction[0]), $instruction[1] ? $instruction[1] : array());
+ }
+ }
+
+ //set info array
+ $info = $Renderer->info;
+
+ // Post process and return the output
+ $data = array($mode,& $Renderer->doc);
+ Event::createAndTrigger('RENDERER_CONTENT_POSTPROCESS',$data);
+ return $Renderer->doc;
+}
+
+/**
+ * Figure out the correct renderer class to use for $mode,
+ * instantiate and return it
+ *
+ * @param string $mode Mode of the renderer to get
+ * @return null|Doku_Renderer The renderer
+ *
+ * @author Christopher Smith <chris@jalakai.co.uk>
+ */
+function p_get_renderer($mode) {
+ /** @var PluginController $plugin_controller */
+ global $conf, $plugin_controller;
+
+ $rname = !empty($conf['renderer_'.$mode]) ? $conf['renderer_'.$mode] : $mode;
+ $rclass = "Doku_Renderer_$rname";
+
+ // if requested earlier or a bundled renderer
+ if( class_exists($rclass) ) {
+ $Renderer = new $rclass();
+ return $Renderer;
+ }
+
+ // not bundled, see if its an enabled renderer plugin & when $mode is 'xhtml', the renderer can supply that format.
+ /** @var Doku_Renderer $Renderer */
+ $Renderer = $plugin_controller->load('renderer',$rname);
+ if ($Renderer && is_a($Renderer, 'Doku_Renderer') && ($mode != 'xhtml' || $mode == $Renderer->getFormat())) {
+ return $Renderer;
+ }
+
+ // there is a configuration error!
+ // not bundled, not a valid enabled plugin, use $mode to try to fallback to a bundled renderer
+ $rclass = "Doku_Renderer_$mode";
+ if ( class_exists($rclass) ) {
+ // viewers should see renderered output, so restrict the warning to admins only
+ $msg = "No renderer '$rname' found for mode '$mode', check your plugins";
+ if ($mode == 'xhtml') {
+ $msg .= " and the 'renderer_xhtml' config setting";
+ }
+ $msg .= ".<br/>Attempting to fallback to the bundled renderer.";
+ msg($msg,-1,'','',MSG_ADMINS_ONLY);
+
+ $Renderer = new $rclass;
+ $Renderer->nocache(); // fallback only (and may include admin alerts), don't cache
+ return $Renderer;
+ }
+
+ // fallback failed, alert the world
+ msg("No renderer '$rname' found for mode '$mode'",-1);
+ return null;
+}
+
+/**
+ * Gets the first heading from a file
+ *
+ * @param string $id dokuwiki page id
+ * @param int $render rerender if first heading not known
+ * default: METADATA_RENDER_USING_SIMPLE_CACHE
+ * Possible values: METADATA_DONT_RENDER,
+ * METADATA_RENDER_USING_SIMPLE_CACHE,
+ * METADATA_RENDER_USING_CACHE,
+ * METADATA_RENDER_UNLIMITED
+ * @return string|null The first heading
+ *
+ * @author Andreas Gohr <andi@splitbrain.org>
+ * @author Michael Hamann <michael@content-space.de>
+ */
+function p_get_first_heading($id, $render=METADATA_RENDER_USING_SIMPLE_CACHE){
+ return p_get_metadata(cleanID($id),'title',$render);
+}
+
+/**
+ * Wrapper for GeSHi Code Highlighter, provides caching of its output
+ *
+ * @param string $code source code to be highlighted
+ * @param string $language language to provide highlighting
+ * @param string $wrapper html element to wrap the returned highlighted text
+ * @return string xhtml code
+ *
+ * @author Christopher Smith <chris@jalakai.co.uk>
+ * @author Andreas Gohr <andi@splitbrain.org>
+ */
+function p_xhtml_cached_geshi($code, $language, $wrapper='pre', array $options=null) {
+ global $conf, $config_cascade, $INPUT;
+ $language = strtolower($language);
+
+ // remove any leading or trailing blank lines
+ $code = preg_replace('/^\s*?\n|\s*?\n$/','',$code);
+
+ $optionsmd5 = md5(serialize($options));
+ $cache = getCacheName($language.$code.$optionsmd5,".code");
+ $ctime = @filemtime($cache);
+ if($ctime && !$INPUT->bool('purge') &&
+ $ctime > filemtime(DOKU_INC.'vendor/composer/installed.json') && // libraries changed
+ $ctime > filemtime(reset($config_cascade['main']['default']))){ // dokuwiki changed
+ $highlighted_code = io_readFile($cache, false);
+ } else {
+
+ $geshi = new GeSHi($code, $language);
+ $geshi->set_encoding('utf-8');
+ $geshi->enable_classes();
+ $geshi->set_header_type(GESHI_HEADER_PRE);
+ $geshi->set_link_target($conf['target']['extern']);
+ if($options !== null) {
+ foreach ($options as $function => $params) {
+ if(is_callable(array($geshi, $function))) {
+ $geshi->$function($params);
+ }
+ }
+ }
+
+ // remove GeSHi's wrapper element (we'll replace it with our own later)
+ // we need to use a GeSHi wrapper to avoid <BR> throughout the highlighted text
+ $highlighted_code = trim(preg_replace('!^<pre[^>]*>|</pre>$!','',$geshi->parse_code()),"\n\r");
+ io_saveFile($cache,$highlighted_code);
+ }
+
+ // add a wrapper element if required
+ if ($wrapper) {
+ return "<$wrapper class=\"code $language\">$highlighted_code</$wrapper>";
+ } else {
+ return $highlighted_code;
+ }
+}
+
generated by cgit v1.2.1 (git 2.18.0) at 2024-04-20 04:09:09 +0000