ServiceProvider::getPackagePath() - Code Metrics - Inspection of "[TASK] Refactor low level console commands to avoi..." - TYPO3/TYPO3.CMS - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 39145a...3500a5 )

unknown

created 2021-02-19 21:28 UTC

ServiceProvider::getPackagePath() A

↳ Parent: ServiceProvider

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

/*
 * This file is part of the TYPO3 CMS project.
 *
 * It is free software; you can redistribute it and/or modify it under
 * the terms of the GNU General Public License, either version 2
 * of the License, or any later version.
 *
 * For the full copyright and license information, please read the
 * LICENSE.txt file that was distributed with this source code.
 *
 * The TYPO3 project - inspiring people to share!
 */

namespace TYPO3\CMS\Core;

use ArrayObject;
use Psr\Container\ContainerInterface;
use Psr\EventDispatcher\EventDispatcherInterface;
use Symfony\Component\Console\Command\HelpCommand;
use Symfony\Contracts\EventDispatcher\EventDispatcherInterface as SymfonyEventDispatcherInterface;
use TYPO3\CMS\Core\Core\Environment;
use TYPO3\CMS\Core\DependencyInjection\ContainerBuilder;
use TYPO3\CMS\Core\Package\AbstractServiceProvider;
use TYPO3\SymfonyPsrEventDispatcherAdapter\EventDispatcherAdapter as SymfonyEventDispatcher;

/**
 * @internal
 */
class ServiceProvider extends AbstractServiceProvider
{
    protected static function getPackagePath(): string
    {
        return __DIR__ . '/../';
    }

    public function getFactories(): array
    {
        return [
            SymfonyEventDispatcher::class => [ static::class, 'getSymfonyEventDispatcher' ],
            Cache\CacheManager::class => [ static::class, 'getCacheManager' ],
            Charset\CharsetConverter::class => [ static::class, 'getCharsetConverter' ],
            Configuration\SiteConfiguration::class => [ static::class, 'getSiteConfiguration' ],
            Command\ListCommand::class => [ static::class, 'getListCommand' ],
            HelpCommand::class => [ static::class, 'getHelpCommand' ],
            Command\DumpAutoloadCommand::class => [ static::class, 'getDumpAutoloadCommand' ],
            Console\CommandApplication::class => [ static::class, 'getConsoleCommandApplication' ],
            Console\CommandRegistry::class => [ static::class, 'getConsoleCommandRegistry' ],
            Context\Context::class => [ static::class, 'getContext' ],
            Core\BootService::class => [ static::class, 'getBootService' ],
            Crypto\PasswordHashing\PasswordHashFactory::class => [ static::class, 'getPasswordHashFactory' ],
            EventDispatcher\EventDispatcher::class => [ static::class, 'getEventDispatcher' ],
            EventDispatcher\ListenerProvider::class => [ static::class, 'getEventListenerProvider' ],
            Http\MiddlewareStackResolver::class => [ static::class, 'getMiddlewareStackResolver' ],
            Http\RequestFactory::class => [ static::class, 'getRequestFactory' ],
            Imaging\IconFactory::class => [ static::class, 'getIconFactory' ],
            Imaging\IconRegistry::class => [ static::class, 'getIconRegistry' ],
            Localization\LanguageServiceFactory::class => [ static::class, 'getLanguageServiceFactory' ],
            Localization\LanguageStore::class => [ static::class, 'getLanguageStore' ],
            Localization\Locales::class => [ static::class, 'getLocales' ],
            Localization\LocalizationFactory::class => [ static::class, 'getLocalizationFactory' ],
            Mail\TransportFactory::class => [ static::class, 'getMailTransportFactory' ],
            Messaging\FlashMessageService::class => [ static::class, 'getFlashMessageService' ],
            Middleware\ResponsePropagation::class => [ static::class, 'getResponsePropagationMiddleware' ],
            Package\FailsafePackageManager::class => [ static::class, 'getFailsafePackageManager' ],
            Registry::class => [ static::class, 'getRegistry' ],
            Resource\Index\FileIndexRepository::class => [ static::class, 'getFileIndexRepository' ],
            Resource\Index\MetaDataRepository::class => [ static::class, 'getMetaDataRepository' ],
            Resource\Driver\DriverRegistry::class => [ static::class, 'getDriverRegistry' ],
            Resource\ProcessedFileRepository::class => [ static::class, 'getProcessedFileRepository' ],
            Resource\ResourceFactory::class => [ static::class, 'getResourceFactory' ],
            Resource\StorageRepository::class => [ static::class, 'getStorageRepository' ],
            Service\DependencyOrderingService::class => [ static::class, 'getDependencyOrderingService' ],
            Service\FlexFormService::class => [ static::class, 'getFlexFormService' ],
            Service\OpcodeCacheService::class => [ static::class, 'getOpcodeCacheService' ],
            TimeTracker\TimeTracker::class => [ static::class, 'getTimeTracker' ],
            TypoScript\Parser\ConstantConfigurationParser::class => [ static::class, 'getTypoScriptConstantConfigurationParser' ],
            TypoScript\TypoScriptService::class => [ static::class, 'getTypoScriptService' ],
            'middlewares' => [ static::class, 'getMiddlewares' ],
        ];
    }

