コード例 #1
0
ファイル: App.php プロジェクト: tiaanl/pullist
 /**
  * Run the application.
  *
  * @param string $httpMethod
  * @param string $path
  * @throws \Exception
  */
 public function run($httpMethod, $path)
 {
     $routeInfo = $this->dispatcher->dispatch($httpMethod, $path);
     switch ($routeInfo[0]) {
         case Dispatcher::NOT_FOUND:
             echo '404';
             break;
         case Dispatcher::METHOD_NOT_ALLOWED:
             echo 'Method not allowed';
             break;
         case Dispatcher::FOUND:
             $handler = $routeInfo[1];
             $vars = $routeInfo[2];
             if (is_string($handler)) {
                 $parts = explode('.', $handler);
                 // If we have only 1 part, we assume it's just a global function.
                 if (count($parts) === 2) {
                     list($className, $methodName) = $parts;
                     $controller = new $className();
                     echo call_user_func_array([$controller, $methodName], $vars);
                 } elseif (count($parts) === 1) {
                     $funcName = $parts[0];
                     echo call_user_func_array($funcName, $vars);
                 } else {
                     throw new \Exception('Invalid handler name.');
                 }
             }
             break;
         default:
             assert(false);
             break;
     }
 }
コード例 #2
0
ファイル: ShinyBlog.php プロジェクト: nekudo/shiny_blog
 /**
  * Tries to find a route matching the current request. If found the defined action is called.
  */
 protected function dispatch()
 {
     $httpMethod = $_SERVER['REQUEST_METHOD'];
     $uri = rawurldecode(parse_url($_SERVER['REQUEST_URI'], PHP_URL_PATH));
     $routeInfo = $this->dispatcher->dispatch($httpMethod, $uri);
     if (!isset($routeInfo[0])) {
         throw new RuntimeException('Could not dispatch request.');
     }
     switch ($routeInfo[0]) {
         case FastRoute\Dispatcher::NOT_FOUND:
             $responder = new NotFoundResponder($this->config);
             $responder->__invoke();
             break;
         case FastRoute\Dispatcher::METHOD_NOT_ALLOWED:
             $responder = new HttpResponder($this->config);
             $responder->methodNotAllowed();
             break;
         case FastRoute\Dispatcher::FOUND:
             $handler = $routeInfo[1];
             $arguments = $routeInfo[2];
             $this->runAction($handler, $arguments);
             break;
         default:
             throw new RuntimeException('Could not dispatch request.');
     }
 }
コード例 #3
0
 public function getEventForRequest(RequestInterface $request)
 {
     $requestedRoute = $request->getUrl()->getPath();
     $requestedMethod = $request->getMethod();
     $routeInfo = $this->dispatcher->dispatch($requestedMethod, $requestedRoute);
     switch ($routeInfo[0]) {
         case Dispatcher::NOT_FOUND:
             throw new NotFoundException('Route \'' . $requestedRoute . '\' with method \'' . $requestedMethod . '\' not found.');
             break;
         case Dispatcher::METHOD_NOT_ALLOWED:
             //$allowedMethods = $routeInfo[1];
             throw new Exception('Method not allowed', StatusCode::METHOD_NOT_ALLOWED);
             break;
         case Dispatcher::FOUND:
             /** @var string $eventClass */
             $eventClass = $routeInfo[1];
             /** @var RouteFoundEvent $event */
             $event = new $eventClass();
             /** @var string[] $vars */
             $vars = $routeInfo[2];
             $request->getRouteParameterCollection()->setAll($vars);
             $event->setRequest($request);
             return $event;
         default:
             throw new Exception('Error in FastRoute!');
     }
 }
