SiteConfiguration.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Config;
 
class SiteConfiguration {
 
    public $suffixes = [];
 
    public $wikis = [];
 
    public $settings = [];
 
    public $fullLoadCallback = null;
 
    public $fullLoadDone = false;
 
    public $siteParamsCallback = null;
 
    protected $cfgCache = [];
 
    public function get(
        $settingName,
        $wiki,
        $site = null,
        $params = [],
        $wikiTags = []
    ) {
        $params = $this->mergeParams( $wiki, $site, $params, $wikiTags );
        $overrides = $this->settings[$settingName] ?? null;
        $value = $overrides ? $this->processSetting( $overrides, $wiki, $params['tags'] ) : null;
        if ( !array_key_exists( '@replaceableSettings', $this->settings )
            || in_array( $settingName, $this->settings['@replaceableSettings'] )
        ) {
            $this->doReplacements( $value, $params['replacements'] );
        }
        return $value;
    }
 
    private function processSetting( $thisSetting, $wiki, $tags ) {
        // Optimization: Avoid native type hint on private method called by hot getAll()
        // <https://gerrit.wikimedia.org/r/c/mediawiki/core/+/820244>
 
        $retval = null;
 
        if ( array_key_exists( $wiki, $thisSetting ) ) {
            // Found override by Wiki ID.
            $retval = $thisSetting[$wiki];
        } else {
            if ( array_key_exists( "+$wiki", $thisSetting ) ) {
                // Found mergable override by Wiki ID.
                // We continue to look for more merge candidates.
                $retval = $thisSetting["+$wiki"];
            }
 
            foreach ( $tags as $tag ) {
                if ( array_key_exists( $tag, $thisSetting ) ) {
                    if ( is_array( $retval ) && is_array( $thisSetting[$tag] ) ) {
                        // Found a mergable override by Tag, without "+" operator.
                        // Merge it with any "+wiki" match from before, and stop the cascade.
                        $retval = self::arrayMerge( $retval, $thisSetting[$tag] );
                    } else {
                        // Found a non-mergable override by Tag.
                        // This could in theory replace a "+wiki" match, but it should never happen
                        // that a setting uses both mergable array values and non-array values.
                        $retval = $thisSetting[$tag];
                    }
                    return $retval;
                } elseif ( array_key_exists( "+$tag", $thisSetting ) ) {
                    // Found a mergable override by Tag with "+" operator.
                    // Merge it with any "+wiki" or "+tag" matches from before,
                    // and keep looking for more merge candidates.
                    $retval = self::arrayMerge( $retval ?? [], $thisSetting["+$tag"] );
                }
            }
 
            if ( array_key_exists( 'default', $thisSetting ) ) {
                if ( is_array( $retval ) && is_array( $thisSetting['default'] ) ) {
                    // Found a mergable default
                    // Merge it with any "+wiki" or "+tag" matches from before.
                    $retval = self::arrayMerge( $retval, $thisSetting['default'] );
                } else {
                    // Found a default
                    // If any array-based values were built up via "+wiki" or "+tag" matches,
                    // these are thrown away here. We don't support merging array values into
                    // non-array values, and the fallback here is to use the default.
                    $retval = $thisSetting['default'];
                }
            }
        }
        return $retval;
    }
 
    private function doReplacements( &$value, $replacements ) {
        // Optimization: Avoid native type hint on private method called by hot getAll()
        // <https://gerrit.wikimedia.org/r/c/mediawiki/core/+/820244>
 
        if ( is_string( $value ) ) {
            $value = strtr( $value, $replacements );
        } elseif ( is_array( $value ) ) {
            foreach ( $value as &$val ) {
                if ( is_string( $val ) ) {
                    $val = strtr( $val, $replacements );
                }
            }
        }
    }
 
