xref: /plugin/dokutexit/config.php

<?php
/**
 * texit multifunction Class
 * Copyright (C) 2013   Elie Roux <elie.roux@telecom-bretagne.eu>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * --------------------------------------------------------------------
 *
 */
if(!defined('DOKU_INC')) die();
if(!defined('DOKU_PLUGIN')) define('DOKU_PLUGIN',DOKU_INC.'lib/plugins/');
if(!defined('PLUGIN_TEXIT')) define('PLUGIN_TEXIT',DOKU_PLUGIN.'texit/');
if(!defined('PLUGIN_TEXIT_CONF')) define('PLUGIN_TEXIT_CONF',PLUGIN_TEXIT.'conf/');
require_once(PLUGIN_TEXIT.'texitrender.php');

class config_plugin_texit {
  var $id;
  var $ns;
  var $namespace_mode;
  var $nsbpc;
  var $conf;
  var $mediadir;
  var $texitdir;
  var $prfix;
  var $all_files;
  var $texit_render_obj; // not initialized by constructor, done only if needed
  var $bibfn;
 /*
  * I didn't use a helper plugin because I needed a constructor.
  * This basically sets up the environment by computing base the filenames, etc.
  *
  */
  function __construct($id, $namespace_mode, $conf, $nsbpc_obj) {
    $this->id = cleanID($id);
    $this->ns = getNS(cleanID($id));
    $this->namespace_mode = $namespace_mode;
    $this->nsbpc = $nsbpc_obj;
    $this->conf = $conf;
    $this->set_prefix();
    $this->_set_texit_dir();
    $this->_set_media_dir();
    $this->bibfn = $this->generate_bib();
    $this->get_all_files();
    $this->conf['latexentities'] = false; // we generate it at compile time
    $this->texit_render_obj = false;
  }
 /*
  * This function sets $this->latexentities to an array where keys are
  * the initial characters and values are the characters escaped in
  * LaTeX (ex: _ => \_). It gets in by calling conftohash on conf/entities.cfg
  * in the plugin's directory.
  */
  function get_entities() {
    $basefn = PLUGIN_TEXIT_CONF.'entities.cfg';
    return $this->confToHash($basefn);
  }

  /**
  * Builds a hash from a configfile
  *
  * If $lower is set to true all hash keys are converted to
  * lower case.
  *
  * This is a modified version of Dokuwiki's function
  * that doesn't consider # as a comment character (we
  * need it for LaTeX entities).
  */
  function confToHash($file) {
    $conf = array();
    $lines = @file( $file );
    if ( !$lines ) return false;
    foreach ( $lines as $line ) {
      $line = trim($line);
      if(empty($line)) continue;
      $line = preg_split('/[\s\t]+/',$line,2);
      // Build the associative array
      $conf[$line[0]] = $line[1];
    }
    return $conf;
  }

 /*
  * This function (eventually) generates the file texit.bib, in the directory
  * of the namespace pointed by the "reference-db-enable" configuration option
  * of the refnotes plugin.
  *
  * To do so, it merges:
  *   - the BibTeX parts of all pages in the refnotes's database namespace
  *       ("refnotes" by default)
  *   - the conf/bibliography.bib in the texit plugin directory
  */
  function generate_bib() {
    global $conf;
    $bibtext = ''; // we merge all the files in this string
    $basefn = PLUGIN_TEXIT_CONF.'bibliography.bib';
    if (!is_callable("refnotes_configuration::getSetting")) {
      // case where refnotes isn't available. In this case the
      // file to include is just $basefn.
      return $basefn;
    }
    // code coming from refnotes' syntax.php
    $refnotes_nsdir = refnotes_configuration::getSetting('reference-db-namespace');
    $refnotes_nsdir = str_replace(':', '/', $refnotes_nsdir);
    $refnotes_nsdir = trim($refnotes_nsdir, '/ ');
    $destfn = $conf['datadir'].'/'.$refnotes_nsdir.'/texit.bib';
    $all_refnotes_pages = Array();
    $opts = array('listdirs'  => false,
      'listfiles' => true,
      'pagesonly' => true,
      'skipacl'   => false, // to check for read right
      'sneakyacl' => true,
      'showhidden'=> false,
      );
    // we cannot use $opts in search_list or in search_namespaces, see
    // https://bugs.dokuwiki.org/index.php?do=details&task_id=2858
    search($all_refnotes_pages,$conf['datadir'],'search_universal',$opts,$refnotes_nsdir);
    // now all_refnotes_pages contains all the configuration pages of refnotes, that
    // we'll have to merge...
    // First step here is to see if we need to recompile anything:
    if (is_readable($destfn)) {
      // if the file is readable, then it might be up-to-date?
      $needsupdate = false;
      if (is_readable($basefn)) {
        $needsupdate = $this->_needs_update($basefn, $destfn);
      }
      foreach ($all_refnotes_pages as $page) {
        // A problem here: if the refnote page doesn't contain
        // any bibtex code, the update will take place anyway,
        // but it doesn't sound critical.
        if ($this->_needs_update(wikiFN($page['id']), $destfn)) {
          $needsupdate = true;
        }
      }
      // if the file doesn't need update, we just return.
      if (!$needsupdate) {
        return $destfn;
      }
    }
    if (is_readable($basefn)) {
      $bibtext = file_get_contents($basefn);
    }
    foreach($all_refnotes_pages as $page) {
      $fn = wikiFN($page['id']);
      $bibtext .= $this->parse_refnotes_page($fn);
    }
    if (empty($bibtext)) {
      return false;
    }
    file_put_contents($destfn, $bibtext);
    // we return the filename where the bibliography is saved
    return $destfn;
  }

