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'))]; }