Class ORM_Validation_Exception

ORM_Validation_Exception

extends Kohana_ORM_Validation_Exception
extends Kohana_Exception
extends Kohana_Kohana_Exception
extends Exception

Implements: Throwable

ORM Validation exceptions.

package
Kohana/ORM
author
Kohana Team
copyright
(c) Kohana Team
license
https://koseven.ga/LICENSE.md


Information

This class is a transparent base class for Kohana_ORM_Validation_Exception

Constants

  • None

Properties

Methods

Properties

public static string $error_view

error rendering view

string(12) "kohana/error"

public static string $error_view_content_type

error view content type

string(9) "text/html"

public static array $php_errors

PHP 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"
)

protected string $_alias

The alias of the main ORM model this exception was created for

Default value: 
NULL

protected array $_objects

Array of validation objects

Default value: 
array(0)

protected $code

Default value: 
integer 0

protected $file

Default value: 
NULL

protected $line

Default value: 
NULL

protected $message

Default value: 
string(0) ""

Methods

public __construct(string $alias , Validation $object [, string $message = string(24) "Failed to validate array" , array $values = NULL , integer $code = integer 0 , $previous = NULL ] ) (defined in Kohana_ORM_Validation_Exception)

Constructs a new exception for the specified model

Parameters

  • 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

Return Values

  • void

Source Code

public 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);
}

public add_object(string $alias , Validation $object [, mixed $has_many = bool FALSE ] ) (defined in Kohana_ORM_Validation_Exception)

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
// array
// (
//   'username' => 'This field is required',
//   'profile'  => array
//   (
//     'first_name' => 'This field is required',
//   ),
// );

Parameters

  • 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

Return Values

  • ORM_Validation_Exception

Source Code

public 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;
}

public alias() (defined in Kohana_ORM_Validation_Exception)

Returns the protected _alias property from this exception

Return Values

  • string

Source Code

public function alias()
{
	return $this->_alias;
}

public errors([ string $directory = NULL , mixed $translate = bool TRUE ] ) (defined in Kohana_ORM_Validation_Exception)

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');

Parameters

  • string $directory = NULL - Directory to load error messages from
  • mixed $translate = bool TRUE - Translate the message

Tags

Return Values

  • array

Source Code

public function errors($directory = NULL, $translate = TRUE)
{
	return $this->generate_errors($this->_alias, $this->_objects, $directory, $translate);
}

public merge(ORM_Validation_Exception $object [, mixed $has_many = bool FALSE ] ) (defined in Kohana_ORM_Validation_Exception)

Merges an ORM_Validation_Exception object into the current exception Useful when you want to combine errors into one array

Parameters

  • 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

Return Values

  • ORM_Validation_Exception

Source Code

public 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;
}

public objects() (defined in Kohana_ORM_Validation_Exception)

Returns the protected _objects property from this exception

Return Values

  • array

Source Code

public function objects()
{
	return $this->_objects;
}

public __toString() (defined in Kohana_Kohana_Exception)

Magic object-to-string method.

echo $exception;

Tags

Return Values

  • string

Source Code

public function __toString()
{
    return Kohana_Exception::text($this);
}

public static _handler(Exception $e ) (defined in Kohana_Kohana_Exception)

Exception handler, logs the exception and generates a Response object for display.

Parameters

  • Exception $e required - $e

Tags

Return Values

  • Response

Source Code

public 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);
    }
}

public static handler(Exception $e ) (defined in Kohana_Kohana_Exception)

Inline exception handler, displays the error message, source of the exception, and the stack trace of the error.

Parameters

  • Exception $e required - $e

Tags

Return Values

  • void

Source Code

public static function handler($e)
{
    $response = Kohana_Exception::_handler($e);

    // Send the response to the browser
    echo $response->send_headers()->body();

    exit(1);
}

public static log(Exception $e [, int $level = integer 1 ] ) (defined in Kohana_Kohana_Exception)

Logs an exception.

Parameters

  • Exception $e required - $e
  • int $level = integer 1 - $level

Tags

Return Values

  • void

Source Code

public 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();
    }
}

public static response(Exception $e ) (defined in Kohana_Kohana_Exception)

Get a Response object representing the exception

Parameters

  • Exception $e required - $e

Tags

Return Values

  • Response

Source Code

public static function response($e)
{
    if ( ! $e instanceof Exception AND ! $e instanceof Throwable )
        throw InvalidArgumentException;

    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;
}

public static text(Exception $e ) (defined in Kohana_Kohana_Exception)

Get a single line of text representing the exception:

Error [ Code ]: Message ~ File [ Line ]

Parameters

  • Exception $e required - $e

Return Values

  • string

Source Code

public static function text($e)
{
    if ( ! $e instanceof Exception AND ! $e instanceof Throwable )
        throw InvalidArgumentException;

    return sprintf('%s [ %s ]: %s ~ %s [ %d ]',
        get_class($e), $e->getCode(), strip_tags($e->getMessage()), Debug::path($e->getFile()), $e->getLine());
}

public __wakeup() (defined in Exception)

final public getCode() (defined in Exception)

final public getFile() (defined in Exception)

final public getLine() (defined in Exception)

final public getMessage() (defined in Exception)

final public getPrevious() (defined in Exception)

final public getTrace() (defined in Exception)

final public getTraceAsString() (defined in Exception)

protected generate_errors(string $alias , array $array , string $directory , mixed $translate ) (defined in Kohana_ORM_Validation_Exception)

Recursive method to fetch all the errors in this exception

Parameters

  • 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

Return Values

  • array

Source Code

protected 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;
}

final private __clone() (defined in Exception)

Modules

Do you want to contribute to Koseven?

Koseven Logo

We need YOUR help!

This project is open source. What does this mean? YOU can help:
  • Found a bug? Report it on Github
  • Need a feature? Add it Here
  • Want to help? Join the Forum
Go to Github