/**
* Initialize the route dispatcher and defined routes.
*/
protected function initRoutes()
{
$this->dispatcher = FastRoute\simpleDispatcher(function (RouteCollector $r) {
$r->addRoute('GET', '/', 'IndexController@index');
$r->addRoute('GET', '/{id:\\d+}', 'IndexController@withId');
});
}
/**
* Router constructor.
*/
public function __construct()
{
$dispatcher = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $collector) {
$collector->addRoute(['GET'], '/logout', [new \App\Controllers\AdminController(), 'logout']);
$collector->addRoute(['GET', 'POST'], '/[{table}[/{action}[/{id}]]]', [new \App\Controllers\AdminController(), 'main']);
});
$factory = new Abimo\Factory();
$request = $factory->request();
$method = $request->method();
$uri = $request->uri();
$route = $dispatcher->dispatch($method, $uri);
switch ($route[0]) {
case FastRoute\Dispatcher::NOT_FOUND:
$response = $factory->response();
$response->header('404', true, 404)->send();
throw new \ErrorException("Route {$method} {$uri} not found.");
break;
case FastRoute\Dispatcher::METHOD_NOT_ALLOWED:
$response = $factory->response();
$response->header('405', true, 405)->send();
throw new \ErrorException("Method {$method} not allowed.");
break;
case FastRoute\Dispatcher::FOUND:
$handler = $route[1];
$arguments = $route[2];
call_user_func_array($handler, $arguments);
}
}
/**
* Create a new server application instance.
*
* @param string $path The path to the application files.
*/
public function __construct(string $path)
{
$this->path = $path;
// Register some routes.
$this->dispatcher = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
$r->addRoute('GET', '/', actions\IndexAction::class);
$r->addRoute('GET', '/blog', actions\BlogAction::class);
$r->addRoute('GET', '/category/{category}', actions\CategoryAction::class);
$r->addRoute('GET', '/portfolio', actions\PortfolioAction::class);
$r->addRoute('GET', '/{year:\\d{4}}/{month:\\d{2}}/{day:\\d{2}}/{name}', actions\ArticleAction::class);
$r->addRoute('GET', '/{asset:(?:content|assets)/[^?]+}[?{query}]', actions\AssetAction::class);
// Complicated feed routes :/
$r->addRoute('GET', '/sitemap.xml', actions\SitemapAction::class);
$r->addRoute('GET', '/feed[/{category:[a-z]+}]', actions\AtomFeedAction::class);
$r->addRoute('GET', '/feed.atom', actions\AtomFeedAction::class);
$r->addRoute('GET', '/feed/{category:[a-z]+}.atom', actions\AtomFeedAction::class);
$r->addRoute('GET', '/feed.rss', actions\RssFeedAction::class);
$r->addRoute('GET', '/feed/{category:[a-z]+}.rss', actions\RssFeedAction::class);
});
// Create the server object.
$this->server = new Server(new RequestHandler($this));
// Create some core services.
$this->renderer = new Renderer($path . '/templates');
$this->assetManager = new AssetManager($path . '/static');
$this->articleStore = new ArticleStore($path . '/articles');
}
public function setUp()
{
$router = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
$r->addRoute('GET', '/', ['TestApp\\Controller\\Index', 'index']);
});
$this->app = new App($router);
}
public function setUp()
{
chdir(__DIR__ . '/app/');
$this->router = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
$r->addRoute('GET', '/load', ['TestApp\\Controller\\Index', 'loadedParams'], ['name' => 'load']);
});
}
/**
* Invocation
*
* Register routes container and request attributes
*
* @param ServerRequestInterface $request Request
* @param ResponseInterface $response Response
* @param TornadoHttp $next Next Middleware - TornadoHttp container
* @return ResponseInterface
* @throws HttpMethodNotAllowedException
* @throws HttpNotFoundException
*/
public function __invoke(ServerRequestInterface $request, ResponseInterface $response, TornadoHttp $next)
{
/** @var \FastRoute\Dispatcher\GroupCountBased $dispatcher */
$dispatcher = FastRoute\simpleDispatcher(function (RouteCollector $routeCollector) {
foreach ($this->routes as $key => $route) {
$routeCollector->addRoute($route['methods'], $route['path'], $key);
}
});
$method = $request->getMethod();
$uri = rawurldecode(parse_url($request->getUri(), \PHP_URL_PATH));
$route = $dispatcher->dispatch($method, $uri);
$handler = null;
$vars = null;
switch ($route[0]) {
case Dispatcher::NOT_FOUND:
throw new HttpNotFoundException('Inexistent route for the url ' . $request->getUri());
case Dispatcher::METHOD_NOT_ALLOWED:
throw new HttpMethodNotAllowedException('Method not allowed');
case Dispatcher::FOUND:
$handler = $route[1];
$vars = $route[2];
break;
}
$request = $request->withAttribute(Router::REGISTER_KEY, $handler);
foreach ($vars as $name => $value) {
$request = $request->withAttribute($name, $value);
}
return $next($request, $response);
}
public function setUp()
{
$config = Loader::load();
$config['router'] = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
$r->addRoute('GET', '/', ['TestApp\\Controller\\IndexController', 'index']);
});
$this->app = new App(Container\PHPDiFactory::buildContainer($config));
}
public function __construct()
{
$this->dispatcher = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
$r->addRoute('GET', '/', 'IndexController');
$r->addRoute('POST', '/', 'IndexController');
});
$this->request = Request::createFromGlobals();
}
/**
* Register necessary routes with route provider
*/
protected function registerRoutes()
{
$this->dispatcher = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $routeCollector) {
$this->each(function (RouteRequest $routeRequest) use($routeCollector) {
$routeCollector->addRoute($routeRequest->method, $routeRequest->route, $routeRequest->callable);
});
});
}
/**
* Instantiates the router using the routes in the container.
*/
private function createDispatcher()
{
$this->dispatcher = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $collector) {
foreach ($this->container->get('routes') as $route) {
$collector->addRoute($route['method'], $route['pattern'], $route['service']);
}
});
}
public function setUp()
{
$this->router = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $manager) {
$manager->addRoute('GET', '/', ['TestApp\\Controller\\IndexController', 'index'], ['name' => 'index']);
$manager->addRoute('GET', '/fail', ['TestApp\\Controller\\IndexController', 'none'], ['name' => 'fail']);
$manager->addRoute('GET', '/dummy', ['TestApp\\Controller\\IndexController', 'dummy'], ['name' => 'dummy']);
});
}
/**
* @return Dispatcher
*/
protected function dispatcher()
{
return FastRoute\simpleDispatcher(function (RouteCollector $collector) {
foreach ($this->directory as $request => $action) {
list($method, $path) = explode(' ', $request, 2);
$collector->addRoute($method, $this->directory->prefix($path), $action);
}
});
}
public function setUp()
{
chdir(__DIR__ . '/app/');
$config = Loader::load();
$config['router'] = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
$r->addRoute('GET', '/load', ['TestApp\\Controller\\IndexController', 'loadedParams'], ['name' => 'load']);
});
$this->container = Container\PHPDiFactory::buildContainer($config);
}
public function setUp()
{
$config = Loader::load();
$config['router'] = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
$r->addRoute('GET', '/', [get_class($this), 'index']);
});
$config['dispatcher'] = \Di\object('PennyTest\\Utils\\FastSymfonyDispatcher')->constructor(\Di\get('router'), \Di\get('di'));
$this->app = new App(Container\PHPDiFactory::buildContainer($config));
}
public function setUp()
{
$this->router = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $router) {
$router->addRoute('GET', '/', ['TestApp\\Controller\\Index', 'diTest']);
});
$builder = new ContainerBuilder();
$builder->useAnnotations(true);
$dic = $builder->build();
$this->container = $dic;
}
public function compile()
{
if (!$this->dispatcher) {
$this->dispatcher = BaseFastRoute\simpleDispatcher(function (BaseFastRoute\RouteCollector $r) {
foreach ($this->routes as $route) {
$r->addRoute($route[0], $route[1], $route[2]);
}
});
}
}
/**
* @return Dispatcher
*/
protected function dispatcher()
{
return FastRoute\simpleDispatcher(function (RouteCollector $collector) {
foreach ($this->directory as $request => $action) {
// 'GET /foo' becomes ['GET', '/foo']
list($method, $path) = explode(' ', $request, 2);
$collector->addRoute($method, $path, $action);
}
});
}
/**
* @return Dispatcher
*/
protected function getRouteDispatcher()
{
$dispatcher = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
$routes = Routes::$routeRegister;
foreach ($routes as $route) {
$r->addRoute($route->getRequestMethod(), $route->getPathPattern(), $route);
}
});
return $dispatcher;
}
/**
* Add routes definition to collector and dispatch it
*
* @param array $routes
* @param array $routerOptions
*/
public function __construct(array $routes, array $routerOptions = [])
{
$this->routes = $routes;
$this->routerOptions = array_merge($this->routerOptions, $routerOptions);
if (!$this->routerOptions['cacheDisabled']) {
$this->dispatcher = cachedDispatcher($this->prepareRoutes(), $this->routerOptions);
} else {
$this->dispatcher = simpleDispatcher($this->prepareRoutes(), $this->routerOptions);
}
}
/**
* Initialize a Router.
*
* Routes require a 'path' key and may have optional 'methods' and 'defaults' keys.
*
* @param array $routeData Array of routes
*/
public function __construct(array $routeData)
{
$this->dispatcher = simpleDispatcher(function ($r) use($routeData) {
foreach ($routeData as $data) {
if (is_array($data)) {
$data = Route::fromArray($data);
}
$r->addRoute($data->getMethods(), $data->getPath(), $data);
}
});
}
public function __construct(UserMapper $userMapper, Acl $acl, Directory $directory)
{
$this->userMapper = $userMapper;
$this->acl = $acl;
$this->directory = $directory;
$this->dispatcher = FastRoute\simpleDispatcher(function (RouteCollector $collector) {
foreach ($this->directory as $request => $action) {
list($method, $path) = explode(' ', $request, 2);
$collector->addRoute($method, $path, $action);
}
});
}
/**
* Defines blog and page routes.
*
* @throws RuntimeException
*/
protected function setRoutes()
{
if (empty($this->config['routes'])) {
throw new RuntimeException('No routes defined in configuration file.');
}
$this->dispatcher = FastRoute\simpleDispatcher(function (RouteCollector $collector) {
foreach ($this->config['routes'] as $routeName => $route) {
if (empty($route['method']) || empty($route['route']) || empty($route['action'])) {
throw new RuntimeException('Invalid route in configuration.');
}
$collector->addRoute($route['method'], $route['route'], $route['action']);
}
});
}
/**
* This method is not part of the public API. Implementations should use
* Router::fromArray().
*
* @param RouteInterface[] A collection of routes
*/
public function __construct(array $routes)
{
$this->routes = array();
$this->dispatcher = FastRoute\simpleDispatcher(function (RouteCollector $collector) use($routes) {
foreach ($routes as $route) {
if (!$route instanceof RouteInterface) {
throw new \InvalidArgumentException('Routes array must contain only RouteInterface objects');
}
$key = spl_object_hash($route);
$this->routes[$key] = $route;
$collector->addRoute($route->getMethods(), $route->getPattern(), $key);
}
});
}
public function route($url)
{
$routes = $this->_container->get('routes');
\Debug::addRoutes($routes);
$dispatcher = null;
$callable = function (FastRoute\RouteCollector $r) use($routes) {
foreach ($routes as $key => $value) {
$methodsall = $value->getMethods();
if (count($methodsall) == 0) {
$methodsall = array('GET', 'POST');
}
$chaine = $key . "::" . $value->getDefaults()['controller'] . "::" . $value->getDefaults()['action'];
$r->addRoute($methodsall, $value->getPath(), $chaine);
}
};
if (DEVELOPMENT_ENVIRONMENT) {
$dispatcher = FastRoute\simpleDispatcher($callable);
} else {
$pathCache = CACHEPATH . DS . "route" . DS . "route.cache";
$arrCache = array('cacheFile' => $pathCache, 'cacheDisabled' => false);
$dispatcher = FastRoute\cachedDispatcher($callable, $arrCache);
}
$method = $this->_request->getMethod();
if (false !== ($pos = strpos($url, '?'))) {
$url = substr($url, 0, $pos);
}
$uri = rawurldecode($url);
$routeInfo = $dispatcher->dispatch($method, $uri);
switch ($routeInfo[0]) {
case FastRoute\Dispatcher::NOT_FOUND:
$this->_route = "";
break;
case FastRoute\Dispatcher::METHOD_NOT_ALLOWED:
$allowedMethods = $routeInfo[1];
$this->_route = "";
throw new \GL\Core\Exception\MethodNotAllowedException();
break;
case FastRoute\Dispatcher::FOUND:
$handler = $routeInfo[1];
$vars = $routeInfo[2];
$params = explode("::", $handler);
$this->_args = $vars;
$this->_route = $params[0];
$this->_controller = $params[1];
$this->_method = $params[2];
break;
}
return $this->_route != "";
}
/**
* Route-ok betöltése. A megfelelő tömb struktúra az osztály leírásában található.
*
* @param array $routes
*/
public function setRoutes(array $routes)
{
$this->routes = $routes;
$this->dispatcher = simpleDispatcher(function (RouteCollector $r) use($routes) {
foreach ($routes as $route) {
// Ha kötelező, akkor csak locale-os url-t készítünk.
if (!isset($route["locale"]) || $route["locale"] == LanguageRouter::LOCALE_REQUIRED) {
$r->addRoute($route["method"], "/{locale:[a-z]+}" . $route["url"], $route["handler"]);
} elseif ($route["locale"] == LanguageRouter::LOCALE_OPTIONAL) {
$r->addRoute($route["method"], $route["url"], $route["handler"]);
$r->addRoute($route["method"], "/{locale:[a-z]+}" . $route["url"], $route["handler"]);
} elseif ($route["locale"] == LanguageRouter::LOCALE_NOT_ALLOWED) {
$r->addRoute($route["method"], $route["url"], $route["handler"]);
}
}
});
}
public function detectUri()
{
$returnObj = new \stdClass();
$returnObj->fileArbo = '';
$returnObj->nameCtr = '';
$returnObj->nameMethode = '';
$httpMethod = $_SERVER['REQUEST_METHOD'];
$uriParse = parse_url($_SERVER['REQUEST_URI']);
$request = rawurldecode($uriParse['path']);
$routes = (require path . 'configs/bfw-fastroute/routes.php');
$dispatcher = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $router) use($routes) {
foreach ($routes as $slug => $infos) {
$slug = trim($slug);
$method = ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE'];
if (isset($infos['httpMethod'])) {
$method = $infos['httpMethod'];
}
$handler = $infos;
unset($handler['httpMethod']);
$router->addRoute($method, $slug, $handler);
}
});
if ($request === '') {
$request = '/';
}
$routeInfo = $dispatcher->dispatch($httpMethod, $request);
$routeStatus = $routeInfo[0];
$routeError = 0;
if ($routeStatus === FastRoute\Dispatcher::METHOD_NOT_ALLOWED) {
$routeError = 405;
}
if ($routeStatus !== FastRoute\Dispatcher::FOUND) {
$routeError = 404;
}
if ($routeError !== 0) {
ErrorView($routeError, true);
//exit doing in ErrorView
}
$fastRouteCallback = $this->config->routeCallback;
if (isset($fastRouteCallback) && is_callable($fastRouteCallback)) {
$fastRouteCallback($returnObj, $routeInfo[1]);
}
$this->getArgs = $routeInfo[2];
return $returnObj;
}
public function setUp()
{
$router = FastRoute\simpleDispatcher(function (FastRoute\RouteCollector $r) {
$r->addRoute('GET', '/', ['TestApp\\Controller\\Index', 'index']);
$r->addRoute('GET', '/{id:\\d+}', ['TestApp\\Controller\\Index', 'getSingle']);
$r->addRoute('GET', '/fail', ['TestApp\\Controller\\Index', 'failed']);
$r->addRoute('GET', '/dummy', ['TestApp\\Controller\\Index', 'dummy']);
});
$this->app = new App($router);
$this->app->getContainer()->get('event_manager')->attach('ERROR_DISPATCH', function ($e) {
if ($e->getException() instanceof RouteNotFound) {
$response = $e->getResponse()->withStatus(404);
$e->setResponse($response);
}
if (405 == $e->getException() instanceof MethodNotAllowed) {
$response = $e->getResponse()->withStatus(405);
$e->setResponse($response);
}
});
}
/**
* Get routes from dispatcher.
*
* @return mixed
*/
public function getDispatcher()
{
$dispatcher = FastRoute\simpleDispatcher(function (RouteCollector $route) {
// Added all routes
foreach ($this->routes as $param) {
// Check method is defined
if (count($param[2]) == 2) {
$route->addRoute($param[0], $param[1], $param[2]);
} elseif (isset($param[2][0])) {
// Create object reflection
$obj = new ReflectionClass($param[2][0]);
// Check object implements restful interface
if ($obj->implementsInterface(RestfulControllerInterface::class)) {
// Get restful methods
$this->addRestfulMethods($route, $param);
}
}
}
});
return $dispatcher;
}
public function __construct(Injector $injector, Session $session, array $routes)
{
$this->injector = $injector;
$this->session = $session;
$this->dispatcher = simpleDispatcher(function (RouteCollector $r) use($routes) {
foreach ($routes as $i => $route) {
if (!isset($route['method'], $route['pattern'])) {
throw new InvalidRouteException('Invalid route at index ' . $i . ': method and pattern required');
}
if (isset($route['target_builder'])) {
$r->addRoute($route['method'], $route['pattern'], $route['target_builder']);
} else {
if (isset($route['target_class'], $route['target_method'])) {
$r->addRoute($route['method'], $route['pattern'], ['class' => $route['target_class'], 'method' => $route['target_method']]);
} else {
throw new InvalidRouteException('Invalid route at index ' . $i . ': no valid target');
}
}
}
});
}
/**
* @param $method
* @param $uri
* @return array
* @throws HttpNotFoundException
*/
public function findRoute($method, $uri)
{
$routes = $this->getRoutes();
//Hozzá kell még adni a nyelvi url-t, ha van.
$translator = Application::Translator();
if ($translator != null) {
$langRoute = $translator->getCookieSetUrl();
if ($langRoute != null) {
$routes["langSetRoute"] = ["method" => $langRoute["method"], "url" => $langRoute["url"], "handler" => $langRoute["handler"]];
}
}
$this->dispatcher = simpleDispatcher(function (RouteCollector $r) use($routes) {
foreach ($routes as $route) {
$r->addRoute($route["method"], $route["url"], $route["handler"]);
}
});
// Strip query string (?foo=bar) and decode URI
if (false !== ($pos = strpos($uri, '?'))) {
$uri = substr($uri, 0, $pos);
}
$uri = rawurldecode($uri);
$routeInfo = $this->dispatcher->dispatch($method, $uri);
switch ($routeInfo[0]) {
case RouterInterface::NOT_FOUND:
throw new HttpNotFoundException();
case RouterInterface::METHOD_NOT_ALLOWED:
throw new HttpNotFoundException();
case RouterInterface::FOUND:
foreach ($routes as $route) {
if ($route["handler"] == $routeInfo[1]) {
$this->actualRoute = $route;
break;
}
}
return ["handler" => $routeInfo[1], "params" => $routeInfo[2]];
default:
return [];
}
}