コード例 #4
0
 public function getCommand()
 {
     $request = $this->requestKnowledge->getRequest();
     $requestedRoute = $request->getUri()->getPath();
     $requestedMethod = $request->getMethod();
     $routeInfo = $this->dispatcher->dispatch($requestedMethod, $requestedRoute);
     switch ($routeInfo[0]) {
         case Dispatcher::NOT_FOUND:
             throw new NotFoundException('Route \'' . $requestedRoute . '\' with method \'' . $requestedMethod . '\' not found.');
         case Dispatcher::METHOD_NOT_ALLOWED:
             //$allowedMethods = $routeInfo[1];
             throw new MethodNotAllowedException('Method not allowed');
         case Dispatcher::FOUND:
             /** @var string $commandCreatorClass */
             $commandCreatorClass = $routeInfo[1];
             $sl = $this->serviceLocator;
             /** @var CommandCreatorInterface $commandCreator */
             $commandCreator = $sl($commandCreatorClass);
             /** @var string[] $vars */
             $vars = $routeInfo[2];
             $request = $request->withAttribute(RouterInterface::MATCHED_VARIABLES_ARRAY_KEY, $vars);
             $this->requestKnowledge->setRequest($request);
             return $commandCreator->createCommand($request);
         default:
             throw new Exception('Error in FastRoute!');
     }
 }
コード例 #5
0
 /**
  * @param ServerRequestInterface $request
  * @param ResponseInterface $response
  * @param callable $next
  * @return ResponseInterface
  */
 public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next)
 {
     $routeInfo = $this->dispatcher->dispatch($request->getMethod(), $request->getUri()->getPath());
     switch ($routeInfo[0]) {
         case Dispatcher::NOT_FOUND:
             $response = $response->withStatus(404);
             break;
         case Dispatcher::METHOD_NOT_ALLOWED:
             $response = $response->withStatus(405);
             break;
         case Dispatcher::FOUND:
             $callable = $routeInfo[1];
             $args = $routeInfo[2];
             if (isset($this->container)) {
                 $response = $this->container->call($callable, ['request' => $request, 'response' => $response, 'arguments' => $args]);
             } else {
                 if (is_callable($callable)) {
                     call_user_func($callable, $request, $response, $args);
                 } else {
                     $callable = new $callable();
                     call_user_func($callable, $request, $response, $args);
                 }
             }
             break;
         default:
             return $response->withStatus(500);
     }
     $response = $next($request, $response);
     return $response;
 }
コード例 #6
0
 /**
  * {@inheritdoc}
  */
 public function route(ServerRequestInterface $request) : RoutingResponse
 {
     $httpMethod = $request->getMethod();
     $uri = $request->getUri()->getPath();
     $routeInfo = $this->dispatcher->dispatch($httpMethod, $uri);
     return $this->processDispatcherResult($routeInfo);
 }
コード例 #7
0
ファイル: FastRouteMiddleware.php プロジェクト: aracaw/wiring
 /**
  * @param \Psr\Http\Message\ServerRequestInterface $request
  * @param \Psr\Http\Message\ResponseInterface $response
  * @param callable|null $next
  *
  * @throws \Wiring\Exception\MethodNotAllowedException
  * @throws \Wiring\Exception\NotFoundException
  * @return \Psr\Http\Message\ResponseInterface
  */
 public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next = null)
 {
     $routeInfo = $this->fastRoute->dispatch($request->getMethod(), $request->getUri()->getPath());
     if ($routeInfo[0] == Dispatcher::FOUND) {
         // Get request params
         foreach ($routeInfo[2] as $param => $value) {
             $request = $request->withAttribute($param, $value);
         }
         // Get request with attribute
         $request = $request->withAttribute($this->attribute, $routeInfo[1]);
         return $next($request, $response);
     }
     if ($routeInfo[0] == Dispatcher::METHOD_NOT_ALLOWED) {
         // Check has handler
         if (!$this->container->has(MethodNotAllowedHandlerInterface::class)) {
             throw new MethodNotAllowedException($request, $response, $routeInfo[1]);
         }
         /** @var callable $notAllowedHandler */
         $notAllowedHandler = $this->container->get(MethodNotAllowedHandlerInterface::class);
         return $notAllowedHandler($request, $response, $routeInfo[1]);
     }
     // Check has handler
     if (!$this->container->has(NotFoundHandlerInterface::class)) {
         throw new NotFoundException($request, $response);
     }
     /** @var callable $notFoundHandler */
     $notFoundHandler = $this->container->get(NotFoundHandlerInterface::class);
     return $notFoundHandler($request, $response);
 }
