375 lines
12 KiB
PHP
375 lines
12 KiB
PHP
<?php
|
|
/**
|
|
* Router - DuckBrain
|
|
*
|
|
* Librería de Enrrutador.
|
|
* Depende de manera forzada de que la constante ROOT_DIR esté definida
|
|
* y de manera optativa de que la constante SITE_URL lo esté también.
|
|
*
|
|
* @author KJ
|
|
* @website https://kj2.me
|
|
* @licence MIT
|
|
*/
|
|
|
|
namespace Libs;
|
|
|
|
class Router {
|
|
private static $get = [];
|
|
private static $post = [];
|
|
private static $put = [];
|
|
private static $patch = [];
|
|
private static $delete = [];
|
|
private static $last;
|
|
public static $notFoundCallback = 'Libs\Router::defaultNotFound';
|
|
|
|
/**
|
|
* Función callback por defectio para cuando
|
|
* no se encuentra configurada la ruta.
|
|
*
|
|
* @return void
|
|
*/
|
|
public static function defaultNotFound (): void
|
|
{
|
|
header("HTTP/1.0 404 Not Found");
|
|
echo '<h2 style="text-align: center;margin: 25px 0px;">Error 404 - Página no encontrada</h2>';
|
|
}
|
|
|
|
/**
|
|
* __construct
|
|
*/
|
|
private function __construct() {}
|
|
|
|
/**
|
|
* Parsea para deectar las pseudovariables (ej: {variable})
|
|
*
|
|
* @param string $path
|
|
* Ruta con pseudovariables.
|
|
*
|
|
* @param callable $callback
|
|
* Callback que será llamado cuando la ruta configurada en $path coincida.
|
|
*
|
|
* @return array
|
|
* Arreglo con 2 índices:
|
|
* path - Contiene la ruta con las pseudovariables reeplazadas por expresiones regulares.
|
|
* callback - Contiene el callback en formato Namespace\Clase::Método.
|
|
*/
|
|
private static function parse(string $path, callable $callback): array
|
|
{
|
|
preg_match_all('/{(\w+)}/s', $path, $matches, PREG_PATTERN_ORDER);
|
|
$paramNames = $matches[1];
|
|
|
|
$path = preg_quote($path, '/');
|
|
$path = preg_replace(
|
|
['/\\\{\w+\\\}/s'],
|
|
['([^\/]+)'],
|
|
$path);
|
|
|
|
return [
|
|
'path' => $path,
|
|
'callback' => [$callback],
|
|
'paramNames' => $paramNames
|
|
];
|
|
}
|
|
|
|
|
|
/**
|
|
* Devuelve el ruta base o raiz del proyecto sobre la que trabajará el router.
|
|
*
|
|
* Ej: Si la url del sistema está en "https://ejemplo.com/duckbrain"
|
|
* entonces la ruta base sería "/duckbrain"
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function basePath(): string
|
|
{
|
|
if (defined('SITE_URL') && !empty(SITE_URL))
|
|
return rtrim(parse_url(SITE_URL, PHP_URL_PATH), '/').'/';
|
|
return str_replace($_SERVER['DOCUMENT_ROOT'], '/', ROOT_DIR);
|
|
}
|
|
|
|
/**
|
|
* Redirije a una ruta relativa interna.
|
|
*
|
|
* @param string $path
|
|
* La ruta relativa a la ruta base.
|
|
*
|
|
* Ej: Si nuesto sistema está en "https://ejemplo.com/duckbrain"
|
|
* llamamos a Router::redirect('/docs'), entonces seremos
|
|
* redirigidos a "https://ejemplo.com/duckbrain/docs".
|
|
* @return void
|
|
*/
|
|
public static function redirect(string $path): void
|
|
{
|
|
header('Location: '.static::basePath().ltrim($path, '/'));
|
|
exit;
|
|
}
|
|
|
|
/**
|
|
* Añade un middleware a la última ruta usada.
|
|
* Solo se puede usar un middleware a la vez.
|
|
*
|
|
* @param callable $callback
|
|
* @param int $prioriry
|
|
*
|
|
* @return static
|
|
* Devuelve la instancia actual.
|
|
*/
|
|
public static function middleware(callable $callback, ?int $priority = null): static
|
|
{
|
|
if (!isset(static::$last))
|
|
return new static();
|
|
|
|
$method = static::$last[0];
|
|
$index = static::$last[1];
|
|
|
|
if (isset($priority) && $priority <= 0)
|
|
$priority = 1;
|
|
|
|
if (is_null($priority) || $priority >= count(static::$$method[$index]['callback']))
|
|
static::$$method[$index]['callback'][] = $callback;
|
|
else {
|
|
static::$$method[$index]['callback'] = array_merge(
|
|
array_slice(static::$$method[$index]['callback'], 0, $priority),
|
|
[$callback],
|
|
array_slice(static::$$method[$index]['callback'], $priority)
|
|
);
|
|
}
|
|
|
|
return new static();
|
|
}
|
|
|
|
/**
|
|
* Reconfigura el callback final de la última ruta.
|
|
*
|
|
* @param callable $callback
|
|
*
|
|
* @return static
|
|
*/
|
|
public static function reconfigure(callable $callback): static
|
|
{
|
|
if (empty(static::$last))
|
|
return new static();
|
|
|
|
$method = static::$last[0];
|
|
$index = static::$last[1];
|
|
|
|
static::$$method[$index]['callback'][0] = $callback;
|
|
|
|
return new static();
|
|
}
|
|
|
|
/**
|
|
* Configura calquier método para todas las rutas.
|
|
*
|
|
* En caso de no recibir un callback, busca la ruta actual
|
|
* solo configura la ruta como la última configurada
|
|
* siempre y cuando la misma haya sido configurada previamente.
|
|
*
|
|
* @param string $method
|
|
* Método http.
|
|
* @param string $path
|
|
* Ruta con pseudovariables.
|
|
* @param callable|null $callback
|
|
*
|
|
* @return
|
|
* Devuelve la instancia actual.
|
|
*/
|
|
public static function configure(string $method, string $path, ?callable $callback = null): static
|
|
{
|
|
if (is_null($callback)) {
|
|
$path = preg_quote($path, '/');
|
|
$path = preg_replace(
|
|
['/\\\{\w+\\\}/s'],
|
|
['([^\/]+)'],
|
|
$path);
|
|
|
|
foreach(static::$$method as $index => $router)
|
|
if ($router['path'] == $path) {
|
|
static::$last = [$method, $index];
|
|
break;
|
|
}
|
|
|
|
return new static();
|
|
}
|
|
|
|
static::$$method[] = static::parse($path, $callback);
|
|
static::$last = [$method, count(static::$$method)-1];
|
|
return new static();
|
|
}
|
|
|
|
/**
|
|
* Define los routers para el método GET.
|
|
*
|
|
* @param string $path
|
|
* Ruta con pseudovariables.
|
|
* @param callable|null $callback
|
|
* Callback que será llamado cuando la ruta configurada en $path coincida.
|
|
*
|
|
* @return static
|
|
* Devuelve la instancia actual.
|
|
*/
|
|
public static function get(string $path, ?callable $callback = null): static
|
|
{
|
|
return static::configure('get', $path, $callback);
|
|
}
|
|
|
|
/**
|
|
* Define los routers para el método POST.
|
|
*
|
|
* @param string $path
|
|
* Ruta con pseudovariables.
|
|
* @param callable|null $callback
|
|
* Callback que será llamado cuando la ruta configurada en $path coincida.
|
|
*
|
|
* @return static
|
|
* Devuelve la instancia actual.
|
|
*/
|
|
public static function post(string $path, ?callable $callback = null): static
|
|
{
|
|
return static::configure('post', $path, $callback);
|
|
}
|
|
|
|
/**
|
|
* Define los routers para el método PUT.
|
|
*
|
|
* @param string $path
|
|
* Ruta con pseudovariables.
|
|
* @param callable|null $callback
|
|
* Callback que será llamado cuando la ruta configurada en $path coincida.
|
|
*
|
|
* @return static
|
|
* Devuelve la instancia actual
|
|
*/
|
|
|
|
public static function put(string $path, ?callable $callback = null): static
|
|
{
|
|
return static::configure('put', $path, $callback);
|
|
}
|
|
|
|
/**
|
|
* Define los routers para el método PATCH.
|
|
*
|
|
* @param string $path
|
|
* Ruta con pseudovariables.
|
|
* @param callable|null $callback
|
|
* Callback que será llamado cuando la ruta configurada en $path coincida.
|
|
*
|
|
* @return static
|
|
* Devuelve la instancia actual
|
|
*/
|
|
public static function patch(string $path, ?callable $callback = null): static
|
|
{
|
|
return static::configure('patch', $path, $callback);
|
|
}
|
|
|
|
/**
|
|
* Define los routers para el método DELETE.
|
|
*
|
|
* @param string $path
|
|
* Ruta con pseudovariables
|
|
* @param callable|null $callback
|
|
* Callback que será llamado cuando la ruta configurada en $path coincida.
|
|
*
|
|
* @return static
|
|
* Devuelve la instancia actual
|
|
*/
|
|
public static function delete(string $path, ?callable $callback = null): static
|
|
{
|
|
return static::configure('delete', $path, $callback);
|
|
}
|
|
|
|
/**
|
|
* Devuelve la ruta actual tomando como raíz la ruta de instalación de DuckBrain.
|
|
*
|
|
* @return string
|
|
*/
|
|
public static function currentPath() : string
|
|
{
|
|
return preg_replace('/'.preg_quote(static::basePath(), '/').'/',
|
|
'/', strtok($_SERVER['REQUEST_URI'], '?'), 1);
|
|
}
|
|
|
|
/**
|
|
* Aplica la configuración de rutas.
|
|
*
|
|
* @param string|null $path (opcional) Ruta a usar. Si no se define, detecta la ruta actual.
|
|
*
|
|
* @return void
|
|
*/
|
|
public static function apply(?string $path = null): void
|
|
{
|
|
$path = $path ?? static::currentPath();
|
|
$routers = match($_SERVER['REQUEST_METHOD']) { // Según el método selecciona un arreglo de routers
|
|
'POST' => static::$post,
|
|
'PUT' => static::$put,
|
|
'PATCH' => static::$patch,
|
|
'DELETE' => static::$delete,
|
|
default => static::$get
|
|
};
|
|
|
|
foreach ($routers as $router) { // revisa todos los routers para ver si coinciden con la ruta actual
|
|
if (preg_match_all('/^'.$router['path'].'\/?$/si',$path, $matches, PREG_PATTERN_ORDER)) {
|
|
unset($matches[0]);
|
|
|
|
// Objtener un reflection del callback
|
|
$lastCallback = $router['callback'][0];
|
|
if ($lastCallback instanceof \Closure) { // si es función anónima
|
|
$reflectionCallback = new \ReflectionFunction($lastCallback);
|
|
} else {
|
|
if (is_string($lastCallback))
|
|
$lastCallback = preg_split('/::/', $lastCallback);
|
|
|
|
// Revisamos su es un método o solo una función
|
|
if (count($lastCallback) == 2)
|
|
$reflectionCallback = new \ReflectionMethod($lastCallback[0], $lastCallback[1]);
|
|
else
|
|
$reflectionCallback = new \ReflectionFunction($lastCallback[0]);
|
|
}
|
|
|
|
// Obtener los parámetros
|
|
$arguments = $reflectionCallback->getParameters();
|
|
if (isset($arguments[0])) {
|
|
// Obtenemos la clase del primer parámetro
|
|
$argumentClass = strval($arguments[0]->getType());
|
|
|
|
// Verificamos si la clase está o no tipada
|
|
if (empty($argumentClass)) {
|
|
$request = new Request;
|
|
} else {
|
|
$request = new $argumentClass;
|
|
|
|
// Verificamos que sea instancia de Request (requerimiento)
|
|
if (!($request instanceof Request))
|
|
throw new \Exception('Bad argument type on router callback.');
|
|
}
|
|
} else {
|
|
$request = new Request;
|
|
}
|
|
|
|
// Comprobando y guardando los parámetros variables de la ruta
|
|
if (isset($matches[1])) {
|
|
foreach ($matches as $index => $match) {
|
|
$paramName = $router['paramNames'][$index-1];
|
|
$request->params->$paramName = urldecode($match[0]);
|
|
}
|
|
}
|
|
|
|
// Llama a la validación y luego procesa la cola de callbacks
|
|
$request->next = $router['callback'];
|
|
$data = $request->handle();
|
|
|
|
// Por defecto imprime como JSON si se retorna algo
|
|
if (isset($data)) {
|
|
header('Content-Type: application/json');
|
|
print(json_encode($data));
|
|
}
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Si no hay router que coincida llamamos a $notFoundCallBack
|
|
call_user_func_array(static::$notFoundCallback, [new Request]);
|
|
}
|
|
}
|