    public function getExtensions(): array
    {
        return [
            Console\CommandRegistry::class => [ static::class, 'configureCommands' ],
            EventDispatcherInterface::class => [ static::class, 'provideFallbackEventDispatcher' ],
            EventDispatcher\ListenerProvider::class => [ static::class, 'extendEventListenerProvider' ],
        ] + parent::getExtensions();
    }

    public static function getSymfonyEventDispatcher(ContainerInterface $container): SymfonyEventDispatcherInterface
    {
        return self::new($container, SymfonyEventDispatcher::class, [
            $container->get(EventDispatcherInterface::class)
        ]);
    }

    public static function getCacheManager(ContainerInterface $container): Cache\CacheManager
    {
        if (!$container->get('boot.state')->done) {
            throw new \LogicException(Cache\CacheManager::class . ' can not be injected/instantiated during ext_localconf.php loading. Use lazy loading instead.', 1549446998);
        }

        $cacheConfigurations = $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations'] ?? [];
        $disableCaching = $container->get('boot.state')->cacheDisabled;
        $defaultCaches = [
            $container->get('cache.core'),
            $container->get('cache.assets'),
            $container->get('cache.di'),
        ];

        $cacheManager = self::new($container, Cache\CacheManager::class, [$disableCaching]);
        $cacheManager->setCacheConfigurations($cacheConfigurations);
        $cacheConfigurations['di']['groups'] = ['system'];
        foreach ($defaultCaches as $cache) {
            $cacheManager->registerCache($cache, $cacheConfigurations[$cache->getIdentifier()]['groups'] ?? ['all']);
        }

        return $cacheManager;
    }

    public static function getCharsetConverter(ContainerInterface $container): Charset\CharsetConverter
    {
        return self::new($container, Charset\CharsetConverter::class);
    }

    public static function getSiteConfiguration(ContainerInterface $container): Configuration\SiteConfiguration
    {
        return self::new($container, Configuration\SiteConfiguration::class, [
            Environment::getConfigPath() . '/sites',
            $container->get('cache.core')
        ]);
    }

    public static function getListCommand(ContainerInterface $container): Command\ListCommand
    {
        return new Command\ListCommand(
            $container,
            $container->get(Core\BootService::class)
        );
    }

    public static function getHelpCommand(ContainerInterface $container): HelpCommand
    {
        return new HelpCommand();
    }

    public static function getDumpAutoloadCommand(ContainerInterface $container): Command\DumpAutoloadCommand
    {
        return new Command\DumpAutoloadCommand();
    }

    public static function getConsoleCommandApplication(ContainerInterface $container): Console\CommandApplication
    {
        return new Console\CommandApplication(
            $container->get(Context\Context::class),
            $container->get(Console\CommandRegistry::class),
            $container->get(Configuration\ConfigurationManager::class),
            $container->get(Core\BootService::class)
        );
    }

    public static function getConsoleCommandRegistry(ContainerInterface $container): Console\CommandRegistry
    {
        return new Console\CommandRegistry($container);
    }

    public static function getEventDispatcher(ContainerInterface $container): EventDispatcher\EventDispatcher
    {
        return new EventDispatcher\EventDispatcher(
            $container->get(EventDispatcher\ListenerProvider::class)
        );
    }

