Implements: Throwable
ORM Validation exceptions.
Class declared in MODPATH/orm/classes/ORM/Validation/Exception.php on line 11.
string $error_viewerror rendering view
string(12) "kohana/error"string $error_view_content_typeerror view content type
string(9) "text/html"array $php_errorsPHP error code => human readable name
array(9) ( 1 => string(11) "Fatal Error" 256 => string(10) "User Error" 4 => string(11) "Parse Error" 2 => string(7) "Warning" 512 => string(12) "User Warning" 2048 => string(6) "Strict" 8 => string(6) "Notice" 4096 => string(17) "Recoverable Error" 8192 => string(10) "Deprecated" )
string $_aliasThe alias of the main ORM model this exception was created for
NULL
array $_objectsArray of validation objects
array(0) integer 0
NULL
NULL
string(0) ""Constructs a new exception for the specified model
string
$alias
required - The alias to use when looking for error messages Validation
$object
required - The Validation object of the model string
$message
= string(24) "Failed to validate array" - The error message array
$values
= NULL - The array of values for the error message integer
$code
= integer 0 - The error code for the exception unknown
$previous
= NULL voidpublic function __construct($alias, Validation $object, $message = 'Failed to validate array', array $values = null, $code = 0, Exception $previous = null)
{
$this->_alias = $alias;
$this->_objects['_object'] = $object;
$this->_objects['_has_many'] = false;
parent::__construct($message, $values, $code, $previous);
}Adds a Validation object to this exception
// The following will add a validation object for a profile model
// inside the exception for a user model.
$e->add_object('profile', $validation);
// The errors array will now look something like this
// [
// 'username' => 'This field is required'
// 'profile' => [
// 'first_name' => 'This field is required'
// ]
// ];
string
$alias
required - The relationship alias from the model Validation
$object
required - The Validation object to merge mixed
$has_many
= bool FALSE - The array key to use if this exception can be merged multiple times ORM_Validation_Exceptionpublic function add_object($alias, Validation $object, $has_many = false)
{
// We will need this when generating errors
$this->_objects[$alias]['_has_many'] = ($has_many !== false);
if ($has_many === true) {
// This is most likely a has_many relationship
$this->_objects[$alias][]['_object'] = $object;
} elseif ($has_many) {
// This is most likely a has_many relationship
$this->_objects[$alias][$has_many]['_object'] = $object;
} else {
$this->_objects[$alias]['_object'] = $object;
}
return $this;
}Returns the protected _alias property from this exception
stringpublic function alias()
{
return $this->_alias;
}Returns a merged array of the errors from all the Validation objects in this exception
// Will load Model_User errors from messages/orm-validation/user.php
$e->errors('orm-validation');
string
$directory
= NULL - Directory to load error messages from mixed
$translate
= bool TRUE - Translate the message arraypublic function errors($directory = null, $translate = true)
{
return $this->generate_errors($this->_alias, $this->_objects, $directory, $translate);
}Merges an ORM_Validation_Exception object into the current exception Useful when you want to combine errors into one array
ORM_Validation_Exception
$object
required - The exception to merge mixed
$has_many
= bool FALSE - The array key to use if this exception can be merged multiple times ORM_Validation_Exceptionpublic function merge(ORM_Validation_Exception $object, $has_many = false)
{
$alias = $object->alias();
// We will need this when generating errors
$this->_objects[$alias]['_has_many'] = ($has_many !== false);
if ($has_many === true) {
// This is most likely a has_many relationship
$this->_objects[$alias][] = $object->objects();
} elseif ($has_many) {
// This is most likely a has_many relationship
$this->_objects[$alias][$has_many] = $object->objects();
} else {
$this->_objects[$alias] = $object->objects();
}
return $this;
}Returns the protected _objects property from this exception
arraypublic function objects()
{
return $this->_objects;
}Magic object-to-string method.
echo $exception;
stringpublic function __toString()
{
return Kohana_Exception::text($this);
}Exception handler, logs the exception and generates a Response object for display.
Throwable
$e
required - $e Responsepublic static function _handler($e)
{
try {
// Log the exception
Kohana_Exception::log($e);
// Generate the response
$response = Kohana_Exception::response($e);
return $response;
} catch (Exception $e) {
/**
* Things are going *really* badly for us, We now have no choice
* but to bail. Hard.
*/
// Clean the output buffer if one exists
ob_get_level() AND ob_clean();
// Set the Status code to 500, and Content-Type to text/plain.
header('Content-Type: text/plain; charset=' . Kohana::$charset, true, 500);
echo Kohana_Exception::text($e);
exit(1);
}
}Inline exception handler, displays the error message, source of the exception, and the stack trace of the error.
Throwable
$e
required - $e voidpublic static function handler($e)
{
$response = Kohana_Exception::_handler($e);
// Send the response to the browser
echo $response->send_headers()->body();
exit(1);
}Logs an exception.
Throwable
$e
required - $e int
$level
= integer 0 - $level voidpublic static function log($e, $level = Log::EMERGENCY)
{
if (is_object(Kohana::$log)) {
// Create a text version of the exception
$error = Kohana_Exception::text($e);
// Add this exception to the log
Kohana::$log->add($level, $error, null, ['exception' => $e]);
// Make sure the logs are written
Kohana::$log->write();
}
}Get a Response object representing the exception
Throwable
$e
required - $e Responsepublic static function response($e)
{
try {
// Get the exception information
$class = get_class($e);
$code = $e->getCode();
$message = $e->getMessage();
$file = $e->getFile();
$line = $e->getLine();
$trace = $e->getTrace();
/**
* HTTP_Exceptions are constructed in the HTTP_Exception::factory()
* method. We need to remove that entry from the trace and overwrite
* the variables from above.
*/
if ($e instanceof HTTP_Exception AND $trace[0]['function'] == 'factory') {
extract(array_shift($trace));
}
if ($e instanceof ErrorException) {
/**
* If XDebug is installed, and this is a fatal error,
* use XDebug to generate the stack trace
*/
if (function_exists('xdebug_get_function_stack') AND $code == E_ERROR) {
$trace = array_slice(array_reverse(xdebug_get_function_stack()), 4);
foreach ($trace as & $frame) {
/**
* XDebug pre 2.1.1 doesn't currently set the call type key
* http://bugs.xdebug.org/view.php?id=695
*/
if (!isset($frame['type'])) {
$frame['type'] = '??';
}
// Xdebug returns the words 'dynamic' and 'static' instead of using '->' and '::' symbols
if ('dynamic' === $frame['type']) {
$frame['type'] = '->';
} elseif ('static' === $frame['type']) {
$frame['type'] = '::';
}
// XDebug also has a different name for the parameters array
if (isset($frame['params']) AND ! isset($frame['args'])) {
$frame['args'] = $frame['params'];
}
}
}
if (isset(Kohana_Exception::$php_errors[$code])) {
// Use the human-readable error name
$code = Kohana_Exception::$php_errors[$code];
}
}
/**
* The stack trace becomes unmanageable inside PHPUnit.
*
* The error view ends up several GB in size, taking
* serveral minutes to render.
*/
if (
defined('PHPUnit_MAIN_METHOD')
OR
defined('PHPUNIT_COMPOSER_INSTALL')
OR
defined('__PHPUNIT_PHAR__')
) {
$trace = array_slice($trace, 0, 2);
}
// Instantiate the error view.
$view = View::factory(Kohana_Exception::$error_view, get_defined_vars());
// Prepare the response object.
$response = Response::factory();
// Set the response status
$response->status(($e instanceof HTTP_Exception) ? $e->getCode() : 500);
// Set the response headers
$response->headers('Content-Type', Kohana_Exception::$error_view_content_type . '; charset=' . Kohana::$charset);
// Set the response body
$response->body($view->render());
} catch (Exception $e) {
/**
* Things are going badly for us, Lets try to keep things under control by
* generating a simpler response object.
*/
$response = Response::factory();
$response->status(500);
$response->headers('Content-Type', 'text/plain');
$response->body(Kohana_Exception::text($e));
}
return $response;
}Get a single line of text representing the exception:
Error [ Code ]: Message ~ File [ Line ]
Throwable
$e
required - $e stringpublic static function text($e)
{
return sprintf('%s [ %s ]: %s ~ %s [ %d ]', get_class($e), $e->getCode(), strip_tags($e->getMessage()), Debug::path($e->getFile()), $e->getLine());
}Recursive method to fetch all the errors in this exception
string
$alias
required - Alias to use for messages file array
$array
required - Array of Validation objects to get errors from string
$directory
required - Directory to load error messages from mixed
$translate
required - Translate the message arrayprotected function generate_errors($alias, array $array, $directory, $translate)
{
$errors = [];
foreach ($array as $key => $object) {
if (is_array($object)) {
$errors[$key] = ($key === '_external')
// Search for errors in $alias/_external.php
? $this->generate_errors($alias . '/' . $key, $object, $directory, $translate)
// Regular models get their own file not nested within $alias
: $this->generate_errors($key, $object, $directory, $translate);
} elseif ($object instanceof Validation) {
if ($directory === null) {
// Return the raw errors
$file = null;
} else {
$file = trim($directory . '/' . $alias, '/');
}
// Merge in this array of errors
$errors += $object->errors($file, $translate);
}
}
return $errors;
}