  function parse_refnotes_page ($fn) {
    $filestr = file_get_contents($fn);
    preg_match_all('#(?<=<code bibtex>)(((?!</code>).)*)(?=</code>)#ms', $filestr, $matches);
    $return = '';
    foreach($matches[0] as $match) {
      $return .= $match."\n";
    }
    return $return;
  }

  function set_prefix() {
    if (!$this->conf['use_prefix']) {
      $this->prefix = '';
      return;
    } else {
      if (!empty($this->conf['pre_prefix'])) {
        $this->prefix = $this->conf['pre_prefix'].":";
      }
      $this->prefix .= $this->ns;
      if ($this->conf['prefix_separator']) {
        $this->prefix = str_replace(':', $this->conf['prefix_separator'], $this->prefix);
        $this->prefix .= $this->conf['prefix_separator'];
      } // else we keep it this way
    }
  }

  function _create_dir($path) {
    global $conf;
    $res = init_path($path);
    if(empty($res)) {
      // let's create it, recursively
      $res = io_mkdir_p($path);
      //$res = mkdir($path, $conf['dmode'], true);
      if(!$res){
        die("Unable to create directory $path, please create it.");
      }
    }
  }

// This function escapes a filename so that it doesn't contain _ character:
  function _escape_fn($fn) {
    $bn = basename($fn);
    $bn = str_replace('_', '-', $bn);
    $dn = dirname($fn);
    if ($dn == ".") {
      return $bn;
    }
    return dirname($fn).'/'.$bn;
  }

  function _set_media_dir() {
    global $conf;
    $path = $conf['mediadir'];
    $path .= '/'.str_replace(':','/',$this->ns);
    // taken from init_paths in inc/init.php
    $this->_create_dir($path);
    $this->mediadir = $path;
  }

  function _set_texit_dir() {
    global $conf;
    $path = $this->conf['texitdir'];
    // taken from init_paths in inc/init.php
    $path = empty($path) ? $conf['datadir'].'/../texit' : $path;
    $path .= '/'.str_replace(':','/',$this->ns);
    $this->_create_dir($path);
    $path = realpath($path);
    $this->texitdir = $path;
  }

  function get_zip_fn() {
    return $this->mediadir.'/'.$this->get_common_basename().".zip";
  }

  function get_base_bib_fn() {
    return $this->bibfn;
  }

  function get_dest_bib_fn() {
    // we always call it texit.bib for practical reasons, this may
    // change in the future
    return $this->texitdir.'/'.'texit.bib';
  }

  function get_pdf_media_fn() {
    return $this->mediadir.'/'.$this->prefix.$this->get_common_basename().".pdf";
  }

  function get_pdf_media_id() {
    return $this->ns.':'.$this->prefix.$this->get_common_basename().".pdf";
  }

  function get_pdf_texit_fn() {
    return $this->texitdir.'/'.$this->get_common_basename().".pdf";
  }



 /* This returns 'all' if in namespace-mode, or the escaped ID, without extension.
  *
  */
  function get_common_basename() {
    if ($this->namespace_mode) {
      return "all";
    } else {
      return $this->_escape_fn(noNS($this->id));
    }
  }

