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