CHIEFSOFT\ameye
394 lines
13 KiB
PHP
394 lines
13 KiB
PHP
<?php
|
|
|
|
/**
|
|
* @file classes/xslt/XSLTransformer.php
|
|
*
|
|
* Copyright (c) 2014-2021 Simon Fraser University
|
|
* Copyright (c) 2000-2021 John Willinsky
|
|
* Distributed under the GNU GPL v3. For full terms see the file docs/COPYING.
|
|
*
|
|
* @class XSLTransformer
|
|
*
|
|
* @ingroup xslt
|
|
*
|
|
* @brief Wrapper class for running XSL transformations.
|
|
*/
|
|
|
|
namespace PKP\xslt;
|
|
|
|
use DOMDocument;
|
|
use PKP\config\Config;
|
|
use PKP\file\FileManager;
|
|
use XSLTProcessor;
|
|
|
|
class XSLTransformer
|
|
{
|
|
public const XSLT_PROCESSOR_ENCODING = 'utf-8';
|
|
public const XSL_TRANSFORMER_DOCTYPE_STRING = 1;
|
|
public const XSL_TRANSFORMER_DOCTYPE_FILE = 2;
|
|
public const XSL_TRANSFORMER_DOCTYPE_DOM = 3;
|
|
|
|
/** @var string determining the XSLT processor to use for this object */
|
|
public static $processor;
|
|
|
|
/** @var string containing external XSLT shell command */
|
|
public static $externalCommand;
|
|
|
|
/** @var string containing external XSLT shell arguments for parameters */
|
|
public static $externalParameterSnippet;
|
|
|
|
/** @var array of parameters to pass to XSL (built-in libraries only) */
|
|
public $parameters;
|
|
|
|
/** @var array of PHP functions to allow in XSL */
|
|
public $registerPHPFunctions;
|
|
|
|
/** @var array List of error strings */
|
|
public $errors;
|
|
|
|
/**
|
|
* Constructor.
|
|
* Initialize transformer and set parser options.
|
|
*
|
|
* @return bool returns false if no XSLT processor could be created
|
|
*/
|
|
public function __construct()
|
|
{
|
|
// Necessary to fetch configuration.
|
|
self::checkSupport();
|
|
|
|
$this->errors = [];
|
|
}
|
|
|
|
/**
|
|
* Fetch configuration and check whether XSLT is properly supported.
|
|
*
|
|
* @return bool True iff XSLT support is present.
|
|
*/
|
|
public 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
|
|
//
|
|
/**
|
|
* Get the processor type
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function getProcessor()
|
|
{
|
|
return self::$processor;
|
|
}
|
|
|
|
/**
|
|
* Set the parameter list for internal processors.
|
|
*
|
|
* @param array $parameters
|
|
*/
|
|
public function setParameters($parameters)
|
|
{
|
|
$this->parameters = $parameters;
|
|
}
|
|
|
|
/**
|
|
* Set the registerPHPFunctions setting on or off.
|
|
*
|
|
* @param bool $flag
|
|
*/
|
|
public function setRegisterPHPFunctions($flag)
|
|
{
|
|
$this->registerPHPFunctions = $flag;
|
|
}
|
|
//
|
|
// Public methods
|
|
//
|
|
/**
|
|
* Apply an XSLT transform to a given XML and XSL source files
|
|
*
|
|
* @param string $xmlFile absolute pathname to the XML source file
|
|
* @param string $xslFile absolute pathname to the XSL stylesheet
|
|
*
|
|
* @return string containing the transformed XML output, or false on error
|
|
*/
|
|
public function transformFiles($xmlFile, $xslFile)
|
|
{
|
|
return $this->transform($xmlFile, self::XSL_TRANSFORMER_DOCTYPE_FILE, $xslFile, self::XSL_TRANSFORMER_DOCTYPE_FILE, self::XSL_TRANSFORMER_DOCTYPE_STRING);
|
|
}
|
|
|
|
/**
|
|
* Apply an XSLT transform to a given XML and XSL strings
|
|
*
|
|
* @param string $xml containing source XML
|
|
* @param string $xsl containing source XSL
|
|
*
|
|
* @return string containing the transformed XML output, or false on error
|
|
*/
|
|
public function transformStrings($xml, $xsl)
|
|
{
|
|
return $this->transform($xml, self::XSL_TRANSFORMER_DOCTYPE_STRING, $xsl, self::XSL_TRANSFORMER_DOCTYPE_STRING, self::XSL_TRANSFORMER_DOCTYPE_STRING);
|
|
}
|
|
|
|
/**
|
|
* Apply an XSLT transform to a given XML and XSL. Both parameters
|
|
* can be either strings, files or DOM objects.
|
|
*
|
|
* @param int $xmlType
|
|
* @param int $xslType
|
|
* @param int $resultType self::XSL_TRANSFORMER_DOCTYPE_...
|
|
*
|
|
* @return mixed return type depends on the $resultType parameter and can be
|
|
* DOMDocument or string. The method returns a boolean value of false if the
|
|
* transformation fails for some reason.
|
|
*/
|
|
public 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 == self::XSL_TRANSFORMER_DOCTYPE_FILE) {
|
|
if (!$fileManager->fileExists($xml)) {
|
|
return false;
|
|
}
|
|
}
|
|
if ($xslType == self::XSL_TRANSFORMER_DOCTYPE_FILE) {
|
|
if (!$fileManager->fileExists($xsl)) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// The result type can only be string or DOM
|
|
assert($resultType != self::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
|
|
//
|
|
/**
|
|
* Use external programs to do the XSL transformation
|
|
*
|
|
* @param int $xmlType
|
|
* @param int $xslType
|
|
* @param int $resultType self::XSL_TRANSFORMER_DOCTYPE_...
|
|
*
|
|
* @return mixed return type depends on the $resultType parameter and can be
|
|
* DOMDocument or string. Returns boolean "false" on error.
|
|
*/
|
|
public function _transformExternal($xml, $xmlType, $xsl, $xslType, $resultType)
|
|
{
|
|
// External transformation can only be done on files
|
|
if ($xmlType != self::XSL_TRANSFORMER_DOCTYPE_FILE || $xslType != self::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(['%n', '%v'], [$name, $value], self::$externalParameterSnippet);
|
|
}
|
|
|
|
// perform %xsl and %xml replacements for fully-qualified shell command
|
|
$xsltCommand = str_replace(['%xsl', '%xml', '%params'], [$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 self::XSL_TRANSFORMER_DOCTYPE_STRING:
|
|
// Directly return the XML string
|
|
return $resultXML;
|
|
|
|
case self::XSL_TRANSFORMER_DOCTYPE_DOM:
|
|
// Instantiate and configure the result DOM
|
|
$resultDOM = new DOMDocument('1.0', static::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);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Use DOMDocument and XSLTProcessor to do the transformation
|
|
*
|
|
* @param int $xmlType
|
|
* @param int $xslType
|
|
* @param int $resultType self::XSL_TRANSFORMER_DOCTYPE_...
|
|
*
|
|
* @return mixed return type depends on the $resultType parameter and can be
|
|
* DOMDocument or string. Returns boolean "false" on error.
|
|
*/
|
|
public function _transformPHP($xml, $xmlType, $xsl, $xslType, $resultType)
|
|
{
|
|
// Prepare the XML DOM
|
|
if ($xmlType == self::XSL_TRANSFORMER_DOCTYPE_DOM) {
|
|
// We already have a DOM document, no need to create one
|
|
assert($xml instanceof DOMDocument);
|
|
$xmlDOM = $xml;
|
|
} else {
|
|
// Instantiate and configure the XML DOM document
|
|
$xmlDOM = new DOMDocument('1.0', static::XSLT_PROCESSOR_ENCODING);
|
|
|
|
// These are required for external entity resolution (eg. ), 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 self::XSL_TRANSFORMER_DOCTYPE_FILE:
|
|
$xmlDOM->load($xml);
|
|
break;
|
|
|
|
case self::XSL_TRANSFORMER_DOCTYPE_STRING:
|
|
$xmlDOM->loadXML($xml);
|
|
break;
|
|
|
|
default:
|
|
assert(false);
|
|
}
|
|
}
|
|
|
|
// Prepare the XSL DOM
|
|
if ($xslType == self::XSL_TRANSFORMER_DOCTYPE_DOM) {
|
|
// We already have a DOM document, no need to create one
|
|
assert($xsl instanceof DOMDocument);
|
|
$xslDOM = $xsl;
|
|
} else {
|
|
// Instantiate the XSL DOM document
|
|
$xslDOM = new DOMDocument('1.0', static::XSLT_PROCESSOR_ENCODING);
|
|
|
|
// Load the XSL based on its type
|
|
switch ($xslType) {
|
|
case self::XSL_TRANSFORMER_DOCTYPE_FILE:
|
|
$xslDOM->load($xsl);
|
|
break;
|
|
|
|
case self::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 self::XSL_TRANSFORMER_DOCTYPE_STRING:
|
|
$resultXML = $processor->transformToXML($xmlDOM);
|
|
return $resultXML;
|
|
|
|
case self::XSL_TRANSFORMER_DOCTYPE_DOM:
|
|
$resultDOM = $processor->transformToDoc($xmlDOM);
|
|
return $resultDOM;
|
|
|
|
default:
|
|
assert(false);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Add an error to the current error list
|
|
*
|
|
* @param string $error
|
|
*/
|
|
public function addError($error)
|
|
{
|
|
array_push($this->errors, $error);
|
|
}
|
|
}
|
|
|
|
if (!PKP_STRICT_MODE) {
|
|
class_alias('\PKP\xslt\XSLTransformer', '\XSLTransformer');
|
|
foreach (['XSL_TRANSFORMER_DOCTYPE_STRING', 'XSL_TRANSFORMER_DOCTYPE_FILE', 'XSL_TRANSFORMER_DOCTYPE_DOM'] as $constantName) {
|
|
define($constantName, constant('\XSLTransformer::' . $constantName));
|
|
}
|
|
}
|