LocalisationCache.php

Go to the documentation of this file.

<?php
use Cdb\Reader as CdbReader;
use Cdb\Writer as CdbWriter;
use CLDRPluralRuleParser\Evaluator;
use CLDRPluralRuleParser\Error as CLDRPluralRuleError;
use MediaWiki\MediaWikiServices;

class LocalisationCache {
    const VERSION = 4;

    private $conf;

    private $manualRecache = false;

    private $forceRecache = false;

    protected $data = [];

    private $store;

    private $loadedItems = [];

    private $loadedSubitems = [];

    private $initialisedLangs = [];

    private $shallowFallbacks = [];

    private $recachedLangs = [];

    static public $allKeys = [
        'fallback', 'namespaceNames', 'bookstoreList',
        'magicWords', 'messages', 'rtl', 'capitalizeAllNouns', 'digitTransformTable',
        'separatorTransformTable', 'fallback8bitEncoding', 'linkPrefixExtension',
        'linkTrail', 'linkPrefixCharset', 'namespaceAliases',
        'dateFormats', 'datePreferences', 'datePreferenceMigrationMap',
        'defaultDateFormat', 'extraUserToggles', 'specialPageAliases',
        'imageFiles', 'preloadedMessages', 'namespaceGenderAliases',
        'digitGroupingPattern', 'pluralRules', 'pluralRuleTypes', 'compiledPluralRules',
    ];

    static public $mergeableMapKeys = [ 'messages', 'namespaceNames',
        'namespaceAliases', 'dateFormats', 'imageFiles', 'preloadedMessages'
    ];

    static public $mergeableListKeys = [ 'extraUserToggles' ];

    static public $mergeableAliasListKeys = [ 'specialPageAliases' ];

    static public $optionalMergeKeys = [ 'bookstoreList' ];

    static public $magicWordKeys = [ 'magicWords' ];

    static public $splitKeys = [ 'messages' ];

    static public $preloadedKeys = [ 'dateFormats', 'namespaceNames' ];

    private $pluralRules = null;

    private $pluralRuleTypes = null;

    private $mergeableKeys = null;

    function __construct( $conf ) {
        global $wgCacheDirectory;

        $this->conf = $conf;
        $storeConf = [];
        if ( !empty( $conf['storeClass'] ) ) {
            $storeClass = $conf['storeClass'];
        } else {
            switch ( $conf['store'] ) {
                case 'files':
                case 'file':
                    $storeClass = 'LCStoreCDB';
                    break;
                case 'db':
                    $storeClass = 'LCStoreDB';
                    break;
                case 'array':
                    $storeClass = 'LCStoreStaticArray';
                    break;
                case 'detect':
                    if ( !empty( $conf['storeDirectory'] ) ) {
                        $storeClass = 'LCStoreCDB';
                    } elseif ( $wgCacheDirectory ) {
                        $storeConf['directory'] = $wgCacheDirectory;
                        $storeClass = 'LCStoreCDB';
                    } else {
                        $storeClass = 'LCStoreDB';
                    }
                    break;
                default:
                    throw new MWException(
                        'Please set $wgLocalisationCacheConf[\'store\'] to something sensible.'
                    );
            }
        }

        wfDebugLog( 'caches', get_class( $this ) . ": using store $storeClass" );
        if ( !empty( $conf['storeDirectory'] ) ) {
            $storeConf['directory'] = $conf['storeDirectory'];
        }

        $this->store = new $storeClass( $storeConf );
        foreach ( [ 'manualRecache', 'forceRecache' ] as $var ) {
            if ( isset( $conf[$var] ) ) {
                $this->$var = $conf[$var];
            }
        }
    }

    public function isMergeableKey( $key ) {
        if ( $this->mergeableKeys === null ) {
            $this->mergeableKeys = array_flip( array_merge(
                self::$mergeableMapKeys,
                self::$mergeableListKeys,
                self::$mergeableAliasListKeys,
                self::$optionalMergeKeys,
                self::$magicWordKeys
            ) );
        }

        return isset( $this->mergeableKeys[$key] );
    }

    public function getItem( $code, $key ) {
        if ( !isset( $this->loadedItems[$code][$key] ) ) {
            $this->loadItem( $code, $key );
        }

        if ( $key === 'fallback' && isset( $this->shallowFallbacks[$code] ) ) {
            return $this->shallowFallbacks[$code];
        }

        return $this->data[$code][$key];
    }