コード例 #8
0
ファイル: Dispatcher.php プロジェクト: rougin/slytherin
 /**
  * Dispatches against the provided HTTP method verb and URI.
  *
  * @param  string $httpMethod
  * @param  string $uri
  * @return array
  */
 public function dispatch($httpMethod, $uri)
 {
     $result = $this->dispatcher->dispatch($httpMethod, $uri);
     $route = $this->router->getRoute($httpMethod, $uri);
     $this->throwException($result[0], $uri);
     $middlewares = $route[2] == $route[1] && isset($route[3]) ? $route[3] : [];
     return [$result[1], $result[2], $middlewares];
 }
コード例 #9
0
ファイル: RouteMatcherSpec.php プロジェクト: abava/routing
 function it_throws_not_found_exception(ServerRequestInterface $request, RouteCollection $routeCollection, Route $route, UriInterface $uri, Dispatcher $dispatcher)
 {
     $routeCollection->getRoutes()->willReturn([$route]);
     $request->getUri()->willReturn($uri);
     $uri->getPath()->willReturn('/url');
     $request->getMethod()->willReturn('GET');
     $dispatcher->dispatch('GET', '/url')->willReturn([Dispatcher::NOT_FOUND]);
     $this->shouldThrow(NotFoundException::class)->match($request, $routeCollection);
 }
コード例 #10
0
ファイル: Router.php プロジェクト: AndrewCarterUK/SimpleRoute
 /**
  * {@inheritdoc}
  */
 public function match($method, $uri)
 {
     $routeInfo = $this->dispatcher->dispatch($method, $uri);
     switch ($routeInfo[0]) {
         case Dispatcher::METHOD_NOT_ALLOWED:
             throw new MethodNotAllowedException($method, $routeInfo[1]);
         case Dispatcher::NOT_FOUND:
             throw new NotFoundException($uri);
     }
     return new Result($this->routes[$routeInfo[1]], $routeInfo[2]);
 }
コード例 #11
0
 /**
  * @param ServerRequestInterface $request
  * 
  * @return mixed
  */
 public function data(ServerRequestInterface $request)
 {
     /** @var IDataProvider $provider */
     list($result, $provider, $parameters) = $this->dispatcher->dispatch($request->getMethod(), $request->getUri()->getPath()) + [null, null, []];
     switch ($result) {
         case \FastRoute\Dispatcher::FOUND:
             $queryParamsFromRoute = array_merge($request->getQueryParams(), $parameters);
             $request = $request->withQueryParams($queryParamsFromRoute);
             return $provider->data($request);
         default:
             return null;
     }
 }
コード例 #12
0
 /**
  * @param Dispatcher $dispatcher
  * @param string $method
  * @param string $path
  *
  * @return [Action, $arguments]
  *
  * @throws HttpNotFound
  * @throws HttpMethodNotAllowed
  */
 private function dispatch(Dispatcher $dispatcher, $method, $path)
 {
     $route = $dispatcher->dispatch($method, $path);
     $status = array_shift($route);
     if (Dispatcher::FOUND === $status) {
         return $route;
     }
     if (Dispatcher::METHOD_NOT_ALLOWED === $status) {
         $allowed = array_shift($route);
         throw HttpException::methodNotAllowed($path, $method, $allowed);
     }
     throw HttpException::notFound($path);
 }
