/** * Gets the table class name. * * @param string $alias The alias name you want to get. * @param array $options Table options array. * @return string */ protected function _getClassName($alias, array $options = []) { if (empty($options['className'])) { $options['className'] = Inflector::camelize($alias); } return Core::className($options['className'], 'Model/Table', 'Table'); }
/** * Add a provider * * @param string $name The provider's name. * @return $this */ public function useProvider(string $name) { $className = Core::className($name, "", "Provider"); if ($className !== false and !isset($this->_providers[$className])) { $object = new $className(); $this->_providers[$className] = $object; } return $this; }
public static function getEngine() { $engineName = Configuration::getInstance()->get("Cache/engine", "File"); $className = Core::className($engineName, "Cache/Engine", "CacheEngine"); if (!$className) { throw new \RuntimeException(sprintf('Cache Engine class "%s" was not found.', $engineName)); } if (static::$_engine instanceof $className) { return static::$_engine; } return static::_build($className); }
public function __construct(Console $console = null) { parent::__construct($console); foreach ($this->tasks as $task) { if (!($className = Core::className($task, 'Shell/Tasks', 'Task'))) { if (!($className = Core::className($task, 'Console/Tasks', 'Task'))) { throw new MissingTaskException(['class' => $task . 'Task']); } } $this->_loadedTasks[$task] = new $className($console); } }
/** * Renders the response for the exception. * * @return Response The response to be sent. */ public function render($exception) { $exception = $exception instanceof PHP7ErrorException ? $exception->getError() : $exception; list(, $baseClass) = namespaceSplit(get_class($exception)); if (substr($baseClass, -9) === 'Exception') { $baseClass = substr($baseClass, 0, -9); } $action = (new Text($baseClass))->camelBackize() ?: 'error500'; $class = Core::className('Error', 'Controller', 'Controller'); $controller = new $class(); if (!in_array($action, get_class_methods($controller))) { $action = "processError"; } return $controller->callAction($action, ["exception" => $exception, "request" => Router::getInstance()->request()]); }
/** * Returns the class used to hydrate rows for this table or sets * a new one * * @param string|null $name the name of the class to use * @throws \Cake\ORM\Exception\MissingEntityException when the entity class cannot be found * @return string */ public function entityClass($name = null) { if ($name === null && !$this->_entityClass) { $default = '\\Cake\\ORM\\Entity'; $self = get_called_class(); $parts = explode('\\', $self); if ($self === __CLASS__ || count($parts) < 3) { return $this->_entityClass = $default; } $alias = Inflector::singularize(substr(array_pop($parts), 0, -5)); $name = implode('\\', array_slice($parts, 0, -1)) . '\\Entity\\' . $alias; if (!class_exists($name)) { return $this->_entityClass = $default; } } if ($name !== null) { $class = Core::className($name, 'Model/Entity'); $this->_entityClass = $class; } if (!$this->_entityClass) { throw new MissingEntityException([$name]); } return $this->_entityClass; }
/** * Get the crypto implementation based on the loaded extensions. * * You can use this method to forcibly decide between mcrypt/openssl/custom implementations. * * @param AbstractEncryptEngine|string|null $engine The crypto engine to use. * @return AbstractEncryptEngine Crypto instance. * @throws \InvalidArgumentException When no compatible crypto extension is available. */ public static function engine($engine = null) { if ($engine === null && static::$_engine === null) { if (extension_loaded('openssl')) { $engine = new OpenSslEngine(); } elseif (extension_loaded('mcrypt')) { $engine = new MCryptEngine(); } } if (is_string($engine)) { $engine = Core::className($engine, "Util/CrypTyson", "Engine"); $eng = new $engine(); if ($eng instanceof AbstractEncryptEngine) { static::$_engine = $eng; } } if ($engine instanceof AbstractEncryptEngine) { static::$_engine = $engine; } if (isset(static::$_engine)) { return static::$_engine; } throw new InvalidArgumentException('No compatible crypto engine available. ' . 'Load either the openssl or mcrypt extensions'); }
protected function _engine() : AbstractRenderingEngine { if ($this->_engine) { return $this->_engine; } $className = Configuration::getInstance()->get("View/renderingEngine", "Php"); $className = Core::className($className, "View/RenderingEngine", "RenderingEngine"); if (!$className) { throw new \RuntimeException('Rendering Engine class was not found.'); } $engine = new $className(); if (!$engine instanceof AbstractRenderingEngine) { throw new \RuntimeException('Rendering engine must extend AbstractRenderingEngine class.'); } return $this->_engine = $engine; }
/** * Renders the given cell. * * Example: * * ``` * // App\View\Cell\TagCloudCell::smallList() * $cell = $this->cell('TagCloud::smallList', ['limit' => 10]); * ``` * * The `run` action will be used by default when no action is provided: * * ``` * // App\Cell\TagCloudCell::run() * $cell = $this->cell('TagCloud'); * ``` * * Cells are not rendered until they are echoed. * * @param string $cell You must indicate cell name, and optionally a cell action. e.g.: `TagCloud::smallList` * will invoke `View\Cell\TagCloudCell::smallList()`, `display` action will be invoked by default when none is provided. * @param array $data Additional arguments for cell method. e.g.: * `cell('TagCloud::smallList', ['a1' => 'v1', 'a2' => 'v2'])` maps to `View\Cell\TagCloud::smallList(v1, v2)` * @return AbstractCell The cell instance * @throws MissingCellException If Cell class was not found. * @throws BadMethodCallException If Cell class does not specified cell action. */ public function cell(string $cell, $data = []) : AbstractCell { $className = Core::className($cell, 'Cell', 'Cell'); if (!$className) { throw new MissingCellException(['className' => $cell . 'Cell']); } $cell = new $className(); $cell->helpers += $this->getLoadedHelpers(); if (!method_exists($cell, "run")) { throw new BadMethodCallException(sprintf('Class %s does not have a run() method.', $className)); } if ($data instanceof ArrayObject) { $data = $data->toStandardArray(); } call_user_func_array([$cell, "run"], $data); return $cell; }
/** * Initializes the components and models a controller will be using. * Triggers the controller action and invokes the rendering if Controller::$autoRender * is true. If a response object is returned by controller action that is returned * else controller's $response property is returned. * * @param Request $request Controller to invoke * @return Response The resulting response object * @throws MissingControllerException */ public function exec(Request $request) : Response { $response = null; if (is_string($this->_callable)) { $params = explode('#', $this->_callable); $controller = Core::className($params[0], "Controller", "Controller"); if (!$controller) { throw new MissingControllerException([$params[0] . "Controller"]); } $controller = new $controller(); if (!isset($params[1]) or empty($params[1])) { $params[1] = "index"; } $request->params['controller'] = $controller; $request->params['action'] = $params[1]; $request->params['arguments'] = $this->_params; $controller->setUp(); $response = $controller->dispatch($request); $controller->tearDown(); } elseif (is_callable($this->_callable)) { $params = []; foreach ($this->_params as $parameter) { $params[] = $parameter["value"]; } $response = call_user_func_array($this->_callable, $params); } return $response; }
/** * Displays an exception response body. * * @param \Exception $exception The exception to display * @return void * @throws \Exception When the chosen exception renderer is invalid. */ protected function _displayException($exception) { $config = Configuration::getInstance(); $renderer = Core::className($config->get("Error/exceptionRenderer", 'CoreTyson\\Error\\ExceptionRenderer'), 'Error'); try { if (!$renderer) { throw new Exception("{$renderer} is an invalid class."); } $error = new $renderer($exception); $response = $error->render(); $this->_clearOutput(); $this->_sendResponse($response); } catch (Exception $e) { // Disable trace for internal errors. $config->set("Error/printTrace", "false"); $message = sprintf("[%s] %s\n%s", get_class($e), $e->getMessage(), $e->getTraceAsString()); trigger_error($message, E_USER_ERROR); } }
/** * Add a middleware to the controller's registry. * * This method will also set the middleware to a property. * For example: * * ``` * $this->loadMiddleware('Auth'); * ``` * * Will result in a `Auth` property being set. * * @param string $name The name of the middleware to load. * @return \CoreTyson\Controller\Middleware\AbstractMiddleware */ public function loadMiddleware(string $name) : AbstractMiddleware { if (isset($this->_middlewareRegistry[$name])) { return $this->_middlewareRegistry[$name]; } Core::className($name, "Controller/Middleware", "Middleware"); $className = Core::className($name, "Controller/Middleware", "Middleware"); $middleware = new $className(); $this->_middlewareRegistry[$name] = $middleware; $this->{$name} = $middleware; return $this->{$name}; }
/** * Sets the driver instance. If a string is passed it will be treated * as a class name and will be instantiated. * * If no params are passed it will return the current driver instance. * * @param string|null $driver The driver instance to use. * @param array $config Either config for a new driver or null. * @throws \CoreTyson\Database\Exception\MissingDriverException When a driver class is missing. * @throws \CoreTyson\Database\Exception\MissingExtensionException When a driver's PHP extension is missing. * @return \CoreTyson\Database\Driver\AbstractDriver */ public function driver($driver = null, array $config = []) { if ($driver === null) { return $this->_driver; } if (is_string($driver)) { $driver = Core::className($driver, 'Database\\Driver', 'Driver'); if (!class_exists($driver)) { throw new MissingDriverException([$driver]); } $driver = new $driver($config); } else { return null; } if (!$driver->enabled()) { throw new MissingExtensionException(get_class($driver)); } return $this->_driver = $driver; }