[Summary view]

   1  <?php
   2  
   3  /**

   4   * Performs validations on HTMLPurifier_ConfigSchema_Interchange

   5   *

   6   * @note If you see '// handled by InterchangeBuilder', that means a

   7   *       design decision in that class would prevent this validation from

   8   *       ever being necessary. We have them anyway, however, for

   9   *       redundancy.

  10   */
  11  class HTMLPurifier_ConfigSchema_Validator
  12  {
  13  
  14      /**

  15       * @type HTMLPurifier_ConfigSchema_Interchange

  16       */
  17      protected $interchange;
  18  
  19      /**

  20       * @type array

  21       */
  22      protected $aliases;
  23  
  24      /**

  25       * Context-stack to provide easy to read error messages.

  26       * @type array

  27       */
  28      protected $context = array();
  29  
  30      /**

  31       * to test default's type.

  32       * @type HTMLPurifier_VarParser

  33       */
  34      protected $parser;
  35  
  36      public function __construct()
  37      {
  38          $this->parser = new HTMLPurifier_VarParser();
  39      }
  40  
  41      /**

  42       * Validates a fully-formed interchange object.

  43       * @param HTMLPurifier_ConfigSchema_Interchange $interchange

  44       * @return bool

  45       */
  46      public function validate($interchange)
  47      {
  48          $this->interchange = $interchange;
  49          $this->aliases = array();
  50          // PHP is a bit lax with integer <=> string conversions in

  51          // arrays, so we don't use the identical !== comparison

  52          foreach ($interchange->directives as $i => $directive) {
  53              $id = $directive->id->toString();
  54              if ($i != $id) {
  55                  $this->error(false, "Integrity violation: key '$i' does not match internal id '$id'");
  56              }
  57              $this->validateDirective($directive);
  58          }
  59          return true;
  60      }
  61  
  62      /**

  63       * Validates a HTMLPurifier_ConfigSchema_Interchange_Id object.

  64       * @param HTMLPurifier_ConfigSchema_Interchange_Id $id

  65       */
  66      public function validateId($id)
  67      {
  68          $id_string = $id->toString();
  69          $this->context[] = "id '$id_string'";
  70          if (!$id instanceof HTMLPurifier_ConfigSchema_Interchange_Id) {
  71              // handled by InterchangeBuilder

  72              $this->error(false, 'is not an instance of HTMLPurifier_ConfigSchema_Interchange_Id');
  73          }
  74          // keys are now unconstrained (we might want to narrow down to A-Za-z0-9.)

  75          // we probably should check that it has at least one namespace

  76          $this->with($id, 'key')
  77              ->assertNotEmpty()
  78              ->assertIsString(); // implicit assertIsString handled by InterchangeBuilder

  79          array_pop($this->context);
  80      }
  81  
  82      /**

  83       * Validates a HTMLPurifier_ConfigSchema_Interchange_Directive object.

  84       * @param HTMLPurifier_ConfigSchema_Interchange_Directive $d

  85       */
  86      public function validateDirective($d)
  87      {
  88          $id = $d->id->toString();
  89          $this->context[] = "directive '$id'";
  90          $this->validateId($d->id);
  91  
  92          $this->with($d, 'description')
  93              ->assertNotEmpty();
  94  
  95          // BEGIN - handled by InterchangeBuilder

  96          $this->with($d, 'type')
  97              ->assertNotEmpty();
  98          $this->with($d, 'typeAllowsNull')
  99              ->assertIsBool();
 100          try {
 101              // This also tests validity of $d->type

 102              $this->parser->parse($d->default, $d->type, $d->typeAllowsNull);
 103          } catch (HTMLPurifier_VarParserException $e) {
 104              $this->error('default', 'had error: ' . $e->getMessage());
 105          }
 106          // END - handled by InterchangeBuilder

 107  
 108          if (!is_null($d->allowed) || !empty($d->valueAliases)) {
 109              // allowed and valueAliases require that we be dealing with

 110              // strings, so check for that early.

 111              $d_int = HTMLPurifier_VarParser::$types[$d->type];
 112              if (!isset(HTMLPurifier_VarParser::$stringTypes[$d_int])) {
 113                  $this->error('type', 'must be a string type when used with allowed or value aliases');
 114              }
 115          }
 116  
 117          $this->validateDirectiveAllowed($d);
 118          $this->validateDirectiveValueAliases($d);
 119          $this->validateDirectiveAliases($d);
 120  
 121          array_pop($this->context);
 122      }
 123  
 124      /**

 125       * Extra validation if $allowed member variable of

 126       * HTMLPurifier_ConfigSchema_Interchange_Directive is defined.

 127       * @param HTMLPurifier_ConfigSchema_Interchange_Directive $d

 128       */
 129      public function validateDirectiveAllowed($d)
 130      {
 131          if (is_null($d->allowed)) {
 132              return;
 133          }
 134          $this->with($d, 'allowed')
 135              ->assertNotEmpty()
 136              ->assertIsLookup(); // handled by InterchangeBuilder

 137          if (is_string($d->default) && !isset($d->allowed[$d->default])) {
 138              $this->error('default', 'must be an allowed value');
 139          }
 140          $this->context[] = 'allowed';
 141          foreach ($d->allowed as $val => $x) {
 142              if (!is_string($val)) {
 143                  $this->error("value $val", 'must be a string');
 144              }
 145          }
 146          array_pop($this->context);
 147      }
 148  
 149      /**

 150       * Extra validation if $valueAliases member variable of

 151       * HTMLPurifier_ConfigSchema_Interchange_Directive is defined.

 152       * @param HTMLPurifier_ConfigSchema_Interchange_Directive $d

 153       */
 154      public function validateDirectiveValueAliases($d)
 155      {
 156          if (is_null($d->valueAliases)) {
 157              return;
 158          }
 159          $this->with($d, 'valueAliases')
 160              ->assertIsArray(); // handled by InterchangeBuilder

 161          $this->context[] = 'valueAliases';
 162          foreach ($d->valueAliases as $alias => $real) {
 163              if (!is_string($alias)) {
 164                  $this->error("alias $alias", 'must be a string');
 165              }
 166              if (!is_string($real)) {
 167                  $this->error("alias target $real from alias '$alias'", 'must be a string');
 168              }
 169              if ($alias === $real) {
 170                  $this->error("alias '$alias'", "must not be an alias to itself");
 171              }
 172          }
 173          if (!is_null($d->allowed)) {
 174              foreach ($d->valueAliases as $alias => $real) {
 175                  if (isset($d->allowed[$alias])) {
 176                      $this->error("alias '$alias'", 'must not be an allowed value');
 177                  } elseif (!isset($d->allowed[$real])) {
 178                      $this->error("alias '$alias'", 'must be an alias to an allowed value');
 179                  }
 180              }
 181          }
 182          array_pop($this->context);
 183      }
 184  
 185      /**

 186       * Extra validation if $aliases member variable of

 187       * HTMLPurifier_ConfigSchema_Interchange_Directive is defined.

 188       * @param HTMLPurifier_ConfigSchema_Interchange_Directive $d

 189       */
 190      public function validateDirectiveAliases($d)
 191      {
 192          $this->with($d, 'aliases')
 193              ->assertIsArray(); // handled by InterchangeBuilder

 194          $this->context[] = 'aliases';
 195          foreach ($d->aliases as $alias) {
 196              $this->validateId($alias);
 197              $s = $alias->toString();
 198              if (isset($this->interchange->directives[$s])) {
 199                  $this->error("alias '$s'", 'collides with another directive');
 200              }
 201              if (isset($this->aliases[$s])) {
 202                  $other_directive = $this->aliases[$s];
 203                  $this->error("alias '$s'", "collides with alias for directive '$other_directive'");
 204              }
 205              $this->aliases[$s] = $d->id->toString();
 206          }
 207          array_pop($this->context);
 208      }
 209  
 210      // protected helper functions

 211  
 212      /**

 213       * Convenience function for generating HTMLPurifier_ConfigSchema_ValidatorAtom

 214       * for validating simple member variables of objects.

 215       * @param $obj

 216       * @param $member

 217       * @return HTMLPurifier_ConfigSchema_ValidatorAtom

 218       */
 219      protected function with($obj, $member)
 220      {
 221          return new HTMLPurifier_ConfigSchema_ValidatorAtom($this->getFormattedContext(), $obj, $member);
 222      }
 223  
 224      /**

 225       * Emits an error, providing helpful context.

 226       * @throws HTMLPurifier_ConfigSchema_Exception

 227       */
 228      protected function error($target, $msg)
 229      {
 230          if ($target !== false) {
 231              $prefix = ucfirst($target) . ' in ' . $this->getFormattedContext();
 232          } else {
 233              $prefix = ucfirst($this->getFormattedContext());
 234          }
 235          throw new HTMLPurifier_ConfigSchema_Exception(trim($prefix . ' ' . $msg));
 236      }
 237  
 238      /**

 239       * Returns a formatted context string.

 240       * @return string

 241       */
 242      protected function getFormattedContext()
 243      {
 244          return implode(' in ', array_reverse($this->context));
 245      }
 246  }
 247  
 248  // vim: et sw=4 sts=4