  /* This returns the full path of the base header file we take as reference
   * for this compilation. In case nothing is found, false is returned.
   */
  function get_base_header_fn() {
    // first we look for nsbpc headers
    // the names are 'texit-namespace' or 'texit-page'
    $header_name = "texit-page";
    if ($this->namespace_mode) {
      $header_name = "texit-namespace";
    }
    $found = $this->nsbpc->getConfFN($header_name, $this->ns);
    if ($found) {
      return $found;
    }
    // No nsbpc configuration was found, now looking in the conf/ directory of
    // the plugin. Names are different here...
    $header_name = "header-page.tex";
    if ($this->namespace_mode) {
      $header_name = "header-namespace.tex";
    }
    if (is_readable(PLUGIN_TEXIT_CONF.$header_name)) {
      return PLUGIN_TEXIT_CONF.$header_name;
    }
    return false;
  }

  /* This returns the full path of the header file we want in the destination
   * texit namespace.
   */
  function get_dest_header_fn() {
    if ($this->namespace_mode) {
      return $this->texitdir."/all.tex";
    } else {
      return $this->texitdir.'/'.$this->get_common_basename().".tex";
    }
  }
  /* This returns the full path of the base footer file we take as reference
   * for this compilation, or false if there is no such file.
   */
  function get_base_footer_fn() {
    // first we look through nsbpc
    $found = $this->nsbpc->getConfFN("texit-footer", $this->ns);
    if ($found) {
      return $found;
    }
    // No nsbpc configuration was found, now looking in the conf/ directory of
    // the plugin.
    if (is_readable(PLUGIN_TEXIT_CONF."footer.tex")) {
      return PLUGIN_TEXIT_CONF."footer.tex";
    }
    return false;
  }
  /* This returns the full path of the commands file we want in the destination
   * texit namespace.
   */
  function get_dest_footer_fn() {
    return $this->texitdir."/footer.tex";
  }
  /* This returns the full path of the base coommands file we take as reference
   * for this compilation.
   */
  function get_base_commands_fn() {
    // first we look through nsbpc
    $found = $this->nsbpc->getConfFN("texit-commands", $this->ns);
    if ($found) {
      return $found;
    }
    // No nsbpc configuration was found, now looking in the conf/ directory of
    // the plugin.
    if (is_readable(PLUGIN_TEXIT_CONF."commands.tex")) {
      return PLUGIN_TEXIT_CONF."commands.tex";
    }
    return false;
  }
  /* This returns the full path of the commands file we want in the destination
   * texit namespace.
   */
  function get_dest_commands_fn() {
    return $this->texitdir."/commands.tex";
  }

 /* This function returns an array of all IDs of pages to be rendered by TeXit.
  *
  */
  function get_all_IDs() {
    global $conf;
    if ($this->namespace_mode) {
      $list = array();
      $nsdir = str_replace(':', '/', $this->ns);
      $opts = array('listdirs'  => false,
                    'listfiles' => true,
                    'pagesonly' => true,
                    'depth'     => 1,
                    'skipacl'   => false, // to check for read right
                    'sneakyacl' => true,
                    'showhidden'=> false,
                    );
	  if ($this->conf['includestart'] == false) {
	    $opts['idmatch'] = "^((?!start$).)+$";
      }
      search($list,$conf['datadir'],'search_universal',$opts,$nsdir);
      return $list;
    } else {
      return array(array('id' => $this->id));
    }
  }

 /* Returns an array with base and destination filenames. Works with full paths.
  *
  * The returned array has the following structure:
  *    [base] => (type, fn)
  * where:
  *  * base is the base filename (like /path/to/dkwiki/pages/ns/id.txt)
  *  * type is either "header", "commands", "tex" or "bib".
  *  * fn is the absolute destination filename (prefix included)
  */
  function get_all_files() {
   // this gives us all the page ids that need txt->tex conversion:
   $id_array = $this->get_all_IDs();
   $result = array();
   // now we put them all in the $result array
   foreach($id_array as $value) {
     if (!is_array($value) || !$value['id']) { // I did'nt find any more elegant way to do so
       continue;
     }
     $fn = wikiFN($value['id']);
     $dest = $this->texitdir.'/'.noNS($value['id'])."-content.tex";
     $dest = $this->_escape_fn($dest);
     $result[$fn] = array('type' => 'tex', 'fn' => $dest);
   }
   // and we add the header and command
   $base = $this->get_base_header_fn();
   if (!$base) {
     nice_die("TeXit: Unable to find a header file!");
   }
   $result[$base] = array('type' => 'header', 'fn' => $this->get_dest_header_fn());
   $base = $this->get_base_commands_fn();
   if (!$base) {
     nice_die("TeXit: Unable to find a commands file!");
   }
   $result[$base] = array('type' => 'commands', 'fn' => $this->get_dest_commands_fn());
   $bib = $this->get_base_bib_fn();
   if ($bib) { // not mandatory
     $result[$bib] = array('type' => 'bib', 'fn' => $this->get_dest_bib_fn());
   }
   $footer = $this->get_base_footer_fn();
   if ($footer) { // not mandatory
     $result[$footer] = array('type' => 'footer', 'fn' => $this->get_dest_footer_fn());
   }
   $this->all_files = $result;
  }

