/** * Development Mode Exception Handler * * @param Exception $e * Exception thrown */ public static function development(\Exception $e) { // Enforcing Error Handler if ($e instanceof ErrorException) { return self::error(2, $e->getMessage(), $e->getFile(), $e->getLine()); } $code = 406; // Default Code NOT ACCEPTABLE if (method_exists($e, 'getResponseCode')) { $code = $e->getResponseCode(); } self::handle('Next\\Components\\Debug\\Handlers\\Controllers\\ExceptionController', 'development', array('e' => $e), $code); }
/** * Allow extended Objects to be called in this Object context * * IMPORTANT! * * Watch out when use Fluent Interfaces, because the "bridging" * feature WILL return the METHOD called, not the invoker object * * @param string $method * Method trying to be invoked * * @param array|optional $args * Variable list of arguments to the method * * @return mixed|boolean * Return what extended method returns * * @throws Next\Components\Debug\Exception * Object Constructor was overwritten without invoking it through * parent:: context */ public function __call($method, array $args = array()) { if (is_null($this->context)) { throw \Next\Components\Debug\Exception::unfullfilledRequirements('<p> Method <strong>%s</strong> is not known by <strong>%s</strong> and was not trapped by <em>__call()</em>. </p> <p> Could you possibly overwrote <em>Object::__construct()</em> without invoke it under parent context? </p>', array($method, $this)); } // Trying to call as an extended method try { return $this->context->call($this, $method, $args); } catch (\Next\Components\Debug\Exception $e) { // Trying to call as a prototyped method return $this->call($this, $method, $args); } }
/** * Invoke an extended resource from a caller context * * @param Next\Components\Object $caller * Caller Object * * @param string $method * Callable resource name * * @param array $args * Calling Arguments * * @return mixed|boolean * Return what extended method returns. * * If invoking process fail, false will returned. * * @throws Next\Components\Debug\Exception * Called resource is not known as an extended method */ public function call(Object $caller, $method, array $args = array()) { $caller = $caller->getClass()->getName(); if (array_key_exists($caller, $this->callables)) { $offset = ArrayUtils::search($this->callables[$caller], $method); if ($offset != -1) { try { $reflector = new \ReflectionMethod($this->callables[$caller][$offset][0], $method); return $reflector->invokeArgs($this->callables[$caller][$offset][0], $args); } catch (\ReflectionException $e) { return FALSE; } } } // Unknown Method throw \Next\Components\Debug\Exception::wrongUse('Method <strong>%s</strong> could not be matched against any methods in extended Context', array($method)); }
/** * Exception Constructor */ public function __construct() { $args = func_get_args(); // Exception Message $message = array_shift($args); // Listing Additional Exception Components list($code, $replacements, $responseCode) = $args + array(self::UNKNOWN, array(), 200); // Checking Exception Components... $this->checkComponents($message, (array) $replacements, $code, $responseCode); // ... and settle them up $this->replacements = (array) $replacements; $this->responseCode = $responseCode; // Constructing the Exception parent::__construct($this->_getMessage($message), $code); }
/** * Invoke a prototyped resource from a caller context * * @param Next\Components\Object $caller * Caller Object * * @param string $method * Callable resource name * * @param array $args * Calling Arguments * * @return Next\Components\Object * Caller Object updated * * @throws Next\Components\Debug\Exception * Called resource is not known as a prototype nor as a extended method */ public function call(Object $caller, $method, array $args = array()) { if (isset(self::$prototypes[$method])) { // Merging always optional arguments with called arguments if (count($args) > 0) { ArrayUtils::insert(self::$prototypes[$method][1], $args); } else { // Nothing to Merge? OK! $args =& self::$prototypes[$method][1]; } $result = call_user_func_array(self::$prototypes[$method][0], $args); /** * @internal * * If operation results in an Object, let's return it * * This ensures operations of one type can return a different type */ if ($result instanceof Object) { return $result; } // Otherwise let's update caller Object return $caller->set($result); } throw \Next\Components\Debug\Exception::wrongUse('Method <strong>%s</strong> could not be matched against any methods in extended Context or prototyped functions', array($method)); }