Admin Control Panel v2.0

✎ Editing: Validator.php ← Back

<?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

Cancel