/**
* Validates a single argument.
* Validates a single argument. Uses a specified ValidatorRule object for validation.
* @param ref mixed $argument The argument to be validated.
* @param ref object ValidatorRule $rule The rule to use for validation.
* @param optional boolean $isFatal If TRUE, upon validation failure, a fatal error
* will be thrown. Default: FALSE.
* @access public
* @return boolean If validation is successful, returns TRUE. If validation
* fails and $isFatal is FALSE, returns FALSE. If $isFatal is TRUE, then
* if validation fails, the script would halt and nothing would ever be
* returned.
* @static
**/
static function validate($argument, ValidatorRuleInterface $rule, $isFatal = true)
{
if (defined('DISABLE_VALIDATION') && DISABLE_VALIDATION) {
return true;
}
// now try to validate the argument
// if argument is invalid
if (!$rule->check($argument)) {
// then throw an error
$description = "";
$description .= "Argument validation failed in ";
// get information abour the function that called the ArgumentValidator
$debugBacktrace = debug_backtrace();
$class = $debugBacktrace[1]["class"];
$function = $debugBacktrace[1]["function"];
if (isset($debugBacktrace[1]["args"])) {
$arguments = $debugBacktrace[1]["args"];
} else {
$arguments = array();
}
$description .= "<br/><br/> " . $class . "::" . $function;
// print the arguments using the ArgumentRenderer
$description .= "(";
$description .= ArgumentRenderer::renderManyArguments($arguments, false, false);
$description .= ");";
$description .= "<br/><br/>Argument '";
$description .= ArgumentRenderer::renderOneArgument($argument, false, false);
$description .= "' could not be validated using a/an ";
$description .= get_class($rule);
$description .= ".";
// now create the error
throw new InvalidArgumentException($description);
}
// validation is successful
return true;
}
/**
* Prints a single error.
* @param object Error The Error object to be printed.
* @param boolean $isDetailed If TRUE, will print the error with details.
* @access private
*/
function printError($message = "")
{
print "\n<br />\n<b>ERRORS:</b><br /><br />\n";
print "<ul>";
$description = nl2br($message);
print "<li>\n";
print "<b>Description</b>: " . $description . "<br /><br />\n";
/* get the call sequence information */
$traceArray = debug_backtrace();
if (is_array($traceArray)) {
foreach ($traceArray as $trace) {
/* each $traceArray element represents a step in the call hiearchy. Print them from bottom up. */
$file = basename($trace['file']);
$line = $trace['line'];
$function = $trace['function'];
$class = $trace['class'];
$type = $trace['type'];
$args = ArgumentRenderer::renderManyArguments($trace['args'], false, false);
print "in <b>{$file}:{$line}</b> {$class}{$type}{$function}({$args})<br />\n";
}
}
print "<br />";
print "</ul>";
}
/**
* Renders many arguments.
* Renders many arguments by printing their types and values and comma delimiting them.
* In 'detailed' mode, includes some additional information (i.e., for arrays,
* prints all elements of the array; for objects, prints the object structure).
* @param array $arguments The arguments to render.
* @param boolean $isDetailed If TRUE, will print additional details.
* @param boolean $shouldPrint If TRUE, will print on screen; If FALSE, will not
* print, but just return the result as a string.
* @return string The output of the method. This will be output to the browser
* if $shouldPrint is set to TRUE. Returns FALSE, if something goes wrong.
* @access public
**/
function renderManyArguments($arguments, $isDetailed = false, $shouldPrint = false)
{
// see if $arguments is an array
if (!is_array($arguments)) {
return false;
}
// make sure $arguments is not empty
if (count($arguments) == 0) {
return false;
}
// render each element of $arguments
$resultArray = array();
foreach (array_keys($arguments) as $i => $key) {
$resultArray[] = ArgumentRenderer::renderOneArgument($arguments[$key], $isDetailed, false);
}
$glue = $isDetailed ? ",\n" : ", ";
$result = implode($glue, $resultArray);
// print if necessary
if ($shouldPrint) {
echo $result;
}
return $result;
}
/**
* Renders multiple arguments, in detailed mode.
*/
function test_Multiple_Arguments()
{
$arguments = array();
$arguments[] = true;
$arguments[] = 15;
$arguments[] = 15.25;
$arguments[] = "Muhaha";
$arguments[] = array("one", "two");
$arguments[] = new ArgumentRenderer();
$arguments[] = mysql_connect("devo.middlebury.edu", "test", "test");
// detailed mode
$result = ArgumentRenderer::renderManyArguments($arguments, true, true);
// simple mode
$result = ArgumentRenderer::renderManyArguments($arguments, false, true);
$this->assertTrue($result);
}
/**
* Prints a debug_backtrace() array in a pretty plain text way...
* @param optional array $trace The array. If null, a current backtrace is used.
* @param optional boolean $return If true will return the HTML instead of printing it.
* @access public
* @return void
*/
public static function printPlainTextDebugBacktrace($trace = null, $return = false)
{
if (is_array($trace)) {
$traceArray = $trace;
} else {
$traceArray = debug_backtrace();
}
if ($return) {
ob_start();
}
$filenameSize = 5;
if (is_array($traceArray)) {
foreach ($traceArray as $trace) {
if (isset($trace['file'])) {
$filenameSize = max($filenameSize, strlen(basename($trace['file'])));
}
}
}
$filenameSize = $filenameSize + 2;
print "\n* # ";
print "\tFile";
for ($j = 4; $j < $filenameSize; $j++) {
print " ";
}
print "Line";
print "\tCall ";
print "\n*-----------------------------------------------------------------------------";
if (is_array($traceArray)) {
foreach ($traceArray as $i => $trace) {
/* each $traceArray element represents a step in the call hiearchy. Print them from bottom up. */
$file = isset($trace['file']) ? basename($trace['file']) : '';
$line = isset($trace['line']) ? $trace['line'] : '';
$function = isset($trace['function']) ? $trace['function'] : '';
$class = isset($trace['class']) ? $trace['class'] : '';
$type = isset($trace['type']) ? $trace['type'] : '';
$args = ArgumentRenderer::renderManyArguments($trace['args'], false, false);
print "\n* {$i}";
print "\t" . $file;
for ($j = strlen($file); $j < $filenameSize; $j++) {
print " ";
}
print "" . $line;
print "\t";
if ($class || $type || $function || $args) {
print $class . $type . $function . "(" . $args . ");";
}
}
}
if ($return) {
return ob_get_clean();
}
}