 /* This function takes three arguments:
  *    * base is the full path of the base header file
  *           (for instance /path/to/dkwiki/lib/plugin/texit/conf/header-page.tex)
  *    * dest is the full path of the destination header file
  *    * all_files is the table returned by get_all_files()
  *
  * It reads $base, adds \input lines for $all_files and writes the result in
  * $dest.
  */
  function compile_header($base, $dest, $all_files) {
    // first we simply copy the file
    $this->simple_copy($base, $dest);
    // we prepare a string to append at the end:
    $toappend = "\n";
    // we spot the last value:
    $beginning = 1;
    $footer = false;
    foreach($this->all_files as $value) {
      switch($value['type']) {
        case 'tex':
          // between two different files, we call the \dokuinternspagedo
          // macro, doing nothing by default.
          if (!$beginning) {
            $toappend .= "\\dokuinternspagedo\n\n";
          }
          $toappend .= '\dokuinclude{'.basename($value['fn'], '.tex')."}\n\n";
          break;
        case 'footer':
          $footer = basename($value['fn'], '.tex');
        default:
          break;
      }
      $beginning = 0;
    }
    if ($footer) {
      $toappend .= "\dokuinclude{".$footer."}\n";
    }
    $toappend .= "\n\\end{document}";
    // the we open it in append mode to write things at the end:
    file_put_contents($dest, $toappend, FILE_APPEND);
  }

 /* This function takes two arguments:
  *    * base is the full path of the base page file
  *           (for instance /path/to/dkwiki/data/pages/ns/id.txt)
  *    * dest is the full path of the destination tex file
  *
  * It reads $base, renders it into TeX and writes $dest.
  */
  function compile_tex($base, $dest) {
    if (!$this->conf['latexentities'])
      {
        $this->conf['latexentities'] = $this->get_entities();
      }
    if (!$this->texit_render_obj)
      {
        $this->texit_render_obj = new texitrender_plugin_texit($this);
      }
    $this->texit_render_obj->process($base, $dest);
  }

 /* This function takes two arguments:
  *    * base is the full path of the base file
  *    * dest is the full path of the destination tex file
  *
  * It copies $base into $dest.
  */
  function simple_copy($base, $dest) {
    if (!copy($base, $dest)) {
      nice_die("TeXit: unable to copy $base into $dest.");
    }
  }

 /*
  * This functions returns true if $base is more recent that $dest, and
  * false otherwise. If $dest doesn't exist, then we consider it needs
  * update and thus return true.
  */
  function _needs_update($base, $dest) {
    if (!file_exists($dest) || !file_exists($dest)) {
        return true;
      }
    return filemtime($base) > filemtime($dest);
  }

 /* This function sets the TeX compilation environment up by copying the files
  * in the good folders and renames them. It uses file modification timestamps
  * to evaluate if files need to be recompiled or recopied.
  *
  * The returned value is a boolean: true if something has been updated, and
  * false otherwise.
  */
  function setup_files() {
    if (!is_array($this->all_files)) {
        $this->get_all_files();
      }
    if (!is_array($this->all_files)) {
        die("TeXit: cannot analyze files");
      }
    $needsupdate = false;
    foreach($this->all_files as $base => $dest) {
      $destfn = $dest['fn'];
      if ($this->_needs_update($base, $destfn)) {
        $needsupdate = true;
        switch($dest['type']) {
          case "header":
            $this->compile_header($base, $destfn, $this->all_files);
            break;
          case "commands":
            $this->simple_copy($base, $destfn);
            break;
          case "bib":
            $this->simple_copy($base, $destfn);
            break;
          case "footer":
            $this->simple_copy($base, $destfn);
            break;
          case "tex":
            $this->compile_tex($base, $destfn);
            break;
          default:
            break;
        }
      }
    }
    return $needsupdate;
  }

