; режим отладки
slim.debug=Off

; директория шаблонов
templates.dir=template

; кэш шаблонов
templates.cache=var/cache/template

; В этом файле мы только переопределим некоторые параметры. Остальные значения подставятся из основного конфига
; В локальном окружении полезно видеть подробности ошибок
slim.debug=On

; кэш шаблонов для разработки не нужен
templates.cache=

/.idea/*
/config/*
/vendor/*
/var/cache/*
!/config/app.ini
!/var/cache/.gitkeep

<?php
// app/Support/CommandMap.php

namespace AppSupport;

class CommandMap
{

    /**
     * Маппинг команд. Имя команды => Ключ в контейнере
     * @var string[]
     */
    private  $map = [];

    public function set(string $name, string $value)
    {
        $this->map[$name] = $value;
    }

    /**
     * @return string[]
     */
    public function getMap()
    {
        return $this->map;
    }
}

<?php
// app/Support/Config.php

namespace AppSupport;

class Config
{

    /**
     * @var string[]
     */
    private $config = [];

    public function __construct(string $dir, string $env, string $root)
    {
        if (!is_dir($dir)) return;

        /*
         * Парсим основной конфиг
         */
        $config = (array)parse_ini_file($dir . DIRECTORY_SEPARATOR . 'app.ini', false);

        /*
         * Переопределяем параметры из конфига окружения
         */
        $environmentConfigFile = $dir . DIRECTORY_SEPARATOR . 'app.' . $env . '.ini';
        if (is_readable($environmentConfigFile)) {
            $config = array_replace_recursive($config, (array)parse_ini_file($environmentConfigFile, false));
        }

        /*
         * Указываем, какие параметры конфига являются путями
         */
        $dirs = ['templates.dir', 'templates.cache'];

        foreach ($config as $name=>$value) {
            $this->config[$name] = $value;
        }

        /*
         * Устанавливаем абсолютные пути в конфигурации
         */
        foreach ($dirs as $parameter) {
            $value = $config[$parameter];
            if (mb_strpos($value, '/') === 0) {
                continue;
            }
            if (empty($value)) {
                $this->config[$parameter] = null;
                continue;
            }
            $this->config[$parameter] = $root . DIRECTORY_SEPARATOR . $value;
        }
    }

    public function get(string $name)
    {
        return array_key_exists($name, $this->config) ? $this->config[$name] : null;
    }
}

<?php
// app/Support/NotFoundHandler.php

namespace AppSupport;

use PsrHttpMessageResponseFactoryInterface;
use PsrHttpMessageResponseInterface;
use PsrHttpMessageServerRequestInterface;
use SlimInterfacesErrorHandlerInterface;
use Throwable;

class NotFoundHandler implements ErrorHandlerInterface
{

    private $factory;

    public function __construct(ResponseFactoryInterface $factory)
    {
        $this->factory = $factory;
    }

    /**
     * @param ServerRequestInterface $request
     * @param Throwable $exception
     * @param bool $displayErrorDetails
     * @param bool $logErrors
     * @param bool $logErrorDetails
     * @return ResponseInterface
     */
    public function __invoke(ServerRequestInterface $request, Throwable $exception, bool $displayErrorDetails, bool $logErrors, bool $logErrorDetails): ResponseInterface
    {
        $response = $this->factory->createResponse(404);
        return $response;
    }
}

<?php
// .phpstorm.meta.php

namespace PHPSTORM_META {

    override(
        PsrContainerContainerInterface::get(0),
        map([
            '' => '@',
        ])
    );

    override(
        AppSupportConfig::get(0),
        map([
            'slim.debug'      => 'bool',
            'templates.dir'   => 'string|false',
            'templates.cache' => 'string|false',
        ])
    );
}

<?php
// app/Support/ServiceProviderInterface.php

namespace AppSupport;

use UltraLiteContainerContainer;

interface ServiceProviderInterface
{

    public function register(Container $container);
}

<?php
// app/Provider/AppProvider.php

namespace AppProvider;

