private function createContainer(array $definitions = [])
{
$builder = new ContainerBuilder();
$builder->addDefinitions(__DIR__ . '/../../res/config/config.php');
$builder->addDefinitions([ContainerInterface::class => get(Container::class), Twig_LoaderInterface::class => object(Twig_Loader_Array::class)->constructor([]), ResourceRepository::class => object(NullRepository::class)]);
$builder->addDefinitions($definitions);
return $builder->build();
}
/**
* Initial setup of DI\ContainerBuilder.
*
* @param bool $annotation annotation usage.
*
* @return DI\ContainerBuilder
*/
protected static function initialSetupContainerBuilder($annotation)
{
$builder = new DI\ContainerBuilder();
$builder->useAnnotations($annotation);
$builder->addDefinitions(['request' => ServerRequestFactory::fromGlobals(), 'response' => DI\object(Response::class), 'http_flow_event' => DI\object(ZendHttpFlowEvent::class)->constructor('bootstrap', DI\get('request'), DI\get('response')), 'event_manager' => DI\object(ZendEvmProxy::class), 'dispatcher' => DI\factory(function ($container) {
return new Dispatcher($container->get('router'), $container);
})]);
return $builder;
}
/**
* Container compilation.
*
* @param mixed $config Configuration file/array.
*
* @link http://php-di.org/doc/php-definitions.html
*
* @return ContainerInterface
*/
public static function buildContainer($config = [])
{
$builder = new DI\ContainerBuilder();
$builder->useAnnotations(true);
$builder->addDefinitions(['request' => \Zend\Diactoros\ServerRequestFactory::fromGlobals(), 'response' => DI\object('Zend\\Diactoros\\Response'), 'http_flow_event' => DI\object('Penny\\Event\\HttpFlowEvent')->constructor('bootstrap', DI\get('request'), DI\get('response')), 'event_manager' => DI\object('Zend\\EventManager\\EventManager'), 'dispatcher' => DI\factory(function ($container) {
return new \Penny\Dispatcher($container->get('router'), $container);
})]);
$builder->addDefinitions($config);
$container = $builder->build();
$container->set('di', $container);
return $container;
}
<?php declare (strict_types=1); use function DI\get; use Stratify\ErrorHandlerModule\ErrorResponder\ErrorResponder; use Stratify\ErrorHandlerModule\ErrorResponder\WhoopsResponder; return [ErrorResponder::class => get(WhoopsResponder::class)];
<?php
namespace CASS\Application\Bundles\Version;
use function DI\object;
use function DI\factory;
use function DI\get;
use CASS\Application\Bundles\Version\Service\VersionService;
return ['php-di' => [VersionService::class => object()->constructorParameter('current', get('config.version.current'))->constructorParameter('frontendSPABlacklist', get('config.version.blacklist'))]];
<?php
use livetyping\hermitage\app\signer\Signer;
use function DI\env;
use function DI\get;
use function DI\object;
return ['signer' => object(Signer::class)->constructor(env('SIGNER_ALGORITHM', 'sha256')), Signer::class => get('signer')];
<?php use Bamf\Middleware\ControllerMiddleware; use DI\Container; use function DI\object; use function DI\get; return [ControllerMiddleware::class => object()->constructor(get(Container::class))];
<?php
namespace CASS\Domain\Bundles\Colors;
use function DI\object;
use function DI\factory;
use function DI\get;
use DI\Container;
use CASS\Application\Service\BundleService;
use CASS\Domain\Bundles\Avatar\Service\AvatarService;
use CASS\Domain\Bundles\Avatar\Service\Strategy\FileAvatarStrategy;
use CASS\Domain\Bundles\Avatar\Service\Strategy\MockAvatarStrategy;
use CASS\Domain\DomainBundle;
$configDefault = ['php-di' => [AvatarService::class => object()->constructorParameter('strategy', get(FileAvatarStrategy::class))]];
$configMock = ['php-di' => [AvatarService::class => object()->constructorParameter('strategy', get(MockAvatarStrategy::class))]];
return ['php-di' => [FileAvatarStrategy::class => object()->constructorParameter('fontPath', factory(function (Container $container) {
$domainBundle = $container->get(BundleService::class)->getBundleByName(DomainBundle::class);
/** @var DomainBundle $domainBundle */
return sprintf('%s/fonts/Roboto/Roboto-Medium.ttf', $domainBundle->getResourcesDir());
}))], 'env' => ['development' => $configDefault, 'production' => $configDefault, 'stage' => $configDefault, 'test' => $configMock]];
use PHPFramework\Impl\ResponseWriter\CORSResponseHeaderModifierInterface;
use PHPFramework\Impl\ResponseWriter\JsonContentTypeHeaderModifier;
use PHPFramework\Impl\ResponseWriter\JsonResponseContentWriter;
use PHPFramework\Impl\ResponseWriter\ResponseHeaderWriter;
use PHPFramework\Impl\ResponseWriter\ResponseStatusCodeWriter;
use PHPFramework\Impl\ResponseWriter\ResponseWriter;
use PHPFramework\Impl\Routing\FastRouteRouter;
use function DI\factory;
use function DI\get;
use function DI\object;
use function FastRoute\simpleDispatcher;
/*
* @see http://php-di.org/doc/
*/
return [StringUtilityInterface::class => object(StringUtility::class), SerializerInterface::class => function (ContainerInterface $c) {
return SerializerBuilder::create()->build();
}, ExceptionSanitizerInterface::class => object(ExceptionSanitizer::class), ExceptionHandlerInterface::class => object(ExceptionHandler::class), CORSResponseHeaderModifierInterface::class => object(CORSResponseHeaderModifier::class), ContentTypeHeaderModifierInterface::class => object(JsonContentTypeHeaderModifier::class), ResponseWriter::DI_RESPONSE_HEADER_MODIFIER_KEY => [get(CORSResponseHeaderModifierInterface::class), get(ContentTypeHeaderModifierInterface::class)], ResponseContentWriterInterface::class => object(JsonResponseContentWriter::class), ResponseHeaderWriterInterface::class => object(ResponseHeaderWriter::class), ResponseStatusCodeWriterInterface::class => object(ResponseStatusCodeWriter::class), ResponseWriterInterface::class => object(ResponseWriter::class)->constructorParameter('responseHeaderModifier', get(ResponseWriter::DI_RESPONSE_HEADER_MODIFIER_KEY)), Dispatcher::class => function (ContainerInterface $c) {
return simpleDispatcher(function (RouteCollector $r) use($c) {
$routesConfig = $c->get(FastRouteRouter::DI_ROUTE_CONFIG_KEY);
foreach ($routesConfig as $routeConfig) {
/** @var string $method */
$method = $routeConfig[0];
/** @var string $regex */
$regex = $routeConfig[1];
/** @var string $eventClass */
$eventClass = $routeConfig[2];
$r->addRoute($method, $regex, $eventClass);
}
});
}, RouterInterface::class => object(FastRouteRouter::class), UrlInterface::class => object(Url::class)->scope(Scope::PROTOTYPE), RequestUrlReaderInterface::class => object(RequestUrlReader::class), RequestMethodReaderInterface::class => object(RequestMethodReader::class), HeaderCollectionInterface::class => object(HeaderCollection::class)->scope(Scope::PROTOTYPE), RequestHeaderReaderInterface::class => object(RequestHeaderReader::class), RequestContentDeserializerInterface::class => object(RequestContentDeserializer::class), RequestContentInterface::class => object(RequestContent::class)->scope(Scope::PROTOTYPE), RequestContentReaderInterface::class => object(RequestContentReader::class), RouteParameterCollectionInterface::class => object(RouteParameterCollection::class)->scope(Scope::PROTOTYPE), RequestInterface::class => object(Request::class)->scope(Scope::PROTOTYPE), RequestReaderInterface::class => object(RequestReader::class), AppInterface::class => object(App::class), EventManagerInterface::class => object(EventManager::class)->constructorParameter('eventListener', get(EventManager::DI_EVENT_LISTENER_KEY))];
<?php
use function DI\object;
use function DI\get;
use function DI\factory;
return ['config' => object(\Piita\Config\Config::class), 'http_client' => object(\Piita\Support\HttpClient\HttpClientGuzzle::class), 'api' => object(\Piita\Support\API\QiitaAPIV2::class)->constructor(get('http_client')), 'items' => object(\Piita\Item\Items::class)->constructor(get('api')), 'item_id' => object(\Piita\Item\ValueObject\ItemId::class), 'item' => object(\Piita\Item\Item::class)];
<?php
use DI\Bridge\Slim\CallableResolver;
use DI\Bridge\Slim\ControllerInvoker;
use DI\Container;
use DI\Scope;
use Interop\Container\ContainerInterface;
use Invoker\Invoker;
use Invoker\ParameterResolver\AssociativeArrayResolver;
use Invoker\ParameterResolver\Container\TypeHintContainerResolver;
use Invoker\ParameterResolver\ResolverChain;
use Slim\Http\Headers;
use Slim\Http\Request;
use Slim\Http\Response;
use function DI\factory;
use function DI\get;
use function DI\object;
return ['settings.httpVersion' => '1.1', 'settings.responseChunkSize' => 4096, 'settings.outputBuffering' => 'append', 'settings.determineRouteBeforeAppMiddleware' => false, 'settings.displayErrorDetails' => false, 'settings' => ['httpVersion' => get('settings.httpVersion'), 'responseChunkSize' => get('settings.responseChunkSize'), 'outputBuffering' => get('settings.outputBuffering'), 'determineRouteBeforeAppMiddleware' => get('settings.determineRouteBeforeAppMiddleware'), 'displayErrorDetails' => get('settings.displayErrorDetails')], 'router' => object(Slim\Router::class), 'errorHandler' => object(Slim\Handlers\Error::class)->constructor(get('settings.displayErrorDetails')), 'notFoundHandler' => object(Slim\Handlers\NotFound::class), 'notAllowedHandler' => object(Slim\Handlers\NotAllowed::class), 'environment' => function () {
return new Slim\Http\Environment($_SERVER);
}, 'request' => factory(function (ContainerInterface $c) {
return Request::createFromEnvironment($c->get('environment'));
})->scope(Scope::SINGLETON), 'response' => factory(function (ContainerInterface $c) {
$headers = new Headers(['Content-Type' => 'text/html; charset=UTF-8']);
$response = new Response(200, $headers);
return $response->withProtocolVersion($c->get('settings')['httpVersion']);
})->scope(Scope::SINGLETON), 'foundHandler' => object(ControllerInvoker::class)->constructor(get('foundHandler.invoker')), 'foundHandler.invoker' => function (ContainerInterface $c) {
$resolvers = [new AssociativeArrayResolver(), new TypeHintContainerResolver($c)];
return new Invoker(new ResolverChain($resolvers), $c);
}, 'callableResolver' => object(CallableResolver::class), ContainerInterface::class => get(Container::class)];
<?php
use Puli\Repository\Api\ResourceRepository;
use Puli\TwigExtension\PuliExtension;
use Puli\TwigExtension\PuliTemplateLoader;
use Puli\UrlGenerator\Api\UrlGenerator;
use Stratify\TwigModule\Extension\StratifyExtension;
use function DI\add;
use function DI\get;
use function DI\object;
return ['twig.options' => [], 'twig.globals' => [], 'twig.extensions' => add([get(Twig_Extension_Debug::class), get(PuliExtension::class), get(StratifyExtension::class)]), Twig_Environment::class => object()->constructor(get(Twig_LoaderInterface::class), get('twig.options'))->method('setExtensions', get('twig.extensions')), Twig_LoaderInterface::class => object(PuliTemplateLoader::class), PuliExtension::class => object()->constructor(get(ResourceRepository::class), get(UrlGenerator::class))];
<?php
use function DI\object;
use function DI\get;
use Interop\Container\ContainerInterface;
use Piita\Support\API\QiitaAPIV2;
use Piita\Support\API\QiitaAPIInterface;
use Piita\Config\ConfigInterface;
use Piita\Support\HttpClient\HttpClientInterface;
use DI\Scope;
return ['config' => object(\Piita\Config\Config::class), ConfigInterface::class => get('config'), 'http_client' => object(\Piita\Support\HttpClient\HttpClientGuzzle::class), HttpClientInterface::class => get('http_client'), QiitaAPIInterface::class => DI\factory([Piita\Support\API\APIFactory::class, 'create']), 'items' => object(\Piita\Item\Items::class)->scope(Scope::PROTOTYPE), 'itemId' => object(\Piita\Item\ValueObject\ItemId::class)->scope(Scope::PROTOTYPE), 'item' => object(\Piita\Item\Item::class)->scope(Scope::PROTOTYPE), 'tag.items' => object(\Piita\Item\TagItems::class)->scope(Scope::PROTOTYPE), 'user.items' => object(\Piita\Item\UserItems::class)->scope(Scope::PROTOTYPE), 'user.stocks' => object(\Piita\Item\UserItems::class)->scope(Scope::PROTOTYPE), 'authuser.items' => object(\Piita\Item\AuthenticatedUserItems::class)->scope(Scope::PROTOTYPE), 'likes' => object(\Piita\Like\Likes::class)->scope(Scope::PROTOTYPE), 'like' => object(\Piita\Like\Like::class)->scope(Scope::PROTOTYPE), 'tags' => object(\Piita\Tag\Tags::class)->scope(Scope::PROTOTYPE), 'tag' => object(\Piita\Tag\Tag::class)->scope(Scope::PROTOTYPE), 'tagId' => object(\Piita\Tag\ValueObject\TagId::class)->scope(Scope::PROTOTYPE), 'user.tags' => object(\Piita\Tag\UserTags::class)->scope(Scope::PROTOTYPE), 'comments' => object(\Piita\Comment\Comments::class)->scope(Scope::PROTOTYPE), 'comment' => object(\Piita\Comment\Comment::class)->scope(Scope::PROTOTYPE), 'commentId' => object(\Piita\Comment\ValueObject\CommentId::class)->scope(Scope::PROTOTYPE), 'users' => object(\Piita\User\Users::class)->scope(Scope::PROTOTYPE), 'user' => object(\Piita\User\User::class)->scope(Scope::PROTOTYPE), 'userId' => object(\Piita\User\ValueObject\UserId::class)->scope(Scope::PROTOTYPE), 'user.followees' => object(\Piita\User\Followees::class)->scope(Scope::PROTOTYPE), 'user.followers' => object(\Piita\User\Followers::class)->scope(Scope::PROTOTYPE), 'user.stockers' => object(\Piita\User\Stockers::class)->scope(Scope::PROTOTYPE), 'teams' => object(\Piita\Team\Teams::class)->scope(Scope::PROTOTYPE), 'team' => object(\Piita\Team\Team::class)->scope(Scope::PROTOTYPE), 'teamId' => object(\Piita\Team\ValueObject\TeamId::class)->scope(Scope::PROTOTYPE), 'templates' => object(\Piita\Template\Templates::class)->scope(Scope::PROTOTYPE), 'template' => object(\Piita\Template\Template::class)->scope(Scope::PROTOTYPE), 'templateId' => object(\Piita\Template\ValueObject\TemplateId::class)->scope(Scope::PROTOTYPE), 'template.preview' => object(\Piita\Template\Preview::class)->scope(Scope::PROTOTYPE), 'projects' => object(\Piita\Project\Projects::class)->scope(Scope::PROTOTYPE), 'project' => object(\Piita\Project\Project::class)->scope(Scope::PROTOTYPE), 'projectId' => object(\Piita\Project\ValueObject\ProjectId::class)->scope(Scope::PROTOTYPE)];
use Stash\Interfaces\DriverInterface as ICacheDriver;
// Create a new silly cli app
// see: http://mnapoli.fr/silly/
$app = new Silly\Application();
// We will use php-di as our IoC container
// see: http://php-di.org/
$builder = new ContainerBuilder();
// We need to somehow do the caching at build time.
// And then only read from the cache when we detect
// that we are running inside a phar.
//$builder->writeProxiesToFile();
//$builder->setDefinitionCache();
$builder->useAnnotations(true);
$builder->addDefinitions(['vendor.dir' => 'ppm_packages', 'packagist.url' => 'https://packagist.org/packages/', 'semver.minimum-stability' => 'stable', IHttp::class => object(Http::class), IFilesystem::class => object(Filesystem::class), IFileAdapter::class => function () {
return new Local(getcwd());
}, ICache::class => object(Cache::class), ICacheDriver::class => object(CacheDriver::class), Contracts\IConflictDiscoverer::class => object(Services\ConflictDiscoverer::class), Contracts\IPackageCleaner::class => object(Services\PackageCleaner::class), Contracts\IZipExtractor::class => object(Services\ZipExtractor::class), Contracts\IPackageReNamer::class => object(Services\PackageReNamer::class), Contracts\IComposerFileReader::class => object(Services\ComposerFileReader::class), Contracts\IPackageDownloader::class => object(Services\PackageDownloader::class), Contracts\ISemVerSolver::class => object(Services\SemVerSolver::class), Contracts\ITypeExtractor::class => object(Services\TypeExtractor::class), Contracts\IReNameVisitor::class => object(Services\ReNameVisitor::class), Contracts\IProxyGenerator::class => object(Services\ProxyGenerator::class), Contracts\IAutoLoaderGenerator::class => object(Services\AutoLoaderGenerator::class), IParser::class => function () {
return (new ParserFactory())->create(ParserFactory::PREFER_PHP7);
}, ITraverser::class => object(NodeTraverser::class)->method('addVisitor', get(NameResolver::class))]);
// Make silly use php-di
$app->useContainer($builder->build(), true, true);
// Define our commands
$app->command('init', 'Brads\\Ppm\\Commands\\Initalise');
$app->command('install', 'Brads\\Ppm\\Commands\\Install')->descriptions('Installs the project dependencies from the composer.lock ' . 'file if present, or falls back on the composer.json.');
$app->command('update', 'Brads\\Ppm\\Commands\\Update');
$app->command('remove', 'Brads\\Ppm\\Commands\\Remove');
$app->command('require', 'Brads\\Ppm\\Commands\\Require');
$app->command('global', 'Brads\\Ppm\\Commands\\Global');
$app->command('create-project', 'Brads\\Ppm\\Commands\\CreateProject');
$app->command('self-update', 'Brads\\Ppm\\Commands\\SelfUpdate');
// Run the cli application
$app->run();
<?php
use Monolog\Handler\StreamHandler;
use Monolog\Logger;
use Monolog\Processor\PsrLogMessageProcessor;
use Monolog\Processor\WebProcessor;
use Psr\Log\LoggerInterface;
use function DI\env;
use function DI\get;
use function DI\object;
use function DI\string;
return ['logger.name' => get('app.name'), 'logger.path' => env('LOGGER_PATH', string('{storage-dir}/logs/app.log')), 'logger.handlers' => [object(StreamHandler::class)->constructor(get('logger.path'))], 'logger.processors' => [object(PsrLogMessageProcessor::class), object(WebProcessor::class)], 'logger' => object(Logger::class)->constructor(get('logger.name'), get('logger.handlers'), get('logger.processors')), LoggerInterface::class => get('logger')];
<?php
use function DI\get;
use function DI\object;
use Leaderboard\Repository\GithubInfoProvider;
use Leaderboard\Repository\PdoPlayerRepository;
use Leaderboard\Repository\PlayerRepository;
return ['settings.displayErrorDetails' => true, PDO::class => object()->constructor('mysql:host=127.0.0.1;dbname=lazerdrive;charset=utf8mb4', 'root', '', [])->method('setAttribute', PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION), PlayerRepository::class => object(GithubInfoProvider::class)->constructorParameter('decoratedRepository', get(PdoPlayerRepository::class))];
<?php
use livetyping\hermitage\app\factories\CommandBus;
use livetyping\hermitage\foundation\bus\commands;
use livetyping\hermitage\foundation\bus\handlers;
use SimpleBus\Message\Bus\MessageBus;
use function DI\factory;
use function DI\get;
use function DI\object;
return ['command-bus.middleware' => [], 'command-bus' => factory([CommandBus::class, 'create']), MessageBus::class => get('command-bus'), 'command-bus.command-handler-map' => [commands\StoreImageCommand::class => handlers\StoreImageCommandHandler::class, commands\MakeImageVersionCommand::class => handlers\MakeImageVersionCommandHandler::class, commands\DeleteImageCommand::class => handlers\DeleteImageCommandHandler::class], handlers\StoreImageCommandHandler::class => object(handlers\StoreImageCommandHandler::class), handlers\MakeImageVersionCommandHandler::class => object(handlers\MakeImageVersionCommandHandler::class), handlers\DeleteImageCommandHandler::class => object(handlers\DeleteImageCommandHandler::class)];
<?php
declare (strict_types=1);
use function DI\get;
use Interop\Container\ContainerInterface;
use Psr\Log\LoggerInterface;
use Psr\Log\NullLogger;
use Stratify\ErrorHandlerModule\ErrorHandlerMiddleware;
use Stratify\ErrorHandlerModule\ErrorResponder\ErrorResponder;
use Stratify\ErrorHandlerModule\ErrorResponder\SimpleProductionResponder;
use Stratify\ErrorHandlerModule\ErrorResponder\WhoopsResponder;
use Whoops\Handler\PrettyPageHandler;
use Whoops\Run;
return [ErrorHandlerMiddleware::class => function (ContainerInterface $c) {
$logger = $c->has(LoggerInterface::class) ? $c->get(LoggerInterface::class) : new NullLogger();
return new ErrorHandlerMiddleware($c->get(ErrorResponder::class), $logger);
}, ErrorResponder::class => get(SimpleProductionResponder::class), WhoopsResponder::class => DI\object()->constructor(get('error_handler.whoops')), 'error_handler.whoops' => function () {
$whoops = new Run();
$whoops->writeToOutput(false);
$whoops->allowQuit(false);
$handler = new PrettyPageHandler();
$handler->handleUnconditionally(true);
$whoops->pushHandler($handler);
return $whoops;
}];
<?php
use Aws\S3\S3Client;
use livetyping\hermitage\foundation\contracts\images\Generator as GeneratorContract;
use livetyping\hermitage\foundation\contracts\images\Processor as ProcessorContract;
use livetyping\hermitage\foundation\contracts\images\Storage as StorageContract;
use livetyping\hermitage\foundation\images\Generator;
use livetyping\hermitage\foundation\images\processor\Processor;
use livetyping\hermitage\foundation\images\Storage;
use Interop\Container\ContainerInterface;
use Intervention\Image\ImageManager;
use League\Flysystem\Adapter\Local;
use League\Flysystem\AwsS3v3\AwsS3Adapter;
use League\Flysystem\Cached\CachedAdapter;
use League\Flysystem\Cached\Storage\Memory;
use League\Flysystem\Filesystem;
use function DI\env;
use function DI\get;
use function DI\object;
use function DI\string;
return ['images.versions' => ['mini' => ['type' => 'resize', 'height' => 200, 'width' => 200], 'small' => ['type' => 'resize', 'height' => 400, 'width' => 400], 'thumb' => ['type' => 'fit', 'height' => 100, 'width' => 100]], 'images.optimization-params' => ['maxHeight' => 800, 'maxWidth' => 800], 'images.manipulator-map' => [], 'images.manager-config' => ['driver' => 'gd'], 'images.processor.manager' => object(ImageManager::class)->constructor(get('images.manager-config')), 'images.processor' => object(Processor::class)->constructor(get('images.processor.manager'))->method('addManipulatorMap', get('images.manipulator-map'))->method('setVersions', get('images.versions'))->method('setOptimizationParams', get('images.optimization-params')), ProcessorContract::class => get('images.processor'), 'images.generator' => object(Generator::class), GeneratorContract::class => get('images.generator'), 'images.storage.adapter' => env('STORAGE_ADAPTER', 'local'), 'images.storage' => function (ContainerInterface $c) {
$adapter = $c->get('images.storage.adapter');
$adapter = $c->get("images.storage.adapters.{$adapter}");
$adapter = new CachedAdapter($adapter, new Memory());
return new Storage(new Filesystem($adapter));
}, StorageContract::class => get('images.storage'), 'images.storage.adapters.local' => object(Local::class)->constructor(string('{storage-dir}/images')), 'images.storage.adapters.s3' => object(AwsS3Adapter::class)->constructor(get('images.storage.adapters.s3.client'), env('STORAGE_S3_BUCKET')), 'images.storage.adapters.s3.client' => object(S3Client::class)->constructor(get('images.storage.adapters.s3.client-config')), 'images.storage.adapters.s3.client-config' => ['version' => '2006-03-01', 'region' => env('STORAGE_S3_REGION'), 'credentials' => get('images.storage.adapters.s3.client-credentials')], 'images.storage.adapters.s3.client-credentials' => ['key' => env('STORAGE_S3_KEY'), 'secret' => env('STORAGE_S3_SECRET')]];
<?php
namespace CASS\Domain\Bundles\Auth;
use function DI\object;
use function DI\factory;
use function DI\get;
use CASS\Domain\Bundles\Auth\Middleware\AuthMiddleware;
use CASS\Application\Bundles\Frontline\Service\FrontlineService;
$config = ['php-di' => []];
foreach (AuthMiddleware::OAUTH2_PROVIDERS as $provider => $commandClassName) {
$config['php-di'][$commandClassName] = object()->constructorParameter('oauth2Config', get(sprintf('config.oauth2.%s', $provider)));
}
return $config;
<?php
use DI\Container;
use Interop\Container\ContainerInterface;
use Puli\Discovery\Api\Discovery;
use Puli\UrlGenerator\Api\UrlGenerator;
use Stratify\Framework\Middleware\ContainerBasedInvoker;
use Zend\Diactoros\Response\EmitterInterface;
use Zend\Diactoros\Response\SapiEmitter;
use function DI\get;
use function DI\object;
return [\Stratify\Http\Application::class => object()->constructor(get('http'), get('middleware_invoker'), get(EmitterInterface::class)), \Silly\Application::class => object()->method('useContainer', get(Container::class), true, true), 'http' => function () {
throw new Exception('No HTTP stack was defined');
}, ContainerInterface::class => get(Container::class), EmitterInterface::class => get(SapiEmitter::class), 'middleware_invoker' => get(ContainerBasedInvoker::class), UrlGenerator::class => function (ContainerInterface $c) {
$puli = $c->get('puli.factory');
return $puli->createUrlGenerator($c->get(Discovery::class));
}];
use SimpleBus\Message\CallableResolver\CallableMap;
use SimpleBus\Message\CallableResolver\CallableResolver;
use SimpleBus\Message\CallableResolver\ServiceLocatorAwareCallableResolver;
use SimpleBus\Message\Handler\DelegatesToMessageHandlerMiddleware;
use SimpleBus\Message\Handler\Resolver\MessageHandlerResolver;
use SimpleBus\Message\Handler\Resolver\NameBasedMessageHandlerResolver;
use SimpleBus\Message\Name\ClassBasedNameResolver;
use SimpleBus\Message\Name\MessageNameResolver;
use Zend\Diactoros\Response\EmitterInterface;
use Zend\Diactoros\Response\SapiEmitter;
use Zend\Diactoros\ServerRequestFactory;
use function DI\get;
use function DI\object;
use function FastRoute\simpleDispatcher;
return [DiKey::SERVICE_LOCATOR => function (ContainerInterface $c) {
return function ($serviceId) use($c) {
return $c->get($serviceId);
};
}, CallableResolver::class => object(ServiceLocatorAwareCallableResolver::class)->constructorParameter('serviceLocator', get(DiKey::SERVICE_LOCATOR)), CallableMap::class => object(CallableMap::class)->constructorParameter('callablesByName', get(DiKey::COMMAND_TO_HANDLER_MAPPING)), MessageNameResolver::class => object(ClassBasedNameResolver::class), MessageHandlerResolver::class => object(NameBasedMessageHandlerResolver::class), FinishesHandlingMessageBeforeHandlingNext::class => object(FinishesHandlingMessageBeforeHandlingNext::class), DelegatesToMessageHandlerMiddleware::class => object(DelegatesToMessageHandlerMiddleware::class), DiKey::COMMAND_BUS_MIDDLEWARES => [get(FinishesHandlingMessageBeforeHandlingNext::class), get(DelegatesToMessageHandlerMiddleware::class)], DiKey::COMMAND_BUS => object(MessageBusSupportingMiddleware::class)->constructorParameter('middlewares', get(DiKey::COMMAND_BUS_MIDDLEWARES)), Dispatcher::class => function (ContainerInterface $c) {
return simpleDispatcher(function (RouteCollector $r) use($c) {
$routesConfig = $c->get(DiKey::ROUTE_TO_COMMAND_CREATOR_MAPPING);
foreach ($routesConfig as $routeConfig) {
$r->addRoute($routeConfig[0], $routeConfig[1], $routeConfig[2]);
}
});
}, RouterInterface::class => object(FastRouteRouter::class)->constructorParameter('serviceLocator', get(DiKey::SERVICE_LOCATOR)), ServerRequestInterface::class => function () {
return ServerRequestFactory::fromGlobals();
}, RequestKnowledge::class => object(RequestKnowledge::class), SerializerInterface::class => function () {
return SerializerBuilder::create()->build();
}, DiKey::RESPONSE_MODIFIERS => [], ResponderInterface::class => object(Responder::class)->constructorParameter('responseModifiers', get(DiKey::RESPONSE_MODIFIERS)), EmitterInterface::class => object(SapiEmitter::class), RequestBodyParserInterface::class => object(RequestBodyParser::class), HttpExceptionHandlerInterface::class => object(GenericHttpExceptionHandler::class), AppInterface::class => object(App::class)->constructorParameter('commandBus', get(DiKey::COMMAND_BUS))];
public function getDefinitions()
{
return [authentication\ApiToken::class => object()->constructorParameter('apiToken', get('github.apiToken'))];
}