    public static function getEventListenerProvider(ContainerInterface $container): EventDispatcher\ListenerProvider
    {
        return new EventDispatcher\ListenerProvider($container);
    }

    public static function extendEventListenerProvider(
        ContainerInterface $container,
        EventDispatcher\ListenerProvider $listenerProvider
    ): EventDispatcher\ListenerProvider {
        $listenerProvider->addListener(
            Package\Event\PackagesMayHaveChangedEvent::class,
            Package\PackageManager::class,
            'packagesMayHaveChanged'
        );
        return $listenerProvider;
    }

    public static function getContext(ContainerInterface $container): Context\Context
    {
        return new Context\Context();
    }

    public static function getBootService(ContainerInterface $container): Core\BootService
    {
        if ($container->has('_early.boot-service')) {
            return $container->get('_early.boot-service');
        }
        return new Core\BootService(
            $container->get(ContainerBuilder::class),
            $container
        );
    }

    public static function getPasswordHashFactory(ContainerInterface $container): Crypto\PasswordHashing\PasswordHashFactory
    {
        return new Crypto\PasswordHashing\PasswordHashFactory();
    }

    public static function getIconFactory(ContainerInterface $container): Imaging\IconFactory
    {
        return self::new($container, Imaging\IconFactory::class, [
            $container->get(EventDispatcherInterface::class),
            $container->get(Imaging\IconRegistry::class)
        ]);
    }

    public static function getIconRegistry(ContainerInterface $container): Imaging\IconRegistry
    {
        return self::new($container, Imaging\IconRegistry::class);
    }

    public static function getLanguageServiceFactory(ContainerInterface $container): Localization\LanguageServiceFactory
    {
        return self::new($container, Localization\LanguageServiceFactory::class, [
            $container->get(Localization\Locales::class),
            $container->get(Localization\LocalizationFactory::class)
        ]);
    }

    public static function getLanguageStore(ContainerInterface $container): Localization\LanguageStore
    {
        return self::new($container, Localization\LanguageStore::class);
    }

    public static function getLocales(ContainerInterface $container): Localization\Locales
    {
        return self::new($container, Localization\Locales::class);
    }

    public static function getLocalizationFactory(ContainerInterface $container): Localization\LocalizationFactory
    {
        return self::new($container, Localization\LocalizationFactory::class, [
            $container->get(Localization\LanguageStore::class),
            $container->get(Cache\CacheManager::class)
        ]);
    }

    public static function getMailTransportFactory(ContainerInterface $container): Mail\TransportFactory
    {
        return self::new($container, Mail\TransportFactory::class, [
            $container->get(SymfonyEventDispatcher::class),
            $container->get(Log\LogManager::class)
        ]);
    }

    public static function getFlashMessageService(ContainerInterface $container): Messaging\FlashMessageService
    {
        return self::new($container, Messaging\FlashMessageService::class);
    }

    public static function getResponsePropagationMiddleware(ContainerInterface $container): Middleware\ResponsePropagation
    {
        return self::new($container, Middleware\ResponsePropagation::class);
    }

    public static function getFailsafePackageManager(ContainerInterface $container): Package\FailsafePackageManager
    {
        $packageManager = $container->get(Package\PackageManager::class);
        if ($packageManager instanceof Package\FailsafePackageManager) {
            return $packageManager;
        }
        throw new \RuntimeException('FailsafePackageManager can only be instantiated in failsafe (maintenance tool) mode.', 1586861816);
    }

    public static function getRegistry(ContainerInterface $container): Registry
    {
        return self::new($container, Registry::class);
    }

    public static function getFileIndexRepository(ContainerInterface $container): Resource\Index\FileIndexRepository
    {
        return self::new($container, Resource\Index\FileIndexRepository::class, [
            $container->get(EventDispatcherInterface::class)
        ]);
    }

    public static function getMetaDataRepository(ContainerInterface $container): Resource\Index\MetaDataRepository
    {
        return self::new($container, Resource\Index\MetaDataRepository::class, [
            $container->get(EventDispatcherInterface::class)
        ]);
    }

    public static function getDriverRegistry(ContainerInterface $container): Resource\Driver\DriverRegistry
    {
        return self::new($container, Resource\Driver\DriverRegistry::class);
    }