    public function getSubitem( $code, $key, $subkey ) {
        if ( !isset( $this->loadedSubitems[$code][$key][$subkey] ) &&
            !isset( $this->loadedItems[$code][$key] )
        ) {
            $this->loadSubitem( $code, $key, $subkey );
        }

        if ( isset( $this->data[$code][$key][$subkey] ) ) {
            return $this->data[$code][$key][$subkey];
        } else {
            return null;
        }
    }

    public function getSubitemList( $code, $key ) {
        if ( in_array( $key, self::$splitKeys ) ) {
            return $this->getSubitem( $code, 'list', $key );
        } else {
            $item = $this->getItem( $code, $key );
            if ( is_array( $item ) ) {
                return array_keys( $item );
            } else {
                return false;
            }
        }
    }

    protected function loadItem( $code, $key ) {
        if ( !isset( $this->initialisedLangs[$code] ) ) {
            $this->initLanguage( $code );
        }

        // Check to see if initLanguage() loaded it for us
        if ( isset( $this->loadedItems[$code][$key] ) ) {
            return;
        }

        if ( isset( $this->shallowFallbacks[$code] ) ) {
            $this->loadItem( $this->shallowFallbacks[$code], $key );

            return;
        }

        if ( in_array( $key, self::$splitKeys ) ) {
            $subkeyList = $this->getSubitem( $code, 'list', $key );
            foreach ( $subkeyList as $subkey ) {
                if ( isset( $this->data[$code][$key][$subkey] ) ) {
                    continue;
                }
                $this->data[$code][$key][$subkey] = $this->getSubitem( $code, $key, $subkey );
            }
        } else {
            $this->data[$code][$key] = $this->store->get( $code, $key );
        }

        $this->loadedItems[$code][$key] = true;
    }

    protected function loadSubitem( $code, $key, $subkey ) {
        if ( !in_array( $key, self::$splitKeys ) ) {
            $this->loadItem( $code, $key );

            return;
        }

        if ( !isset( $this->initialisedLangs[$code] ) ) {
            $this->initLanguage( $code );
        }

        // Check to see if initLanguage() loaded it for us
        if ( isset( $this->loadedItems[$code][$key] ) ||
            isset( $this->loadedSubitems[$code][$key][$subkey] )
        ) {
            return;
        }

        if ( isset( $this->shallowFallbacks[$code] ) ) {
            $this->loadSubitem( $this->shallowFallbacks[$code], $key, $subkey );

            return;
        }

        $value = $this->store->get( $code, "$key:$subkey" );
        $this->data[$code][$key][$subkey] = $value;
        $this->loadedSubitems[$code][$key][$subkey] = true;
    }

    public function isExpired( $code ) {
        if ( $this->forceRecache && !isset( $this->recachedLangs[$code] ) ) {
            wfDebug( __METHOD__ . "($code): forced reload\n" );

            return true;
        }

        $deps = $this->store->get( $code, 'deps' );
        $keys = $this->store->get( $code, 'list' );
        $preload = $this->store->get( $code, 'preload' );
        // Different keys may expire separately for some stores
        if ( $deps === null || $keys === null || $preload === null ) {
            wfDebug( __METHOD__ . "($code): cache missing, need to make one\n" );

            return true;
        }

        foreach ( $deps as $dep ) {
            // Because we're unserializing stuff from cache, we
            // could receive objects of classes that don't exist
            // anymore (e.g. uninstalled extensions)
            // When this happens, always expire the cache
            if ( !$dep instanceof CacheDependency || $dep->isExpired() ) {
                wfDebug( __METHOD__ . "($code): cache for $code expired due to " .
                    get_class( $dep ) . "\n" );

                return true;
            }
        }

        return false;
    }