コード例 #13
0
ファイル: Router.php プロジェクト: ifcanduela/pew
 /**
  * Get a route matching the provided request information.
  *
  * @param string $pathInfo
  * @param string $httpMethod
  * @return Route
  */
 public function route(string $pathInfo, string $httpMethod) : Route
 {
     $matchedRoute = $this->dispatcher->dispatch($httpMethod, $pathInfo);
     if ($matchedRoute[0] === Dispatcher::NOT_FOUND) {
         throw new \RuntimeException("Route not found");
     }
     if ($matchedRoute[0] === Dispatcher::METHOD_NOT_ALLOWED) {
         throw new \RuntimeException("Method not allowed");
     }
     $route = $matchedRoute[1];
     $route->setParams($matchedRoute[2]);
     return $route;
 }
コード例 #14
0
 public function processRequest(ServerRequestInterface $request) : int
 {
     $ret = $this->dispatcher->dispatch($request->getMethod(), $request->getUri()->getPath());
     switch ($ret[0]) {
         case Dispatcher::FOUND:
             $this->route = $this->collection->getRoute($ret[1]);
             $this->vars = $ret[2];
             return RouterInterface::STATUS_FOUND;
         case Dispatcher::METHOD_NOT_ALLOWED:
             $this->allowed = $ret[1];
             return RouterInterface::STATUS_NOT_ALLOWED;
         default:
             return RouterInterface::STATUS_NOT_FOUND;
     }
 }
コード例 #15
0
 /**
  * @throws \WoohooLabs\Harmony\Exception\MethodNotAllowed
  * @throws \WoohooLabs\Harmony\Exception\RouteNotFound
  */
 public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next) : ResponseInterface
 {
     $route = $this->fastRoute->dispatch($request->getMethod(), $request->getUri()->getPath());
     if ($route[0] === Dispatcher::NOT_FOUND) {
         throw new RouteNotFound($request->getUri()->getPath());
     }
     if ($route[0] === Dispatcher::METHOD_NOT_ALLOWED) {
         throw new MethodNotAllowed($request->getMethod());
     }
     foreach ($route[2] as $name => $value) {
         $request = $request->withAttribute($name, $value);
     }
     $request = $request->withAttribute($this->actionAttributeName, $route[1]);
     return $next($request, $response);
 }
コード例 #16
0
ファイル: Httpd.php プロジェクト: domraider/rxnet
 /**
  * @param HttpdRequest $request
  * @param HttpdResponse $response
  * @param array $labels
  */
 protected function dispatch(HttpdRequest $request, HttpdResponse $response, array $labels = [])
 {
     $labels['method'] = strtolower($request->getMethod());
     if (empty($this->routes)) {
         $request->subscribeCallback(null, null, function () use($request, $response, $labels) {
             $this->notifyNext(new HttpdEvent("/httpd/request", ['request' => $request, 'response' => $response], $labels));
         });
         return;
     }
     $info = $this->dispatcher->dispatch($request->getMethod(), $request->getPath());
     switch ($info[0]) {
         case Dispatcher::NOT_FOUND:
             $response->sendError("Route does not exist", 404);
             break;
         case Dispatcher::METHOD_NOT_ALLOWED:
             $response->sendError("Method not allowed", 405);
             break;
         case Dispatcher::FOUND:
             $labels['method'] = $request->getMethod();
             $labels['path'] = $request->getPath();
             $labels = array_merge($labels, $info[2]);
             $callable = $info[1];
             $request->setRouteParams($info[2]);
             // For streamable route, subscribe on event
             $this->notifyNext(new HttpdEvent("/httpd/request", ['request' => $request, 'response' => $response], $labels));
             // On end of request (whole data received)
             $request->subscribeCallback(null, null, function () use($request, $response, $callable) {
                 $callable($request, $response);
             });
     }
 }
コード例 #17
0
ファイル: ACL.php プロジェクト: skibish/simple-rest-acl
 /**
  * @param string $method - example: 'GET'
  * @param string $uri - example: '/users', '/some/{path}/[0-9]'
  * @return $this
  * @throws AclException
  */
 public function got($method, $uri)
 {
     $this->logger->debug("Try to dispatch {$method} {$uri}.");
     $this->routeInfo = $this->dispatcher->dispatch($method, $uri);
     $this->method = $method;
     $this->uri = $uri;
     return $this;
 }
