ServiceWiring.php

Go to the documentation of this file.

<?php
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Extension\Translate\Cache\PersistentCache;
use MediaWiki\Extension\Translate\Cache\PersistentDatabaseCache;
use MediaWiki\Extension\Translate\FileFormatSupport\FileFormatFactory;
use MediaWiki\Extension\Translate\HookRunner;
use MediaWiki\Extension\Translate\MessageBundleTranslation\MessageBundleMessageGroupFactory;
use MediaWiki\Extension\Translate\MessageBundleTranslation\MessageBundleStore;
use MediaWiki\Extension\Translate\MessageBundleTranslation\MessageBundleTranslationLoader;
use MediaWiki\Extension\Translate\MessageGroupConfiguration\FileBasedMessageGroupFactory;
use MediaWiki\Extension\Translate\MessageGroupConfiguration\HookDefinedMessageGroupFactory;
use MediaWiki\Extension\Translate\MessageGroupConfiguration\MessageGroupConfigurationParser;
use MediaWiki\Extension\Translate\MessageGroupProcessing\AggregateGroupManager;
use MediaWiki\Extension\Translate\MessageGroupProcessing\AggregateGroupMessageGroupFactory;
use MediaWiki\Extension\Translate\MessageGroupProcessing\CsvTranslationImporter;
use MediaWiki\Extension\Translate\MessageGroupProcessing\MessageGroupReviewStore;
use MediaWiki\Extension\Translate\MessageGroupProcessing\MessageGroups;
use MediaWiki\Extension\Translate\MessageGroupProcessing\MessageGroupSubscription;
use MediaWiki\Extension\Translate\MessageGroupProcessing\MessageGroupSubscriptionHookHandler;
use MediaWiki\Extension\Translate\MessageGroupProcessing\MessageGroupSubscriptionStore;
use MediaWiki\Extension\Translate\MessageGroupProcessing\RevTagStore;
use MediaWiki\Extension\Translate\MessageGroupProcessing\SubpageListBuilder;
use MediaWiki\Extension\Translate\MessageGroupProcessing\TranslatableBundleExporter;
use MediaWiki\Extension\Translate\MessageGroupProcessing\TranslatableBundleFactory;
use MediaWiki\Extension\Translate\MessageGroupProcessing\TranslatableBundleImporter;
use MediaWiki\Extension\Translate\MessageGroupProcessing\TranslatableBundleStatusStore;
use MediaWiki\Extension\Translate\MessageGroupProcessing\TranslatablePageStore;
use MediaWiki\Extension\Translate\MessageLoading\CDBMessageIndex;
use MediaWiki\Extension\Translate\MessageLoading\DatabaseMessageIndex;
use MediaWiki\Extension\Translate\MessageLoading\HashMessageIndex;
use MediaWiki\Extension\Translate\MessageLoading\MessageIndex;
use MediaWiki\Extension\Translate\MessageLoading\MessageIndexStore;
use MediaWiki\Extension\Translate\MessageProcessing\MessageGroupMetadata;
use MediaWiki\Extension\Translate\PageTranslation\TranslatableBundleDeleter;
use MediaWiki\Extension\Translate\PageTranslation\TranslatableBundleMover;
use MediaWiki\Extension\Translate\PageTranslation\TranslatablePageMarker;
use MediaWiki\Extension\Translate\PageTranslation\TranslatablePageMessageGroupFactory;
use MediaWiki\Extension\Translate\PageTranslation\TranslatablePageParser;
use MediaWiki\Extension\Translate\PageTranslation\TranslatablePageStateStore;
use MediaWiki\Extension\Translate\PageTranslation\TranslatablePageView;
use MediaWiki\Extension\Translate\PageTranslation\TranslationUnitStoreFactory;
use MediaWiki\Extension\Translate\Statistics\MessageGroupStatsTableFactory;
use MediaWiki\Extension\Translate\Statistics\MessagePrefixStats;
use MediaWiki\Extension\Translate\Statistics\ProgressStatsTableFactory;
use MediaWiki\Extension\Translate\Statistics\TranslationStatsDataProvider;
use MediaWiki\Extension\Translate\Statistics\TranslatorActivity;
use MediaWiki\Extension\Translate\Statistics\TranslatorActivityQuery;
use MediaWiki\Extension\Translate\Synchronization\ExternalMessageSourceStateComparator;
use MediaWiki\Extension\Translate\Synchronization\ExternalMessageSourceStateImporter;
use MediaWiki\Extension\Translate\Synchronization\GroupSynchronizationCache;
use MediaWiki\Extension\Translate\TranslatorInterface\EntitySearch;
use MediaWiki\Extension\Translate\TranslatorSandbox\TranslateSandbox;
use MediaWiki\Extension\Translate\TranslatorSandbox\TranslationStashReader;
use MediaWiki\Extension\Translate\TranslatorSandbox\TranslationStashStorage;
use MediaWiki\Extension\Translate\TtmServer\TtmServerFactory;
use MediaWiki\Extension\Translate\Utilities\ConfigHelper;
use MediaWiki\Extension\Translate\Utilities\ParsingPlaceholderFactory;
use MediaWiki\Extension\Translate\Utilities\StringComparators\SimpleStringComparator;
use MediaWiki\Logger\LoggerFactory;
use MediaWiki\MediaWikiServices;
 