    public static function getProcessedFileRepository(ContainerInterface $container): Resource\ProcessedFileRepository
    {
        return self::new($container, Resource\ProcessedFileRepository::class);
    }

    public static function getResourceFactory(ContainerInterface $container): Resource\ResourceFactory
    {
        return self::new($container, Resource\ResourceFactory::class, [
            $container->get(Resource\StorageRepository::class)
        ]);
    }

    public static function getStorageRepository(ContainerInterface $container): Resource\StorageRepository
    {
        return self::new($container, Resource\StorageRepository::class, [
            $container->get(EventDispatcherInterface::class),
            $container->get(Resource\Driver\DriverRegistry::class),
        ]);
    }

    public static function getDependencyOrderingService(ContainerInterface $container): Service\DependencyOrderingService
    {
        return new Service\DependencyOrderingService();
    }

    public static function getFlexFormService(ContainerInterface $container): Service\FlexFormService
    {
        return self::new($container, Service\FlexFormService::class);
    }

    public static function getOpcodeCacheService(ContainerInterface $container): Service\OpcodeCacheService
    {
        return self::new($container, Service\OpcodeCacheService::class);
    }

    public static function getTimeTracker(ContainerInterface $container): TimeTracker\TimeTracker
    {
        return self::new($container, TimeTracker\TimeTracker::class);
    }

    public static function getTypoScriptConstantConfigurationParser(ContainerInterface $container): TypoScript\Parser\ConstantConfigurationParser
    {
        return self::new($container, TypoScript\Parser\ConstantConfigurationParser::class);
    }

    public static function getTypoScriptService(ContainerInterface $container): TypoScript\TypoScriptService
    {
        return self::new($container, TypoScript\TypoScriptService::class);
    }

    public static function getRequestFactory(ContainerInterface $container): Http\RequestFactory
    {
        return new Http\RequestFactory();
    }

    public static function getMiddlewareStackResolver(ContainerInterface $container): Http\MiddlewareStackResolver
    {
        return new Http\MiddlewareStackResolver(
            $container,
            $container->get(Service\DependencyOrderingService::class),
            $container->get('cache.core')
        );
    }

    public static function getMiddlewares(ContainerInterface $container): ArrayObject
    {
        return new ArrayObject();
    }

    public static function provideFallbackEventDispatcher(
        ContainerInterface $container,
        EventDispatcherInterface $eventDispatcher = null
    ): EventDispatcherInterface {
        // Provide a dummy / empty event dispatcher for the install tool when $eventDispatcher is null (that means when we run without symfony DI)
        return $eventDispatcher ?? new EventDispatcher\EventDispatcher(
            new EventDispatcher\ListenerProvider($container)
        );
    }

