Route.php

Go to the documentation of this file.

<?php
namespace Slim;
 
use InvalidArgumentException;
use Psr\Http\Message\ServerRequestInterface;
use Psr\Http\Message\ResponseInterface;
use Slim\Handlers\Strategies\RequestResponse;
use Slim\Interfaces\InvocationStrategyInterface;
use Slim\Interfaces\RouteInterface;
 
class Route extends Routable implements RouteInterface
{
    use MiddlewareAwareTrait;
 
    protected $methods = [];
 
    protected $identifier;
 
    protected $name;
 
    protected $groups;
 
    private $finalized = false;
 
    protected $outputBuffering = 'append';
 
    protected $arguments = [];
 
    protected $savedArguments = [];
 
    protected $callable;
 
    public function __construct($methods, $pattern, $callable, $groups = [], $identifier = 0)
    {
        $this->methods  = is_string($methods) ? [$methods] : $methods;
        $this->pattern  = $pattern;
        $this->callable = $callable;
        $this->groups   = $groups;
        $this->identifier = 'route' . $identifier;
    }
 
    public function finalize()
    {
        if ($this->finalized) {
            return;
        }
 
        $groupMiddleware = [];
        foreach ($this->getGroups() as $group) {
            $groupMiddleware = array_merge($group->getMiddleware(), $groupMiddleware);
        }
 
        $this->middleware = array_merge($this->middleware, $groupMiddleware);
 
        foreach ($this->getMiddleware() as $middleware) {
            $this->addMiddleware($middleware);
        }
 
        $this->finalized = true;
    }
 
    public function getCallable()
    {
        return $this->callable;
    }
 
    public function setCallable($callable)
    {
        $this->callable = $callable;
    }
 
    public function getMethods()
    {
        return $this->methods;
    }
 
    public function getGroups()
    {
        return $this->groups;
    }
 
    public function getName()
    {
        return $this->name;
    }
 
    public function getIdentifier()
    {
        return $this->identifier;
    }
 
    public function getOutputBuffering()
    {
        return $this->outputBuffering;
    }
 
    public function setOutputBuffering($mode)
    {
        if (!in_array($mode, [false, 'prepend', 'append'], true)) {
            throw new InvalidArgumentException('Unknown output buffering mode');
        }
        $this->outputBuffering = $mode;
        return $this;
    }
 
    public function setName($name)
    {
        if (!is_string($name)) {
            throw new InvalidArgumentException('Route name must be a string');
        }
        $this->name = $name;
        return $this;
    }
 
    public function setArgument($name, $value, $includeInSavedArguments = true)
    {
        if ($includeInSavedArguments) {
            $this->savedArguments[$name] = $value;
        }
        $this->arguments[$name] = $value;
        return $this;
    }
 
    public function setArguments(array $arguments, $includeInSavedArguments = true)
    {
        if ($includeInSavedArguments) {
            $this->savedArguments = $arguments;
        }
        $this->arguments = $arguments;
        return $this;
    }
 
    public function getArguments()
    {
        return $this->arguments;
    }
 
    public function getArgument($name, $default = null)
    {
        if (array_key_exists($name, $this->arguments)) {
            return $this->arguments[$name];
        }
        return $default;
    }
 
    /********************************************************************************
     * Route Runner
     *******************************************************************************/
 
    public function prepare(ServerRequestInterface $request, array $arguments)
    {
        // Remove temp arguments
        $this->setArguments($this->savedArguments);
 
        // Add the route arguments
        foreach ($arguments as $k => $v) {
            $this->setArgument($k, $v, false);
        }
    }
 
    public function run(ServerRequestInterface $request, ResponseInterface $response)
    {
        // Finalise route now that we are about to run it
        $this->finalize();
 
        // Traverse middleware stack and fetch updated response
        return $this->callMiddlewareStack($request, $response);
    }
 
    public function __invoke(ServerRequestInterface $request, ResponseInterface $response)
    {
        $this->callable = $this->resolveCallable($this->callable);
 
        $handler = isset($this->container) ? $this->container->get('foundHandler') : new RequestResponse();
 
        $newResponse = $handler($this->callable, $request, $response, $this->arguments);
 
        if ($newResponse instanceof ResponseInterface) {
            // if route callback returns a ResponseInterface, then use it
            $response = $newResponse;
        } elseif (is_string($newResponse)) {
            // if route callback returns a string, then append it to the response
            if ($response->getBody()->isWritable()) {
                $response->getBody()->write($newResponse);
            }
        }
 
        return $response;
    }
}