ServiceProvider::getFontawesomeIconProvider() - Code Metrics - Inspection of "[TASK] Integrate Pagetree acceptance suite into Ba..." - TYPO3/TYPO3.CMS - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 2345e6...3849ed )

unknown

created 2021-03-01 11:47 UTC

ServiceProvider::getFontawesomeIconProvider() A

↳ Parent: ServiceProvider

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	2
dl	0
loc	4
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\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\IconProvider\FontawesomeIconProvider::class => [ static::class, 'getFontawesomeIconProvider' ],
            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),
            $container
        ]);
    }

    public static function getFontawesomeIconProvider(ContainerInterface $container): Imaging\IconProvider\FontawesomeIconProvider
    {
        return self::new($container, Imaging\IconProvider\FontawesomeIconProvider::class, [
            $container->get('cache.assets')
        ]);
    }

    public static function getIconRegistry(ContainerInterface $container): Imaging\IconRegistry
    {
        return self::new($container, Imaging\IconRegistry::class, [$container->get('cache.assets')]);
    }

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

TYPO3 / TYPO3.CMS

Push — master ( 2345e6...3849ed )

ServiceProvider::getFontawesomeIconProvider() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like