Slim\App Class Reference

Inheritance diagram for Slim\App:

Collaboration diagram for Slim\App:

Public Member Functions
	__construct ($container=[])
	Create new application. More...
	getContainer ()
	Enable access to the DI container by consumers of $app. More...
	add ($callable)
	Add middleware. More...
	__call ($method, $args)
	Calling a non-existant method on App checks to see if there's an item in the container that is callable and if so, calls it. More...
	get ($pattern, $callable)
	Add GET route. More...
	post ($pattern, $callable)
	Add POST route. More...
	put ($pattern, $callable)
	Add PUT route. More...
	patch ($pattern, $callable)
	Add PATCH route. More...
	delete ($pattern, $callable)
	Add DELETE route. More...
	options ($pattern, $callable)
	Add OPTIONS route. More...
	any ($pattern, $callable)
	Add route for any HTTP method. More...
	map (array $methods, $pattern, $callable)
	Add route with multiple methods. More...
	redirect ($from, $to, $status=302)
	Add a route that sends an HTTP redirect. More...
	run ($silent=false)
	Run application. More...
	process (ServerRequestInterface $request, ResponseInterface $response)
	Process a request. More...
	respond (ResponseInterface $response)
	Send the response to the client. More...
	subRequest ( $method, $path, $query='', array $headers=[], array $cookies=[], $bodyContent='', ResponseInterface $response=null)
	Perform a sub-request from within an application route. More...

Data Fields
const	VERSION = '3.11.0'

Protected Member Functions
	processInvalidMethod (ServerRequestInterface $request, ResponseInterface $response)
	Pull route info for a request with a bad method to decide whether to return a not-found error (default) or a bad-method error, then run the handler for that error, returning the resulting response. More...
	dispatchRouterAndPrepareRoute (ServerRequestInterface $request, RouterInterface $router)
	Dispatch the router to find the route. More...
	finalize (ResponseInterface $response)
	Finalize response. More...
	isEmptyResponse (ResponseInterface $response)
	Helper method, which returns true if the provided response must not output a body and false if the response could have a body. More...
	handleException (Exception $e, ServerRequestInterface $request, ResponseInterface $response)
	Call relevant handler from the Container if needed. More...
	handlePhpError (Throwable $e, ServerRequestInterface $request, ResponseInterface $response)
	Call relevant handler from the Container if needed. More...

Private Attributes
	$container

Detailed Description

Definition at line 46 of file App.php.

Constructor & Destructor Documentation

__construct()

Slim\App::__construct

(

$container = []

)

Create new application.

Parameters

ContainerInterface | array

$container

Either a ContainerInterface or an associative array of app settings

Exceptions

InvalidArgumentException

when no container is provided that implements ContainerInterface

Definition at line 74 of file App.php.

References $container.

    {
        if (is_array($container)) {
            $container = new Container($container);
        }
        if (!$container instanceof ContainerInterface) {
            throw new InvalidArgumentException('Expected a ContainerInterface');
        }
        $this->container = $container;
    }

Member Function Documentation

__call()

Slim\App::__call	(		$method,
			$args
	)

Calling a non-existant method on App checks to see if there's an item in the container that is callable and if so, calls it.

Parameters

string	$method
array	$args

Returns

mixed

Definition at line 117 of file App.php.

    {
        if ($this->container->has($method)) {
            $obj = $this->container->get($method);
            if (is_callable($obj)) {
                return call_user_func_array($obj, $args);
            }
        }

        throw new \BadMethodCallException("Method $method is not a valid method");
    }

add()

Slim\App::add

(

$callable

)

Add middleware.

This method prepends new middleware to the app's middleware stack.

Parameters

callable | string

$callable

The callback routine

Returns

static

Definition at line 104 of file App.php.

References Slim\addMiddleware().

    {
        return $this->addMiddleware(new DeferredCallable($callable, $this->container));
    }

Here is the call graph for this function:

any()

Slim\App::any	(		$pattern,
			$callable
	)

Add route for any HTTP method.

Parameters

string	$pattern	The route URI pattern
callable | string	$callable	The route callback routine

Returns

