ParserFactory.php

Go to the documentation of this file.

<?php
use MediaWiki\Category\TrackingCategories;
use MediaWiki\Config\ServiceOptions;
use MediaWiki\HookContainer\HookContainer;
use MediaWiki\Http\HttpRequestFactory;
use MediaWiki\Languages\LanguageConverterFactory;
use MediaWiki\Linker\LinkRendererFactory;
use MediaWiki\Page\File\BadFileLookup;
use MediaWiki\Parser\MagicWordFactory;
use MediaWiki\Parser\Parser;
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;
 
class ParserFactory {
    private $svcOptions;
 
    private $magicWordFactory;
 
    private $contLang;
 
    private $urlUtils;
 
    private $specialPageFactory;
 
    private $linkRendererFactory;
 
    private $nsInfo;
 
    private $logger;
 
    private $badFileLookup;
 
    private $languageConverterFactory;
 
    private $userOptionsLookup;
 
    private $userFactory;
 
    private $titleFormatter;
 
    private $httpRequestFactory;
 
    private $trackingCategories;
 
    private $signatureValidatorFactory;
 
    private $userNameUtils;
 
    public static $inParserFactory = 0;
 
    private $hookContainer;
 
    private $tidy;
 
    private $wanCache;
 
    private $mainInstance;
 
    public function __construct(
        ServiceOptions $svcOptions,
        MagicWordFactory $magicWordFactory,
        Language $contLang,
        UrlUtils $urlUtils,
        SpecialPageFactory $spFactory,
        LinkRendererFactory $linkRendererFactory,
        NamespaceInfo $nsInfo,
        LoggerInterface $logger,
        BadFileLookup $badFileLookup,
        LanguageConverterFactory $languageConverterFactory,
        HookContainer $hookContainer,
        TidyDriverBase $tidy,
        WANObjectCache $wanCache,
        UserOptionsLookup $userOptionsLookup,
        UserFactory $userFactory,
        TitleFormatter $titleFormatter,
        HttpRequestFactory $httpRequestFactory,
        TrackingCategories $trackingCategories,
        SignatureValidatorFactory $signatureValidatorFactory,
        UserNameUtils $userNameUtils
    ) {
        $svcOptions->assertRequiredOptions( Parser::CONSTRUCTOR_OPTIONS );
 
        wfDebug( __CLASS__ . ": using default preprocessor" );
 
        $this->svcOptions = $svcOptions;
        $this->magicWordFactory = $magicWordFactory;
        $this->contLang = $contLang;
        $this->urlUtils = $urlUtils;
        $this->specialPageFactory = $spFactory;
        $this->linkRendererFactory = $linkRendererFactory;
        $this->nsInfo = $nsInfo;
        $this->logger = $logger;
        $this->badFileLookup = $badFileLookup;
        $this->languageConverterFactory = $languageConverterFactory;
        $this->hookContainer = $hookContainer;
        $this->tidy = $tidy;
        $this->wanCache = $wanCache;
        $this->userOptionsLookup = $userOptionsLookup;
        $this->userFactory = $userFactory;
        $this->titleFormatter = $titleFormatter;
        $this->httpRequestFactory = $httpRequestFactory;
        $this->trackingCategories = $trackingCategories;
        $this->signatureValidatorFactory = $signatureValidatorFactory;
        $this->userNameUtils = $userNameUtils;
    }
 
    public function create(): Parser {
        self::$inParserFactory++;
        try {
            return new Parser(
                $this->svcOptions,
                $this->magicWordFactory,
                $this->contLang,
                $this,
                $this->urlUtils,
                $this->specialPageFactory,
                $this->linkRendererFactory,
                $this->nsInfo,
                $this->logger,
                $this->badFileLookup,
                $this->languageConverterFactory,
                $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;
    }
 
}