File indexing completed on 2025-02-02 05:43:42

 <?php
 
 /**
  * Performs validations on HTMLPurifier_ConfigSchema_Interchange
  *
  * @note If you see '// handled by InterchangeBuilder', that means a
  *       design decision in that class would prevent this validation from
  *       ever being necessary. We have them anyway, however, for
  *       redundancy.
  */
 class HTMLPurifier_ConfigSchema_Validator
 {
 
     /**
      * @type HTMLPurifier_ConfigSchema_Interchange
      */
     protected $interchange;
 
     /**
      * @type array
      */
     protected $aliases;
 
     /**
      * Context-stack to provide easy to read error messages.
      * @type array
      */
     protected $context = array();
 
     /**
      * to test default's type.
      * @type HTMLPurifier_VarParser
      */
     protected $parser;
 
     public function __construct()
     {
         $this->parser = new HTMLPurifier_VarParser();
     }
 
     /**
      * Validates a fully-formed interchange object.
      * @param HTMLPurifier_ConfigSchema_Interchange $interchange
      * @return bool
      */
     public function validate($interchange)
     {
         $this->interchange = $interchange;
         $this->aliases = array();
         // PHP is a bit lax with integer <=> string conversions in
         // arrays, so we don't use the identical !== comparison
         foreach ($interchange->directives as $i => $directive) {
             $id = $directive->id->toString();
             if ($i != $id) {
                 $this->error(false, "Integrity violation: key '$i' does not match internal id '$id'");
             }
             $this->validateDirective($directive);
         }
         return true;
     }
 
     /**
      * Validates a HTMLPurifier_ConfigSchema_Interchange_Id object.
      * @param HTMLPurifier_ConfigSchema_Interchange_Id $id
      */
     public function validateId($id)
     {
         $id_string = $id->toString();
         $this->context[] = "id '$id_string'";
         if (!$id instanceof HTMLPurifier_ConfigSchema_Interchange_Id) {
             // handled by InterchangeBuilder
             $this->error(false, 'is not an instance of HTMLPurifier_ConfigSchema_Interchange_Id');
         }
         // keys are now unconstrained (we might want to narrow down to A-Za-z0-9.)
         // we probably should check that it has at least one namespace
         $this->with($id, 'key')
             ->assertNotEmpty()
             ->assertIsString(); // implicit assertIsString handled by InterchangeBuilder
         array_pop($this->context);
     }
 
     /**
      * Validates a HTMLPurifier_ConfigSchema_Interchange_Directive object.
      * @param HTMLPurifier_ConfigSchema_Interchange_Directive $d
      */
     public function validateDirective($d)
     {
         $id = $d->id->toString();
         $this->context[] = "directive '$id'";
         $this->validateId($d->id);
 
         $this->with($d, 'description')
             ->assertNotEmpty();
 
         // BEGIN - handled by InterchangeBuilder
         $this->with($d, 'type')
             ->assertNotEmpty();
         $this->with($d, 'typeAllowsNull')
             ->assertIsBool();
         try {
             // This also tests validity of $d->type
             $this->parser->parse($d->default, $d->type, $d->typeAllowsNull);
         } catch (HTMLPurifier_VarParserException $e) {
             $this->error('default', 'had error: ' . $e->getMessage());
         }
         // END - handled by InterchangeBuilder
 
         if (!is_null($d->allowed) || !empty($d->valueAliases)) {
             // allowed and valueAliases require that we be dealing with
             // strings, so check for that early.
             $d_int = HTMLPurifier_VarParser::$types[$d->type];
             if (!isset(HTMLPurifier_VarParser::$stringTypes[$d_int])) {
                 $this->error('type', 'must be a string type when used with allowed or value aliases');
             }
         }
 
         $this->validateDirectiveAllowed($d);
         $this->validateDirectiveValueAliases($d);
         $this->validateDirectiveAliases($d);
 
         array_pop($this->context);
     }
 
     /**
      * Extra validation if $allowed member variable of
      * HTMLPurifier_ConfigSchema_Interchange_Directive is defined.
      * @param HTMLPurifier_ConfigSchema_Interchange_Directive $d
      */
     public function validateDirectiveAllowed($d)
     {
         if (is_null($d->allowed)) {
             return;
         }
         $this->with($d, 'allowed')
             ->assertNotEmpty()
             ->assertIsLookup(); // handled by InterchangeBuilder
         if (is_string($d->default) && !isset($d->allowed[$d->default])) {
             $this->error('default', 'must be an allowed value');
         }
         $this->context[] = 'allowed';
         foreach ($d->allowed as $val => $x) {
             if (!is_string($val)) {
                 $this->error("value $val", 'must be a string');
             }
         }
         array_pop($this->context);
     }
 
     /**
      * Extra validation if $valueAliases member variable of
      * HTMLPurifier_ConfigSchema_Interchange_Directive is defined.
      * @param HTMLPurifier_ConfigSchema_Interchange_Directive $d
      */
     public function validateDirectiveValueAliases($d)
     {
         if (is_null($d->valueAliases)) {
             return;
         }
         $this->with($d, 'valueAliases')
             ->assertIsArray(); // handled by InterchangeBuilder
         $this->context[] = 'valueAliases';
         foreach ($d->valueAliases as $alias => $real) {
             if (!is_string($alias)) {
                 $this->error("alias $alias", 'must be a string');
             }
             if (!is_string($real)) {
                 $this->error("alias target $real from alias '$alias'", 'must be a string');
             }
             if ($alias === $real) {
                 $this->error("alias '$alias'", "must not be an alias to itself");
             }
         }
         if (!is_null($d->allowed)) {
             foreach ($d->valueAliases as $alias => $real) {
                 if (isset($d->allowed[$alias])) {
                     $this->error("alias '$alias'", 'must not be an allowed value');
                 } elseif (!isset($d->allowed[$real])) {
                     $this->error("alias '$alias'", 'must be an alias to an allowed value');
                 }
             }
         }
         array_pop($this->context);
     }
 
     /**
      * Extra validation if $aliases member variable of
      * HTMLPurifier_ConfigSchema_Interchange_Directive is defined.
      * @param HTMLPurifier_ConfigSchema_Interchange_Directive $d
      */
     public function validateDirectiveAliases($d)
     {
         $this->with($d, 'aliases')
             ->assertIsArray(); // handled by InterchangeBuilder
         $this->context[] = 'aliases';
         foreach ($d->aliases as $alias) {
             $this->validateId($alias);
             $s = $alias->toString();
             if (isset($this->interchange->directives[$s])) {
                 $this->error("alias '$s'", 'collides with another directive');
             }
             if (isset($this->aliases[$s])) {
                 $other_directive = $this->aliases[$s];
                 $this->error("alias '$s'", "collides with alias for directive '$other_directive'");
             }
             $this->aliases[$s] = $d->id->toString();
         }
         array_pop($this->context);
     }
 
     // protected helper functions
 
     /**
      * Convenience function for generating HTMLPurifier_ConfigSchema_ValidatorAtom
      * for validating simple member variables of objects.
      * @param $obj
      * @param $member
      * @return HTMLPurifier_ConfigSchema_ValidatorAtom
      */
     protected function with($obj, $member)
     {
         return new HTMLPurifier_ConfigSchema_ValidatorAtom($this->getFormattedContext(), $obj, $member);
     }
 
     /**
      * Emits an error, providing helpful context.
      * @throws HTMLPurifier_ConfigSchema_Exception
      */
     protected function error($target, $msg)
     {
         if ($target !== false) {
             $prefix = ucfirst($target) . ' in ' . $this->getFormattedContext();
         } else {
             $prefix = ucfirst($this->getFormattedContext());
         }
         throw new HTMLPurifier_ConfigSchema_Exception(trim($prefix . ' ' . $msg));
     }
 
     /**
      * Returns a formatted context string.
      * @return string
      */
     protected function getFormattedContext()
     {
         return implode(' in ', array_reverse($this->context));
     }
 }
 
 // vim: et sw=4 sts=4