Definition at line 219 of file App.php.

    {
        return $this->map(['GET', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS'], $pattern, $callable);
    }

delete()

Slim\App::delete	(		$pattern,
			$callable
	)

Add DELETE route.

Parameters

string	$pattern	The route URI pattern
callable | string	$callable	The route callback routine

Returns

Definition at line 193 of file App.php.

    {
        return $this->map(['DELETE'], $pattern, $callable);
    }

dispatchRouterAndPrepareRoute()

Slim\App::dispatchRouterAndPrepareRoute ( ServerRequestInterface  $request, RouterInterface  $router  )

protected

Dispatch the router to find the route.

Prepare the route for use.

Parameters

ServerRequestInterface	$request
RouterInterface	$router

Returns

ServerRequestInterface

Definition at line 583 of file App.php.

References Slim\Interfaces\RouterInterface\dispatch(), Psr\Http\Message\RequestInterface\getMethod(), Psr\Http\Message\RequestInterface\getUri(), Slim\Interfaces\RouterInterface\lookupRoute(), string, and Psr\Http\Message\ServerRequestInterface\withAttribute().

    {
        $routeInfo = $router->dispatch($request);

        if ($routeInfo[0] === Dispatcher::FOUND) {
            $routeArguments = [];
            foreach ($routeInfo[2] as $k => $v) {
                $routeArguments[$k] = urldecode($v);
            }

            $route = $router->lookupRoute($routeInfo[1]);
            $route->prepare($request, $routeArguments);

            // add route to the request's attributes in case a middleware or handler needs access to the route
            $request = $request->withAttribute('route', $route);
        }

        $routeInfo['request'] = [$request->getMethod(), (string) $request->getUri()];

        return $request->withAttribute('routeInfo', $routeInfo);
    }

Here is the call graph for this function:

finalize()

Slim\App::finalize ( ResponseInterface  $response )

protected

Finalize response.

Parameters

ResponseInterface

$response

Returns

ResponseInterface

Definition at line 611 of file App.php.

References $response, $size, Psr\Http\Message\MessageInterface\getBody(), Psr\Http\Message\MessageInterface\hasHeader(), Psr\Http\Message\MessageInterface\withHeader(), and Psr\Http\Message\MessageInterface\withoutHeader().

    {
        // stop PHP sending a Content-Type automatically
        ini_set('default_mimetype', '');

        if ($this->isEmptyResponse($response)) {
            return $response->withoutHeader('Content-Type')->withoutHeader('Content-Length');
        }

        // Add Content-Length header if `addContentLengthHeader` setting is set
        if (isset($this->container->get('settings')['addContentLengthHeader']) &&
            $this->container->get('settings')['addContentLengthHeader'] == true) {
            if (ob_get_length() > 0) {
                throw new \RuntimeException("Unexpected data in output buffer. " .
                    "Maybe you have characters before an opening <?php tag?");
            }
            $size = $response->getBody()->getSize();
            if ($size !== null && !$response->hasHeader('Content-Length')) {
                $response = $response->withHeader('Content-Length', (string) $size);
            }
        }

        return $response;
    }

Here is the call graph for this function:

get()

Slim\App::get	(		$pattern,
			$callable
	)

Add GET route.

Parameters

string	$pattern	The route URI pattern
callable | string	$callable	The route callback routine

Returns

Definition at line 141 of file App.php.

    {
        return $this->map(['GET'], $pattern, $callable);
    }

getContainer()

Slim\App::getContainer

(

)

Enable access to the DI container by consumers of $app.

Returns

ContainerInterface

Definition at line 90 of file App.php.

References $container.

    {
        return $this->container;
    }

handleException()

Slim\App::handleException ( Exception  $e, ServerRequestInterface  $request, ResponseInterface  $response  )

protected

Call relevant handler from the Container if needed.

If it doesn't exist, then just re-throw.

Parameters

Exception	$e
ServerRequestInterface	$request
ResponseInterface	$response

Returns

ResponseInterface

Exceptions

Exception

if a handler is needed and not found

Definition at line 665 of file App.php.

References $handler, $params, and $response.

    {
        if ($e instanceof MethodNotAllowedException) {
            $handler = 'notAllowedHandler';
            $params = [$e->getRequest(), $e->getResponse(), $e->getAllowedMethods()];
        } elseif ($e instanceof NotFoundException) {
            $handler = 'notFoundHandler';
            $params = [$e->getRequest(), $e->getResponse(), $e];
        } elseif ($e instanceof SlimException) {
            // This is a Stop exception and contains the response
            return $e->getResponse();
        } else {
            // Other exception, use $request and $response params
            $handler = 'errorHandler';
            $params = [$request, $response, $e];
        }

        if ($this->container->has($handler)) {
            $callable = $this->container->get($handler);
            // Call the registered handler
            return call_user_func_array($callable, $params);
        }

        // No handlers found, so just throw the exception
        throw $e;
    }

handlePhpError()

Slim\App::handlePhpError ( Throwable  $e, ServerRequestInterface  $request, ResponseInterface  $response  )

protected

Call relevant handler from the Container if needed.

If it doesn't exist, then just re-throw.

Parameters

Throwable	$e
ServerRequestInterface	$request
ResponseInterface	$response

Returns

ResponseInterface

Exceptions

Throwable

Definition at line 702 of file App.php.

References $handler, $params, and $response.

    {
        $handler = 'phpErrorHandler';
        $params = [$request, $response, $e];

        if ($this->container->has($handler)) {
            $callable = $this->container->get($handler);
            // Call the registered handler
            return call_user_func_array($callable, $params);
        }

        // No handlers found, so just throw the exception
        throw $e;
    }

isEmptyResponse()

Slim\App::isEmptyResponse ( ResponseInterface  $response )

protected

Helper method, which returns true if the provided response must not output a body and false if the response could have a body.

See also

https://tools.ietf.org/html/rfc7231

Parameters

ResponseInterface

$response

Returns

bool

Definition at line 645 of file App.php.

References Psr\Http\Message\ResponseInterface\getStatusCode().

    {
        if (method_exists($response, 'isEmpty')) {
            return $response->isEmpty();
        }

        return in_array($response->getStatusCode(), [204, 205, 304]);
    }

Here is the call graph for this function:

map()

Slim\App::map	(	array	$methods,
			$pattern,
			$callable
	)

Add route with multiple methods.

Parameters

	string[]	$methods Numeric array of HTTP method names
string	$pattern	The route URI pattern
callable | string	$callable	The route callback routine

Returns

RouteInterface

Definition at line 233 of file App.php.

    {
        if ($callable instanceof Closure) {
            $callable = $callable->bindTo($this->container);
        }

        $route = $this->container->get('router')->map($methods, $pattern, $callable);
        if (is_callable([$route, 'setContainer'])) {
            $route->setContainer($this->container);
        }

        if (is_callable([$route, 'setOutputBuffering'])) {
            $route->setOutputBuffering($this->container->get('settings')['outputBuffering']);
        }

        return $route;
    }

options()

Slim\App::options	(		$pattern,
			$callable
	)

Add OPTIONS route.

Parameters

string	$pattern	The route URI pattern
callable | string	$callable	The route callback routine

Returns

Definition at line 206 of file App.php.

    {
        return $this->map(['OPTIONS'], $pattern, $callable);
    }

patch()

Slim\App::patch	(		$pattern,
			$callable
	)

Add PATCH route.

Parameters

string	$pattern	The route URI pattern
callable | string	$callable	The route callback routine

Returns

Definition at line 180 of file App.php.

    {
        return $this->map(['PATCH'], $pattern, $callable);
    }

post()

Slim\App::post	(		$pattern,
			$callable
	)

Add POST route.

Parameters

string	$pattern	The route URI pattern
callable | string	$callable	The route callback routine

Returns

Definition at line 154 of file App.php.

Referenced by ilRestServer\init().

    {
        return $this->map(['POST'], $pattern, $callable);
    }

Here is the caller graph for this function:

process()

Slim\App::process	(	ServerRequestInterface	$request,
		ResponseInterface	$response
	)

Process a request.

This method traverses the application middleware stack and then returns the resultant Response object.

Parameters

ServerRequestInterface	$request
ResponseInterface	$response

Returns

ResponseInterface

Exceptions

Exception
MethodNotAllowedException
NotFoundException

Definition at line 390 of file App.php.

References $response, and Psr\Http\Message\RequestInterface\getUri().

    {
        // Ensure basePath is set
        $router = $this->container->get('router');
        if (is_callable([$request->getUri(), 'getBasePath']) && is_callable([$router, 'setBasePath'])) {
            $router->setBasePath($request->getUri()->getBasePath());
        }

        // Dispatch the Router first if the setting for this is on
        if ($this->container->get('settings')['determineRouteBeforeAppMiddleware'] === true) {
            // Dispatch router (note: you won't be able to alter routes after this)
            $request = $this->dispatchRouterAndPrepareRoute($request, $router);
        }

        // Traverse middleware stack
        try {
            $response = $this->callMiddlewareStack($request, $response);
        } catch (Exception $e) {
            $response = $this->handleException($e, $request, $response);
        } catch (Throwable $e) {
            $response = $this->handlePhpError($e, $request, $response);
        }

        return $response;
    }

Here is the call graph for this function:

processInvalidMethod()

Slim\App::processInvalidMethod ( ServerRequestInterface  $request, ResponseInterface  $response  )

protected

Pull route info for a request with a bad method to decide whether to return a not-found error (default) or a bad-method error, then run the handler for that error, returning the resulting response.

Used for cases where an incoming request has an unrecognized method, rather than throwing an exception and not catching it all the way up.

Parameters

ServerRequestInterface	$request
ResponseInterface	$response

Returns

ResponseInterface

Definition at line 355 of file App.php.

References Psr\Http\Message\ServerRequestInterface\getAttribute(), and Psr\Http\Message\RequestInterface\getUri().

    {
        $router = $this->container->get('router');
        if (is_callable([$request->getUri(), 'getBasePath']) && is_callable([$router, 'setBasePath'])) {
            $router->setBasePath($request->getUri()->getBasePath());
        }

        $request = $this->dispatchRouterAndPrepareRoute($request, $router);
        $routeInfo = $request->getAttribute('routeInfo', [RouterInterface::DISPATCH_STATUS => Dispatcher::NOT_FOUND]);

        if ($routeInfo[RouterInterface::DISPATCH_STATUS] === Dispatcher::METHOD_NOT_ALLOWED) {
            return $this->handleException(
                new MethodNotAllowedException($request, $response, $routeInfo[RouterInterface::ALLOWED_METHODS]),
                $request,
                $response
            );
        }

        return $this->handleException(new NotFoundException($request, $response), $request, $response);
    }

Here is the call graph for this function:

put()

Slim\App::put	(		$pattern,
			$callable
	)

Add PUT route.

Parameters

string	$pattern	The route URI pattern
callable | string	$callable	The route callback routine

Returns

Definition at line 167 of file App.php.

    {
        return $this->map(['PUT'], $pattern, $callable);
    }

redirect()

Slim\App::redirect	(		$from,
			$to,
			$status = 302
	)

Add a route that sends an HTTP redirect.

Parameters

string	$from
string | UriInterface	$to
int	$status

Returns

RouteInterface

Definition at line 260 of file App.php.

References $from, $handler, and $response.

    {
        $handler = function ($request, ResponseInterface $response) use ($to, $status) {
            return $response->withHeader('Location', (string)$to)->withStatus($status);
        };

        return $this->get($from, $handler);
    }

respond()

Slim\App::respond

(

ResponseInterface

$response

)

Send the response to the client.

Parameters

ResponseInterface

$response

Definition at line 421 of file App.php.

References $contentLength, $data, $name, $response, Psr\Http\Message\ServerRequestInterface\getAttribute(), Psr\Http\Message\MessageInterface\getBody(), Psr\Http\Message\MessageInterface\getHeaderLine(), Psr\Http\Message\MessageInterface\getHeaders(), Psr\Http\Message\RequestInterface\getMethod(), Psr\Http\Message\MessageInterface\getProtocolVersion(), Psr\Http\Message\ResponseInterface\getReasonPhrase(), Psr\Http\Message\ResponseInterface\getStatusCode(), Psr\Http\Message\RequestInterface\getUri(), header, and string.

    {
        // Send response
        if (!headers_sent()) {
            // Headers
            foreach ($response->getHeaders() as $name => $values) {
                $first = stripos($name, 'Set-Cookie') === 0 ? false : true;
                foreach ($values as $value) {
                    header(sprintf('%s: %s', $name, $value), $first);
                    $first = false;
                }
            }

            // Set the status _after_ the headers, because of PHP's "helpful" behavior with location headers.
            // See https://github.com/slimphp/Slim/issues/1730

            // Status
            header(sprintf(
                'HTTP/%s %s %s',
                $response->getProtocolVersion(),
                $response->getStatusCode(),
                $response->getReasonPhrase()
            ), true, $response->getStatusCode());
        }

        // Body
        if (!$this->isEmptyResponse($response)) {
            $body = $response->getBody();
            if ($body->isSeekable()) {
                $body->rewind();
            }
            $settings       = $this->container->get('settings');
            $chunkSize      = $settings['responseChunkSize'];

            $contentLength  = $response->getHeaderLine('Content-Length');
            if (!$contentLength) {
                $contentLength = $body->getSize();
            }


            if (isset($contentLength)) {
                $amountToRead = $contentLength;
                while ($amountToRead > 0 && !$body->eof()) {
                    $data = $body->read(min($chunkSize, $amountToRead));
                    echo $data;

                    $amountToRead -= strlen($data);

                    if (connection_status() != CONNECTION_NORMAL) {
                        break;
                    }
                }
            } else {
                while (!$body->eof()) {
                    echo $body->read($chunkSize);
                    if (connection_status() != CONNECTION_NORMAL) {
                        break;
                    }
                }
            }
        }
    }

Here is the call graph for this function:

run()

Slim\App::run

(

$silent = false

)

Run application.

This method traverses the application middleware stack and then sends the resultant Response object to the HTTP client.

Parameters

bool | false

$silent

Returns

ResponseInterface

Exceptions

Exception
MethodNotAllowedException
NotFoundException

Definition at line 308 of file App.php.

References $output, $response, and Slim\Exception\InvalidMethodException\getRequest().

    {
        $response = $this->container->get('response');

        try {
            ob_start();
            $response = $this->process($this->container->get('request'), $response);
        } catch (InvalidMethodException $e) {
            $response = $this->processInvalidMethod($e->getRequest(), $response);
        } finally {
            $output = ob_get_clean();
        }

        if (!empty($output) && $response->getBody()->isWritable()) {
            $outputBuffering = $this->container->get('settings')['outputBuffering'];
            if ($outputBuffering === 'prepend') {
                // prepend output buffer content
                $body = new Http\Body(fopen('php://temp', 'r+'));
                $body->write($output . $response->getBody());
                $response = $response->withBody($body);
            } elseif ($outputBuffering === 'append') {
                // append output buffer content
                $response->getBody()->write($output);
            }
        }

        $response = $this->finalize($response);

        if (!$silent) {
            $this->respond($response);
        }

        return $response;
    }

Here is the call graph for this function:

subRequest()

Slim\App::subRequest	(		$method,
			$path,
			$query = '',
		array	$headers = [],
		array	$cookies = [],
			$bodyContent = '',
		ResponseInterface	$response = null
	)

Perform a sub-request from within an application route.

This method allows you to prepare and initiate a sub-request, run within the context of the current request. This WILL NOT issue a remote HTTP request. Instead, it will route the provided URL, method, headers, cookies, body, and server variables against the set of registered application routes. The result response object is returned.

Parameters

string	$method	The request method (e.g., GET, POST, PUT, etc.)
string	$path	The request URI path
string	$query	The request URI query string
array	$headers	The request headers (key-value array)
array	$cookies	The request cookies (key-value array)
string	$bodyContent	The request body
ResponseInterface	$response	The response object (optional)

Returns

ResponseInterface

Definition at line 551 of file App.php.

References $env, $path, and $query.

      {
        $env = $this->container->get('environment');
        $uri = Uri::createFromEnvironment($env)->withPath($path)->withQuery($query);
        $headers = new Headers($headers);
        $serverParams = $env->all();
        $body = new Body(fopen('php://temp', 'r+'));
        $body->write($bodyContent);
        $body->rewind();
        $request = new Request($method, $uri, $headers, $cookies, $serverParams, $body);

        if (!$response) {
            $response = $this->container->get('response');
        }

        return $this($request, $response);
    }

Field Documentation

$container

Slim\App::$container

private

Definition at line 62 of file App.php.

Referenced by ilRestServer\__construct().

VERSION

const Slim\App::VERSION = '3.11.0'

Definition at line 55 of file App.php.

---

The documentation for this class was generated from the following file:

• libs/composer/vendor/slim/slim/Slim/App.php