DokuWiki

It's better when it's simple

User Tools

Site Tools


plugin:pagetemplate:listing

← Back

Manual Installation

  1. Create directory /lib/plugins/pagetemplate
  2. Create the following three files

/lib/plugins/pagetemplate/action.php

action.php
<?php
/**
 * Pagetemplate action plugin
 * 
 * @author     Luke Howson <mail@lukehowson.com>
 */
 
if(!defined('DOKU_INC')) die();
if(!defined('DOKU_PLUGIN')) define('DOKU_PLUGIN',DOKU_INC.'lib/plugins/');
require_once(DOKU_PLUGIN.'action.php');
require_once(DOKU_INC.'inc/parserutils.php');
require_once(DOKU_INC.'inc/search.php');
require_once(DOKU_INC.'inc/parser/parser.php');
require_once('pagetemplate_backlinks.php');
 
class action_plugin_pagetemplate extends DokuWiki_Action_Plugin {
 
  /**
   * return some info
   */
  function getInfo(){
    return array(
		 'author' => 'Luke Howson',
		 'email'  => 'mail@lukehowson.com',
		 'date'   => '2007-07-25',
		 'name'   => 'Page Template',
		 'desc'   => 'Generates a template when Create this Page is clicked.',
		 );
  }
 
  /*
   * Register its handlers with the dokuwiki's event controller
   */
  function register(Doku_Event_Handler $controller) {
    $controller->register_hook('HTML_PAGE_FROMTEMPLATE', 'BEFORE',  $this, '_generateTemplate');
    $controller->register_hook('HTML_PAGE_FROMTEMPLATE', 'AFTER',  $this, '_removeTemplate');
  }
 
  function _removeTemplate(&$event, $param) {
    $page = getID();
    $theTemplate = _templateFN($page);
    if (file_exists($theTemplate)) {
        unlink($theTemplate);
        io_sweepNS($page);
    }
    $backup = $theTemplate.'.bak';
    if (file_exists($backup) ) {
      io_rename($backup,$theTemplate);
    }
    return;
  }
 
  /**
   * Hooked into a newly created page (as editor boots up).
   */
  function _generateTemplate(&$event, $param) {
        // page already exists?
        $page = getID();
        $pageFile = wikiFN($page);
        if(file_exists($pageFile) ) {
            return;
        }
        global $conf;
        $ID = getID();
        //$ID = $event->data[0];
        $backlinks = array();
        $lib = new PageTemplateBacklink;
        $backlinks = $lib->getBacklinks($ID);
        if (!sizeof($backlinks)) return;
        $firstLink = $backlinks[0];
        $templatePage = $firstLink[2];
        $context = $firstLink[4];
        $templatePage = resolve_id(getNS($context),$templatePage);
        // $displayName = $firstLink[3];
        $pageName = $firstLink[1];
        $pageName = resolve_id(getNS($context),$pageName);
        $fp = wikiFN($pageName);
        $templateFile = wikiFN($templatePage);
        $newTemplate = _templateFN($pageName);
        $backup = $newTemplate.'.bak';
        if (file_exists($newTemplate) ) {
          io_rename($newTemplate,$backup);
        }
 
        io_makeFileDir($newTemplate);
        copy($templateFile, $newTemplate);
        return;
  }
}
 
function _templateFN($pageName) {
  $newTemplate = resolve_id(getNS($pageName),'template');
  $newTemplate = wikiFN($newTemplate);
  $newTemplate = preg_replace('/(?<=\\/)(?=template.txt$)/','_',$newTemplate);
  // hack for page / subpage model
  $newTemplate = preg_replace('/(?<=\\/)template\\/page.txt$/','_template.txt',$newTemplate);
  return $newTemplate;
}
 
