ServiceProvider::getHelpCommand() - Code Metrics - Inspection of "[FEATURE] Implement lazy console command list" - TYPO3/TYPO3.CMS - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( daf0b2...38121e )

unknown

created 2021-02-09 09:40 UTC

ServiceProvider::getHelpCommand() A

↳ Parent: ServiceProvider

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

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

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

    public static function getListCommand(ContainerInterface $container): Command\ListCommand
    {
        return new Command\ListCommand(
            $container->get(Console\CommandRegistry::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)
        );
    }

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

TYPO3 / TYPO3.CMS

Push — master ( daf0b2...38121e )

ServiceProvider::getHelpCommand() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like