コード例 #18
0
 public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $next = null)
 {
     $routeInfo = $this->dispatcher->dispatch($request->getMethod(), $request->getUri()->getPath());
     switch ($routeInfo[0]) {
         case FastRoute\Dispatcher::NOT_FOUND:
             return $response->withStatus(404);
         case FastRoute\Dispatcher::METHOD_NOT_ALLOWED:
             return $response->withStatus(405);
         case FastRoute\Dispatcher::FOUND:
             $action = $routeInfo[1];
             $parameters = $routeInfo[2];
             $request = $request->withAttribute($this->actionAttributeName, $action)->withAttribute($this->parametersAttributeName, $parameters);
             return $next($request, $response, $next);
         default:
             return $response->withStatus(500);
     }
 }
コード例 #19
0
 /**
  * @param \Psr\Http\Message\ServerRequestInterface $request
  * @param \Psr\Http\Message\ResponseInterface $response
  * @param \WoohooLabs\Harmony\Harmony $next
  * @throws \WoohooLabs\Harmony\Exception\MethodNotAllowedException
  * @throws \WoohooLabs\Harmony\Exception\RouteNotFoundException
  */
 public function __invoke(ServerRequestInterface $request, ResponseInterface $response, Harmony $next)
 {
     $routeInfo = $this->fastRoute->dispatch($request->getMethod(), $request->getUri()->getPath());
     switch ($routeInfo[0]) {
         case Dispatcher::NOT_FOUND:
             throw new RouteNotFoundException();
         case Dispatcher::METHOD_NOT_ALLOWED:
             throw new MethodNotAllowedException();
         case Dispatcher::FOUND:
             foreach ($routeInfo[2] as $param => $value) {
                 $request = $request->withAttribute($param, $value);
             }
             $request = $request->withAttribute("__callable", $routeInfo[1]);
             break;
     }
     $next($request, $response);
 }
コード例 #20
0
ファイル: Routing.php プロジェクト: anctemarry27/cogs
 /**
  * Look for a route that matches the request.
  *
  * @param $http_method
  * @param $uri
  *
  * @return array
  */
 public function match($http_method = NULL, $uri = NULL)
 {
     // Fetch method and uri from injected request object
     $http_method = $http_method ?: $this->request->getMethod();
     $uri = $uri ?: $this->request->getUri()->getPath();
     // parse the request and return a status array
     $routeInfo = $this->dispatcher->dispatch($http_method, $uri);
     return $routeInfo;
 }
コード例 #21
0
 /**
  * @return array
  */
 public function dispatch()
 {
     $this->http_fields = $_GET;
     $info = $this->fast_router->dispatch($_SERVER['REQUEST_METHOD'], $_SERVER['PATH_INFO']);
     switch ($info[0]) {
         case Dispatcher::FOUND:
             $attributes = explode('.', $info[1]);
             $resource = $attributes[0];
             $action = $attributes[1];
             $this->http_fields = array_merge($this->http_fields, $info[2]);
             break;
         default:
             $not_found_attributes = $this->getNotFoundAttributes();
             $resource = $not_found_attributes[1];
             $action = $not_found_attributes[2];
             break;
     }
     $this->input = file_get_contents("php://input");
     $data_type = $this->options['data_type'];
     // Get query parameters and args depending from type of data in the http request body
     $args = [];
     if ($data_type == 'query_string') {
         parse_str($this->input, $args);
     } else {
         if ($data_type == 'json') {
             $args = $this->input ? json_decode($this->input, true) : [];
             if (!is_array($args)) {
                 $args = [];
             }
         }
     }
     $this->http_fields = array_merge($this->http_fields, $args);
     // Trim all fields if auto_trim setting enabled
     if ($this->options['auto_trim']) {
         $this->http_fields = Arr::trim($this->http_fields);
     }
     // Convert empty strings to null values if auto_null setting enabled
     if ($this->options['auto_null']) {
         $this->http_fields = Arr::convertValues($this->http_fields, '', null);
     }
     return [$resource, $action, []];
 }
