XSLTransformer.inc.php

<?php
 
// The default character encoding
define('XSLT_PROCESSOR_ENCODING', Config::getVar('i18n', 'client_charset'));
 
define('XSL_TRANSFORMER_DOCTYPE_STRING', 0x01);
define('XSL_TRANSFORMER_DOCTYPE_FILE', 0x02);
define('XSL_TRANSFORMER_DOCTYPE_DOM', 0x03);
 
class XSLTransformer {
 
   static $processor;
 
   static $externalCommand;
 
   static $externalParameterSnippet;
 
   var $parameters;
 
   var $registerPHPFunctions;
 
   var $errors;
 
   function __construct() {
      // Necessary to fetch configuration.
      self::checkSupport();
 
      $this->errors = array();
   }
 
   static function checkSupport() {
      self::$externalCommand = Config::getVar('cli', 'xslt_command');
      self::$externalParameterSnippet = Config::getVar('cli', 'xslt_parameter_option');
 
      // Determine the appropriate XSLT processor for the system
      if (self::$externalCommand) {
         // check the external command to check for %xsl and %xml parameter substitution
         if ( strpos(self::$externalCommand, '%xsl') === false ) return false;
         if ( strpos(self::$externalCommand, '%xml') === false ) return false;
         self::$processor = 'External';
 
      } elseif (extension_loaded('xsl') && extension_loaded('dom')) {
         // XSL/DOM modules present
         self::$processor = 'PHP';
 
      } else {
         // no XSLT support
         return false;
      }
      return true;
   }
 
   //
   // Getters and Setters
   //
   static function getProcessor() {
      return self::$processor;
   }
 
   function setParameters($parameters) {
      $this->parameters = $parameters;
   }
 
   function setRegisterPHPFunctions($flag) {
      $this->registerPHPFunctions = $flag;
   }
   //
   // Public methods
   //
   function transformFiles($xmlFile, $xslFile) {
      return $this->transform($xmlFile, XSL_TRANSFORMER_DOCTYPE_FILE, $xslFile, XSL_TRANSFORMER_DOCTYPE_FILE, XSL_TRANSFORMER_DOCTYPE_STRING);
   }
 
   function transformStrings($xml, $xsl) {
      return $this->transform($xml, XSL_TRANSFORMER_DOCTYPE_STRING, $xsl, XSL_TRANSFORMER_DOCTYPE_STRING, XSL_TRANSFORMER_DOCTYPE_STRING);
   }
 
   function transform($xml, $xmlType, $xsl, $xslType, $resultType) {
      // If either XML or XSL file don't exist, then fail without trying to process XSLT
      $fileManager = new FileManager();
      if ($xmlType == XSL_TRANSFORMER_DOCTYPE_FILE) {
         if (!$fileManager->fileExists($xml)) return false;
      }
      if ($xslType == XSL_TRANSFORMER_DOCTYPE_FILE) {
         if (!$fileManager->fileExists($xsl)) return false;
      }
 
      // The result type can only be string or DOM
      assert($resultType != XSL_TRANSFORMER_DOCTYPE_FILE);
 
      switch (self::$processor) {
         case 'External':
            return $this->_transformExternal($xml, $xmlType, $xsl, $xslType, $resultType);
 
         case 'PHP':
            return $this->_transformPHP($xml, $xmlType, $xsl, $xslType, $resultType);
 
         default:
            // No XSLT processor available
            return false;
      }
   }
 
