TrackingCategories.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Category;
 
use MediaWiki\Config\ServiceOptions;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\MainConfigNames;
use MediaWiki\Page\PageReference;
use MediaWiki\Parser\Parser;
use MediaWiki\Registration\ExtensionRegistry;
use MediaWiki\Title\NamespaceInfo;
use MediaWiki\Title\Title;
use MediaWiki\Title\TitleParser;
use Psr\Log\LoggerInterface;
use Wikimedia\Parsoid\Core\ContentMetadataCollector;
 
class TrackingCategories {
 
    public const CONSTRUCTOR_OPTIONS = [
        MainConfigNames::TrackingCategories,
        MainConfigNames::EnableMagicLinks,
    ];
 
    private $options;
 
    private $namespaceInfo;
 
    private $titleParser;
 
    private $extensionRegistry;
 
    private $logger;
 
    private const CORE_TRACKING_CATEGORIES = [
        'broken-file-category',
        'duplicate-args-category',
        'expansion-depth-exceeded-category',
        'expensive-parserfunction-category',
        'hidden-category-category',
        'index-category',
        'node-count-exceeded-category',
        'noindex-category',
        'nonnumeric-formatnum',
        'post-expand-template-argument-category',
        'post-expand-template-inclusion-category',
        'restricted-displaytitle-ignored',
        # template-equals-category is unused in MW>=1.39, but the category
        # can be left around for a major release or so for an easier
        # transition for anyone who didn't do the cleanup. T91154
        'template-equals-category',
        'template-loop-category',
        'unstrip-depth-category',
        'unstrip-size-category',
        'bad-language-code-category',
        'bad-double-underscore-category',
        'double-px-category',
    ];
 
    public function __construct(
        ServiceOptions $options,
        NamespaceInfo $namespaceInfo,
        TitleParser $titleParser,
        LoggerInterface $logger
    ) {
        $options->assertRequiredOptions( self::CONSTRUCTOR_OPTIONS );
        $this->options = $options;
        $this->namespaceInfo = $namespaceInfo;
        $this->titleParser = $titleParser;
        $this->logger = $logger;
 
        // TODO convert ExtensionRegistry to a service and inject it
        $this->extensionRegistry = ExtensionRegistry::getInstance();
    }
 
    public function getTrackingCategories() {
        $categories = array_merge(
            self::CORE_TRACKING_CATEGORIES,
            $this->extensionRegistry->getAttribute( MainConfigNames::TrackingCategories ),
            $this->options->get( MainConfigNames::TrackingCategories ) // deprecated
        );
 
        // Only show magic link tracking categories if they are enabled
        $enableMagicLinks = $this->options->get( MainConfigNames::EnableMagicLinks );
        if ( $enableMagicLinks['ISBN'] ) {
            $categories[] = 'magiclink-tracking-isbn';
        }
        if ( $enableMagicLinks['RFC'] ) {
            $categories[] = 'magiclink-tracking-rfc';
        }
        if ( $enableMagicLinks['PMID'] ) {
            $categories[] = 'magiclink-tracking-pmid';
        }
 
        $trackingCategories = [];
        foreach ( $categories as $catMsg ) {
            /*
             * Check if the tracking category varies by namespace
             * Otherwise only pages in the current namespace will be displayed
             * If it does vary, show pages considering all namespaces
             *
             * TODO replace uses of wfMessage with an injected service once that is available
             */
            $msgObj = wfMessage( $catMsg )->inContentLanguage();
            $allCats = [];
            $catMsgTitle = $this->titleParser->makeTitleValueSafe( NS_MEDIAWIKI, $catMsg );
            if ( !$catMsgTitle ) {
                continue;
            }
 
            // Match things like {{NAMESPACE}} and {{NAMESPACENUMBER}}.
            // False positives are ok, this is just an efficiency shortcut
            if ( str_contains( $msgObj->plain(), '{{' ) ) {
                $ns = $this->namespaceInfo->getValidNamespaces();
                foreach ( $ns as $namesp ) {
                    $tempTitle = $this->titleParser->makeTitleValueSafe( $namesp, $catMsg );
                    if ( !$tempTitle ) {
                        continue;
                    }
                    // XXX: should be a better way to convert a TitleValue
                    // to a PageReference!
                    $tempTitle = Title::newFromLinkTarget( $tempTitle );
                    $allCats[] = $msgObj->page( $tempTitle )->text();
                }
            } else {
                $allCats[] = $msgObj->text();
            }
            $titles = [];
            foreach ( $allCats as $catName ) {
                // Extra check in case a message does fancy stuff with {{#if:… and such
                if ( $catName !== '-' ) {
                    $catTitle = $this->titleParser->makeTitleValueSafe( NS_CATEGORY, $catName );
                    if ( $catTitle ) {
                        $titles[] = $catTitle;
                    }
                }
            }
            $trackingCategories[$catMsg] = [
                'cats' => $titles,
                'msg' => $catMsgTitle,
            ];
        }
 
        return $trackingCategories;
    }
 
    public function resolveTrackingCategory( string $msg, ?PageReference $contextPage ): ?LinkTarget {
        if ( !$contextPage ) {
            $this->logger->debug( "Not adding tracking category $msg to missing page!" );
            return null;
        }
 
        if ( $contextPage->getNamespace() === NS_SPECIAL ) {
            $this->logger->debug( "Not adding tracking category $msg to special page!" );
            return null;
        }
 
        // Important to parse with correct title (T33469)
        // TODO replace uses of wfMessage with an injected service once that is available
        $cat = wfMessage( $msg )
            ->page( $contextPage )
            ->inContentLanguage()
            ->text();
 
        # Allow tracking categories to be disabled by setting them to "-"
        if ( $cat === '-' ) {
            return null;
        }
 
        $containerCategory = $this->titleParser->makeTitleValueSafe( NS_CATEGORY, $cat );
        if ( $containerCategory === null ) {
            $this->logger->debug( "[[MediaWiki:$msg]] is not a valid title!" );
            return null;
        }
        return $containerCategory;
    }
 
    public function addTrackingCategory(
        ContentMetadataCollector $parserOutput,
        string $msg,
        ?PageReference $contextPage
    ): bool {
        $categoryPage = $this->resolveTrackingCategory( $msg, $contextPage );
        if ( $categoryPage === null ) {
            return false;
        }
        $parserOutput->addCategory( $categoryPage );
        return true;
    }
}