XMLTypeDescription.inc.php

<?php
 
import('lib.pkp.classes.filter.TypeDescription');
import('lib.pkp.classes.filter.TypeDescriptionFactory');
 
define('XML_TYPE_DESCRIPTION_VALIDATE_NONE', '*');
define('XML_TYPE_DESCRIPTION_VALIDATE_SCHEMA', 'schema');
define('XML_TYPE_DESCRIPTION_VALIDATE_DTD', 'dtd');
define('XML_TYPE_DESCRIPTION_VALIDATE_RELAX_NG', 'relax-ng');
 
class XMLTypeDescription extends TypeDescription {
   var $_validationStrategy = XML_TYPE_DESCRIPTION_VALIDATE_SCHEMA;
 
   var $_validationSource;
 
 
   function __construct($typeName) {
      parent::__construct($typeName);
   }
 
 
   //
   // Setters and Getters
   //
   function getNamespace() {
      return TYPE_DESCRIPTION_NAMESPACE_XML;
   }
 
   function setValidationStrategy($validationStrategy) {
      $this->_validationStrategy = $validationStrategy;
   }
 
   //
   // Implement abstract template methods from TypeDescription
   //
   function parseTypeName($typeName) {
      // We expect a validation strategy and an optional validation argument
      $typeNameParts = explode('(', $typeName);
      switch (count($typeNameParts)) {
         case 1:
            // No argument present (only dtd or no validation)
            $validationStrategy = $typeName;
            if ($validationStrategy != XML_TYPE_DESCRIPTION_VALIDATE_NONE
                  && $validationStrategy != XML_TYPE_DESCRIPTION_VALIDATE_DTD) return false;
            $validationSource = null;
            break;
 
         case 2:
            // We have an argument (only available for schema and relax-ng)
            $validationStrategy = $typeNameParts[0];
            if ($validationStrategy != XML_TYPE_DESCRIPTION_VALIDATE_SCHEMA
                  && $validationStrategy != XML_TYPE_DESCRIPTION_VALIDATE_RELAX_NG) return false;
            $validationSource = trim($typeNameParts[1], ')');
            break;
 
         default:
            return false;
      }
 
      $this->_validationStrategy = $validationStrategy;
      $this->_validationSource = $validationSource;
 
      return true;
   }
 
   function checkType(&$object) {
      // We only accept DOMDocument objects and source strings.
      if (!is_a($object, 'DOMDocument') && !is_string($object)) return false;
 
      // No validation...
      if ($this->_validationStrategy == XML_TYPE_DESCRIPTION_VALIDATE_NONE) return true;
 
      // Validation - requires DOMDocument
      if (is_string($object)) {
         $xmlDom = new DOMDocument();
         $xmlDom->loadXML($object);
      } else {
         $xmlDom =& $object;
      }
 
      switch($this->_validationStrategy) {
         // We have to suppress validation errors, otherwise the script
         // will stop when validation errors occur.
         case XML_TYPE_DESCRIPTION_VALIDATE_DTD:
            if (!$xmlDom->validate()) return false;
            break;
 
         case XML_TYPE_DESCRIPTION_VALIDATE_SCHEMA:
            libxml_use_internal_errors(true);
            if (!$xmlDom->schemaValidate($this->_validationSource)) {
               $errors = libxml_get_errors();
               return false;
            }
            
            break;
 
         case XML_TYPE_DESCRIPTION_VALIDATE_RELAX_NG:
            if (!$xmlDom->relaxNGValidate($this->_validationSource)) return false;
            break;
 
         default:
            assert(false);
      }
 
      return true;
   }
}