GenderCache.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Cache;
 
use MediaWiki\Context\RequestContext;
use MediaWiki\Linker\LinkTarget;
use MediaWiki\Title\NamespaceInfo;
use MediaWiki\User\Options\UserOptionsLookup;
use MediaWiki\User\UserIdentity;
use Wikimedia\Rdbms\IResultWrapper;
 
class GenderCache {
    protected $cache = [];
    protected $default = null;
    protected $misses = 0;
    protected $missLimit = 1000;
 
    private NamespaceInfo $nsInfo;
    private UserOptionsLookup $userOptionsLookup;
 
    public function __construct(
        NamespaceInfo $nsInfo,
        UserOptionsLookup $userOptionsLookup
    ) {
        $this->nsInfo = $nsInfo;
        $this->userOptionsLookup = $userOptionsLookup;
    }
 
    protected function getDefault() {
        $this->default ??= $this->userOptionsLookup->getDefaultOption( 'gender' );
        return $this->default;
    }
 
    public function getGenderOf( $username, $caller = '' ) {
        if ( $username instanceof UserIdentity ) {
            $username = $username->getName();
        }
 
        $username = self::normalizeUsername( $username );
        if ( !isset( $this->cache[$username] ) ) {
            if ( $this->misses < $this->missLimit ||
                RequestContext::getMain()->getUser()->getName() === $username
            ) {
                $this->misses++;
                $this->doQuery( $username );
            }
            if ( $this->misses === $this->missLimit ) {
                // Log only once and don't bother incrementing beyond limit+1
                $this->misses++;
                wfDebug( __METHOD__ . ': too many misses, returning default onwards' );
            }
        }
 
        return $this->cache[$username] ?? $this->getDefault();
    }
 
    public function doLinkBatch( array $data, $caller = '' ) {
        $users = [];
        foreach ( $data as $ns => $pagenames ) {
            if ( $this->nsInfo->hasGenderDistinction( $ns ) ) {
                $users += $pagenames;
            }
        }
        $this->doQuery( array_keys( $users ) );
    }
 
    public function doTitlesArray( $titles, $caller = '' ) {
        $users = [];
        foreach ( $titles as $titleObj ) {
            if ( $this->nsInfo->hasGenderDistinction( $titleObj->getNamespace() ) ) {
                $users[] = $titleObj->getText();
            }
        }
        $this->doQuery( $users );
    }
 
    public function doPageRows( $rows ) {
        $users = [];
        foreach ( $rows as $row ) {
            if ( $this->nsInfo->hasGenderDistinction( (int)$row->page_namespace ) ) {
                $users[] = $row->page_title;
            }
        }
        $this->doQuery( $users );
    }
 
    public function doQuery( $users, $caller = '' ) {
        $usersToFetch = [];
        foreach ( (array)$users as $userName ) {
            $userName = self::normalizeUsername( $userName );
            if ( !isset( $this->cache[$userName] ) ) {
                $usersToFetch[] = $userName;
            }
        }
        if ( !$usersToFetch ) {
            return;
        }
 
        // Limit batch size to 1000 since the usernames need to be put into an
        // IN() expression in SQL. Could be done closer to the backend, but
        // there are multiple backends.
        foreach ( array_chunk( array_unique( $usersToFetch ), 1000 ) as $batch ) {
            $genders = $this->userOptionsLookup->getOptionBatchForUserNames( $batch, 'gender' );
            foreach ( $genders as $userName => $gender ) {
                $this->cache[$userName] = $gender;
            }
        }
    }
 
    private static function normalizeUsername( string $username ): string {
        // Strip off subpages
        $indexSlash = strpos( $username, '/' );
        if ( $indexSlash !== false ) {
            $username = substr( $username, 0, $indexSlash );
        }
 
        // normalize underscore/spaces
        return strtr( $username, '_', ' ' );
    }
}
 
class_alias( GenderCache::class, 'GenderCache' );