    protected function initLanguage( $code ) {
        if ( isset( $this->initialisedLangs[$code] ) ) {
            return;
        }

        $this->initialisedLangs[$code] = true;

        # If the code is of the wrong form for a Messages*.php file, do a shallow fallback
        if ( !Language::isValidBuiltInCode( $code ) ) {
            $this->initShallowFallback( $code, 'en' );

            return;
        }

        # Recache the data if necessary
        if ( !$this->manualRecache && $this->isExpired( $code ) ) {
            if ( Language::isSupportedLanguage( $code ) ) {
                $this->recache( $code );
            } elseif ( $code === 'en' ) {
                throw new MWException( 'MessagesEn.php is missing.' );
            } else {
                $this->initShallowFallback( $code, 'en' );
            }

            return;
        }

        # Preload some stuff
        $preload = $this->getItem( $code, 'preload' );
        if ( $preload === null ) {
            if ( $this->manualRecache ) {
                // No Messages*.php file. Do shallow fallback to en.
                if ( $code === 'en' ) {
                    throw new MWException( 'No localisation cache found for English. ' .
                        'Please run maintenance/rebuildLocalisationCache.php.' );
                }
                $this->initShallowFallback( $code, 'en' );

                return;
            } else {
                throw new MWException( 'Invalid or missing localisation cache.' );
            }
        }
        $this->data[$code] = $preload;
        foreach ( $preload as $key => $item ) {
            if ( in_array( $key, self::$splitKeys ) ) {
                foreach ( $item as $subkey => $subitem ) {
                    $this->loadedSubitems[$code][$key][$subkey] = true;
                }
            } else {
                $this->loadedItems[$code][$key] = true;
            }
        }
    }

    public function initShallowFallback( $primaryCode, $fallbackCode ) {
        $this->data[$primaryCode] =& $this->data[$fallbackCode];
        $this->loadedItems[$primaryCode] =& $this->loadedItems[$fallbackCode];
        $this->loadedSubitems[$primaryCode] =& $this->loadedSubitems[$fallbackCode];
        $this->shallowFallbacks[$primaryCode] = $fallbackCode;
    }

    protected function readPHPFile( $_fileName, $_fileType ) {
        // Disable APC caching
        MediaWiki\suppressWarnings();
        $_apcEnabled = ini_set( 'apc.cache_by_default', '0' );
        MediaWiki\restoreWarnings();

        include $_fileName;

        MediaWiki\suppressWarnings();
        ini_set( 'apc.cache_by_default', $_apcEnabled );
        MediaWiki\restoreWarnings();

        if ( $_fileType == 'core' || $_fileType == 'extension' ) {
            $data = compact( self::$allKeys );
        } elseif ( $_fileType == 'aliases' ) {
            $data = compact( 'aliases' );
        } else {
            throw new MWException( __METHOD__ . ": Invalid file type: $_fileType" );
        }

        return $data;
    }

    public function readJSONFile( $fileName ) {

        if ( !is_readable( $fileName ) ) {
            return [];
        }

        $json = file_get_contents( $fileName );
        if ( $json === false ) {
            return [];
        }

        $data = FormatJson::decode( $json, true );
        if ( $data === null ) {

            throw new MWException( __METHOD__ . ": Invalid JSON file: $fileName" );
        }

        // Remove keys starting with '@', they're reserved for metadata and non-message data
        foreach ( $data as $key => $unused ) {
            if ( $key === '' || $key[0] === '@' ) {
                unset( $data[$key] );
            }
        }

        // The JSON format only supports messages, none of the other variables, so wrap the data
        return [ 'messages' => $data ];
    }

    public function getCompiledPluralRules( $code ) {
        $rules = $this->getPluralRules( $code );
        if ( $rules === null ) {
            return null;
        }
        try {
            $compiledRules = Evaluator::compile( $rules );
        } catch ( CLDRPluralRuleError $e ) {
            wfDebugLog( 'l10n', $e->getMessage() );

            return [];
        }

        return $compiledRules;
    }

    public function getPluralRules( $code ) {
        if ( $this->pluralRules === null ) {
            $this->loadPluralFiles();
        }
        if ( !isset( $this->pluralRules[$code] ) ) {
            return null;
        } else {
            return $this->pluralRules[$code];
        }
    }

    public function getPluralRuleTypes( $code ) {
        if ( $this->pluralRuleTypes === null ) {
            $this->loadPluralFiles();
        }
        if ( !isset( $this->pluralRuleTypes[$code] ) ) {
            return null;
        } else {
            return $this->pluralRuleTypes[$code];
        }
    }

    protected function loadPluralFiles() {
        global $IP;
        $cldrPlural = "$IP/languages/data/plurals.xml";
        $mwPlural = "$IP/languages/data/plurals-mediawiki.xml";
        // Load CLDR plural rules
        $this->loadPluralFile( $cldrPlural );
        if ( file_exists( $mwPlural ) ) {
            // Override or extend
            $this->loadPluralFile( $mwPlural );
        }
    }

