mediawiki-extensions-AbuseF.../includes/Variables/VariablesManager.php
Bartosz Dziewoński 237d54d545 Replace gettype() with get_debug_type() in exception messages etc.
get_debug_type() does the same thing but better (spelling type names
in the same way as in type declarations, and including names of
object classes and resource types). It was added in PHP 8, but the
symfony/polyfill-php80 package provides it while we still support 7.4.

Also remove uses of get_class() where the new method already provides
the same information.

For reference:
https://www.php.net/manual/en/function.get-debug-type.php
https://www.php.net/manual/en/function.gettype.php

Change-Id: I5e65a0759df7fa0c10bfa26ebc3cda436630f456
2024-08-12 23:05:16 +02:00

223 lines
6.9 KiB
PHP

<?php
namespace MediaWiki\Extension\AbuseFilter\Variables;
use LogicException;
use MediaWiki\Extension\AbuseFilter\KeywordsManager;
use MediaWiki\Extension\AbuseFilter\Parser\AFPData;
/**
* Service that allows manipulating a VariableHolder
*/
class VariablesManager {
public const SERVICE_NAME = 'AbuseFilterVariablesManager';
/**
* Used in self::getVar() to determine what to do if the requested variable is missing. See
* the docs of that method for an explanation.
*/
public const GET_LAX = 0;
public const GET_STRICT = 1;
public const GET_BC = 2;
/** @var KeywordsManager */
private $keywordsManager;
/** @var LazyVariableComputer */
private $lazyComputer;
/**
* @param KeywordsManager $keywordsManager
* @param LazyVariableComputer $lazyComputer
*/
public function __construct(
KeywordsManager $keywordsManager,
LazyVariableComputer $lazyComputer
) {
$this->keywordsManager = $keywordsManager;
$this->lazyComputer = $lazyComputer;
}
/**
* Checks whether any deprecated variable is stored with the old name, and replaces it with
* the new name. This should normally only happen when a DB dump is retrieved from the DB.
*
* @param VariableHolder $holder
*/
public function translateDeprecatedVars( VariableHolder $holder ): void {
$deprecatedVars = $this->keywordsManager->getDeprecatedVariables();
foreach ( $holder->getVars() as $name => $value ) {
if ( array_key_exists( $name, $deprecatedVars ) ) {
$holder->setVar( $deprecatedVars[$name], $value );
$holder->removeVar( $name );
}
}
}
/**
* Get a variable from the current object
*
* @param VariableHolder $holder
* @param string $varName The variable name
* @param int $mode One of the self::GET_* constants, determines how to behave when the variable is unset:
* - GET_STRICT -> Throw UnsetVariableException
* - GET_LAX -> Return a DUNDEFINED AFPData
* - GET_BC -> Return a DNULL AFPData (this should only be used for BC, see T230256)
* @return AFPData
*/
public function getVar(
VariableHolder $holder,
string $varName,
$mode = self::GET_STRICT
): AFPData {
$varName = strtolower( $varName );
if ( $holder->varIsSet( $varName ) ) {
/** @var LazyLoadedVariable|AFPData $variable */
$variable = $holder->getVarThrow( $varName );
if ( $variable instanceof LazyLoadedVariable ) {
$getVarCB = function ( string $varName ) use ( $holder ): AFPData {
return $this->getVar( $holder, $varName );
};
$value = $this->lazyComputer->compute( $variable, $holder, $getVarCB );
$holder->setVar( $varName, $value );
return $value;
} elseif ( $variable instanceof AFPData ) {
return $variable;
} else {
// @codeCoverageIgnoreStart
throw new \UnexpectedValueException(
"Variable $varName has unexpected type " . get_debug_type( $variable )
);
// @codeCoverageIgnoreEnd
}
}
// The variable is not set.
switch ( $mode ) {
case self::GET_STRICT:
throw new UnsetVariableException( $varName );
case self::GET_LAX:
return new AFPData( AFPData::DUNDEFINED );
case self::GET_BC:
// Old behaviour, which can sometimes lead to unexpected results (e.g.
// `edit_delta < -5000` will match any non-edit action).
return new AFPData( AFPData::DNULL );
default:
// @codeCoverageIgnoreStart
throw new LogicException( "Mode '$mode' not recognized." );
// @codeCoverageIgnoreEnd
}
}
/**
* Dump all variables stored in the holder in their native types.
* If you want a not yet set variable to be included in the results you can
* either set $compute to an array with the name of the variable or set
* $compute to true to compute all not yet set variables.
*
* @param VariableHolder $holder
* @param array|bool $compute Variables we should compute if not yet set
* @param bool $includeUserVars Include user set variables
* @return array
*/
public function dumpAllVars(
VariableHolder $holder,
$compute = [],
bool $includeUserVars = false
): array {
$coreVariables = [];
if ( !$includeUserVars ) {
// Compile a list of all variables set by the extension to be able
// to filter user set ones by name
$activeVariables = array_keys( $this->keywordsManager->getVarsMappings() );
$deprecatedVariables = array_keys( $this->keywordsManager->getDeprecatedVariables() );
$disabledVariables = array_keys( $this->keywordsManager->getDisabledVariables() );
$coreVariables = array_merge( $activeVariables, $deprecatedVariables, $disabledVariables );
$coreVariables = array_map( 'strtolower', $coreVariables );
}
$exported = [];
foreach ( array_keys( $holder->getVars() ) as $varName ) {
$computeThis = ( is_array( $compute ) && in_array( $varName, $compute ) ) || $compute === true;
if (
( $includeUserVars || in_array( strtolower( $varName ), $coreVariables ) ) &&
// Only include variables set in the extension in case $includeUserVars is false
( $computeThis || $holder->getVarThrow( $varName ) instanceof AFPData )
) {
$exported[$varName] = $this->getVar( $holder, $varName )->toNative();
}
}
return $exported;
}
/**
* Compute all vars which need DB access. Useful for vars which are going to be saved
* cross-wiki or used for offline analysis.
*
* @param VariableHolder $holder
*/
public function computeDBVars( VariableHolder $holder ): void {
static $dbTypes = [
'links-from-database',
'links-from-update',
'links-from-wikitext-or-database',
'load-recent-authors',
'page-age',
'revision-age-by-id',
'revision-age-by-title',
'previous-revision-age',
'get-page-restrictions',
'user-editcount',
'user-emailconfirm',
'user-groups',
'user-rights',
'user-age',
'user-block',
'revision-text-by-id',
'content-model-by-id',
];
/** @var LazyLoadedVariable[] $missingVars */
$missingVars = array_filter( $holder->getVars(), static function ( $el ) {
return ( $el instanceof LazyLoadedVariable );
} );
foreach ( $missingVars as $name => $var ) {
if ( in_array( $var->getMethod(), $dbTypes ) ) {
$holder->setVar( $name, $this->getVar( $holder, $name ) );
}
}
}
/**
* Export all variables stored in this object with their native (PHP) types.
*
* @param VariableHolder $holder
* @return array
*/
public function exportAllVars( VariableHolder $holder ): array {
$exported = [];
foreach ( array_keys( $holder->getVars() ) as $varName ) {
$exported[ $varName ] = $this->getVar( $holder, $varName )->toNative();
}
return $exported;
}
/**
* Export all non-lazy variables stored in this object as string
*
* @param VariableHolder $holder
* @return string[]
*/
public function exportNonLazyVars( VariableHolder $holder ): array {
$exported = [];
foreach ( $holder->getVars() as $varName => $data ) {
if ( !( $data instanceof LazyLoadedVariable ) ) {
$exported[$varName] = $holder->getComputedVariable( $varName )->toString();
}
}
return $exported;
}
}