   //
   // Private helper methods
   //
   function _transformExternal($xml, $xmlType, $xsl, $xslType, $resultType) {
 
      // External transformation can only be done on files
      if ($xmlType != XSL_TRANSFORMER_DOCTYPE_FILE || $xslType != XSL_TRANSFORMER_DOCTYPE_FILE) return false;
 
      // check the external command to check for %xsl and %xml parameter substitution
      if ( strpos(self::$externalCommand, '%xsl') === false ) return false;
      if ( strpos(self::$externalCommand, '%xml') === false ) return false;
 
      // Assemble the parameters to be supplied to the stylesheet
      $parameterString = '';
      foreach ($this->parameters as $name => $value) {
         $parameterString .= str_replace(array('%n', '%v'), array($name, $value), self::$externalParameterSnippet);
      }
 
      // perform %xsl and %xml replacements for fully-qualified shell command
      $xsltCommand = str_replace(array('%xsl', '%xml', '%params'), array($xsl, $xml, $parameterString), self::$externalCommand);
 
      // check for safe mode and escape the shell command
      if( !ini_get('safe_mode') ) $xsltCommand = escapeshellcmd($xsltCommand);
 
      // run the shell command and get the results
      exec($xsltCommand . ' 2>&1', $contents, $status);
 
      // if there is an error state, copy result to error property
      if ($status != false) {
         if ($contents) {
            $this->addError(implode("\n", $contents));
         }
         // completed with errors
         return false;
      }
 
      $resultXML = implode("\n", $contents);
 
      switch ($resultType) {
         case XSL_TRANSFORMER_DOCTYPE_STRING:
            // Directly return the XML string
            return $resultXML;
 
         case XSL_TRANSFORMER_DOCTYPE_DOM:
            // Instantiate and configure the result DOM
            $resultDOM = new DOMDocument('1.0', XSLT_PROCESSOR_ENCODING);
            $resultDOM->recover = true;
            $resultDOM->substituteEntities = true;
            $resultDOM->resolveExternals = true;
 
            // Load the XML and return the DOM
            $resultDOM->loadXML($resultXML);
            return $resultDOM;
 
         default:
            assert(false);
      }
   }
 
   function _transformPHP($xml, $xmlType, $xsl, $xslType, $resultType) {
      // Prepare the XML DOM
      if ($xmlType == XSL_TRANSFORMER_DOCTYPE_DOM) {
         // We already have a DOM document, no need to create one
         assert(is_a($xml, 'DOMDocument'));
         $xmlDOM = $xml;
      } else {
         // Instantiate and configure the XML DOM document
         $xmlDOM = new DOMDocument('1.0', XSLT_PROCESSOR_ENCODING);
 
         // These are required for external entity resolution (eg. &nbsp;), but can slow processing
         // substantially (20-100x), often up to 60s.  This can be solved by use of local catalogs, ie.
         // putenv("XML_CATALOG_FILES=/path/to/catalog.ent");
         //
         // see:  http://www.whump.com/moreLikeThis/link/03815
         $xmlDOM->recover = true;
         $xmlDOM->substituteEntities = true;
         $xmlDOM->resolveExternals = true;
 
         // Load the XML based on its type
         switch ($xmlType) {
            case XSL_TRANSFORMER_DOCTYPE_FILE:
               $xmlDOM->load($xml);
               break;
 
            case XSL_TRANSFORMER_DOCTYPE_STRING:
               $xmlDOM->loadXML($xml);
               break;
 
            default:
               assert(false);
         }
      }
 
      // Prepare the XSL DOM
      if ($xslType == XSL_TRANSFORMER_DOCTYPE_DOM) {
         // We already have a DOM document, no need to create one
         assert(is_a($xsl, 'DOMDocument'));
         $xslDOM = $xsl;
      } else {
         // Instantiate the XSL DOM document
         $xslDOM = new DOMDocument('1.0', XSLT_PROCESSOR_ENCODING);
 
         // Load the XSL based on its type
         switch ($xslType) {
            case XSL_TRANSFORMER_DOCTYPE_FILE:
               $xslDOM->load($xsl);
               break;
 
            case XSL_TRANSFORMER_DOCTYPE_STRING:
               $xslDOM->loadXML($xsl);
               break;
 
            default:
               assert(false);
         }
      }
 
      // Create and configure the XSL processor
      $processor = new XSLTProcessor();
 
      // Register PHP functions if requested.
      // NB: This can open potential security issues; see FAQ/README
      if ($this->registerPHPFunctions) {
         $processor->registerPHPFunctions();
      }
 
      // Set XSL parameters (if any)
      if (is_array($this->parameters)) {
         foreach ($this->parameters as $param => $value) {
            $processor->setParameter(null, $param, $value);
         }
      }
 
      //  Import the style sheet
      $processor->importStylesheet($xslDOM);
 
      // Process depending on the requested result type
      switch($resultType) {
         case XSL_TRANSFORMER_DOCTYPE_STRING:
            $resultXML = $processor->transformToXML($xmlDOM);
            return $resultXML;
 
         case XSL_TRANSFORMER_DOCTYPE_DOM:
            $resultDOM = $processor->transformToDoc($xmlDOM);
            return $resultDOM;
 
         default:
            assert(false);
      }
   }
 
   function addError($error) {
      array_push($this->errors, $error);
   }
}