    public function getAll( $wiki, $site = null, $params = [], $wikiTags = [] ) {
        $params = $this->mergeParams( $wiki, $site, $params, $wikiTags );
        $tags = $params['tags'];
        $localSettings = [];
        foreach ( $this->settings as $varname => $overrides ) {
            $value = $this->processSetting( $overrides, $wiki, $tags );
            if ( $varname[0] === '+' ) {
                $varname = substr( $varname, 1 );
                if ( is_array( $value ) && is_array( $GLOBALS[$varname] ) ) {
                    $value = self::arrayMerge( $value, $GLOBALS[$varname] );
                }
            }
            if ( $value !== null ) {
                $localSettings[$varname] = $value;
            }
        }
 
        $replacements = $params['replacements'];
        if ( array_key_exists( '@replaceableSettings', $this->settings ) ) {
            foreach ( $this->settings['@replaceableSettings'] as $varname ) {
                if ( array_key_exists( $varname, $localSettings ) ) {
                    $this->doReplacements( $localSettings[$varname], $replacements );
                }
            }
        } else {
            foreach ( $localSettings as &$value ) {
                $this->doReplacements( $value, $replacements );
            }
        }
        return $localSettings;
    }
 
    public function getBool( $setting, $wiki, $site = null, $wikiTags = [] ) {
        return (bool)$this->get( $setting, $wiki, $site, [], $wikiTags );
    }
 
    public function getLocalDatabases() {
        return $this->wikis;
    }
 
    public function extractVar(
        $setting,
        $wiki,
        $site,
        &$var,
        $params = [],
        $wikiTags = []
    ) {
        wfDeprecated( __METHOD__, '1.41' );
        $value = $this->get( $setting, $wiki, $site, $params, $wikiTags );
        if ( $value !== null ) {
            $var = $value;
        }
    }
 
    public function extractGlobal(
        $setting,
        $wiki,
        $site = null,
        $params = [],
        $wikiTags = []
    ) {
        wfDeprecated( __METHOD__, '1.41' );
        $params = $this->mergeParams( $wiki, $site, $params, $wikiTags );
        $this->extractGlobalSetting( $setting, $wiki, $params );
    }
 
    public function extractGlobalSetting( $setting, $wiki, $params ) {
        $overrides = $this->settings[$setting] ?? null;
        $value = $overrides ? $this->processSetting( $overrides, $wiki, $params['tags'] ) : null;
        if ( !array_key_exists( '@replaceableSettings', $this->settings )
            || in_array( $setting, $this->settings['@replaceableSettings'] )
        ) {
            $this->doReplacements( $value, $params['replacements'] );
        }
        if ( $value !== null ) {
            if ( substr( $setting, 0, 1 ) == '+' && is_array( $value ) ) {
                $setting = substr( $setting, 1 );
                if ( is_array( $GLOBALS[$setting] ) ) {
                    $GLOBALS[$setting] = self::arrayMerge( $GLOBALS[$setting], $value );
                } else {
                    $GLOBALS[$setting] = $value;
                }
            } else {
                $GLOBALS[$setting] = $value;
            }
        }
    }
 
    public function extractAllGlobals(
        $wiki,
        $site = null,
        $params = [],
        $wikiTags = []
    ) {
        $params = $this->mergeParams( $wiki, $site, $params, $wikiTags );
        foreach ( $this->settings as $varName => $setting ) {
            $this->extractGlobalSetting( $varName, $wiki, $params );
        }
    }
 
    protected function getWikiParams( $wiki ) {
        static $default = [
            'suffix' => null,
            'lang' => null,
            'tags' => [],
            'params' => [],
        ];
 
        if ( !is_callable( $this->siteParamsCallback ) ) {
            return $default;
        }
 
        $ret = ( $this->siteParamsCallback )( $this, $wiki );
        # Validate the returned value
        if ( !is_array( $ret ) ) {
            return $default;
        }
 
        foreach ( $default as $name => $def ) {
            if ( !isset( $ret[$name] ) || ( is_array( $def ) && !is_array( $ret[$name] ) ) ) {
                $ret[$name] = $def;
            }
        }
 
        return $ret;
    }
 