use AppSupportCommandMap;
use AppSupportConfig;
use AppSupportNotFoundHandler;
use AppSupportServiceProviderInterface;
use PsrContainerContainerInterface;
use PsrHttpMessageResponseFactoryInterface;
use SlimCallableResolver;
use SlimExceptionHttpNotFoundException;
use SlimInterfacesCallableResolverInterface;
use SlimInterfacesRouteCollectorInterface;
use SlimInterfacesRouteResolverInterface;
use SlimMiddlewareErrorMiddleware;
use SlimMiddlewareRoutingMiddleware;
use SlimPsr7FactoryResponseFactory;
use SlimRoutingRouteCollector;
use SlimRoutingRouteResolver;
use UltraLiteContainerContainer;

class AppProvider implements ServiceProviderInterface
{

    public function register(Container $container)
    {

        /*
         * Регистрируем маппинг консольных команд
         */
        $container->set(CommandMap::class, function () {
            return new CommandMap();
        });

        /*
         * Регистрируем фабрику http-запроса
         */
        $container->set(ResponseFactory::class, function () {
            return new ResponseFactory();
        });

        /*
         * Связываем интерфейс фабрики http-запроса с реализацией
         */
        $container->set(ResponseFactoryInterface::class, function (ContainerInterface $container) {
            return $container->get(ResponseFactory::class);
        });

        /*
         * Регистрируем обработчик вызываемых методов
         */
        $container->set(CallableResolver::class, function (ContainerInterface $container) {
            return new CallableResolver($container);
        });

        /*
         * Связываем интерфейс обработчика вызываемых методов с реализацией
         */
        $container->set(CallableResolverInterface::class, function (ContainerInterface $container) {
            return $container->get(CallableResolver::class);
        });

        /*
         * Регистрируем роутер
         */
        $container->set(RouteCollector::class, function (ContainerInterface $container) {
            $router = new RouteCollector(
                $container->get(ResponseFactoryInterface::class),
                $container->get(CallableResolverInterface::class),
                $container
            );
            return $router;
        });

        /*
         * Связываем интерфес роутера с реализацией
         */
        $container->set(RouteCollectorInterface::class, function (ContainerInterface $container) {
            return $container->get(RouteCollector::class);
        });

        /*
         * Регистрируем обработчик результатов роутера
         */
        $container->set(RouteResolver::class, function (ContainerInterface $container) {
            return new RouteResolver($container->get(RouteCollectorInterface::class));
        });

        /*
         * Связываем интерфес обработчика результатов роутера с реализацией
         */
        $container->set(RouteResolverInterface::class, function (ContainerInterface $container) {
            return $container->get(RouteResolver::class);
        });

        /*
         * Регистрируем обработчика ошибки 404
         */
        $container->set(NotFoundHandler::class, function (ContainerInterface $container) {
            return new NotFoundHandler($container->get(ResponseFactoryInterface::class));
        });

        /*
         * Регистрируем middleware обработки ошибок
         */
        $container->set(ErrorMiddleware::class, function (ContainerInterface $container) {
            $middleware = new ErrorMiddleware(
                $container->get(CallableResolverInterface::class),
                $container->get(ResponseFactoryInterface::class),
                $container->get(Config::class)->get('slim.debug'),
                true,
                true);
            $middleware->setErrorHandler(HttpNotFoundException::class, $container->get(NotFoundHandler::class));
            return $middleware;
        });

        /*
         * Регистрируем middleware роутера
         */
        $container->set(RoutingMiddleware::class, function (ContainerInterface $container) {
            return new RoutingMiddleware($container->get(RouteResolverInterface::class));
        });
    }
}

<?php
// bootstrap.php

require_once __DIR__ . DIRECTORY_SEPARATOR . 'vendor' . DIRECTORY_SEPARATOR . 'autoload.php';

use AppSupportServiceProviderInterface;
use AppProviderAppProvider;
use AppSupportConfig;
use UltraLiteContainerContainer;

/*
 * Определяем окружение
 */
$env = getenv('APP_ENV');
if (!$env) $env = 'local';

