Namespaces

Classes

Interfaces

Exceptions

Functions

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:
API documentation generated by ApiGen v7.0.0-alpha.6