function _pt_search_backlinks(&$data,$base,$file,$type,$lvl,$opts){
  //we do nothing with directories
  if($type == 'd') return true;;
  //only search txt files
  if(!preg_match('#\.txt$#',$file)) return true;;
 
  //absolute search id
  $sid = parentNS(cleanID($opts['ns'].':'.$opts['name']));
 
  //current id and namespace
  $cid = pathID($file);
  $cns = parentNS($cid);
 
  //check ACL
  if(auth_quickaclcheck($cid) < AUTH_READ){
    return false;
  }
 
  //fetch instructions
  $instructions = _pt_get_instructions(io_readfile($base.$file));
  if(is_null($instructions)) return false;
  $ret = false;
 
  //check all links for match
  foreach($instructions as $ins){
    if($ins[0] == 'plugin' && $ins[1][0] == 'pagetemplate' && strlen($ins[1][1][0]) > 0) {
      $mid = $ins[1][1][1];
      resolve_pageid($cns,$mid,$exists); //exists is not used
      if($mid == $sid){
        //we have a match - finish
        $ins[1][1][1] = resolve_id($cns,$ins[1][1][1]);
        $ins[1][1][2] = resolve_id($cns,$ins[1][1][2]);
        $data[]['id'] = $ins[1][1];
        break;
      }
    }
  }
  return false;
}
 
function _pt_get_instructions($text) {
    // get the instructions
      // Create the parser
  $Parser = & new Doku_Parser();
 
  // Add the Handler
  $Parser->Handler = & new Doku_Handler();
 
  //add modes to parser
  $pagetemplate_obj =& plugin_load('syntax','pagetemplate');
  $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');
  foreach($std_modes as $m){
    $class = "Doku_Parser_Mode_$m";
    $obj   = new $class();
    $mode = array(
                 'sort' => $obj->getSort(),
                 'mode' => $m,
                 'obj'  => $obj
               );
    $Parser->addMode($m,$obj);    
  }
  $Parser->addMode('plugin_pagetemplate',$pagetemplate_obj);
  // Do the parsing
  $p = $Parser->parse($text);
  return $p;
}

/lib/plugins/pagetemplate/pagetemplate_backlinks.php

pagetemplate_backlinks.php
<?php
// High performance pagetemplate backlink
// subsystem
// @author 'Luke Howson'
 
if(!defined('DOKU_PLUGIN')) define('DOKU_PLUGIN',DOKU_INC.'lib/plugins/');
 
class PageTemplateBacklink {
    function getBacklinks($id) {
        $checkedBacklinks = array();
        $backlinks = $this->_load($id);
        foreach ($backlinks as $backlink) {
            $link = $this->_verifyLink($backlink, $id);
            if ( $link) {
                $checkedBacklinks[] = $link;
            }
        }
        $this->_save($checkedBacklinks, $id);
        return $checkedBacklinks;
    }
 
    function _save($backlinks, $page) {
        if (!sizeof($backlinks) ) return;
        $pickle = serialize($backlinks);
        $file = $this->_pageTemplateMetaFN($page);
        io_makeFileDir($file);
        io_saveFile($file, $pickle);
        return;
    }
 
    function _load($page) {
        $file = $this->_pageTemplateMetaFN($page);
        $backlinks = array();
        if ( file_exists($file) ) {
            $contents = io_readFile($file);
            $backlinks = unserialize($contents);
        }
        return $backlinks;
    }
 
    function insert($backlink) {
        $to = $backlink[1];
        $context = $backlink[4];
        $context = getNS($context);
        $to = resolve_id($context,$to);
        $backlinks = $this->_load($to);
        foreach ($backlinks as $bl) {
            if ($bl == $backlink) return;
        }
        $backlinks[] = $backlink;
        $this->_save($backlinks, $to);
        return;
    }
 
    function _verifyLink($backlink, $to) {
        //absolute search id
        $to = cleanID($to);
 
        $page = $backlink[4];
        $file = wikiFN($page);
        if (!file_exists($file)) return false;
 
        //fetch instructions
        global $__PAGETEMPLATE_ID;
        $__PAGETEMPLATE_ID = $page;
        $instructions = _pt_get_instructions(io_readfile($file));
        if(is_null($instructions)) return false;
        $ret = false;
 
        //check all links for match
        foreach($instructions as $ins){
          if($ins[0] == 'plugin' && $ins[1][0] == 'pagetemplate' && strlen($ins[1][1][0]) > 0) {
            $mid = $ins[1][1][1];
            resolve_pageid(getNS($page),$mid,$exists); //exists is not used
            if($mid == $to){
              //we have a match - finish
              $ins[1][1][1] = resolve_id($cns,$ins[1][1][1]);
              $ins[1][1][2] = resolve_id($cns,$ins[1][1][2]);
              $backlink = $ins[1][1];
              return $backlink;
            }
          }
        }
        return false;
    }
 
    function _pageTemplateMetaFN($raw_id,$rev='',$clean=true){
      global $conf;
 
      $id = cleanID($raw_id);
      $id = str_replace(':','/',$raw_id);
      $id .= '.link';
      $backlinkDir = DOKU_PLUGIN.'/pagetemplate';
      $backlinkDir .= '/cache';
      $fn = $backlinkDir.'/'.utf8_encodeFN($id);
      io_makeFileDir($fn);
      return $fn;
    }
 
    function _pt_get_instructions($text) {
    // get the instructions
    // Create the parser
    $Parser = & new Doku_Parser();
 
    // Add the Handler
    $Parser->Handler = & new Doku_Handler();
 
    //add modes to parser
    $pagetemplate_obj =& plugin_load('syntax','pagetemplate');
    $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');
    foreach($std_modes as $m){
      $class = "Doku_Parser_Mode_$m";
      $obj   = new $class();
      $mode = array(
                   'sort' => $obj->getSort(),
                   'mode' => $m,
                   'obj'  => $obj
                 );
      $Parser->addMode($m,$obj);    
    }
    $Parser->addMode('plugin_pagetemplate',$pagetemplate_obj);
    // Do the parsing
    $p = $Parser->parse($text);
    return $p;
  }
 
}

/lib/plugins/pagetemplate/syntax.php

syntax.php
<?php
/**
 * pagetemplate plugin
 *
 * @license    GPL 2 (http://www.gnu.org/licenses/gpl.html)
 * @author     Luke Howson <mail@lukehowson.com>
 */
if(!defined('DOKU_INC')) define('DOKU_INC',realpath(dirname(__FILE__).'/../../').'/');
if(!defined('DOKU_PLUGIN')) define('DOKU_PLUGIN',DOKU_INC.'lib/plugins/');
require_once(DOKU_PLUGIN.'syntax.php');
require_once('pagetemplate_backlinks.php');
 
class syntax_plugin_pagetemplate extends DokuWiki_Syntax_Plugin {
 
    function getSort(){ return 15; }
 
    /**
     * Connect pattern to lexer
     */
    function connectTo($mode) {
      $this->Lexer->addEntryPattern('\[\[\[.*?(?=.*?\]\]\])',$mode,'plugin_pagetemplate');
    }
 
    function postConnect() {
      $this->Lexer->addEntryPattern('\[\[\[.*?(?=.*?\]\]\])','base','plugin_pagetemplate');
      $this->Lexer->addExitPattern('\]\]\]', 'plugin_pagetemplate');
    }
 
    /**
     * General Info
     *
     * Needs to return a associative array with the following values:
     *
     * author - Author of the plugin
     * email  - Email address to contact the author
     * date   - Last modified date of the plugin in YYYY-MM-DD format
     * name   - Name of the plugin
     * desc   - Short description of the plugin (Text only)
     * url    - Website with more information on the plugin (eg. syntax description)
     */
    function getInfo(){
      return array(
        'author' => 'Luke Howson',
        'email'  => 'mail@lukehowson.com',
        'date'   => '2007-07-23',
        'name'   => 'PageTemplate Plugin',
        'desc'   => "links to a page. If the specified page doesn't exist, it creates a templated version",
      );
    }
 
    /**
     * Syntax Type
     *
     * Needs to return one of the mode types defined in $PARSER_MODES in parser.php
     */
    function getType(){ return 'container';}
 
