/** * Tries to match a URL based on Apache mod_rewrite matching. * * Returns false if no route matches the URL. * * @param string $pathinfo The pathinfo to be parsed * * @return array An array of parameters * * @throws MethodNotAllowedException If the current method is not allowed */ public function match($pathinfo) { $parameters = array(); $allow = array(); $match = false; foreach ($_SERVER as $key => $value) { $name = $key; if (0 === strpos($name, 'REDIRECT_')) { $name = substr($name, 9); } if (0 === strpos($name, '_ROUTING_')) { $name = substr($name, 9); } else { continue; } if ('_route' == $name) { $match = true; } elseif (0 === strpos($name, '_allow_')) { $allow[] = substr($name, 7); } else { $parameters[$name] = $value; } unset($_SERVER[$key]); } if ($match) { return $parameters; } elseif (0 < count($allow)) { throw new MethodNotAllowedException($allow); } else { return parent::match($pathinfo); } }
public function testMatch() { // test the patterns are matched are parameters are returned $collection = new RouteCollection(); $collection->add('foo', new Route('/foo/{bar}')); $matcher = new UrlMatcher($collection, array(), array()); try { $matcher->match('/no-match'); $this->fail(); } catch (NotFoundException $e) { } $this->assertEquals(array('_route' => 'foo', 'bar' => 'baz'), $matcher->match('/foo/baz')); // test that defaults are merged $collection = new RouteCollection(); $collection->add('foo', new Route('/foo/{bar}', array('def' => 'test'))); $matcher = new UrlMatcher($collection, array(), array()); $this->assertEquals(array('_route' => 'foo', 'bar' => 'baz', 'def' => 'test'), $matcher->match('/foo/baz')); // test that route "method" is ignored if no method is given in the context $collection = new RouteCollection(); $collection->add('foo', new Route('/foo', array(), array('_method' => 'GET|head'))); $matcher = new UrlMatcher($collection, array(), array()); $this->assertInternalType('array', $matcher->match('/foo')); // route does not match with POST method context $matcher = new UrlMatcher($collection, array('method' => 'POST'), array()); try { $matcher->match('/foo'); $this->fail(); } catch (MethodNotAllowedException $e) { } // route does match with GET or HEAD method context $matcher = new UrlMatcher($collection, array('method' => 'GET'), array()); $this->assertInternalType('array', $matcher->match('/foo')); $matcher = new UrlMatcher($collection, array('method' => 'HEAD'), array()); $this->assertInternalType('array', $matcher->match('/foo')); }
protected function getRoute() { $routeConfig = $this->application->getConfig('routes'); $context = new RequestContext('/'); $matcher = new UrlMatcher($routeConfig, $context); return $matcher->match($_SERVER['REQUEST_URI']); }
/** * @param boolean $bool * @param \WP $wp */ public function dispatch($bool, \WP $wp) { // get path info after domain part of the URL $pathinfo = $this->request->getPathInfo(); // try to match for stored routes $context = new RequestContext('/'); $matcher = new UrlMatcher($this->routes, $context); try { $parameters = $matcher->match($pathinfo); // without WordPress theme around if ('basic_output' == $parameters['type']) { $parameters['handler']($this->request, $parameters); $this->handleExit(); // with WordPress theme around } elseif ('page' == $parameters['type']) { do_action('parse_request', $wp); $this->setupQuery($parameters['page'], $this->request, $parameters); do_action('wp', $wp); $this->loader->load(); $this->handleExit(); } } catch (ResourceNotFoundException $e) { // route not found. we dont bother for now, because the request will be handled by WordPress which will show // something like a page not found page. } return $bool; }
/** * Tries to match a URL path with a set of routes. * * If the matcher can not find information, it must throw one of the * exceptions documented below. * * @param string $pathinfo The path info to be parsed (raw format, i.e. not * urldecoded) * * @return array An array of parameters * * @throws ResourceNotFoundException If the resource could not be found * @throws MethodNotAllowedException If the resource was found but the * request method is not allowed */ public function match($pathinfo) { $urlMatcher = new UrlMatcher($this->routeCollection, $this->getContext()); $result = $urlMatcher->match($pathinfo); if (!empty($result)) { try { // The route matches, now check if it actually exists $result['content'] = $this->contentManager->findActiveBySlug($result['slug']); } catch (NoResultException $e) { try { //is it directory index if (substr($result['slug'], -1) == '/' || $result['slug'] == '') { $result['content'] = $this->contentManager->findActiveBySlug($result['slug'] . 'index'); } else { if ($this->contentManager->findActiveBySlug($result['slug'] . '/index')) { $redirect = new RedirectResponse($this->request->getBaseUrl() . "/" . $result['slug'] . '/'); $redirect->sendHeaders(); exit; } } } catch (NoResultException $ex) { try { $result['content'] = $this->contentManager->findActiveByAlias($result['slug']); } catch (NoResultException $ex) { throw new ResourceNotFoundException('No page found for slug ' . $pathinfo); } } } } return $result; }
public function handle(Request $request, $type = HttpKernelInterface::MASTER_REQUEST, $catch = true) { try { $this->request = $request; $pathInfo = $request->getPathInfo(); $this->loadRoutes($pathInfo); $this->loadGeneralConfig(); $this->loadZyncroAppConfig($pathInfo); $this->loadDatabaseConfig($pathInfo); $this->loadSecurityConfig($pathInfo); $this->loadTwig($pathInfo); $this->loadUtils(); $this->method = $request->getMethod(); $this->dispatcher->dispatch('request', new RequestEvent($request, $this->session, $this->securityConfig, $this->routes)); $this->loadApi(); $context = new Routing\RequestContext(); $matcher = new Routing\Matcher\UrlMatcher($this->routes, $context); $context->fromRequest($request); $request->attributes->add($matcher->match($request->getPathInfo())); $resolver = new ControllerResolver(); $controller = $resolver->getController($request); $arguments = $resolver->getArguments($request, $controller); $arguments[0] = $this; $response = call_user_func_array($controller, $arguments); } catch (Routing\Exception\ResourceNotFoundException $e) { $response = new Response('Not Found', 404); } catch (\Exception $e) { $response = new Response('An error occurred: ' . $e->getMessage(), 500); } return $response; }
/** * @param string $pathinfo * * @return array */ public function match($pathinfo) { $urlMatcher = new UrlMatcher($this->getRouteCollection(), $this->getContext()); $result = $urlMatcher->match($pathinfo); if (!empty($result)) { // Remap locale for front-end requests if ($this->isMultiDomainHost() && $this->isMultiLanguage() && !$result['preview']) { $localeMap = $this->getLocaleMap(); $locale = $result['_locale']; $result['_request_locale'] = $locale; $result['_locale'] = $localeMap[$locale]; } // Add extra parameters to parameter bag $extraData = $this->domainConfiguration->getExtraData(); if (!empty($extraData)) { $result['_extra'] = $extraData; } $nodeTranslation = $this->getNodeTranslation($result); if (is_null($nodeTranslation)) { throw new ResourceNotFoundException('No page found for slug ' . $pathinfo); } $result['_nodeTranslation'] = $nodeTranslation; } return $result; }
public static function listener(RequestEvent $requestEvent) { $request = $requestEvent->getRequest(); $pathInfo = $request->getPathInfo(); $session = $requestEvent->getSession(); $configSecurity = $requestEvent->getSecurityConfig(); $routes = $requestEvent->getRoutes(); $context = new RequestContext(); $matcher = new UrlMatcher($routes, $context); $context->fromRequest($request); $matching = $matcher->match($pathInfo); $matchedRoute = $matching['_route']; if (isset($configSecurity['protected'])) { $protected = $configSecurity['protected']; $protectedRoutes = $protected['routes']; $sessionKey = $protected['session']; $notLoggedRoute = $protected['not_logged']; $loggedRoute = $protected['logged']; $redirectRoute = null; if ($session->get($sessionKey) && $matchedRoute === $notLoggedRoute) { $redirectRoute = $routes->get($loggedRoute); } if (!$session->get($sessionKey) && in_array($matchedRoute, $protectedRoutes)) { $redirectRoute = $routes->get($notLoggedRoute); } if ($redirectRoute) { $redirectResponse = new RedirectResponse($request->getBaseUrl() . $redirectRoute->getPath()); $redirectResponse->send(); } } }
/** * @return array|bool */ protected function resolveController() { try { // doctrine mabo jambo to prepare route detection $context = new RequestContext(); $context->fromRequest($this->request); $matcher = new UrlMatcher($this->routeCollection, $context); // try detecting controller & stuff $this->request->attributes->add($matcher->match($this->request->getPathInfo())); // resolve controller $resolver = new ControllerResolver(); $controller = $resolver->getController($this->request); $controller = $this->assembleController($controller); // adding request and response variables to the controller if (!empty($controller[0]) && $controller[0] instanceof AbstractSimplexController) { $controller[0]->setRequest($this->request)->setResponse($this->response); } else { // or as attributes for a 'function' controller $req = array('request' => $this->request, 'response' => $this->response); $this->request->attributes->add($req); } // parsing arguments for the request and adding a last argument the request parameter itself $arguments = $resolver->getArguments($this->request, $controller); return array($controller, $arguments); } catch (ResourceNotFoundException $e) { } return false; }
function run() { $routes = new RouteCollection(); foreach ($this->serviceManager->get('ConfigManager')->getConfig('routes') as $rota => $values) { $routes->add($rota, new Route($values['route'], array('controller' => $values['controller'], 'action' => $values['action']))); } $context = $this->serviceManager->get('RequestManager')->getContext(); $matcher = new UrlMatcher($routes, $context); $errorController = $this->getServiceManager()->get('ErrorController'); try { $parameters = $matcher->match($context->getPathInfo()); $controller = $this->getServiceManager()->get($parameters['controller']); $action = $this->getNomeAction($parameters['action']); if (false == method_exists($controller, $action)) { throw new Exception(sprintf('O Controller %s não possui o método %s', get_class($controller), $action)); } $actionParameters = $this->getActionParameters($parameters); if (true == method_exists($controller, 'beforeDispatch')) { call_user_func(array($controller, 'beforeDispatch')); } return call_user_func_array(array($controller, $action), $actionParameters); } catch (ResourceNotFoundException $ex) { return $errorController->actionError404(); } catch (MethodNotAllowedException $ex) { return $errorController->actionError500($ex); } catch (Exception $ex) { return $errorController->actionError500($ex); } }
/** * Run Application. */ public function run() { $request = $this['request'] = Request::createFromGlobals(); $routes = $this['routes']; $context = $this['request_context']; $context->fromRequest($this['request']); $matcher = new UrlMatcher($routes, $context); $resolver = new ControllerResolver(); try { $request->attributes->add($matcher->match($request->getPathInfo())); $controller = $resolver->getController($request); $arguments = $resolver->getArguments($request, $controller); if (is_array($controller) && $controller[0] instanceof \Task\Controllers\BaseController) { $controller[0]->setRequest($request); $controller[0]->setApplication($this); } $response = call_user_func_array($controller, $arguments); } catch (ResourceNotFoundException $e) { $response = new JsonResponse(["errors" => ["type" => "Not found"]], Response::HTTP_NOT_FOUND); } catch (\Exception $e) { $response = new JsonResponse(["errors" => ["type" => $e->getMessage(), "stacktrace" => $e->getTraceAsString()]], Response::HTTP_INTERNAL_SERVER_ERROR); } $response->headers->set("Access-Control-Allow-Origin", "*"); $response->headers->set("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS"); $response->headers->set("Access-Control-Allow-Headers", "Content-Type"); $response->headers->set("Server", "Test task REST"); return $response; }
/** * Run Application. */ public function run() { if (empty($this['request'])) { $this['request'] = Request::createFromGlobals(); } $routes = $this['routes']; $request = $this['request']; $context = $this['requestContext']; $context->fromRequest($this['request']); $matcher = new UrlMatcher($routes, $context); $resolver = new ControllerResolver(); try { $request->attributes->add($matcher->match($request->getPathInfo())); $controller = $resolver->getController($request); $arguments = $resolver->getArguments($request, $controller); if (is_array($controller) && $controller[0] instanceof BaseController) { $controller[0]->setRequest($request); $controller[0]->setApplication($this); } $response = call_user_func_array($controller, $arguments); } catch (ResourceNotFoundException $e) { $response = new Response('Not Found', 404); } catch (\Exception $e) { $response = new Response('An error occurred', 500); } return $response; }
public function testMatch() { // test the patterns are matched are parameters are returned $collection = new RouteCollection(); $collection->add('foo', new Route('/foo/{bar}')); $matcher = new UrlMatcher($collection, array(), array()); $this->assertEquals(false, $matcher->match('/no-match')); $this->assertEquals(array('_route' => 'foo', 'bar' => 'baz'), $matcher->match('/foo/baz')); // test that defaults are merged $collection = new RouteCollection(); $collection->add('foo', new Route('/foo/{bar}', array('def' => 'test'))); $matcher = new UrlMatcher($collection, array(), array()); $this->assertEquals(array('_route' => 'foo', 'bar' => 'baz', 'def' => 'test'), $matcher->match('/foo/baz')); // test that route "metod" is ignore if no method is given in the context $collection = new RouteCollection(); $collection->add('foo', new Route('/foo', array(), array('_method' => 'GET|head'))); // route matches with no context $matcher = new UrlMatcher($collection, array(), array()); $this->assertNotEquals(false, $matcher->match('/foo')); // route does not match with POST method context $matcher = new UrlMatcher($collection, array('method' => 'POST'), array()); $this->assertEquals(false, $matcher->match('/foo')); // route does match with GET or HEAD method context $matcher = new UrlMatcher($collection, array('method' => 'GET'), array()); $this->assertNotEquals(false, $matcher->match('/foo')); $matcher = new UrlMatcher($collection, array('method' => 'HEAD'), array()); $this->assertNotEquals(false, $matcher->match('/foo')); }
public function match(Request $request) { $context = new RequestContext(); $context->fromRequest($request); $this->context = $context; $matcher = new UrlMatcher($this->getRouteCollection(), $context); return $matcher->match($request->getPathInfo()); }
public function parseRequest(Event $event) { $request = $event->get('request'); $matcher = new UrlMatcher($this->routes, array('base_url' => $request->getBaseUrl(), 'method' => $request->getMethod(), 'host' => $request->getHost(), 'is_secure' => $request->isSecure())); if (false === ($attributes = $matcher->match($request->getPathInfo()))) { return false; } $request->attributes->add($attributes); }
public function testSimpleRoute() { $context = new RequestContext(); $request = Request::create("/hello"); $context->fromRequest($request); $matcher = new UrlMatcher($this->routes, $context); $parameters = $matcher->match('/hello'); $this->assertJsonStringEqualsJsonString('{"_route": "hello", "_controller": "foo"}', json_encode($parameters)); }
/** * Match given urls via the context to the routes we defined. * This functionality re-uses the default Symfony way of routing and its components * * @param string $pathinfo * * @return array */ public function match($pathinfo) { $enableAutodetect = $this->container->getParameter('kunstmaan_language_chooser.autodetectlanguage'); $enableSplashpage = $this->container->getParameter('kunstmaan_language_chooser.showlanguagechooser'); // splashpage AND autodetect are disabled, this request may not be routed if (!$enableSplashpage && !$enableAutodetect) { throw new ResourceNotFoundException('Autodetect and splashpage disabled, can not possibly match.'); } $urlMatcher = new UrlMatcher($this->routeCollection, $this->getContext()); return $urlMatcher->match($pathinfo); }
private function dispatch() { $req = Request::createFromGlobals(); $ctx = new RequestContext(); $ctx->fromRequest($req); $matcher = new UrlMatcher($this->routes, $ctx); $pi = $req->getPathInfo(); try { $match = $matcher->match($pi); $callable = null; $controller = null; $method = null; if (isset($match['callable'])) { $callable = $match['callable']; } if (isset($match['controller'])) { $controller = $match['controller']; $method = $match['method']; } unset($match['callable']); unset($match['_route']); unset($match['controller']); unset($match['method']); $match['request'] = $req; $response = ''; if ($callable) { $invoker = new Invoker(); $response = $invoker->call($callable, $match); } if ($controller) { if (!class_exists($controller)) { $error = new Response('Invalid method', 501); $error->send(); die; } $controllerInst = new $controller($this->context); $response = call_user_func_array([$controllerInst, $method], array_values($match)); } if (is_object($response) && $response instanceof Response) { $response->send(); } else { if (is_string($response)) { echo $response; } } die; } catch (MethodNotAllowedException $mex) { // let wordpress continue doing what it does. $response = new Response('Method not allowed', 405); $response->send(); } catch (ResourceNotFoundException $ex) { // let wordpress continue doing what it does. } }
/** * @return Response * @throws \Exception */ public function match() { $request = Request::createFromGlobals(); if (!$request->hasSession()) { $session = new Session(); $request->setSession($session); $request->getSession()->start(); } $requestContext = new RequestContext(); $requestContext->fromRequest($request); $matcher = new UrlMatcher($this->routes, $requestContext); $parameters = $matcher->match($request->getPathInfo()); $this->security->configure($request); $response = $this->security->accessCheck($request->getPathInfo()); if ($response) { $parameters = $matcher->match($response); } //var_dump(extract($matcher->match($request->getPathInfo()), EXTR_SKIP)); die('oki'); $parametersController = explode("::", $parameters['_controller']); $controllerName = $parametersController[0]; $actionName = $parametersController[1]; $namespace = "app\\controller\\" . $controllerName; $controller = new $namespace($requestContext, $this->routes, $request, $this->mode); $action = $actionName . 'Action'; $request->attributes->add($parameters); $response = $controller->{$action}($request); if (!$response instanceof Response) { if ($this->mode == 'dev') { try { throw new \Exception('Le controller doit renvoyer une réponse (Symfony\\Component\\HttpFoundation\\Response)', 500); } catch (\Exception $e) { echo '<br />' . $e; } } else { return $controller->render('erreur_500.php'); } } else { $response->send(); } //return $response; }
/** * Handles request event * * @param HttpRequestEvent $event * * @throws NotFoundHttpException */ public function onRequest(HttpRequestEvent $event) { $event->getResponse()->getHeaders()->set('X-Powered-By', 'ThinFrame/Karma (v0.2, engine ReactPHP)'); $matcher = new UrlMatcher($this->routeCollection, new RequestContext('', $event->getRequest()->getMethod())); try { $route = $matcher->match($event->getRequest()->getPath()); $this->handleRoute($route, $event->getRequest(), $event->getResponse()); $event->stopPropagation(); } catch (ResourceNotFoundException $exception) { throw new NotFoundHttpException(); } }
public function match() { $context = new RequestContext(); $context->fromRequest($this->app->request()); $matcher = new UrlMatcher($this->routes, $context); try { $parameters = $matcher->match($this->app->request()->getPathInfo()); } catch (Exception $e) { $parameters = array(); } return $parameters; }
/** * @return array|bool */ public function matchCurrentRoute() { $context = new RequestContext(); $matcher = new UrlMatcher($this->routes, $context); $request = new CakeRequest(); try { return $matcher->match($request->here()); } catch (Exception $e) { //route is not registered in yml file return false; } }
/** * @param Request $request * @return Response */ public function handle(Request $request) { try { $request->attributes->add($this->matcher->match($request->getPathInfo())); $session = new Session(new NativeSessionStorage(array('cookie_lifetime' => 60 * 60))); $session->start(); $request->setSession($session); $controllerParams = $this->resolver->getController($request); $arguments = $this->resolver->getArguments($request, $controllerParams); /** @var Controller $controller */ $controller = $controllerParams[0]; $controller->setContainer($this->container); $response = call_user_func_array($controllerParams, $arguments); $this->dispatcher->dispatch('post.controller', new ResponseEvent($session)); return $response; } catch (ResourceNotFoundException $e) { return new Response('Not Found', 404); } catch (\Exception $e) { return new Response('An error occurred', 500); } }
/** * Match given urls via the context to the routes we defined. * This functionality re-uses the default Symfony way of routing and its * components * * @param string $pathinfo * * @throws ResourceNotFoundException * * @return array */ public function match($pathinfo) { $urlMatcher = new UrlMatcher($this->getRouteCollection(), $this->getContext()); $result = $urlMatcher->match($pathinfo); if (!empty($result)) { $nodeTranslation = $this->getNodeTranslation($result); if (is_null($nodeTranslation)) { throw new ResourceNotFoundException('No page found for slug ' . $pathinfo); } $result['_nodeTranslation'] = $nodeTranslation; } return $result; }
/** * @param string $pathInfo * * @return array */ public function match($pathInfo) { $host = strtr($this->context->getHost(), '.', '_'); $method = strtolower($this->context->getMethod()); $key = 'route_' . $method . '_' . $host . '_' . $pathInfo; if ($this->cache->hasItem($key)) { return $this->cache->getItem($key)->get(); } $match = parent::match($pathInfo); $item = $this->cache->getItem($key); $item->set($match)->expiresAfter(self::CACHE_LIFETIME); return $match; }
/** * Tries to match a URL path with a set of routes. * * If the matcher can not find information, it must throw one of the * exceptions documented below. * * @param string $pathinfo The path info to be parsed (raw format, i.e. not * urldecoded) * * @return array An array of parameters * * @throws ResourceNotFoundException If the resource could not be found */ public function match($pathinfo) { $urlMatcher = new UrlMatcher($this->routeCollection, $this->getContext()); $result = $urlMatcher->match($pathinfo); if (!empty($result)) { $entity = $this->container->get('opifer.crud.slug_transformer')->transform($result['slug']); if (false === $entity) { throw new ResourceNotFoundException('The route ' . $pathinfo . ' is not registered on the CrudBundle.'); } $result['entity'] = $entity; } return $result; }
/** * Automatically generated run method * * @param Request $request * @return Response */ public function run(Request $request) { $prefs = $this->getServiceContainer()->getPreferenceLoader()->getSystemPreferences(); $routes = $this->generateRoutes(); $response = new Response(); $context = new RequestContext($prefs->getAccountUrl()); $matcher = new UrlMatcher($routes, $context); $payload = []; $match = $matcher->match($this->getDestination()); $route = $match['_route']; $module = $this->getModule(); $auth = $this->getServiceContainer()->getAuthManager(); $action = null; switch ($route) { case 'index': if ($auth->isRecognized()) { $action = $module->loadAction('dashboard', 'html'); } else { $action = $module->loadAction('index', 'html'); } break; case 'register': $action = $module->loadAction('register', 'html'); break; case 'forgot-password': case 'forgot-password-token': $action = $module->loadAction('forgot-password', 'html'); $action->setParams(['token' => isset($match['token']) ? $match['token'] : null]); break; case 'login': $action = $module->loadAction('login', 'html'); break; case 'activity': $action = $module->loadAction('activity', 'html'); break; case 'settings': $action = $module->loadAction('settings', 'html'); $action->setParams(['section' => $match['section']]); break; case 'logout': $action = $module->loadAction('logout'); break; } $kernel = $this->getServiceContainer()->getKernel(); $response = $kernel->handle($action, $request); if ($response instanceof RedirectResponse) { return $response; } $payload = ['main' => $response->getContent()]; return $this->responder->run($request, new Blank($payload)); }
/** * Tries to match a URL based on Apache mod_rewrite matching. * * Returns false if no route matches the URL. * * @param string $pathinfo The pathinfo to be parsed * * @return array An array of parameters * * @throws MethodNotAllowedException If the current method is not allowed */ public function match($pathinfo) { $parameters = array(); $defaults = array(); $allow = array(); $route = null; foreach ($this->denormalizeValues($_SERVER) as $key => $value) { $name = $key; // skip non-routing variables // this improves performance when $_SERVER contains many usual // variables like HTTP_*, DOCUMENT_ROOT, REQUEST_URI, ... if (false === strpos($name, '_ROUTING_')) { continue; } while (0 === strpos($name, 'REDIRECT_')) { $name = substr($name, 9); } // expect _ROUTING_<type>_<name> // or _ROUTING_<type> if (0 !== strpos($name, '_ROUTING_')) { continue; } if (false !== ($pos = strpos($name, '_', 9))) { $type = substr($name, 9, $pos - 9); $name = substr($name, $pos + 1); } else { $type = substr($name, 9); } if ('param' === $type) { if ('' !== $value) { $parameters[$name] = $value; } } elseif ('default' === $type) { $defaults[$name] = $value; } elseif ('route' === $type) { $route = $value; } elseif ('allow' === $type) { $allow[] = $name; } unset($_SERVER[$key]); } if (null !== $route) { $parameters['_route'] = $route; return $this->mergeDefaults($parameters, $defaults); } elseif (0 < count($allow)) { throw new MethodNotAllowedException($allow); } else { return parent::match($pathinfo); } }
/** * Efetua a análise da URL para detectar se houve alguma rota encontrada, caso contrário irá retornar * uma rota para tela de erro. * * @return array * * @todo Por o bloco de verificação dentro de um try...catch pois o match lança excessão caso não encontre rotas se cair no catch retorna rota de erro */ public function match() { $context = new RequestContext(); $context->fromRequest(Request::createFromGlobals()); $matcher = new UrlMatcher($this->collection, $context); try { $parameters = $matcher->match(Request::createFromGlobals()->getPathInfo()); } catch (ResourceNotFoundException $e) { return new Response('caminho_nao_encontrado', 404); } catch (MethodNotAllowedException $e) { return new Response('metodo_nao_permitido', 405); } return $parameters; }
/** * Tries to match a URL based on Apache mod_rewrite matching. * * Returns false if no route matches the URL. * * @param string $url URL to be parsed * * @return array|false An array of parameters or false if no route matches */ public function match($url) { if (!isset($_SERVER['_ROUTING__route'])) { // fall-back to the default UrlMatcher return parent::match($url); } $parameters = array(); foreach ($_SERVER as $key => $value) { if ('_ROUTING_' === substr($key, 0, 9)) { $parameters[substr($key, 9)] = $value; unset($_SERVER[$key]); } } return $parameters; }