Admin Control Panel v2.0

✎ Editing: ErrorCollector.php ← Back

<?php

/**

* Error collection class that enables HTML Purifier to report HTML

* problems back to the user

class HTMLPurifier_ErrorCollector

{

/**

* Identifiers for the returned error array. These are purposely numeric

* so list() can be used.

const LINENO   = 0;

const SEVERITY = 1;

const MESSAGE  = 2;

const CHILDREN = 3;

/**

* @type array

protected $errors;

/**

* @type array

protected $_current;

/**

* @type array

protected $_stacks = array(array());

/**

* @type HTMLPurifier_Language

protected $locale;

/**

* @type HTMLPurifier_Generator

protected $generator;

/**

* @type HTMLPurifier_Context

protected $context;

/**

* @type array

protected $lines = array();

/**

* @param HTMLPurifier_Context $context

public function __construct($context)

{

$this->locale    =& $context->get('Locale');

$this->context   = $context;

$this->_current  =& $this->_stacks[0];

$this->errors    =& $this->_stacks[0];

}

/**

* Sends an error message to the collector for later use

* @param int $severity Error severity, PHP error style (don't use E_USER_)

* @param string $msg Error message text

public function send($severity, $msg)

{

$args = array();

if (func_num_args() > 2) {

$args = func_get_args();

array_shift($args);

unset($args[0]);

}

$token = $this->context->get('CurrentToken', true);

$line  = $token ? $token->line : $this->context->get('CurrentLine', true);

$col   = $token ? $token->col  : $this->context->get('CurrentCol', true);

$attr  = $this->context->get('CurrentAttr', true);

// perform special substitutions, also add custom parameters

$subst = array();

if (!is_null($token)) {

$args['CurrentToken'] = $token;

}

if (!is_null($attr)) {

$subst['$CurrentAttr.Name'] = $attr;

if (isset($token->attr[$attr])) {

$subst['$CurrentAttr.Value'] = $token->attr[$attr];

}

if (empty($args)) {

$msg = $this->locale->getMessage($msg);

} else {

$msg = $this->locale->formatMessage($msg, $args);

}

if (!empty($subst)) {

$msg = strtr($msg, $subst);

}

// (numerically indexed)

$error = array(

self::LINENO   => $line,

self::SEVERITY => $severity,

self::MESSAGE  => $msg,

self::CHILDREN => array()

);

$this->_current[] = $error;

// NEW CODE BELOW ...

// Top-level errors are either:

//  TOKEN type, if $value is set appropriately, or

//  "syntax" type, if $value is null

$new_struct = new HTMLPurifier_ErrorStruct();

$new_struct->type = HTMLPurifier_ErrorStruct::TOKEN;

if ($token) {

$new_struct->value = clone $token;

}

if (is_int($line) && is_int($col)) {

if (isset($this->lines[$line][$col])) {

$struct = $this->lines[$line][$col];

} else {

$struct = $this->lines[$line][$col] = $new_struct;

}

// These ksorts may present a performance problem

ksort($this->lines[$line], SORT_NUMERIC);

} else {

if (isset($this->lines[-1])) {

$struct = $this->lines[-1];

} else {

$struct = $this->lines[-1] = $new_struct;

}

ksort($this->lines, SORT_NUMERIC);

// Now, check if we need to operate on a lower structure

if (!empty($attr)) {

$struct = $struct->getChild(HTMLPurifier_ErrorStruct::ATTR, $attr);

if (!$struct->value) {

$struct->value = array($attr, 'PUT VALUE HERE');

}

if (!empty($cssprop)) {

$struct = $struct->getChild(HTMLPurifier_ErrorStruct::CSSPROP, $cssprop);

if (!$struct->value) {

// if we tokenize CSS this might be a little more difficult to do

$struct->value = array($cssprop, 'PUT VALUE HERE');

}

// Ok, structs are all setup, now time to register the error

$struct->addError($severity, $msg);

}

/**

* Retrieves raw error data for custom formatter to use

public function getRaw()

{

return $this->errors;

}

/**

* Default HTML formatting implementation for error messages

* @param HTMLPurifier_Config $config Configuration, vital for HTML output nature

* @param array $errors Errors array to display; used for recursion.

* @return string

public function getHTMLFormatted($config, $errors = null)

{

$ret = array();

$this->generator = new HTMLPurifier_Generator($config, $this->context);

if ($errors === null) {

$errors = $this->errors;

}

// 'At line' message needs to be removed

// generation code for new structure goes here. It needs to be recursive.

foreach ($this->lines as $line => $col_array) {

if ($line == -1) {

continue;

}

foreach ($col_array as $col => $struct) {

$this->_renderStruct($ret, $struct, $line, $col);

}

if (isset($this->lines[-1])) {

$this->_renderStruct($ret, $this->lines[-1]);

}

if (empty($errors)) {

return '' . $this->locale->getMessage('ErrorCollector: No errors') . '';

} else {

return '<ul><li>' . implode('</li><li>', $ret) . '</li></ul>';

}

private function _renderStruct(&$ret, $struct, $line = null, $col = null)

{

$stack = array($struct);

$context_stack = array(array());

while ($current = array_pop($stack)) {

$context = array_pop($context_stack);

foreach ($current->errors as $error) {

list($severity, $msg) = $error;

$string = '';

$string .= '<div>';

// W3C uses an icon to indicate the severity of the error.

$error = $this->locale->getErrorName($severity);

$string .= "$error ";

if (!is_null($line) && !is_null($col)) {

$string .= "Line $line, Column $col: ";

} else {

$string .= 'End of Document: ';

}

$string .= '' . $this->generator->escape($msg) . ' ';

$string .= '</div>';

// Here, have a marker for the character on the column appropriate.

// Be sure to clip extremely long lines.

//$string .= '<pre>';

//$string .= '';

//$string .= '</pre>';

$ret[] = $string;

}

foreach ($current->children as $array) {

$context[] = $current;

$stack = array_merge($stack, array_reverse($array, true));

for ($i = count($array); $i > 0; $i--) {

$context_stack[] = $context;

}

// vim: et sw=4 sts=4

Cancel