    /**
     * Allowed Mode Types
     *
     * Defines the mode types for other dokuwiki markup that maybe nested within the
     * plugin's own markup. Needs to return an array of one or more of the mode types
     * defined in $PARSER_MODES in parser.php
     */
    function getAllowedTypes() {
        return array('container', 'substition', 'protected', 'disabled', 'formatting', 'paragraphs'); }
 
    /**
     * Paragraph Type
     *
     * Defines how this syntax is handled regarding paragraphs. This is important
     * for correct XHTML nesting. Should return one of the following:
     *
     * 'normal' - The plugin can be used inside paragraphs
     * 'block'  - Open paragraphs need to be closed before plugin output
     * 'stack'  - Special case. Plugin wraps other paragraphs.
     *
     * @see Doku_Handler_Block
     */
    function getPType(){
        return 'normal';
    }
 
    /**
     * Handler to prepare matched data for the rendering process
     *
     * This function can only pass data to render() via its return value - render()
     * may be not be run during the object's current life.
     *
     * Usually you should only need the $match param.
     *
     * @param   $match   string    The text matched by the patterns
     * @param   $state   int       The lexer state for the match
     * @param   $pos     int       The character position of the matched text
     * @param   $handler ref       Reference to the Doku_Handler object
     * @return  array              Return an array with all data you want to use in render
     */
    function handle($match, $state, $pos, Doku_Handler $handler){         
        switch ($state) {
            case DOKU_LEXER_ENTER:
                $data = (substr($match, 3, -1));
                return array(1, $data);
 
            case DOKU_LEXER_MATCHED:
                return array(2, $match);
 
            case DOKU_LEXER_UNMATCHED:
                global $__PAGETEMPLATE_ID;
                global $conf;
                if ($__PAGETEMPLATE_ID) $cNS = $__PAGETEMPLATE_ID;
                else { $cNS = getID();
                  $cNS = getNS($cNS);
                }
                $cNS = $cNS ? $cNS : $conf['start'];
                $match = split('\?',$match);
                $pageName = $match[0];
                $match = split('\|',$match[1]);
                $templatePage = $match[0];
                $displayName = $match[1];
                $lib = new PageTemplateBacklink;
                $backlink = array('pagetemplate', $pageName, $templatePage, $displayName, $cNS);
                $lib->insert($backlink);
                return $backlink;                
            case DOKU_LEXER_EXIT:
                return array(4, '');
 
        }       
        return false;
    }
 
    /**
     * Handles the actual output creation.
     *
     * The function must not assume any other of the classes methods have been run
     * during the object's current life. The only reliable data it receives are its
     * parameters.
     *
     * The function should always check for the given output format and return false
     * when a format isn't supported.
     *
     * $renderer contains a reference to the renderer object which is
     * currently handling the rendering. You need to use it for writing
     * the output. How this is done depends on the renderer used (specified
     * by $format
     *
     * The contents of the $data array depends on what the handler() function above
     * created
     *
     * @param   $format   string   output format being rendered
     * @param   $renderer ref      reference to the current renderer object
     * @param   $data     array    data created by handler()
     * @return  boolean            rendered correctly?
     */
    function render($format, Doku_Renderer $renderer, $data) {
        if ($data[0] != 'pagetemplate') return;
        $pageName = $data[1];
        $displayName = $data[3];
        $renderer->doc .= html_wikilink($pageName,$displayName);
        return;
    }
 
    /**
     *  There should be no need to override these functions
     */
    function accepts($mode) {
 
        if (!$this->allowedModesSetup) {
            global $PARSER_MODES;
 
            $allowedModeTypes = $this->getAllowedTypes();
            foreach($allowedModeTypes as $mt) {
                $this->allowedModes = array_merge($this->allowedModes, $PARSER_MODES[$mt]);
            }
 
            $idx = array_search(substr(get_class($this), 7), $this->allowedModes);
            if ($idx !== false) {
              unset($this->allowedModes[$idx]);
            }
            $this->allowedModesSetup = true;
        }
 
        return parent::accepts($mode);
    }
 
