ParserFactory.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Parser;
 
use MediaWiki\Category\TrackingCategories;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\FileRepo\RepoGroup;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\Http\HttpRequestFactory;
use MediaWiki\Language\Language;
use MediaWiki\Language\LanguageConverterFactory;
use MediaWiki\Language\LanguageFactory;
use MediaWiki\Language\LanguageNameUtils;
use MediaWiki\Linker\LinkRendererFactory;
use MediaWiki\Page\File\BadFileLookup;
use MediaWiki\Preferences\SignatureValidatorFactory;
use MediaWiki\SpecialPage\SpecialPageFactory;
use MediaWiki\Tidy\TidyDriverBase;
use MediaWiki\Title\NamespaceInfo;
use MediaWiki\Title\TitleFormatter;
use MediaWiki\User\Options\UserOptionsLookup;
use MediaWiki\User\UserFactory;
use MediaWiki\User\UserNameUtils;
use MediaWiki\Utils\UrlUtils;
use Psr\Log\LoggerInterface;
use Wikimedia\ObjectCache\WANObjectCache;
 
class ParserFactory {
    public static $inParserFactory = 0;
 
    private $mainInstance;
 
    public function __construct(
        private readonly ServiceOptions $svcOptions,
        private readonly ParserCoreTagHooks $parserCoreTagHooks,
        private readonly MagicWordFactory $magicWordFactory,
        private readonly Language $contLang,
        private readonly UrlUtils $urlUtils,
        private readonly SpecialPageFactory $specialPageFactory,
        private readonly LinkRendererFactory $linkRendererFactory,
        private readonly NamespaceInfo $nsInfo,
        private readonly LoggerInterface $logger,
        private readonly BadFileLookup $badFileLookup,
        private readonly RepoGroup $repoGroup,
        private readonly LanguageFactory $languageFactory,
        private readonly LanguageConverterFactory $languageConverterFactory,
        private readonly LanguageNameUtils $languageNameUtils,
        private readonly HookContainer $hookContainer,
        private readonly TidyDriverBase $tidy,
        private readonly WANObjectCache $wanCache,
        private readonly UserOptionsLookup $userOptionsLookup,
        private readonly UserFactory $userFactory,
        private readonly TitleFormatter $titleFormatter,
        private readonly HttpRequestFactory $httpRequestFactory,
        private readonly TrackingCategories $trackingCategories,
        private readonly SignatureValidatorFactory $signatureValidatorFactory,
        private readonly UserNameUtils $userNameUtils,
    ) {
        $svcOptions->assertRequiredOptions( Parser::CONSTRUCTOR_OPTIONS );
 
        wfDebug( __CLASS__ . ": using default preprocessor" );
    }
 
    public function create(): Parser {
        self::$inParserFactory++;
        try {
            return new Parser(
                $this->svcOptions,
                $this->parserCoreTagHooks,
                $this->magicWordFactory,
                $this->contLang,
                $this->urlUtils,
                $this->specialPageFactory,
                $this->linkRendererFactory,
                $this->nsInfo,
                $this->logger,
                $this->badFileLookup,
                $this->repoGroup,
                $this->languageFactory,
                $this->languageConverterFactory,
                $this->languageNameUtils,
                $this->hookContainer,
                $this->tidy,
                $this->wanCache,
                $this->userOptionsLookup,
                $this->userFactory,
                $this->titleFormatter,
                $this->httpRequestFactory,
                $this->trackingCategories,
                $this->signatureValidatorFactory,
                $this->userNameUtils
            );
        } finally {
            self::$inParserFactory--;
        }
    }
 
    public function getMainInstance() {
        if ( $this->mainInstance === null ) {
            $this->mainInstance = $this->create();
        }
        return $this->mainInstance;
    }
 
    public function getInstance() {
        $instance = $this->getMainInstance();
        if ( $instance->isLocked() ) {
            $instance = $this->create();
        }
        return $instance;
    }
 
}
 
class_alias( ParserFactory::class, 'ParserFactory' );