 /* This function calls latexmk with the good options on the good files.
  */
  function _do_latexmk() {
    if (!is_dir($this->texitdir)) {
      die("TeXit: directory $this->texitdir doesn't exit");
    }
    chdir($this->texitdir);
    $basecmdline = '';
    if (isset($this->conf['latexmk_path'])
      && trim($this->conf['latexmk_path']) != "") {
      $basecmdline = $this->conf['latexmk_path'] . DIRECTORY_SEPARATOR;
    } else {
      $basecmdline = '';
    }
    $cmdline = $basecmdline."latexmk -f ";
    if ($this->bibfn) {
      $cmdline .= "-bibtex ";
    }
    switch ($this->conf['latex_mode'])
    {
      case "latex":
        // TODO: test, comes from http://users.phys.psu.edu/~collins/software/latexmk-jcc/
        $cmdline .= "-e '\$dvipdf = \"dvipdfm %O -o %D %S\";' -pdfdvi ";
        break;
      case "pdflatex":
        $cmdline .= "-pdf ";
        break;
      case "lualatex":
        $cmdline .= "-pdf -pdflatex=lualatex ";
        break;
      case "xelatex":
        $cmdline .= "-latex=xelatex -e '\$dvipdf = \"dvipdfmx %O -o %D %S\";' -pdfdvi ";
        break;
      default:
        // error
        break;
    }
    $file = basename($this->get_dest_header_fn());
    $cmdline .= $file . ' 2>&1 ';
    $ret = 0;
    @exec($cmdline, $output, $ret);
    if ($ret) {
      print("<br/>TeXit error: latexmk returned error code ".$ret."<br/>\n<br/>Log:<br/>\n");
      print_r(implode("<br/>\n", $output));
    }
    // at the end, we clean temporary files. There is currently no way to tell
    // latexmk to clean at the end of the compilation... quite a shame...
    // An email has been written to the author in this sense.
    $cmdline = $basecmdline."latexmk -c 2>&1";
    $log = @exec($cmdline, $output, $ret);
    if ($ret) {
      print("<br/>TeXit error: latexmk -c returned error code ".$ret."<br/>\n<br/>Log:<br/>\n");
      print_r(implode("<br/>\n", $output));
    }
  }

 /* This function zips the good files in the texit namespace in a .zip archive
  * in the media namespace.
  */
  function compile_zip() {
    $zipfn = $this->get_zip_fn();
    // if the file already exists and needs update, remove it.
    if (@file_exists($zipfn)) {
      unlink($zipfn);
    }
    $zip = new ZipArchive();
    if ($zip->open($zipfn, ZipArchive::CREATE) !== true) {
      exit("Unable to create $zipfn\n");
    }
    // First argument of addFile is the absolute, second is the name we want
    // in the archive (in our case, the basename).
    $zip->addFile($this->get_pdf_texit_fn(), basename($this->get_pdf_texit_fn()));
    foreach($this->all_files as $base => $dest) {
      $zip->addFile($dest['fn'], basename($dest['fn']));
    }
    $zip->close();
  }

 /* My mind is too used to C programming and thus this is a bit too
  * iterative and not object-oriented enough...
  *
  * This function processes everything when the user asks for a PDF.
  */
  function process() {
    $needsupdate = $this->setup_files();
    $pdftexitfn  = $this->get_pdf_texit_fn();
    $pdfmediafn  = $this->get_pdf_media_fn();
    $pdfmediaid  = $this->get_pdf_media_id();
    $zipfn       = $this->get_zip_fn();
    if ($needsupdate || !@file_exists($pdftexitfn)) {
      $this->_do_latexmk();
    }
    // then copy the pdf to media
    if ($needsupdate || !@file_exists($pdfmediafn)) {
      $this->simple_copy($pdftexitfn, $pdfmediafn);
    }
    if ($this->conf['use_zip'] && ($needsupdate || !@file_exists($zipfn))) {
        $this->compile_zip();
    }
    return $this->id_to_url($pdfmediaid);
  }

 /* This returns an absolute URL from a media ID.
  */
  function id_to_url($pdfmediaid) {
    // internal dokuwiki function, defined in inc/common.php
    return ml($pdfmediaid, '', true, '&amp;', true);
  }
}

?>