コード例 #22
0
 public function matchRequest(SymfonyRequest $request)
 {
     $method = $request->getMethod();
     $path = $request->getPathInfo();
     $routeInfo = $this->dispatcher->dispatch($method, $path);
     switch ($routeInfo[0]) {
         case Dispatcher::METHOD_NOT_ALLOWED:
             //                $allowedMethods = $routeInfo[1];
             throw new MethodNotAllowedException();
         case Dispatcher::FOUND:
             $vars = $routeInfo[2];
             $vars['_route'] = $method . ' ' . $path;
             $vars['_controller'] = $routeInfo[1];
             $vars['_module'] = $this->getModuleName();
             return $vars;
         case Dispatcher::NOT_FOUND:
             throw new ResourceNotFoundException();
         default:
             throw new ResourceNotFoundException();
     }
 }
コード例 #23
0
ファイル: RouteManager.php プロジェクト: simukti/kadalkesit
 /**
  * @param   ServerRequestInterface  $request
  * @param   ResponseInterface       $response
  * @param   callable                $out
  */
 public function __invoke(ServerRequestInterface $request, ResponseInterface $response, callable $out = null)
 {
     $path = $request->getUri()->getPath();
     $endSlash = substr($path, -1);
     if (strlen($path) > 1 && $endSlash === '/') {
         // redirect *example* /tag/ --> /tag
         return $response->withHeader('Location', rtrim($request->getUri()->getPath(), '/'));
     }
     $currentRoute = $this->dispatcher->dispatch($request->getMethod(), $request->getUri()->getPath());
     switch ($currentRoute[0]) {
         case Dispatcher::METHOD_NOT_ALLOWED:
             throw new \UnexpectedValueException('Method not allowed');
         case Dispatcher::NOT_FOUND:
             throw new \OutOfRangeException('Route not found');
         case Dispatcher::FOUND:
             $response = $this->handleRoute($request, $response, $currentRoute);
             break;
     }
     if (!$response instanceof ResponseInterface) {
         throw new \InvalidArgumentException(sprintf("Action handler must return '%s' instance", ResponseInterface::class));
     }
     $response = $response instanceof Response ?: new Response($response);
     return $out($request, $response);
 }
コード例 #24
0
 /**
  * Get the handler service name for a request.
  * 
  * @param ServerRequestInterface $request  Request.
  * @param ResponseInterface      $response Response.
  * 
  * @return ResponseInterface The response.
  * 
  * @throws ApplicationException On request not found or method not allowed.
  */
 public function getResponse(ServerRequestInterface $request, ResponseInterface $response)
 {
     $method = $request->getMethod();
     $path = $request->getUri()->getPath();
     $routeInfo = $this->dispatcher->dispatch($method, $path);
     switch ($routeInfo[0]) {
         case FastRoute\Dispatcher::FOUND:
             break;
         case FastRoute\Dispatcher::NOT_FOUND:
             throw $this->createNotFoundException();
         case FastRoute\Dispatcher::METHOD_NOT_ALLOWED:
             throw $this->createMethodNotAllowedException();
         default:
             throw new \Exception('Unexpected dispatcher response');
     }
     foreach ($routeInfo[2] as $name => $value) {
         $request = $request->withAttribute($name, $value);
     }
     $service = $this->container->get($routeInfo[1]);
     if (!is_callable($service)) {
         throw new \Exception('Route handler is not callable');
     }
     return $service($request, $response);
 }