    protected function loadPluralFile( $fileName ) {
        // Use file_get_contents instead of DOMDocument::load (T58439)
        $xml = file_get_contents( $fileName );
        if ( !$xml ) {
            throw new MWException( "Unable to read plurals file $fileName" );
        }
        $doc = new DOMDocument;
        $doc->loadXML( $xml );
        $rulesets = $doc->getElementsByTagName( "pluralRules" );
        foreach ( $rulesets as $ruleset ) {
            $codes = $ruleset->getAttribute( 'locales' );
            $rules = [];
            $ruleTypes = [];
            $ruleElements = $ruleset->getElementsByTagName( "pluralRule" );
            foreach ( $ruleElements as $elt ) {
                $ruleType = $elt->getAttribute( 'count' );
                if ( $ruleType === 'other' ) {
                    // Don't record "other" rules, which have an empty condition
                    continue;
                }
                $rules[] = $elt->nodeValue;
                $ruleTypes[] = $ruleType;
            }
            foreach ( explode( ' ', $codes ) as $code ) {
                $this->pluralRules[$code] = $rules;
                $this->pluralRuleTypes[$code] = $ruleTypes;
            }
        }
    }

    protected function readSourceFilesAndRegisterDeps( $code, &$deps ) {
        global $IP;

        // This reads in the PHP i18n file with non-messages l10n data
        $fileName = Language::getMessagesFileName( $code );
        if ( !file_exists( $fileName ) ) {
            $data = [];
        } else {
            $deps[] = new FileDependency( $fileName );
            $data = $this->readPHPFile( $fileName, 'core' );
        }

        # Load CLDR plural rules for JavaScript
        $data['pluralRules'] = $this->getPluralRules( $code );
        # And for PHP
        $data['compiledPluralRules'] = $this->getCompiledPluralRules( $code );
        # Load plural rule types
        $data['pluralRuleTypes'] = $this->getPluralRuleTypes( $code );

        $deps['plurals'] = new FileDependency( "$IP/languages/data/plurals.xml" );
        $deps['plurals-mw'] = new FileDependency( "$IP/languages/data/plurals-mediawiki.xml" );

        return $data;
    }

    protected function mergeItem( $key, &$value, $fallbackValue ) {
        if ( !is_null( $value ) ) {
            if ( !is_null( $fallbackValue ) ) {
                if ( in_array( $key, self::$mergeableMapKeys ) ) {
                    $value = $value + $fallbackValue;
                } elseif ( in_array( $key, self::$mergeableListKeys ) ) {
                    $value = array_unique( array_merge( $fallbackValue, $value ) );
                } elseif ( in_array( $key, self::$mergeableAliasListKeys ) ) {
                    $value = array_merge_recursive( $value, $fallbackValue );
                } elseif ( in_array( $key, self::$optionalMergeKeys ) ) {
                    if ( !empty( $value['inherit'] ) ) {
                        $value = array_merge( $fallbackValue, $value );
                    }

                    if ( isset( $value['inherit'] ) ) {
                        unset( $value['inherit'] );
                    }
                } elseif ( in_array( $key, self::$magicWordKeys ) ) {
                    $this->mergeMagicWords( $value, $fallbackValue );
                }
            }
        } else {
            $value = $fallbackValue;
        }
    }

    protected function mergeMagicWords( &$value, $fallbackValue ) {
        foreach ( $fallbackValue as $magicName => $fallbackInfo ) {
            if ( !isset( $value[$magicName] ) ) {
                $value[$magicName] = $fallbackInfo;
            } else {
                $oldSynonyms = array_slice( $fallbackInfo, 1 );
                $newSynonyms = array_slice( $value[$magicName], 1 );
                $synonyms = array_values( array_unique( array_merge(
                    $newSynonyms, $oldSynonyms ) ) );
                $value[$magicName] = array_merge( [ $fallbackInfo[0] ], $synonyms );
            }
        }
    }

    protected function mergeExtensionItem( $codeSequence, $key, &$value, $fallbackValue ) {
        $used = false;
        foreach ( $codeSequence as $code ) {
            if ( isset( $fallbackValue[$code] ) ) {
                $this->mergeItem( $key, $value, $fallbackValue[$code] );
                $used = true;
            }
        }

        return $used;
    }

    public function getMessagesDirs() {
        global $IP;

        $config = MediaWikiServices::getInstance()->getMainConfig();
        $messagesDirs = $config->get( 'MessagesDirs' );
        return [
            'core' => "$IP/languages/i18n",
            'api' => "$IP/includes/api/i18n",
            'oojs-ui' => "$IP/resources/lib/oojs-ui/i18n",
        ] + $messagesDirs;
    }