/*
 * Строим конфиг
 */
$config = new Config(__DIR__ . DIRECTORY_SEPARATOR . 'config', $env, __DIR__);

/*
 * Определяем сервис-провайдеры
 */
$providers = [
    AppProvider::class,
];

/*
 * Создаем экземпляр контейнера
 */
$container = new Container([
    Config::class => function () use ($config) { return $config;},
]);

/*
 * Регистрируем сервисы
 */
foreach ($providers as $className) {
    if (!class_exists($className)) {
        /** @noinspection PhpUnhandledExceptionInspection */
        throw new Exception('Provider ' . $className . ' not found');
    }
    $provider = new $className;
    if (!$provider instanceof ServiceProviderInterface) {
        /** @noinspection PhpUnhandledExceptionInspection */
        throw new Exception($className . ' has not provider');
    }
    $provider->register($container);
}

/*
 * Возвращаем контейнер
 */
return $container;

#!/usr/bin/env php
<?php
// bin/console

use AppSupportCommandMap;
use PsrContainerContainerInterface;
use SymfonyComponentConsoleApplication;
use SymfonyComponentConsoleCommandLoaderContainerCommandLoader;
use SymfonyComponentConsoleInputArgvInput;
use SymfonyComponentConsoleOutputConsoleOutput;

/** @var ContainerInterface $container */
$container = require dirname(__DIR__) . DIRECTORY_SEPARATOR . 'bootstrap.php';

$loader = new ContainerCommandLoader($container, $container->get(CommandMap::class)->getMap());
$app = new Application();
$app->setCommandLoader($loader);
/** @noinspection PhpUnhandledExceptionInspection */
$app->run(new ArgvInput(), new ConsoleOutput());

<?php
// public/index.php

use PsrContainerContainerInterface;
use PsrHttpMessageResponseFactoryInterface;
use SlimApp;
use SlimInterfacesCallableResolverInterface;
use SlimInterfacesRouteCollectorInterface;
use SlimInterfacesRouteResolverInterface;
use SlimMiddlewareErrorMiddleware;
use SlimMiddlewareRoutingMiddleware;
use SlimPsr7FactoryServerRequestFactory;

/** @var ContainerInterface $container */
$container = require dirname(__DIR__) . DIRECTORY_SEPARATOR . 'bootstrap.php';
$request = ServerRequestFactory::createFromGlobals();

SlimFactoryAppFactory::create();
$app = new App(
    $container->get(ResponseFactoryInterface::class),
    $container,
    $container->get(CallableResolverInterface::class),
    $container->get(RouteCollectorInterface::class),
    $container->get(RouteResolverInterface::class)
);

$app->add($container->get(RoutingMiddleware::class));
$app->add($container->get(ErrorMiddleware::class));
$app->run($request);

{# template/layout.twig #}
<!DOCTYPE html>
<html lang="en">
<head>
    <title>{% block title %}Slim demo{% endblock %}</title>
</head>
<body>
{% block content %}{% endblock %}
</body>
</html>

{# template/hello.twig #}
{% extends 'layout.twig' %}
{% block title %}Slim demo::hello, {{ name }}{% endblock %}
{% block content %}
<h1>Welcome!</h1>
<p>Hello, {{ name }}!</p>
{% endblock %}

{# template/err404.twig #}
{% extends 'layout.twig' %}
{% block title %}Slim demo::not found{% endblock %}
{% block content %}
<h1>Error!</h1>
<p>Page not found =(</p>
{% endblock %}

<?php
// app/Provider/RenderProvider.php

namespace AppProvider;

use AppSupportConfig;
use AppSupportServiceProviderInterface;
use PsrContainerContainerInterface;
use TwigEnvironment;
use TwigLoaderFilesystemLoader;
use UltraLiteContainerContainer;

class RenderProvider implements ServiceProviderInterface
{
    public function register(Container $container)
    {
        $container->set(Environment::class, function (ContainerInterface $container) {
            $config = $container->get(Config::class);
            $loader = new FilesystemLoader($config->get('templates.dir'));
            $cache = $config->get('templates.cache');
            $options = [
                'cache' => empty($cache) ? false : $cache,
            ];
            $twig = new Environment($loader, $options);
            return $twig;
        });
    }
}

<?php
// bootstrap.php
// ...
use AppProviderRenderProvider;
// ...
$providers = [
// ...
    RenderProvider::class,
// ...
];
// ...

--- a/app/Support/NotFoundHandler.php
+++ b/app/Support/NotFoundHandler.php
@@ -8,15 +8,22 @@ use PsrHttpMessageResponseInterface;
 use PsrHttpMessageServerRequestInterface;
 use SlimInterfacesErrorHandlerInterface;
 use Throwable;
+use TwigEnvironment;
+use TwigErrorLoaderError;
+use TwigErrorRuntimeError;
+use TwigErrorSyntaxError;

 class NotFoundHandler implements ErrorHandlerInterface
 {

     private $factory;

-    public function __construct(ResponseFactoryInterface $factory)
+    private $render;
+
+    public function __construct(ResponseFactoryInterface $factory, Environment $render)
     {
         $this->factory = $factory;
+        $this->render = $render;
     }

     /**
@@ -26,10 +33,14 @@ class NotFoundHandler implements ErrorHandlerInterface
      * @param bool $logErrors
      * @param bool $logErrorDetails
      * @return ResponseInterface
+     * @throws LoaderError
+     * @throws RuntimeError
+     * @throws SyntaxError
      */
     public function __invoke(ServerRequestInterface $request, Throwable $exception, bool $displayErrorDetails, bool $logErrors, bool $logErrorDetails): ResponseInterface
     {
         $response = $this->factory->createResponse(404);
+        $response->getBody()->write($this->render->render('err404.twig'));
         return $response;
     }
 }

--- a/app/Provider/AppProvider.php
+++ b/app/Provider/AppProvider.php
@@ -19,6 +19,7 @@ use SlimMiddlewareRoutingMiddleware;
 use SlimPsr7FactoryResponseFactory;
 use SlimRoutingRouteCollector;
 use SlimRoutingRouteResolver;
+use TwigEnvironment;
 use UltraLiteContainerContainer;

 class AppProvider implements ServiceProviderInterface
@@ -99,7 +100,7 @@ class AppProvider implements ServiceProviderInterface
          * Регистрируем обработчика ошибки 404
          */
         $container->set(NotFoundHandler::class, function (ContainerInterface $container) {
-            return new NotFoundHandler($container->get(ResponseFactoryInterface::class));
+            return new NotFoundHandler($container->get(ResponseFactoryInterface::class), $container->get(Environment::class));
         });

         /*

<?php
// app/Controller/HomeController.php

namespace AppController;

use PsrHttpMessageResponseInterface;
use PsrHttpMessageServerRequestInterface;
use SlimInterfacesRouteParserInterface;

class HomeController
{

    /**
     * @var RouteParserInterface
     */
    private $router;

    public function __construct(RouteParserInterface $router)
    {
        $this->router = $router;
    }

    public function index(ServerRequestInterface $request, ResponseInterface $response)
    {
        $uri = $this->router->fullUrlFor($request->getUri(), 'hello', ['name' => 'world']);
        return $response
            ->withStatus(301)
            ->withHeader('location', $uri);
    }
}

<?php
// app/Controller/HelloController.php

namespace AppController;

use PsrHttpMessageResponseInterface;
use PsrHttpMessageServerRequestInterface;
use TwigEnvironment as Render;
use TwigErrorLoaderError;
use TwigErrorRuntimeError;
use TwigErrorSyntaxError;

class HelloController
{

    /**
     * @var Render
     */
    private $render;

    public function __construct(Render $render)
    {
        $this->render = $render;
    }

    /**
     * @param ServerRequestInterface $request
     * @param ResponseInterface $response
     * @return ResponseInterface
     * @throws LoaderError
     * @throws RuntimeError
     * @throws SyntaxError
     */
    public function show(ServerRequestInterface $request, ResponseInterface $response)
    {
        $response->getBody()->write($this->render->render('hello.twig', ['name' => $request->getAttribute('name')]));
        return $response;
    }
}

<?php
// app/Provider/WebProvider.php

namespace AppProvider;

use AppControllerHelloController;
use AppControllerHomeController;
use AppSupportServiceProviderInterface;
use PsrContainerContainerInterface;
use SlimInterfacesRouteCollectorInterface;
use SlimInterfacesRouteCollectorProxyInterface;
use TwigEnvironment;
use UltraLiteContainerContainer;

class WebProvider implements ServiceProviderInterface
{
    public function register(Container $container)
    {
        /*
         * Зарегистрируем контроллеры
         */
        $container->set(HomeController::class, function (ContainerInterface $container) {
            return new HomeController($container->get(RouteCollectorInterface::class)->getRouteParser());
        });

        $container->set(HelloController::class, function (ContainerInterface $container) {
            return new HelloController($container->get(Environment::class));
        });

        /*
         * Зарегистрируем маршруты
         */
        $router = $container->get(RouteCollectorInterface::class);
        $router->group('/', function(RouteCollectorProxyInterface $router) {
            $router->get('', HomeController::class . ':index')->setName('index');
            $router->get('hello/{name}', HelloController::class . ':show')->setName('hello');
        });
    }
}

<?php
// bootstrap.php
// ...
use AppProviderWebProvider;
// ...
$providers = [
// ...
    WebProvider::class,
// ...
];
// ...

<?php
// app/Command/RouteListCommand.php

namespace AppCommand;

use SlimInterfacesRouteCollectorInterface;
use SymfonyComponentConsoleCommandCommand;
use SymfonyComponentConsoleInputInputInterface;
use SymfonyComponentConsoleOutputOutputInterface;
use SymfonyComponentConsoleStyleSymfonyStyle;

class RouteListCommand extends Command
{

    /*
     * Имя вынесено в константу, чтобы было меньше ошибок при маппинге команд
     */
    const NAME = 'route:list';

    /**
     * @var RouteCollectorInterface
     */
    private $router;

    public function __construct(RouteCollectorInterface $router)
    {
        $this->router = $router;
        parent::__construct();
    }

    protected function configure()
    {
        $this->setName(self::NAME)
            ->setDescription('List of routes.')
            ->setHelp('List of routes.')
        ;
    }

    protected function execute(InputInterface $input, OutputInterface $output)
    {
        $io = new SymfonyStyle($input, $output);
        $io->title('Routes');
        $rows = [];
        $routes = $this->router->getRoutes();
        if (!$routes) {
            $io->text('Routes list is empty');
            return 0;
        }
        foreach ($routes as $route) {
            $rows[] = [
                'path' => $route->getPattern(),
                'methods' => implode(', ', $route->getMethods()),
                'name' => $route->getName(),
                'handler' => $route->getCallable(),
            ];
        }
        $io->table(
            ['Route', 'Methods', 'Name', 'Handler'],
            $rows
        );
        return 0;
    }
}

<?php
// app/Provider/CommandProvider.php

namespace AppProvider;

use AppCommandRouteListCommand;
use AppSupportCommandMap;
use AppSupportServiceProviderInterface;
use PsrContainerContainerInterface;
use SlimInterfacesRouteCollectorInterface;
use UltraLiteContainerContainer;

class CommandProvider implements ServiceProviderInterface
{
    public function register(Container $container)
    {
        /*
         * Добавим команду списка маршрутов в контейнер
         */
        $container->set(RouteListCommand::class, function (ContainerInterface $container) {
            return new RouteListCommand($container->get(RouteCollectorInterface::class));
        });

        /*
         * Добавим команду списка маршрутов в маппинг команд
         */
        $container->get(CommandMap::class)->set(RouteListCommand::NAME, RouteListCommand::class);
    }
}

<?php
// bootstrap.php
// ...
use AppProviderCommandProvider;
// ...
$providers = [
// ...
    CommandProvider::class,
// ...
];
// ...