コード例 #25
0
ファイル: Application.php プロジェクト: skamenetskiy/bamba
 private function finish()
 {
     $routeInfo = $this->dispatcher->dispatch($this->request->method(), $this->request->uri());
     switch ($routeInfo[0]) {
         case Dispatcher::NOT_FOUND:
             $this->response->code(404);
             $this->response->getLayout()->content = (new Controller())->error404();
             break;
         case Dispatcher::METHOD_NOT_ALLOWED:
             $allowedMethods = $routeInfo[1];
             $this->response->code(415);
             break;
         case Dispatcher::FOUND:
             $handler = explode('::', $routeInfo[1]);
             /** @var Controller $class */
             $class = $handler[0];
             $method = $handler[1];
             $vars = $routeInfo[2];
             $this->response->type($class::type());
             $this->response->getLayout()->content = call_user_func_array([new $class(), $method], $vars);
             break;
     }
     $this->response->output();
 }
コード例 #26
0
ファイル: AppTest.php プロジェクト: voidcontext/arc-reactor
 private function registeredHandlerTest(Dispatcher $dispatcher, $method, $route, $resultNum = Dispatcher::FOUND)
 {
     list($result) = $dispatcher->dispatch($method, $route);
     $this->assertEquals($resultNum, $result);
 }
コード例 #27
0
ファイル: Dispatcher.php プロジェクト: wandu/router
 /**
  * @param \FastRoute\Dispatcher $dispatcher
  * @param string $method
  * @param string $path
  * @return array
  */
 protected function runDispatcher(FastDispatcher $dispatcher, $method, $path)
 {
     $routeInfo = $dispatcher->dispatch($method, $path);
     switch ($routeInfo[0]) {
         case FastDispatcher::NOT_FOUND:
             throw new RouteNotFoundException();
         case FastDispatcher::METHOD_NOT_ALLOWED:
             throw new MethodNotAllowedException();
         case FastDispatcher::FOUND:
             return $routeInfo;
     }
 }
コード例 #28
0
ファイル: FrontController.php プロジェクト: codecollab/router
 /**
  * Gets the "method not allowed (405)" route
  *
  * @param \FastRoute\Dispatcher $dispatcher The request dispatcher
  *
  * @return array The route
  */
 private function runMethodNotAllowed(Dispatcher $dispatcher) : array
 {
     return $dispatcher->dispatch('GET', '/method-not-allowed');
 }
コード例 #29
0
ファイル: Router.php プロジェクト: jicjjang/june
 /**
  * @param Dispatcher $dispatcher
  * @param string $method
  * @param string $path
  * @return string
  */
 protected function runDispatcher(Dispatcher $dispatcher, $method, $path)
 {
     $routeInfo = $dispatcher->dispatch($method, $path);
     try {
         switch ($routeInfo[0]) {
             case Dispatcher::NOT_FOUND:
                 throw new HandlerNotFoundException();
             case Dispatcher::METHOD_NOT_ALLOWED:
                 throw new MethodNotAllowedException();
             case Dispatcher::FOUND:
                 return $routeInfo;
         }
     } catch (RuntimeException $e) {
         if (isset($routeInfo[1]) && in_array('*', $routeInfo[1])) {
             return $this->runDispatcher($dispatcher, '*', $path);
         } else {
             throw $e;
         }
     }
 }
コード例 #30
0
ファイル: App.php プロジェクト: voidcontext/arc-reactor
 /**
  * Creates a request handler
  *
  * @param Dispatcher $dispatcher
  * @return callable
  */
 protected function requestHandler(Dispatcher $dispatcher)
 {
     return function (Request $req, Response $res) use($dispatcher) {
         try {
             $result = $dispatcher->dispatch($req->getMethod(), $req->getPath());
             switch ($result[0]) {
                 case Dispatcher::FOUND:
                     // @todo param handling -> result 2
                     $this->runNext(array_merge($this->middlewares, (array) $result[1]), $req, $res);
                     break;
                 case Dispatcher::METHOD_NOT_ALLOWED:
                 case Dispatcher::NOT_FOUND:
                     $res->writeHead(404);
                     $res->end();
                     break;
             }
         } catch (\Exception $e) {
             $this->emit('error', [$e, $req, $res]);
         }
     };
 }