return [
    'Translate:AggregateGroupManager' => static function (
        MediaWikiServices $services
    ): AggregateGroupManager {
        return new AggregateGroupManager( $services->getTitleFactory() );
    },
 
    'Translate:AggregateGroupMessageGroupFactory' => static function (
        MediaWikiServices $services
    ): AggregateGroupMessageGroupFactory {
        return new AggregateGroupMessageGroupFactory(
            $services->get( 'Translate:MessageGroupMetadata' )
        );
    },
 
    'Translate:ConfigHelper' => static function (): ConfigHelper {
        return new ConfigHelper();
    },
 
    'Translate:CsvTranslationImporter' => static function ( MediaWikiServices $services ): CsvTranslationImporter {
        return new CsvTranslationImporter( $services->getWikiPageFactory() );
    },
 
    'Translate:EntitySearch' => static function ( MediaWikiServices $services ): EntitySearch {
        return new EntitySearch(
            $services->getMainWANObjectCache(),
            $services->getCollationFactory()->makeCollation( 'uca-default-u-kn' ),
            MessageGroups::singleton(),
            $services->getNamespaceInfo(),
            $services->get( 'Translate:MessageIndex' ),
            $services->getTitleParser(),
            $services->getTitleFormatter()
        );
    },
 
    'Translate:ExternalMessageSourceStateComparator' => static function (
        MediaWikiServices $services
    ): ExternalMessageSourceStateComparator {
        return new ExternalMessageSourceStateComparator(
            new SimpleStringComparator(),
            $services->getRevisionLookup(),
            $services->getPageStore()
        );
    },
 
    'Translate:ExternalMessageSourceStateImporter' => static function (
        MediaWikiServices $services
    ): ExternalMessageSourceStateImporter {
        return new ExternalMessageSourceStateImporter(
            $services->get( 'Translate:GroupSynchronizationCache' ),
            $services->getJobQueueGroup(),
            LoggerFactory::getInstance( 'Translate.GroupSynchronization' ),
            $services->get( 'Translate:MessageIndex' ),
            $services->getTitleFactory(),
            new ServiceOptions(
                ExternalMessageSourceStateImporter::CONSTRUCTOR_OPTIONS,
                $services->getMainConfig()
            )
        );
    },
 
    'Translate:FileBasedMessageGroupFactory' => static function (
        MediaWikiServices $services
    ): FileBasedMessageGroupFactory {
        return new FileBasedMessageGroupFactory(
            new MessageGroupConfigurationParser(),
            new ServiceOptions(
                FileBasedMessageGroupFactory::SERVICE_OPTIONS,
                $services->getMainConfig()
            ),
        );
    },
 
    'Translate:FileFormatFactory' => static function ( MediaWikiServices $services ): FileFormatFactory {
        return new FileFormatFactory( $services->getObjectFactory() );
    },
 
    'Translate:GroupSynchronizationCache' => static function (
        MediaWikiServices $services
    ): GroupSynchronizationCache {
        return new GroupSynchronizationCache( $services->get( 'Translate:PersistentCache' ) );
    },
 
    'Translate:HookDefinedMessageGroupFactory' => static function (
        MediaWikiServices $services
    ): HookDefinedMessageGroupFactory {
        return new HookDefinedMessageGroupFactory( $services->get( 'Translate:HookRunner' ) );
    },
 
    'Translate:HookRunner' => static function (
        MediaWikiServices $services
    ): HookRunner {
        return new HookRunner( $services->getHookContainer() );
    },
 
    'Translate:MessageBundleMessageGroupFactory' => static function (
        MediaWikiServices $services
    ): MessageBundleMessageGroupFactory {
        return new MessageBundleMessageGroupFactory(
            $services->get( 'Translate:MessageGroupMetadata' ),
            new ServiceOptions(
                MessageBundleMessageGroupFactory::SERVICE_OPTIONS,
                $services->getMainConfig()
            ),
        );
    },
 
    'Translate:MessageBundleStore' => static function ( MediaWikiServices $services ): MessageBundleStore {
        return new MessageBundleStore(
            $services->get( 'Translate:RevTagStore' ),
            $services->getJobQueueGroup(),
            $services->getLanguageNameUtils(),
            $services->get( 'Translate:MessageIndex' ),
            $services->get( 'Translate:MessageGroupMetadata' )
        );
    },
 
    'Translate:MessageBundleTranslationLoader' => static function (
        MediaWikiServices $services
    ): MessageBundleTranslationLoader {
        return new MessageBundleTranslationLoader( $services->getLanguageFallback() );
    },
 
    'Translate:MessageGroupMetadata' => static function ( MediaWikiServices $services ): MessageGroupMetadata {
        return new MessageGroupMetadata( $services->getDBLoadBalancer() );
    },
 
    'Translate:MessageGroupReviewStore' => static function ( MediaWikiServices $services ): MessageGroupReviewStore {
        return new MessageGroupReviewStore(
            $services->getDBLoadBalancer(),
            $services->get( 'Translate:HookRunner' )
        );
    },
 
    'Translate:MessageGroupStatsTableFactory' => static function (
        MediaWikiServices $services
    ): MessageGroupStatsTableFactory {
        return new MessageGroupStatsTableFactory(
            $services->get( 'Translate:ProgressStatsTableFactory' ),
            $services->getDBLoadBalancer(),
            $services->getLinkRenderer(),
            $services->get( 'Translate:MessageGroupReviewStore' ),
            $services->get( 'Translate:MessageGroupMetadata' ),
            $services->getMainConfig()->get( 'TranslateWorkflowStates' ) !== false
        );
    },
 
    'Translate:MessageGroupSubscription' => static function (
        MediaWikiServices $services
    ): MessageGroupSubscription {
        return new MessageGroupSubscription(
            $services->get( 'Translate:MessageGroupSubscriptionStore' ),
            $services->getJobQueueGroup(),
            $services->getUserIdentityLookup(),
            LoggerFactory::getInstance( 'Translate.MessageGroupSubscription' ),
            new ServiceOptions(
                MessageGroupSubscription::CONSTRUCTOR_OPTIONS,
                $services->getMainConfig()
            )
        );
    },
 
    'Translate:MessageGroupSubscriptionHookHandler' => static function (
        MediaWikiServices $services
    ): MessageGroupSubscriptionHookHandler {
        return new MessageGroupSubscriptionHookHandler(
            $services->get( 'Translate:MessageGroupSubscription' ),
            $services->getUserFactory()
        );
    },
 
    'Translate:MessageGroupSubscriptionStore' => static function (
        MediaWikiServices $services
    ): MessageGroupSubscriptionStore {
        return new MessageGroupSubscriptionStore( $services->getDBLoadBalancerFactory() );
    },
 
    'Translate:MessageIndex' => static function ( MediaWikiServices $services ): MessageIndex {
        $params = (array)$services->getMainConfig()->get( 'TranslateMessageIndex' );
        $class = array_shift( $params );
 
        $implementationMap = [
            // Aliases for BC
            'HashMessageIndex' => HashMessageIndex::class,
            'CDBMessageIndex' => CDBMessageIndex::class,
            'DatabaseMessageIndex' => DatabaseMessageIndex::class,
            // Recommended values
            'hash' => HashMessageIndex::class,
            'cdb' => CDBMessageIndex::class,
            'database' => DatabaseMessageIndex::class,
        ];
 
        $messageIndexStoreClass = $implementationMap[$class] ?? $implementationMap['database'];
        return new MessageIndex(
            new $messageIndexStoreClass,
            $services->getMainWANObjectCache(),
            $services->getJobQueueGroup(),
            $services->get( 'Translate:HookRunner' ),
            LoggerFactory::getInstance( 'Translate' ),
            $services->getMainObjectStash(),
            $services->getDBLoadBalancerFactory(),
            $services->get( 'Translate:MessageGroupSubscription' ),
            new ServiceOptions( MessageIndex::SERVICE_OPTIONS, $services->getMainConfig() ),
        );
    },
 
    'Translate:MessagePrefixStats' => static function ( MediaWikiServices $services ): MessagePrefixStats {
        return new MessagePrefixStats( $services->getTitleParser() );
    },
 
    'Translate:ParsingPlaceholderFactory' => static function (): ParsingPlaceholderFactory {
        return new ParsingPlaceholderFactory();
    },
 
    'Translate:PersistentCache' => static function ( MediaWikiServices $services ): PersistentCache {
        return new PersistentDatabaseCache(
            $services->getDBLoadBalancer(),
            $services->getJsonCodec()
        );
    },
 
    'Translate:ProgressStatsTableFactory' => static function ( MediaWikiServices $services ): ProgressStatsTableFactory
    {
        return new ProgressStatsTableFactory(
            $services->getLinkRenderer(),
            $services->get( 'Translate:ConfigHelper' ),
            $services->get( 'Translate:MessageGroupMetadata' )
        );
    },
 
    'Translate:RevTagStore' => static function ( MediaWikiServices $services ): RevTagStore {
        return new RevTagStore( $services->getDBLoadBalancer() );
    },
 
    'Translate:SubpageListBuilder' => static function ( MediaWikiServices $services ): SubpageListBuilder
    {
        return new SubpageListBuilder(
            $services->get( 'Translate:TranslatableBundleFactory' ),
            $services->getLinkBatchFactory()
        );
    },
 
    'Translate:TranslatableBundleDeleter' => static function ( MediaWikiServices $services ): TranslatableBundleDeleter
    {
        return new TranslatableBundleDeleter(
            $services->getMainObjectStash(),
            $services->getJobQueueGroup(),
            $services->get( 'Translate:SubpageListBuilder' ),
            $services->get( 'Translate:TranslatableBundleFactory' )
        );
    },
 
    'Translate:TranslatableBundleExporter' => static function (
        MediaWikiServices $services
    ): TranslatableBundleExporter {
        return new TranslatableBundleExporter(
            $services->get( 'Translate:SubpageListBuilder' ),
            $services->getWikiExporterFactory(),
            $services->getDBLoadBalancer()
        );
    },
 
    'Translate:TranslatableBundleFactory' => static function ( MediaWikiServices $services ): TranslatableBundleFactory
    {
        return new TranslatableBundleFactory(
            $services->get( 'Translate:TranslatablePageStore' ),
            $services->get( 'Translate:MessageBundleStore' )
        );
    },
 
    'Translate:TranslatableBundleImporter' => static function (
        MediaWikiServices $services
    ): TranslatableBundleImporter {
        return new TranslatableBundleImporter(
            $services->getWikiImporterFactory(),
            $services->get( 'Translate:TranslatablePageParser' ),
            $services->getRevisionLookup(),
            $services->getNamespaceInfo(),
            $services->getTitleFactory()
        );
    },
 
    'Translate:TranslatableBundleMover' => static function ( MediaWikiServices $services ): TranslatableBundleMover
    {
        return new TranslatableBundleMover(
            $services->getMovePageFactory(),
            $services->getJobQueueGroup(),
            $services->getLinkBatchFactory(),
            $services->get( 'Translate:TranslatableBundleFactory' ),
            $services->get( 'Translate:SubpageListBuilder' ),
            $services->getDBLoadBalancerFactory(),
            $services->getMainConfig()->get( 'TranslatePageMoveLimit' )
        );
    },
 
    'Translate:TranslatableBundleStatusStore' =>
        static function ( MediaWikiServices $services ): TranslatableBundleStatusStore {
            return new TranslatableBundleStatusStore(
                $services->getDBLoadBalancer()->getConnection( DB_PRIMARY ),
                $services->getCollationFactory()->makeCollation( 'uca-default-u-kn' ),
                $services->getDBLoadBalancer()->getMaintenanceConnectionRef( DB_PRIMARY )
            );
        },
 
    'Translate:TranslatablePageMarker' => static function ( MediaWikiServices $services ): TranslatablePageMarker {
        return new TranslatablePageMarker(
            $services->getDBLoadBalancer(),
            $services->getJobQueueGroup(),
            $services->getLinkRenderer(),
            MessageGroups::singleton(),
            $services->get( 'Translate:MessageIndex' ),
            $services->getTitleFormatter(),
            $services->getTitleParser(),
            $services->get( 'Translate:TranslatablePageParser' ),
            $services->get( 'Translate:TranslatablePageStore' ),
            $services->get( 'Translate:TranslatablePageStateStore' ),
            $services->get( 'Translate:TranslationUnitStoreFactory' ),
            $services->get( 'Translate:MessageGroupMetadata' ),
            $services->getWikiPageFactory(),
            $services->get( 'Translate:TranslatablePageView' )
        );
    },
 
    'Translate:TranslatablePageMessageGroupFactory' => static function (
        MediaWikiServices $services
    ): TranslatablePageMessageGroupFactory {
        return new TranslatablePageMessageGroupFactory(
            new ServiceOptions(
                TranslatablePageMessageGroupFactory::SERVICE_OPTIONS,
                $services->getMainConfig()
            ),
        );
    },
 
    'Translate:TranslatablePageParser' => static function ( MediaWikiServices $services ): TranslatablePageParser
    {
        return new TranslatablePageParser(
            $services->get( 'Translate:ParsingPlaceholderFactory' )
        );
    },
 
    'Translate:TranslatablePageStateStore' => static function (
        MediaWikiServices $services
    ): TranslatablePageStateStore {
        return new TranslatablePageStateStore(
            $services->get( 'Translate:PersistentCache' ),
            $services->getPageStore()
        );
    },
 
    'Translate:TranslatablePageStore' => static function ( MediaWikiServices $services ): TranslatablePageStore
    {
        return new TranslatablePageStore(
            $services->get( 'Translate:MessageIndex' ),
            $services->getJobQueueGroup(),
            $services->get( 'Translate:RevTagStore' ),
            $services->getDBLoadBalancer(),
            $services->get( 'Translate:TranslatableBundleStatusStore' ),
            $services->get( 'Translate:TranslatablePageParser' ),
            $services->get( 'Translate:MessageGroupMetadata' )
        );
    },
 
    'Translate:TranslatablePageView' => static function ( MediaWikiServices $services ): TranslatablePageView {
        return new TranslatablePageView(
            $services->getDBLoadBalancerFactory(),
            $services->get( 'Translate:TranslatablePageStateStore' ),
            new ServiceOptions(
                TranslatablePageView::SERVICE_OPTIONS,
                $services->getMainConfig()
            )
        );
    },
 
    'Translate:TranslateSandbox' => static function ( MediaWikiServices $services ): TranslateSandbox
    {
        return new TranslateSandbox(
            $services->getUserFactory(),
            $services->getDBLoadBalancer(),
            $services->getPermissionManager(),
            $services->getAuthManager(),
            $services->getUserGroupManager(),
            $services->getActorStore(),
            $services->getUserOptionsManager(),
            $services->getJobQueueGroup(),
            $services->get( 'Translate:HookRunner' ),
            new ServiceOptions(
                TranslateSandbox::CONSTRUCTOR_OPTIONS,
                $services->getMainConfig()
            )
        );
    },
 
    'Translate:TranslationStashReader' => static function ( MediaWikiServices $services ): TranslationStashReader
    {
        $db = $services->getDBLoadBalancer()->getConnection( DB_REPLICA );
        return new TranslationStashStorage( $db );
    },
 
    'Translate:TranslationStatsDataProvider' => static function (
        MediaWikiServices $services
    ): TranslationStatsDataProvider {
        return new TranslationStatsDataProvider(
            new ServiceOptions(
                TranslationStatsDataProvider::CONSTRUCTOR_OPTIONS,
                $services->getMainConfig()
            ),
            $services->getObjectFactory(),
            $services->getDBLoadBalancer()
        );
    },
 
    'Translate:TranslationUnitStoreFactory' => static function (
        MediaWikiServices $services
    ): TranslationUnitStoreFactory {
        return new TranslationUnitStoreFactory( $services->getDBLoadBalancer() );
    },
 
    'Translate:TranslatorActivity' => static function ( MediaWikiServices $services ): TranslatorActivity {
        $query = new TranslatorActivityQuery(
            $services->getMainConfig(),
            $services->getDBLoadBalancer()
        );
 
        return new TranslatorActivity(
            $services->getMainObjectStash(),
            $query,
            $services->getJobQueueGroup()
        );
    },
 
    'Translate:TtmServerFactory' => static function ( MediaWikiServices $services ): TtmServerFactory {
        $config = $services->getMainConfig();
 
        $default = $config->get( 'TranslateTranslationDefaultService' );
        if ( $default === false ) {
            $default = null;
        }
 
        return new TtmServerFactory( $config->get( 'TranslateTranslationServices' ), $default );
    }
];