/**
* @param IContainer $container
*/
public function initialize(IContainer $container)
{
$container->set([ISwiftMailerManager::class, SwiftMailerManager::class], SwiftMailerManager::class)->singleton();
$container->set([SwiftMailer::class, Swift_Mailer::class], function (SwiftMailerManager $swiftMailerManager) {
return $swiftMailerManager->getMailer();
});
}
function it_initializes(IHttpApp $httpApp, IErrorHandler $errorHandler, IContainer $container)
{
$httpApp->getDebug()->willReturn(true);
$errorHandler->addErrorHandler(Argument::any())->shouldBeCalled();
$errorHandler->addExceptionHandler(Argument::any())->shouldBeCalled();
$container->set(JsonErrorHandler::class, Argument::type(JsonErrorHandler::class))->shouldBeCalled();
$this->initialize($httpApp, $errorHandler, $container);
}
/**
* @param IContainer $container
* @param IMonologErrorHandlerConfig $monologConfig
* @param IErrorHandler $errorHandler
* @param IMonologChannelManager $channelManager
*/
public function initialize(IContainer $container, IMonologErrorHandlerConfig $monologConfig, IErrorHandler $errorHandler, IMonologChannelManager $channelManager)
{
$logger = $channelManager->getLogger($monologConfig->getErrorChannelName());
$monologErrorHandler = new MonologErrorHandler($logger, $errorHandler);
$monologErrorHandler->enableErrorHandling();
$monologErrorHandler->enableExceptionHandling();
$container->set(MonologErrorHandler::class, $monologErrorHandler);
}
/**
* @param IRoute $route
* @param IContainer $container
*
* @return mixed
*/
public function invoke(IRoute $route, IContainer $container)
{
list($controller, $method) = $this->extractControllerAndMethod($route->getAction());
$this->ensureClassExists($controller);
$instance = $container->get($controller);
$this->ensureMethodExists($instance, $method);
return $container->callMethod($instance, $method, $route->getParameters());
}
/**
* @param IBlackHoleErrorHandlerConfig $config
* @param IErrorHandler $errorHandler
* @param IContainer $container
*/
public function initialize(IBlackHoleErrorHandlerConfig $config, IErrorHandler $errorHandler, IContainer $container)
{
if ($config->getEnabled()) {
$errorHandler = new BlackHoleErrorHandler($errorHandler);
$errorHandler->enable();
$container->set(BlackHoleErrorHandler::class, $errorHandler);
}
}
/**
* @param IContainer $container
* @param ErrorHandler $errorHandler
*
* @throws \Weew\ErrorHandler\Exceptions\InvalidHandlerType
*/
public function initialize(IContainer $container, ErrorHandler $errorHandler)
{
$container->set([ErrorHandler::class, IErrorHandler::class], $errorHandler);
$errorHandler->enableErrorHandling();
$errorHandler->enableExceptionHandling();
$errorHandler->addErrorHandler([$this, 'handleError']);
$errorHandler->addExceptionHandler([$this, 'handleException']);
}
/**
* @param IApp $app
* @param IErrorHandler $errorHandler
* @param IContainer $container
*/
public function initialize(IApp $app, IErrorHandler $errorHandler, IContainer $container)
{
if ($app instanceof IHttpApp && $app->getDebug()) {
$jsonErrorHandler = new JsonErrorHandler($app, $errorHandler);
$jsonErrorHandler->enableErrorHandling();
$jsonErrorHandler->enableExceptionHandling();
$container->set(JsonErrorHandler::class, $jsonErrorHandler);
}
}
function it_shares_an_instance_of_the_default_logger_in_the_container()
{
$channelManager = $this->createChannelManager();
expect($this->container->has(LoggerInterface::class))->shouldBe(false);
$this->initialize($this->container, $channelManager);
expect($this->container->has(LoggerInterface::class))->shouldBe(true);
expect($this->container->has(Logger::class))->shouldBe(true);
$logger = $this->container->get(LoggerInterface::class);
$defaultLogger = $channelManager->getLogger();
expect($logger)->shouldBe($defaultLogger);
}
/**
* @param $abstract
* @param array $args
*
* @return mixed
*/
protected function resolveAbstract($abstract, array $args)
{
if (is_callable($abstract)) {
return $this->container->call($abstract, $args);
} else {
if (is_object($abstract)) {
return $abstract;
} else {
if (class_exists($abstract)) {
return $this->getClass(new ClassDefinition($abstract, null), $args);
}
}
}
return null;
}
/**
* Start App.
*/
public function start()
{
if ($this->started) {
return;
}
$this->started = true;
$this->getConfigLoader()->setEnvironment($this->getEnvironment());
$this->config = $this->getConfigLoader()->load();
$this->container->set([Config::class, IConfig::class], $this->config);
$this->config->set('env', $this->getEnvironment());
$this->config->set('debug', $this->getDebug());
$this->eventer->dispatch(new ConfigLoadedEvent($this->config));
$this->kernel->initialize();
$this->eventer->dispatch(new KernelInitializedEvent($this->kernel));
$this->kernel->boot();
$this->eventer->dispatch(new KernelBootedEvent($this->kernel));
$this->eventer->dispatch(new AppStartedEvent($this));
}
/**
* @param IContainer $container
* @param ReflectionParameter $parameter
*
* @return mixed
* @throws Exception
* @throws ValueNotFoundException
*/
protected function getParameterFromContainer(IContainer $container, ReflectionParameter $parameter)
{
try {
return $container->get($parameter->getClass()->getName());
} catch (Exception $ex) {
$ignoreException = $ex instanceof ValueNotFoundException || $ex instanceof ImplementationNotFoundException;
if (!($ignoreException && $parameter->isDefaultValueAvailable())) {
throw $ex;
}
}
}
/**
* @param callable $subscriber
* @param IEvent $event
*/
protected function invokeSubscriber(callable $subscriber, IEvent $event)
{
$this->container->call($subscriber, ['event' => $event]);
}
/**
* @param IContainer $container
*/
public function initialize(IContainer $container)
{
$container->set(IDoctrineConfig::class, DoctrineConfig::class);
$container->set([EntityManager::class, ObjectManager::class, EntityManagerInterface::class], [$this, 'createEntityManager'])->singleton();
}
/**
* BugsnagErrorHandlerProvider constructor.
*
* @param IContainer $container
*/
public function __construct(IContainer $container)
{
$container->set(IBugsnagErrorHandlerConfig::class, BugsnagErrorHandlerConfig::class);
$container->set(BugsnagErrorHandler::class, [$this, 'createBugsnagErrorHandler'])->singleton();
}
/**
* Share instances in the container.
*/
protected function shareInstancesInContainer()
{
$this->container->set([Router::class, IRouter::class], $this->router);
$this->container->set([RequestHandler::class, IRequestHandler::class], $this->requestHandler);
}
/**
* @param IContainer $container
* @param MonologChannelManager $channelManager
*/
public function initialize(IContainer $container, MonologChannelManager $channelManager)
{
$container->set([LoggerInterface::class, Logger::class], $channelManager->getLogger());
$container->set([IMonologChannelManager::class, MonologChannelManager::class], $channelManager);
}
/**
* @param object $provider
* @param IDictionary $shared
*/
public function shutdown($provider, IDictionary $shared)
{
$this->container->callMethod($provider, 'shutdown', ['shared' => $shared]);
}
/**
* @param $subscriber
* @param IEvent $event
*/
protected function invokeSubscriber($subscriber, IEvent $event)
{
$this->container->callMethod($subscriber, 'handle', ['event' => $event]);
}
/**
* @param callable $handler
* @param $command
*
* @return mixed
*/
protected function invokeHandler(callable $handler, $command)
{
return $this->container->call($handler, ['command' => $command, 'task' => $command]);
}
/**
* @return mixed
*/
public function enable()
{
$this->container->set($this->repositoryNameParser->getRepositoryNamePattern(), [$this, 'getRepository'])->singleton();
}
function it_enables_error_handling(IBlackHoleErrorHandlerConfig $config, IErrorHandler $errorHandler, IContainer $container)
{
$config->getEnabled()->willReturn(true);
$container->set(BlackHoleErrorHandler::class, Argument::type(BlackHoleErrorHandler::class))->shouldBeCalled();
$this->initialize($config, $errorHandler, $container);
}
/**
* @param $callable
* @param IRouter $router
*/
public function invoke($callable, IRouter $router)
{
$this->container->call($callable, ['router' => $router]);
}
/**
* @param IRoute $route
* @param IContainer $container
*
* @return mixed
*/
public function invoke(IRoute $route, IContainer $container)
{
return $container->call($route->getAction(), $route->getParameters());
}
/**
* @param $handler
* @param $command
*
* @return mixed
*/
protected function invokeHandler($handler, $command)
{
return $this->container->callMethod($handler, 'handle', ['command' => $command, 'task' => $command]);
}
/**
* @param IContainer $container
*/
public function initialize(IContainer $container)
{
$container->set([TwigLoader::class, Twig_Loader_Filesystem::class], [$this, 'createTwigLoaderFilesystem'])->singleton();
$container->set([Twig::class, Twig_Environment::class], [$this, 'createTwigEnvironment'])->singleton();
}
/**
* @param $resolver
* @param $parameter
*
* @return mixed
*/
public function invoke($resolver, $parameter)
{
return $this->container->call($resolver, ['parameter' => $parameter]);
}
/**
* @param object $handler
* @param IInput $input
* @param IOutput $output
* @param IConsole $console
*
* @return mixed
*/
public function run($handler, IInput $input, IOutput $output, IConsole $console)
{
return $this->container->callMethod($handler, 'run', ['input' => $input, 'in' => $input, 'output' => $output, 'out' => $output, 'console' => $console]);
}
/**
* @param $filter
* @param IRoute $route
*
* @return bool
*/
public function invoke($filter, IRoute $route)
{
return $this->container->call($filter, ['route' => $route]);
}
