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
249: