/**
* @param ContainerInterface $app
*/
public function register(ContainerInterface $app)
{
$this->app = $app;
$app->singleton('MiddlewareResolver', function () {
return [$this, 'middlewareResolver'];
});
$app->singleton([RelayBuilder::class => 'RelayBuilder'], function () use($app) {
return new RelayBuilder($app['MiddlewareResolver']);
});
}
/**
* @param ContainerInterface $app
* @throws \InvalidArgumentException
*/
public function register(ContainerInterface $app)
{
$app->singleton([Logger::class => 'Logger'], function () use($app) {
$logger = new Logger($app['Config']['logger.name']);
if (!$app['Config']->offsetExists('logger.handler')) {
throw new \InvalidArgumentException('expected at least one logger handler in array(class, array config) format');
}
/**
* register logger handler
*/
foreach ($app['Config']['logger.handler'] as $class => $config) {
$handler = (new \ReflectionClass($class))->newInstanceArgs($config['args']);
if (!$handler instanceof HandlerInterface) {
throw new \InvalidArgumentException(sprintf('logger handler must implement %s', HandlerInterface::class));
}
$formatter = (new \ReflectionClass(key($config['formatter'])))->newInstance($config['formatter'][key($config['formatter'])]);
if (!$formatter instanceof FormatterInterface) {
throw new InvalidArgumentException(sprintf('logger formatter must implement %s', FormatterInterface::class));
}
$handler->setFormatter($formatter);
$logger->pushHandler($handler);
}
return $logger;
});
$app->bind(LoggerInterface::class, 'Logger');
}
private function registerEventDispatcherProvider()
{
$this->app->singleton([EventDispatcher::class => 'EventDispatcher'], function () {
return new EventDispatcher();
});
$this->app->bind(EventDispatcherInterface::class, 'EventDispatcher');
}
/**
* @param ContainerInterface $app
*/
public function register(ContainerInterface $app)
{
$app->singleton([RouteParser::class => 'RouteParser']);
$app->singleton([DataGenerator::class => 'DataGenerator']);
$app->singleton([RouteCollector::class => 'RouteCollector']);
/**
* contextual binding
*/
$app->bind(RouteParserInterface::class, 'RouteParser');
$app->bind(DataGeneratorInterface::class, 'DataGenerator');
/**
* register routing dispatcher
*/
$app->singleton([RouteDispatcher::class => 'RouteDispatcher'], function () use($app) {
return new RouteDispatcher($app['RouteCollector']->getData());
});
}
/**
* @param string $method
* @param string $route
* @param callable|string $handler
*/
private function registerRoute($method, $route, $handler)
{
/**
* if handler is class based register it in container
*/
if (is_string($handler) && class_exists($handler)) {
$this->container->singleton($handler);
}
$this->routes[] = ['method' => $method, 'route' => $route, 'handler' => $handler];
}
/**
* @param ContainerInterface $application
* @throws \InvalidArgumentException
*/
public function register(ContainerInterface $application)
{
$this->app = $application;
/**
* register whoops when debug mode enabled
*/
$this->app->singleton([ErrorHandler::class => 'ErrorHandler'], function () {
if ($this->errorHandler instanceof PrettyPageHandler) {
$this->errorHandler->handleUnconditionally(true);
}
$this->whoops = new Run();
$this->whoops->allowQuit(false);
$this->whoops->pushHandler($this->errorHandler);
return new ErrorHandler($this->app, $this->whoops, $this->contentType);
});
/**
* catch fatal error
*/
register_shutdown_function([$this->app['ErrorHandler'], 'handleError']);
}
/**
* @param ContainerInterface $app
*/
public function register(ContainerInterface $app)
{
/**
* swoole server
*/
$app->singleton('Server', function () use($app) {
return new Server($app);
});
/**
* swoole server request handler
*/
$app->singleton('ServerRequestHandler', function () use($app) {
return new ServerRequestHandler($app, $app['EventDispatcher']);
});
/**
* swoole server responder
*/
$app->singleton('ServerResponder', function () use($app) {
return new ServerResponder($app);
});
$app->bind(ServerInterface::class, 'Server');
$app->bind(ServerRequestHandlerInterface::class, 'ServerRequestHandler');
$app->bind(ServerResponderInterface::class, 'ServerResponder');
}
public function it_should_able_to_register_class_name_as_middleware(ContainerInterface $container)
{
$container->singleton(NotValidMiddlewareClass::class)->shouldBeCalled();
$this->middleware(NotValidMiddlewareClass::class);
}