    // plugin introspection methods
    // extract from class name, format = <plugin type>_plugin_<name>[_<component name>]
    function getPluginType() { list($t) = explode('_', get_class($this), 2); return $t;  }
    function getPluginName() { list($t, $p, $n) = explode('_', get_class($this), 4); return $n; }
    function getPluginComponent() { list($t, $p, $n, $c) = explode('_', get_class($this), 4); return (isset($c)?$c:''); }
 
    // localisation methods
    /**
     * getLang($id)
     *
     * use this function to access plugin language strings
     * to try to minimise unnecessary loading of the strings when the plugin doesn't require them
     * e.g. when info plugin is querying plugins for information about themselves.
     *
     * @param   $id     id of the string to be retrieved
     * @return  string  string in appropriate language or english if not available
     */
    function getLang($id) {
      if (!$this->localised) $this->setupLocale();
 
      return (isset($this->lang[$id]) ? $this->lang[$id] : '');
    }
 
    /**
     * locale_xhtml($id)
     *
     * retrieve a language dependent wiki page and pass to xhtml renderer for display
     * plugin equivalent of p_locale_xhtml()
     *
     * @param   $id     id of language dependent wiki page
     * @return  string  parsed contents of the wiki page in xhtml format
     */
    function locale_xhtml($id) {
      return p_cached_output($this->localFN($id));
    }
 
    /**
     * localFN($id)
     * prepends appropriate path for a language dependent filename
     * plugin equivalent of localFN()
     */
    function localFN($id) {
      global $conf;
      $plugin = $this->getPluginName();
      $file = DOKU_PLUGIN.$plugin.'/lang/'.$conf['lang'].'/'.$id.'.txt';
      if(!@file_exists($file)){
        //fall back to english
        $file = DOKU_PLUGIN.$plugin.'/lang/en/'.$id.'.txt';
      }
      return $file;
    }
 
    /**
     *  setupLocale()
     *  reads all the plugins language dependent strings into $this->lang
     *  this function is automatically called by getLang()
     */
    function setupLocale() {
        if ($this->localised) return;
 
      global $conf;            // definitely don't invoke "global $lang"
      $path = DOKU_PLUGIN.$this->getPluginName().'/lang/';
 
      // don't include once, in case several plugin components require the same language file
      @include($path.'en/lang.php');
      if ($conf['lang'] != 'en') @include($path.$conf['lang'].'/lang.php');
 
      $this->lang = $lang;
      $this->localised = true;
    }
 
  // configuration methods
  /**
   * getConf($setting)
   *
   * use this function to access plugin configuration variables
   */
  function getConf($setting){
    if (!$this->configloaded){ $this->loadConfig(); }
    return $this->conf[$setting];
  }
 
  /**
   * loadConfig()
   * merges the plugin's default settings with any local settings
   * this function is automatically called through getConf()
   */
  function loadConfig(){
    global $conf;
 
    $defaults = $this->readDefaultSettings();
    $plugin = $this->getPluginName();
 
    foreach ($defaults as $key => $value) {
      if (isset($conf['plugin'][$plugin][$key])) continue;
      $conf['plugin'][$plugin][$key] = $value;
    }
 
    $this->configloaded = true;
    $this->conf =& $conf['plugin'][$plugin];
  }
 
  /**
   * read the plugin's default configuration settings from conf/default.php
   * this function is automatically called through getConf()
   *
   * @return    array    setting => value
   */
  function readDefaultSettings() {
 
    $path = DOKU_PLUGIN.$this->getPluginName().'/conf/';
    $conf = array();
 
    if (@file_exists($path.'default.php')) {
      include($path.'default.php');
    }
 
    return $conf;
  }
 
}
//Setup VIM: ex: et ts=4 enc=utf-8 :
plugin/pagetemplate/listing.txt · Last modified: 2015-10-02 13:02 by Aleksandr