    public static function configureCommands(ContainerInterface $container, Console\CommandRegistry $commandRegistry): Console\CommandRegistry
    {
        $commandRegistry->addLazyCommand('list', Command\ListCommand::class, 'Lists commands');

        $commandRegistry->addLazyCommand('help', HelpCommand::class, 'Displays help for a command');

        $commandRegistry->addLazyCommand('dumpautoload', Command\DumpAutoloadCommand::class, 'Updates class loading information in non-composer mode.', Environment::isComposerMode());
        $commandRegistry->addLazyCommand('extensionmanager:extension:dumpclassloadinginformation', Command\DumpAutoloadCommand::class, null, Environment::isComposerMode(), false, 'dumpautoload');
        $commandRegistry->addLazyCommand('extension:dumpclassloadinginformation', Command\DumpAutoloadCommand::class, null, Environment::isComposerMode(), false, 'dumpautoload');

        return $commandRegistry;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			/*
6			* This file is part of the TYPO3 CMS project.
7			*
8			* It is free software; you can redistribute it and/or modify it under
9			* the terms of the GNU General Public License, either version 2
10			* of the License, or any later version.
11			*
12			* For the full copyright and license information, please read the
13			* LICENSE.txt file that was distributed with this source code.
14			*
15			* The TYPO3 project - inspiring people to share!
16			*/
17
18			namespace TYPO3\CMS\Core;
19
20			use ArrayObject;
21			use Psr\Container\ContainerInterface;
22			use Psr\EventDispatcher\EventDispatcherInterface;
23			use Symfony\Component\Console\Command\HelpCommand;
24			use Symfony\Contracts\EventDispatcher\EventDispatcherInterface as SymfonyEventDispatcherInterface;
25			use TYPO3\CMS\Core\Core\Environment;
26			use TYPO3\CMS\Core\DependencyInjection\ContainerBuilder;
27			use TYPO3\CMS\Core\Package\AbstractServiceProvider;
28			use TYPO3\SymfonyPsrEventDispatcherAdapter\EventDispatcherAdapter as SymfonyEventDispatcher;
29
30			/**
31			* @internal
32			*/
33			class ServiceProvider extends AbstractServiceProvider
34			{
35			protected static function getPackagePath(): string
36			{
37			return __DIR__ . '/../';
38			}
39
40			public function getFactories(): array
41			{
42			return [
43			SymfonyEventDispatcher::class => [ static::class, 'getSymfonyEventDispatcher' ],
44			Cache\CacheManager::class => [ static::class, 'getCacheManager' ],
45			Charset\CharsetConverter::class => [ static::class, 'getCharsetConverter' ],
46			Configuration\SiteConfiguration::class => [ static::class, 'getSiteConfiguration' ],
47			Command\ListCommand::class => [ static::class, 'getListCommand' ],
48			HelpCommand::class => [ static::class, 'getHelpCommand' ],
49			Command\DumpAutoloadCommand::class => [ static::class, 'getDumpAutoloadCommand' ],
50			Console\CommandApplication::class => [ static::class, 'getConsoleCommandApplication' ],
51			Console\CommandRegistry::class => [ static::class, 'getConsoleCommandRegistry' ],
52			Context\Context::class => [ static::class, 'getContext' ],
53			Core\BootService::class => [ static::class, 'getBootService' ],
54			Crypto\PasswordHashing\PasswordHashFactory::class => [ static::class, 'getPasswordHashFactory' ],
55			EventDispatcher\EventDispatcher::class => [ static::class, 'getEventDispatcher' ],
56			EventDispatcher\ListenerProvider::class => [ static::class, 'getEventListenerProvider' ],
57			Http\MiddlewareStackResolver::class => [ static::class, 'getMiddlewareStackResolver' ],
58			Http\RequestFactory::class => [ static::class, 'getRequestFactory' ],
59			Imaging\IconFactory::class => [ static::class, 'getIconFactory' ],
60			Imaging\IconRegistry::class => [ static::class, 'getIconRegistry' ],
61			Localization\LanguageServiceFactory::class => [ static::class, 'getLanguageServiceFactory' ],
62			Localization\LanguageStore::class => [ static::class, 'getLanguageStore' ],
63			Localization\Locales::class => [ static::class, 'getLocales' ],
64			Localization\LocalizationFactory::class => [ static::class, 'getLocalizationFactory' ],
65			Mail\TransportFactory::class => [ static::class, 'getMailTransportFactory' ],
66			Messaging\FlashMessageService::class => [ static::class, 'getFlashMessageService' ],
67			Middleware\ResponsePropagation::class => [ static::class, 'getResponsePropagationMiddleware' ],
68			Package\FailsafePackageManager::class => [ static::class, 'getFailsafePackageManager' ],
69			Registry::class => [ static::class, 'getRegistry' ],
70			Resource\Index\FileIndexRepository::class => [ static::class, 'getFileIndexRepository' ],
71			Resource\Index\MetaDataRepository::class => [ static::class, 'getMetaDataRepository' ],
72			Resource\Driver\DriverRegistry::class => [ static::class, 'getDriverRegistry' ],
73			Resource\ProcessedFileRepository::class => [ static::class, 'getProcessedFileRepository' ],
74			Resource\ResourceFactory::class => [ static::class, 'getResourceFactory' ],
75			Resource\StorageRepository::class => [ static::class, 'getStorageRepository' ],
76			Service\DependencyOrderingService::class => [ static::class, 'getDependencyOrderingService' ],
77			Service\FlexFormService::class => [ static::class, 'getFlexFormService' ],
78			Service\OpcodeCacheService::class => [ static::class, 'getOpcodeCacheService' ],
79			TimeTracker\TimeTracker::class => [ static::class, 'getTimeTracker' ],
80			TypoScript\Parser\ConstantConfigurationParser::class => [ static::class, 'getTypoScriptConstantConfigurationParser' ],
81			TypoScript\TypoScriptService::class => [ static::class, 'getTypoScriptService' ],
82			'middlewares' => [ static::class, 'getMiddlewares' ],
83			];
84			}
85
86			public function getExtensions(): array
87			{
88			return [
89			Console\CommandRegistry::class => [ static::class, 'configureCommands' ],
90			EventDispatcherInterface::class => [ static::class, 'provideFallbackEventDispatcher' ],
91			EventDispatcher\ListenerProvider::class => [ static::class, 'extendEventListenerProvider' ],
92			] + parent::getExtensions();
93			}
94
95			public static function getSymfonyEventDispatcher(ContainerInterface $container): SymfonyEventDispatcherInterface
96			{
97			return self::new($container, SymfonyEventDispatcher::class, [
98			$container->get(EventDispatcherInterface::class)
99			]);
100			}
101
102			public static function getCacheManager(ContainerInterface $container): Cache\CacheManager
103			{
104			if (!$container->get('boot.state')->done) {
105			throw new \LogicException(Cache\CacheManager::class . ' can not be injected/instantiated during ext_localconf.php loading. Use lazy loading instead.', 1549446998);
106			}
107
108			$cacheConfigurations = $GLOBALS['TYPO3_CONF_VARS']['SYS']['caching']['cacheConfigurations'] ?? [];
109			$disableCaching = $container->get('boot.state')->cacheDisabled;
110			$defaultCaches = [
111			$container->get('cache.core'),
112			$container->get('cache.assets'),
113			$container->get('cache.di'),
114			];
115
116			$cacheManager = self::new($container, Cache\CacheManager::class, [$disableCaching]);
117			$cacheManager->setCacheConfigurations($cacheConfigurations);
118			$cacheConfigurations['di']['groups'] = ['system'];
119			foreach ($defaultCaches as $cache) {
120			$cacheManager->registerCache($cache, $cacheConfigurations[$cache->getIdentifier()]['groups'] ?? ['all']);
121			}
122
123			return $cacheManager;
124			}
125
126			public static function getCharsetConverter(ContainerInterface $container): Charset\CharsetConverter
127			{
128			return self::new($container, Charset\CharsetConverter::class);
129			}
130
131			public static function getSiteConfiguration(ContainerInterface $container): Configuration\SiteConfiguration
132			{
133			return self::new($container, Configuration\SiteConfiguration::class, [
134			Environment::getConfigPath() . '/sites',
135			$container->get('cache.core')
136			]);
137			}
138
139			public static function getListCommand(ContainerInterface $container): Command\ListCommand
140			{
141			return new Command\ListCommand(
142			$container,
143			$container->get(Core\BootService::class)
144			);
145			}
146
147			public static function getHelpCommand(ContainerInterface $container): HelpCommand
148			{
149			return new HelpCommand();
150			}
151
152			public static function getDumpAutoloadCommand(ContainerInterface $container): Command\DumpAutoloadCommand
153			{
154			return new Command\DumpAutoloadCommand();
155			}
156
157			public static function getConsoleCommandApplication(ContainerInterface $container): Console\CommandApplication
158			{
159			return new Console\CommandApplication(
160			$container->get(Context\Context::class),
161			$container->get(Console\CommandRegistry::class),
162			$container->get(Configuration\ConfigurationManager::class),
163			$container->get(Core\BootService::class)
164			);
165			}
166
167			public static function getConsoleCommandRegistry(ContainerInterface $container): Console\CommandRegistry
168			{
169			return new Console\CommandRegistry($container);
170			}
171
172			public static function getEventDispatcher(ContainerInterface $container): EventDispatcher\EventDispatcher
173			{
174			return new EventDispatcher\EventDispatcher(
175			$container->get(EventDispatcher\ListenerProvider::class)
176			);
177			}
178
179			public static function getEventListenerProvider(ContainerInterface $container): EventDispatcher\ListenerProvider
180			{
181			return new EventDispatcher\ListenerProvider($container);
182			}
183
184			public static function extendEventListenerProvider(
185			ContainerInterface $container,
186			EventDispatcher\ListenerProvider $listenerProvider
187			): EventDispatcher\ListenerProvider {
188			$listenerProvider->addListener(
189			Package\Event\PackagesMayHaveChangedEvent::class,
190			Package\PackageManager::class,
191			'packagesMayHaveChanged'
192			);
193			return $listenerProvider;
194			}
195
196			public static function getContext(ContainerInterface $container): Context\Context
197			{
198			return new Context\Context();
199			}
200
201			public static function getBootService(ContainerInterface $container): Core\BootService
202			{
203			if ($container->has('_early.boot-service')) {
204			return $container->get('_early.boot-service');
205			}
206			return new Core\BootService(
207			$container->get(ContainerBuilder::class),
208			$container
209			);
210			}
211
212			public static function getPasswordHashFactory(ContainerInterface $container): Crypto\PasswordHashing\PasswordHashFactory
213			{
214			return new Crypto\PasswordHashing\PasswordHashFactory();
215			}
216
217			public static function getIconFactory(ContainerInterface $container): Imaging\IconFactory
218			{
219			return self::new($container, Imaging\IconFactory::class, [
220			$container->get(EventDispatcherInterface::class),
221			$container->get(Imaging\IconRegistry::class)
222			]);
223			}
224
225			public static function getIconRegistry(ContainerInterface $container): Imaging\IconRegistry
226			{
227			return self::new($container, Imaging\IconRegistry::class);
228			}
229
230			public static function getLanguageServiceFactory(ContainerInterface $container): Localization\LanguageServiceFactory
231			{
232			return self::new($container, Localization\LanguageServiceFactory::class, [
233			$container->get(Localization\Locales::class),
234			$container->get(Localization\LocalizationFactory::class)
235			]);
236			}
237
238			public static function getLanguageStore(ContainerInterface $container): Localization\LanguageStore
239			{
240			return self::new($container, Localization\LanguageStore::class);
241			}
242
243			public static function getLocales(ContainerInterface $container): Localization\Locales
244			{
245			return self::new($container, Localization\Locales::class);
246			}
247
248			public static function getLocalizationFactory(ContainerInterface $container): Localization\LocalizationFactory
249			{
250			return self::new($container, Localization\LocalizationFactory::class, [
251			$container->get(Localization\LanguageStore::class),
252			$container->get(Cache\CacheManager::class)
253			]);
254			}
255
256			public static function getMailTransportFactory(ContainerInterface $container): Mail\TransportFactory
257			{
258			return self::new($container, Mail\TransportFactory::class, [
259			$container->get(SymfonyEventDispatcher::class),
260			$container->get(Log\LogManager::class)
261			]);
262			}
263
264			public static function getFlashMessageService(ContainerInterface $container): Messaging\FlashMessageService
265			{
266			return self::new($container, Messaging\FlashMessageService::class);
267			}
268
269			public static function getResponsePropagationMiddleware(ContainerInterface $container): Middleware\ResponsePropagation
270			{
271			return self::new($container, Middleware\ResponsePropagation::class);
272			}
273
274			public static function getFailsafePackageManager(ContainerInterface $container): Package\FailsafePackageManager
275			{
276			$packageManager = $container->get(Package\PackageManager::class);
277			if ($packageManager instanceof Package\FailsafePackageManager) {
278			return $packageManager;
279			}
280			throw new \RuntimeException('FailsafePackageManager can only be instantiated in failsafe (maintenance tool) mode.', 1586861816);
281			}
282
283			public static function getRegistry(ContainerInterface $container): Registry
284			{
285			return self::new($container, Registry::class);
286			}
287
288			public static function getFileIndexRepository(ContainerInterface $container): Resource\Index\FileIndexRepository
289			{
290			return self::new($container, Resource\Index\FileIndexRepository::class, [
291			$container->get(EventDispatcherInterface::class)
292			]);
293			}
294
295			public static function getMetaDataRepository(ContainerInterface $container): Resource\Index\MetaDataRepository
296			{
297			return self::new($container, Resource\Index\MetaDataRepository::class, [
298			$container->get(EventDispatcherInterface::class)
299			]);
300			}
301
302			public static function getDriverRegistry(ContainerInterface $container): Resource\Driver\DriverRegistry
303			{
304			return self::new($container, Resource\Driver\DriverRegistry::class);
305			}
306
307			public static function getProcessedFileRepository(ContainerInterface $container): Resource\ProcessedFileRepository
308			{
309			return self::new($container, Resource\ProcessedFileRepository::class);
310			}
311
312			public static function getResourceFactory(ContainerInterface $container): Resource\ResourceFactory
313			{
314			return self::new($container, Resource\ResourceFactory::class, [
315			$container->get(Resource\StorageRepository::class)
316			]);
317			}
318
319			public static function getStorageRepository(ContainerInterface $container): Resource\StorageRepository
320			{
321			return self::new($container, Resource\StorageRepository::class, [
322			$container->get(EventDispatcherInterface::class),
323			$container->get(Resource\Driver\DriverRegistry::class),
324			]);
325			}
326
327			public static function getDependencyOrderingService(ContainerInterface $container): Service\DependencyOrderingService
328			{
329			return new Service\DependencyOrderingService();
330			}
331
332			public static function getFlexFormService(ContainerInterface $container): Service\FlexFormService
333			{
334			return self::new($container, Service\FlexFormService::class);
335			}
336
337			public static function getOpcodeCacheService(ContainerInterface $container): Service\OpcodeCacheService
338			{
339			return self::new($container, Service\OpcodeCacheService::class);
340			}
341
342			public static function getTimeTracker(ContainerInterface $container): TimeTracker\TimeTracker
343			{
344			return self::new($container, TimeTracker\TimeTracker::class);
345			}
346
347			public static function getTypoScriptConstantConfigurationParser(ContainerInterface $container): TypoScript\Parser\ConstantConfigurationParser
348			{
349			return self::new($container, TypoScript\Parser\ConstantConfigurationParser::class);
350			}
351
352			public static function getTypoScriptService(ContainerInterface $container): TypoScript\TypoScriptService
353			{
354			return self::new($container, TypoScript\TypoScriptService::class);
355			}
356
357			public static function getRequestFactory(ContainerInterface $container): Http\RequestFactory
358			{
359			return new Http\RequestFactory();
360			}
361
362			public static function getMiddlewareStackResolver(ContainerInterface $container): Http\MiddlewareStackResolver
363			{
364			return new Http\MiddlewareStackResolver(
365			$container,
366			$container->get(Service\DependencyOrderingService::class),
367			$container->get('cache.core')
368			);
369			}
370
371			public static function getMiddlewares(ContainerInterface $container): ArrayObject
372			{
373			return new ArrayObject();
374			}
375
376			public static function provideFallbackEventDispatcher(
377			ContainerInterface $container,
378			EventDispatcherInterface $eventDispatcher = null
379			): EventDispatcherInterface {
380			// Provide a dummy / empty event dispatcher for the install tool when $eventDispatcher is null (that means when we run without symfony DI)
381			return $eventDispatcher ?? new EventDispatcher\EventDispatcher(
382			new EventDispatcher\ListenerProvider($container)
383			);
384			}
385
386			public static function configureCommands(ContainerInterface $container, Console\CommandRegistry $commandRegistry): Console\CommandRegistry
387			{
388			$commandRegistry->addLazyCommand('list', Command\ListCommand::class, 'Lists commands');
389
390			$commandRegistry->addLazyCommand('help', HelpCommand::class, 'Displays help for a command');
391
392			$commandRegistry->addLazyCommand('dumpautoload', Command\DumpAutoloadCommand::class, 'Updates class loading information in non-composer mode.', Environment::isComposerMode());
393			$commandRegistry->addLazyCommand('extensionmanager:extension:dumpclassloadinginformation', Command\DumpAutoloadCommand::class, null, Environment::isComposerMode(), false, 'dumpautoload');
394			$commandRegistry->addLazyCommand('extension:dumpclassloadinginformation', Command\DumpAutoloadCommand::class, null, Environment::isComposerMode(), false, 'dumpautoload');
395
396			return $commandRegistry;
397			}
398			}
399

TYPO3 / TYPO3.CMS

Push — master ( 39145a...3500a5 )

ServiceProvider::getPackagePath() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like