    protected function mergeParams( $wiki, $site, array $params, array $wikiTags ) {
        $ret = $this->getWikiParams( $wiki );
 
        $ret['suffix'] ??= $site;
 
        // Make tags based on the db suffix (e.g. wiki family) automatically
        // available for use in wgConf. The user does not have to maintain
        // wiki tag lookups (e.g. dblists at WMF) for the wiki family.
        $wikiTags[] = $ret['suffix'];
 
        $ret['tags'] = array_unique( array_merge( $ret['tags'], $wikiTags ) );
 
        $ret['params'] += $params;
 
        // Make the $lang and $site parameters automatically available if they
        // were provided by `siteParamsCallback` via getWikiParams()
        if ( !isset( $ret['params']['lang'] ) && $ret['lang'] !== null ) {
            $ret['params']['lang'] = $ret['lang'];
        }
        if ( !isset( $ret['params']['site'] ) && $ret['suffix'] !== null ) {
            $ret['params']['site'] = $ret['suffix'];
        }
 
        // Optimization: For hot getAll() code path, precompute replacements to re-use
        // over hundreds of processSetting() calls.
        $ret['replacements'] = [];
        // @phan-suppress-next-line PhanTypePossiblyInvalidDimOffset False positive
        foreach ( $ret['params'] as $key => $value ) {
            $ret['replacements']['$' . $key] = $value;
        }
 
        return $ret;
    }
 
    public function siteFromDB( $wiki ) {
        // Allow override
        $def = $this->getWikiParams( $wiki );
        if ( $def['suffix'] !== null && $def['lang'] !== null ) {
            return [ $def['suffix'], $def['lang'] ];
        }
 
        $languageCode = str_replace( '_', '-', $wiki );
        foreach ( $this->suffixes as $altSite => $suffix ) {
            if ( $suffix === '' ) {
                return [ '', $languageCode ];
            } elseif ( str_ends_with( $wiki, $suffix ) ) {
                $site = is_string( $altSite ) ? $altSite : $suffix;
                $languageCode = substr( $languageCode, 0, -strlen( $suffix ) );
                return [ $site, $languageCode ];
            }
        }
 
        return [ null, null ];
    }
 
    private static function arrayMerge( array $array1, array $array2 ) {
        $out = $array1;
        foreach ( $array2 as $key => $value ) {
            if ( isset( $out[$key] ) ) {
                if ( is_array( $out[$key] ) && is_array( $value ) ) {
                    // Merge the new array into the existing one
                    $out[$key] = self::arrayMerge( $out[$key], $value );
                } elseif ( is_numeric( $key ) ) {
                    // A numerical key is taken, append the value at the end instead.
                    // It is important that we generally preserve numerical keys and only
                    // fallback to appending values if there are conflicts. This is needed
                    // by configuration variables that hold associative arrays with
                    // meaningful numerical keys, such as $wgNamespacesWithSubpages,
                    // $wgNamespaceProtection, $wgNamespacesToBeSearchedDefault, etc.
                    $out[] = $value;
                } elseif ( $out[$key] === false ) {
                    // A non-numerical key is taken and holds a false value,
                    // allow it to be overridden always. This exists mainly for the purpose
                    // merging permissions arrays, such as $wgGroupPermissions.
                    $out[$key] = $value;
                }
                // Else: The key is already taken and we keep the current value
 
            } else {
                // Add a new key.
                $out[$key] = $value;
            }
        }
 
        return $out;
    }
 
    public function loadFullData() {
        if ( $this->fullLoadCallback && !$this->fullLoadDone ) {
            ( $this->fullLoadCallback )( $this );
            $this->fullLoadDone = true;
        }
    }
}
 
class_alias( SiteConfiguration::class, 'SiteConfiguration' );