mr-legend_wiki/inc/parserutils.php

<?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\Extension\PluginInterface;
use dokuwiki\Cache\CacheInstructions;
use dokuwiki\Cache\CacheRenderer;
use dokuwiki\ChangeLog\PageChangeLog;
use dokuwiki\Extension\PluginController;
use dokuwiki\Extension\Event;
use dokuwiki\Extension\SyntaxPlugin;
use dokuwiki\Parsing\Parser;
use dokuwiki\Parsing\ParserMode\Acronym;
use dokuwiki\Parsing\ParserMode\Camelcaselink;
use dokuwiki\Parsing\ParserMode\Entity;
use dokuwiki\Parsing\ParserMode\Formatting;
use dokuwiki\Parsing\ParserMode\Smiley;

/**
 * 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
 *
 * @param string $id page id
 * @param string|int $rev revision timestamp or empty string
 * @param bool $excuse
 * @param string $date_at
 *
 * @return null|string
 * @author Andreas Gohr <andi@splitbrain.org>
 *
 */
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');
        }
    } elseif (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
 *
 * @param string $id page id
 * @return null|string
 * @author Andreas Gohr <andi@splitbrain.org>
 *
 */
function p_locale_xhtml($id)
{
    //fetch parsed locale
    $data = ['id' => $id, 'html' => ''];

    $event = new Event('PARSER_LOCALE_XHTML', $data);
    if ($event->advise_before()) {
        $data['html'] = p_cached_output(localeFN($data['id']));
    }
    $event->advise_after();

    return $data['html'];
}

/**
 * Returns the given file parsed into the requested output format
 *
 * @param string $file filename, path to file
 * @param string $format
 * @param string $id page id
 * @return null|string
 * @author Andreas Gohr <andi@splitbrain.org>
 * @author Chris Smith <chris@jalakai.co.uk>
 *
 */
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 (!empty($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
 *
 * @param string $file filename, path to file
 * @param bool $cacheonly
 * @param string $id page id
 * @return array|null
 * @author Andreas Gohr <andi@splitbrain.org>
 *
 */
function p_cached_instructions($file, $cacheonly = false, $id = '')
{
    static $run = null;
    if (is_null($run)) $run = [];

    $cache = new CacheInstructions($id, $file);

    if ($cacheonly || $cache->useCache() || (isset($run[$file]) && !defined('DOKU_UNITTEST'))) {
        return $cache->retrieveCache();
    } elseif (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
 *
 * @param string $text raw wiki syntax text
 * @return array a list of instruction arrays
 * @author Harry Fuecks <hfuecks@gmail.com>
 * @author Andreas Gohr <andi@splitbrain.org>
 *
 */
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);
    return $Parser->parse($text);
}

/**
 * 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 = [];

    // 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'] ?? null;

    // 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 = ['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]) ?
                    $value :
                    array_replace((array)$meta['current'][$key], $value);

                if ($persistent) {
                    $meta['persistent'][$key] = empty($meta['persistent'][$key]) ?
                        $value :
                        array_replace((array)$meta['persistent'][$key], $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
 *
 * @param string $id page id
 * @return bool  success / fail
 * @author Michael Klier <chi@chimeric.de>
 *
 */
function p_purge_metadata($id)
{
    $meta = p_read_metadata($id);
    foreach ($meta['current'] as $key => $value) {
        if (isset($meta[$key]) && is_array($meta[$key])) {
            $meta['current'][$key] = [];
        } 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)
 *
 * @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
 * @author   Christopher Smith <chris@jalakai.co.uk>
 *
 */
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)) :
        ['current' => [], 'persistent' => []];

    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) && isset($INFO['id']) && ($id == $INFO['id'])) {
        $INFO['meta'] = $meta['current'];
    }

    return io_saveFile(metaFN($id, '.meta'), serialize($meta));
}

/**
 * renders the metadata of a page
 *
 * @param string $id page id
 * @param array $orig the original metadata
 * @return array|null array('current'=> array,'persistent'=> array);
 * @author Esther Brunner <esther@kaffeehaus.ch>
 *
 */
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([&$renderer, $instruction[0]], (array)$instruction[1]);
        }

        $evt->result = ['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
 *
 * @return array[] with for each plugin the array('sort' => sortnumber, 'mode' => mode string, 'obj'  => plugin object)
 * @author Andreas Gohr <andi@splitbrain.org>
 *
 */
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 = [];

    // add syntax plugins
    $pluginlist = plugin_list('syntax');
    if ($pluginlist !== []) {
        global $PARSER_MODES;
        foreach ($pluginlist as $p) {
            /** @var SyntaxPlugin $obj */
            $obj = plugin_load('syntax', $p);
            if (!$obj instanceof PluginInterface) continue;
            $PARSER_MODES[$obj->getType()][] = "plugin_$p"; //register mode type
            //add to modes
            $modes[] = [
                'sort' => $obj->getSort(),
                'mode' => "plugin_$p",
                'obj' => $obj,
            ];
            unset($obj); //remove the reference
        }
    }

    // add default modes
    $std_modes = [
        'listblock', 'preformatted', 'notoc', 'nocache', 'header', 'table', 'linebreak', 'footnote', 'hr',
        'unformatted', '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[] = ['sort' => $obj->getSort(), 'mode' => $m, 'obj' => $obj];
    }

    // add formatting modes
    $fmt_modes = [
        'strong', 'emphasis', 'underline', 'monospace', 'subscript', 'superscript', 'deleted'
    ];
    foreach ($fmt_modes as $m) {
        $obj = new Formatting($m);
        $modes[] = [
            'sort' => $obj->getSort(),
            'mode' => $m,
            'obj' => $obj
        ];
    }

    // add modes which need files
    $obj = new Smiley(array_keys(getSmileys()));
    $modes[] = ['sort' => $obj->getSort(), 'mode' => 'smiley', 'obj' => $obj];
    $obj = new Acronym(array_keys(getAcronyms()));
    $modes[] = ['sort' => $obj->getSort(), 'mode' => 'acronym', 'obj' => $obj];
    $obj = new Entity(array_keys(getEntities()));
    $modes[] = ['sort' => $obj->getSort(), 'mode' => 'entity', 'obj' => $obj];

    // add optional camelcase mode
    if ($conf['camelcase']) {
        $obj = new Camelcaselink();
        $modes[] = ['sort' => $obj->getSort(), 'mode' => 'camelcaselink', 'obj' => $obj];
    }

    //sort modes
    usort($modes, 'p_sort_modes');

    return $modes;
}

/**
 * Callback function for usort
 *
 * @param array $a
 * @param array $b
 * @return int $a is lower/equal/higher than $b
 * @author Andreas Gohr <andi@splitbrain.org>
 *
 */
function p_sort_modes($a, $b)
{
    return $a['sort'] <=> $b['sort'];
}

/**
 * Renders a list of instruction to the specified output mode
 *
 * In the $info array is information from the renderer returned
 *
 * @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
 * @author Andreas Gohr <andi@splitbrain.org>
 *
 * @author Harry Fuecks <hfuecks@gmail.com>
 */
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([&$Renderer, $instruction[0]], $instruction[1] ?: []);
        }
    }

    //set info array
    $info = $Renderer->info;

    // Post process and return the output
    $data = [$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]) ? $mode : $conf['renderer_' . $mode];
    $rclass = "Doku_Renderer_$rname";

    // if requested earlier or a bundled renderer
    if (class_exists($rclass)) {
        return new $rclass();
    }

    // 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([$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;
    }
}