    public function recache( $code ) {
        global $wgExtensionMessagesFiles;

        if ( !$code ) {
            throw new MWException( "Invalid language code requested" );
        }
        $this->recachedLangs[$code] = true;

        # Initial values
        $initialData = array_fill_keys( self::$allKeys, null );
        $coreData = $initialData;
        $deps = [];

        # Load the primary localisation from the source file
        $data = $this->readSourceFilesAndRegisterDeps( $code, $deps );
        if ( $data === false ) {
            wfDebug( __METHOD__ . ": no localisation file for $code, using fallback to en\n" );
            $coreData['fallback'] = 'en';
        } else {
            wfDebug( __METHOD__ . ": got localisation for $code from source\n" );

            # Merge primary localisation
            foreach ( $data as $key => $value ) {
                $this->mergeItem( $key, $coreData[$key], $value );
            }
        }

        # Fill in the fallback if it's not there already
        if ( is_null( $coreData['fallback'] ) ) {
            $coreData['fallback'] = $code === 'en' ? false : 'en';
        }
        if ( $coreData['fallback'] === false ) {
            $coreData['fallbackSequence'] = [];
        } else {
            $coreData['fallbackSequence'] = array_map( 'trim', explode( ',', $coreData['fallback'] ) );
            $len = count( $coreData['fallbackSequence'] );

            # Ensure that the sequence ends at en
            if ( $coreData['fallbackSequence'][$len - 1] !== 'en' ) {
                $coreData['fallbackSequence'][] = 'en';
            }
        }

        $codeSequence = array_merge( [ $code ], $coreData['fallbackSequence'] );
        $messageDirs = $this->getMessagesDirs();

        # Load non-JSON localisation data for extensions
        $extensionData = array_fill_keys( $codeSequence, $initialData );
        foreach ( $wgExtensionMessagesFiles as $extension => $fileName ) {
            if ( isset( $messageDirs[$extension] ) ) {
                # This extension has JSON message data; skip the PHP shim
                continue;
            }

            $data = $this->readPHPFile( $fileName, 'extension' );
            $used = false;

            foreach ( $data as $key => $item ) {
                foreach ( $codeSequence as $csCode ) {
                    if ( isset( $item[$csCode] ) ) {
                        $this->mergeItem( $key, $extensionData[$csCode][$key], $item[$csCode] );
                        $used = true;
                    }
                }
            }

            if ( $used ) {
                $deps[] = new FileDependency( $fileName );
            }
        }

        # Load the localisation data for each fallback, then merge it into the full array
        $allData = $initialData;
        foreach ( $codeSequence as $csCode ) {
            $csData = $initialData;

            # Load core messages and the extension localisations.
            foreach ( $messageDirs as $dirs ) {
                foreach ( (array)$dirs as $dir ) {
                    $fileName = "$dir/$csCode.json";
                    $data = $this->readJSONFile( $fileName );

                    foreach ( $data as $key => $item ) {
                        $this->mergeItem( $key, $csData[$key], $item );
                    }

                    $deps[] = new FileDependency( $fileName );
                }
            }

            # Merge non-JSON extension data
            if ( isset( $extensionData[$csCode] ) ) {
                foreach ( $extensionData[$csCode] as $key => $item ) {
                    $this->mergeItem( $key, $csData[$key], $item );
                }
            }

            if ( $csCode === $code ) {
                # Merge core data into extension data
                foreach ( $coreData as $key => $item ) {
                    $this->mergeItem( $key, $csData[$key], $item );
                }
            } else {
                # Load the secondary localisation from the source file to
                # avoid infinite cycles on cyclic fallbacks
                $fbData = $this->readSourceFilesAndRegisterDeps( $csCode, $deps );
                if ( $fbData !== false ) {
                    # Only merge the keys that make sense to merge
                    foreach ( self::$allKeys as $key ) {
                        if ( !isset( $fbData[$key] ) ) {
                            continue;
                        }

                        if ( is_null( $coreData[$key] ) || $this->isMergeableKey( $key ) ) {
                            $this->mergeItem( $key, $csData[$key], $fbData[$key] );
                        }
                    }
                }
            }

            # Allow extensions an opportunity to adjust the data for this
            # fallback
            Hooks::run( 'LocalisationCacheRecacheFallback', [ $this, $csCode, &$csData ] );

            # Merge the data for this fallback into the final array
            if ( $csCode === $code ) {
                $allData = $csData;
            } else {
                foreach ( self::$allKeys as $key ) {
                    if ( !isset( $csData[$key] ) ) {
                        continue;
                    }

                    if ( is_null( $allData[$key] ) || $this->isMergeableKey( $key ) ) {
                        $this->mergeItem( $key, $allData[$key], $csData[$key] );
                    }
                }
            }
        }

        # Add cache dependencies for any referenced globals
        $deps['wgExtensionMessagesFiles'] = new GlobalDependency( 'wgExtensionMessagesFiles' );
        // The 'MessagesDirs' config setting is used in LocalisationCache::getMessagesDirs().
        // We use the key 'wgMessagesDirs' for historical reasons.
        $deps['wgMessagesDirs'] = new MainConfigDependency( 'MessagesDirs' );
        $deps['version'] = new ConstantDependency( 'LocalisationCache::VERSION' );

        # Add dependencies to the cache entry
        $allData['deps'] = $deps;

        # Replace spaces with underscores in namespace names
        $allData['namespaceNames'] = str_replace( ' ', '_', $allData['namespaceNames'] );

        # And do the same for special page aliases. $page is an array.
        foreach ( $allData['specialPageAliases'] as &$page ) {
            $page = str_replace( ' ', '_', $page );
        }
        # Decouple the reference to prevent accidental damage
        unset( $page );

        # If there were no plural rules, return an empty array
        if ( $allData['pluralRules'] === null ) {
            $allData['pluralRules'] = [];
        }
        if ( $allData['compiledPluralRules'] === null ) {
            $allData['compiledPluralRules'] = [];
        }
        # If there were no plural rule types, return an empty array
        if ( $allData['pluralRuleTypes'] === null ) {
            $allData['pluralRuleTypes'] = [];
        }

        # Set the list keys
        $allData['list'] = [];
        foreach ( self::$splitKeys as $key ) {
            $allData['list'][$key] = array_keys( $allData[$key] );
        }
        # Run hooks
        $purgeBlobs = true;
        Hooks::run( 'LocalisationCacheRecache', [ $this, $code, &$allData, &$purgeBlobs ] );

        if ( is_null( $allData['namespaceNames'] ) ) {
            throw new MWException( __METHOD__ . ': Localisation data failed sanity check! ' .
                'Check that your languages/messages/MessagesEn.php file is intact.' );
        }

        # Set the preload key
        $allData['preload'] = $this->buildPreload( $allData );

        # Save to the process cache and register the items loaded
        $this->data[$code] = $allData;
        foreach ( $allData as $key => $item ) {
            $this->loadedItems[$code][$key] = true;
        }

        # Save to the persistent cache
        $this->store->startWrite( $code );
        foreach ( $allData as $key => $value ) {
            if ( in_array( $key, self::$splitKeys ) ) {
                foreach ( $value as $subkey => $subvalue ) {
                    $this->store->set( "$key:$subkey", $subvalue );
                }
            } else {
                $this->store->set( $key, $value );
            }
        }
        $this->store->finishWrite();

        # Clear out the MessageBlobStore
        # HACK: If using a null (i.e. disabled) storage backend, we
        # can't write to the MessageBlobStore either
        if ( $purgeBlobs && !$this->store instanceof LCStoreNull ) {
            $blobStore = new MessageBlobStore();
            $blobStore->clear();
        }

    }

    protected function buildPreload( $data ) {
        $preload = [ 'messages' => [] ];
        foreach ( self::$preloadedKeys as $key ) {
            $preload[$key] = $data[$key];
        }

        foreach ( $data['preloadedMessages'] as $subkey ) {
            if ( isset( $data['messages'][$subkey] ) ) {
                $subitem = $data['messages'][$subkey];
            } else {
                $subitem = null;
            }
            $preload['messages'][$subkey] = $subitem;
        }

        return $preload;
    }

    public function unload( $code ) {
        unset( $this->data[$code] );
        unset( $this->loadedItems[$code] );
        unset( $this->loadedSubitems[$code] );
        unset( $this->initialisedLangs[$code] );
        unset( $this->shallowFallbacks[$code] );

        foreach ( $this->shallowFallbacks as $shallowCode => $fbCode ) {
            if ( $fbCode === $code ) {
                $this->unload( $shallowCode );
            }
        }
    }

    public function unloadAll() {
        foreach ( $this->initialisedLangs as $lang => $unused ) {
            $this->unload( $lang );
        }
    }

    public function disableBackend() {
        $this->store = new LCStoreNull;
        $this->manualRecache = false;
    }

}