languages.inc

Go to the documentation of this file.

<?php
class Languages {
    protected $mLanguages;
 
    protected $mRawMessages;
 
    protected $mMessages;
 
    protected $mFallback;
 
    protected $mGeneralMessages;
 
    protected $mIgnoredMessages;
 
    protected $mOptionalMessages;
 
    protected $mNamespaceNames;
 
    protected $mNamespaceAliases;
 
    protected $mMagicWords;
 
    protected $mSpecialPageAliases;
 
    function __construct() {
        Hooks::run( 'LocalisationIgnoredOptionalMessages',
            [ &$this->mIgnoredMessages, &$this->mOptionalMessages ] );
 
        $this->mLanguages = array_keys( Language::fetchLanguageNames( null, 'mwfile' ) );
        sort( $this->mLanguages );
    }
 
    public function getLanguages() {
        return $this->mLanguages;
    }
 
    public function getIgnoredMessages() {
        return $this->mIgnoredMessages;
    }
 
    public function getOptionalMessages() {
        return $this->mOptionalMessages;
    }
 
    protected function loadFile( $code ) {
        if ( isset( $this->mRawMessages[$code] ) &&
            isset( $this->mFallback[$code] ) &&
            isset( $this->mNamespaceNames[$code] ) &&
            isset( $this->mNamespaceAliases[$code] ) &&
            isset( $this->mMagicWords[$code] ) &&
            isset( $this->mSpecialPageAliases[$code] )
        ) {
            return;
        }
        $this->mRawMessages[$code] = [];
        $this->mFallback[$code] = '';
        $this->mNamespaceNames[$code] = [];
        $this->mNamespaceAliases[$code] = [];
        $this->mMagicWords[$code] = [];
        $this->mSpecialPageAliases[$code] = [];
 
        $jsonfilename = Language::getJsonMessagesFileName( $code );
        if ( file_exists( $jsonfilename ) ) {
            $json = Language::getLocalisationCache()->readJSONFile( $jsonfilename );
            $this->mRawMessages[$code] = $json['messages'];
        }
 
        $filename = Language::getMessagesFileName( $code );
        if ( file_exists( $filename ) ) {
            require $filename;
            if ( isset( $fallback ) ) {
                $this->mFallback[$code] = $fallback;
            }
            if ( isset( $namespaceNames ) ) {
                $this->mNamespaceNames[$code] = $namespaceNames;
            }
            if ( isset( $namespaceAliases ) ) {
                $this->mNamespaceAliases[$code] = $namespaceAliases;
            }
            if ( isset( $magicWords ) ) {
                $this->mMagicWords[$code] = $magicWords;
            }
            if ( isset( $specialPageAliases ) ) {
                $this->mSpecialPageAliases[$code] = $specialPageAliases;
            }
        }
    }
 
    private function loadMessages( $code ) {
        if ( isset( $this->mMessages[$code] ) ) {
            return;
        }
        $this->loadFile( $code );
        $this->loadGeneralMessages();
        $this->mMessages[$code]['all'] = $this->mRawMessages[$code];
        $this->mMessages[$code]['required'] = [];
        $this->mMessages[$code]['optional'] = [];
        $this->mMessages[$code]['obsolete'] = [];
        $this->mMessages[$code]['translated'] = [];
        foreach ( $this->mMessages[$code]['all'] as $key => $value ) {
            if ( isset( $this->mGeneralMessages['required'][$key] ) ) {
                $this->mMessages[$code]['required'][$key] = $value;
                $this->mMessages[$code]['translated'][$key] = $value;
            } elseif ( isset( $this->mGeneralMessages['optional'][$key] ) ) {
                $this->mMessages[$code]['optional'][$key] = $value;
                $this->mMessages[$code]['translated'][$key] = $value;
            } else {
                $this->mMessages[$code]['obsolete'][$key] = $value;
            }
        }
    }
 
    private function loadGeneralMessages() {
        if ( isset( $this->mGeneralMessages ) ) {
            return;
        }
        $this->loadFile( 'en' );
        $this->mGeneralMessages['all'] = $this->mRawMessages['en'];
        $this->mGeneralMessages['required'] = [];
        $this->mGeneralMessages['optional'] = [];
        $this->mGeneralMessages['ignored'] = [];
        $this->mGeneralMessages['translatable'] = [];
        foreach ( $this->mGeneralMessages['all'] as $key => $value ) {
            if ( in_array( $key, $this->mIgnoredMessages ) ) {
                $this->mGeneralMessages['ignored'][$key] = $value;
            } elseif ( in_array( $key, $this->mOptionalMessages ) ) {
                $this->mGeneralMessages['optional'][$key] = $value;
                $this->mGeneralMessages['translatable'][$key] = $value;
            } else {
                $this->mGeneralMessages['required'][$key] = $value;
                $this->mGeneralMessages['translatable'][$key] = $value;
            }
        }
    }
 
    public function getMessages( $code ) {
        $this->loadMessages( $code );
 
        return $this->mMessages[$code];
    }
 
    public function getGeneralMessages() {
        $this->loadGeneralMessages();
 
        return $this->mGeneralMessages;
    }
 
    public function getFallback( $code ) {
        $this->loadFile( $code );
 
        return $this->mFallback[$code];
    }
 
    public function getNamespaceNames( $code ) {
        $this->loadFile( $code );
 
        return $this->mNamespaceNames[$code];
    }
 
    public function getNamespaceAliases( $code ) {
        $this->loadFile( $code );
 
        return $this->mNamespaceAliases[$code];
    }
 
    public function getMagicWords( $code ) {
        $this->loadFile( $code );
 
        return $this->mMagicWords[$code];
    }
 
    public function getSpecialPageAliases( $code ) {
        $this->loadFile( $code );
 
        return $this->mSpecialPageAliases[$code];
    }
 
    public function getUntranslatedMessages( $code ) {
        $this->loadGeneralMessages();
        $this->loadMessages( $code );
 
        return array_diff_key( $this->mGeneralMessages['required'], $this->mMessages[$code]['required'] );
    }
 
    public function getDuplicateMessages( $code ) {
        $this->loadGeneralMessages();
        $this->loadMessages( $code );
        $duplicateMessages = [];
        foreach ( $this->mMessages[$code]['translated'] as $key => $value ) {
            if ( $this->mGeneralMessages['translatable'][$key] == $value ) {
                $duplicateMessages[$key] = $value;
            }
        }
 
        return $duplicateMessages;
    }
 
    public function getObsoleteMessages( $code ) {
        $this->loadGeneralMessages();
        $this->loadMessages( $code );
 
        return $this->mMessages[$code]['obsolete'];
    }
 
    public function getMessagesWithMismatchVariables( $code ) {
        $this->loadGeneralMessages();
        $this->loadMessages( $code );
        $variables = [ '\$1', '\$2', '\$3', '\$4', '\$5', '\$6', '\$7', '\$8', '\$9' ];
        $mismatchMessages = [];
        foreach ( $this->mMessages[$code]['translated'] as $key => $value ) {
            $missing = false;
            foreach ( $variables as $var ) {
                if ( preg_match( "/$var/sU", $this->mGeneralMessages['translatable'][$key] ) &&
                    !preg_match( "/$var/sU", $value )
                ) {
                    $missing = true;
                }
                if ( !preg_match( "/$var/sU", $this->mGeneralMessages['translatable'][$key] ) &&
                    preg_match( "/$var/sU", $value )
                ) {
                    $missing = true;
                }
            }
            if ( $missing ) {
                $mismatchMessages[$key] = $value;
            }
        }
 
        return $mismatchMessages;
    }
 
    public function getMessagesWithoutPlural( $code ) {
        $this->loadGeneralMessages();
        $this->loadMessages( $code );
        $messagesWithoutPlural = [];
        foreach ( $this->mMessages[$code]['translated'] as $key => $value ) {
            if ( stripos( $this->mGeneralMessages['translatable'][$key], '{{plural:' ) !== false &&
                stripos( $value, '{{plural:' ) === false
            ) {
                $messagesWithoutPlural[$key] = $value;
            }
        }
 
        return $messagesWithoutPlural;
    }
 
    public function getEmptyMessages( $code ) {
        $this->loadGeneralMessages();
        $this->loadMessages( $code );
        $emptyMessages = [];
        foreach ( $this->mMessages[$code]['translated'] as $key => $value ) {
            if ( $value === '' || $value === '-' ) {
                $emptyMessages[$key] = $value;
            }
        }
 
        return $emptyMessages;
    }
 
    public function getMessagesWithWhitespace( $code ) {
        $this->loadGeneralMessages();
        $this->loadMessages( $code );
        $messagesWithWhitespace = [];
        foreach ( $this->mMessages[$code]['translated'] as $key => $value ) {
            if ( $this->mGeneralMessages['translatable'][$key] !== '' && $value !== rtrim( $value ) ) {
                $messagesWithWhitespace[$key] = $value;
            }
        }
 
        return $messagesWithWhitespace;
    }
 
    public function getNonXHTMLMessages( $code ) {
        $this->loadGeneralMessages();
        $this->loadMessages( $code );
        $wrongPhrases = [
            '<hr *\\?>',
            '<br *\\?>',
            '<hr/>',
            '<br/>',
            '<hr>',
            '<br>',
        ];
        $wrongPhrases = '~(' . implode( '|', $wrongPhrases ) . ')~sDu';
        $nonXHTMLMessages = [];
        foreach ( $this->mMessages[$code]['translated'] as $key => $value ) {
            if ( preg_match( $wrongPhrases, $value ) ) {
                $nonXHTMLMessages[$key] = $value;
            }
        }
 
        return $nonXHTMLMessages;
    }
 
    public function getMessagesWithWrongChars( $code ) {
        $this->loadGeneralMessages();
        $this->loadMessages( $code );
        $wrongChars = [
            '[LRM]' => "\u{200E}",
            '[RLM]' => "\u{200F}",
            '[LRE]' => "\u{202A}",
            '[RLE]' => "\u{202B}",
            '[POP]' => "\u{202C}",
            '[LRO]' => "\u{202D}",
            '[RLO]' => "\u{202B}",
            '[ZWSP]' => "\u{200B}",
            '[NBSP]' => "\u{00A0}",
            '[WJ]' => "\u{2060}",
            '[BOM]' => "\u{FEFF}",
            '[FFFD]' => "\u{FFFD}",
        ];
        $wrongRegExp = '/(' . implode( '|', array_values( $wrongChars ) ) . ')/sDu';
        $wrongCharsMessages = [];
        foreach ( $this->mMessages[$code]['translated'] as $key => $value ) {
            if ( preg_match( $wrongRegExp, $value ) ) {
                foreach ( $wrongChars as $viewableChar => $hiddenChar ) {
                    $value = str_replace( $hiddenChar, $viewableChar, $value );
                }
                $wrongCharsMessages[$key] = $value;
            }
        }
 
        return $wrongCharsMessages;
    }
 
    public function getMessagesWithDubiousLinks( $code ) {
        $this->loadGeneralMessages();
        $this->loadMessages( $code );
        $tc = Title::legalChars() . '#%{}';
        $messages = [];
        foreach ( $this->mMessages[$code]['translated'] as $key => $value ) {
            $matches = [];
            preg_match_all( "/\[\[([{$tc}]+)(?:\\|(.+?))?]]/sDu", $value, $matches );
            $numMatches = count( $matches[0] );
            for ( $i = 0; $i < $numMatches; $i++ ) {
                if ( preg_match( "/.*project.*/isDu", $matches[1][$i] ) ) {
                    $messages[$key][] = $matches[0][$i];
                }
            }
 
            if ( isset( $messages[$key] ) ) {
                $messages[$key] = implode( ", ", $messages[$key] );
            }
        }
 
        return $messages;
    }
 
    public function getMessagesWithUnbalanced( $code ) {
        $this->loadGeneralMessages();
        $this->loadMessages( $code );
        $messages = [];
        foreach ( $this->mMessages[$code]['translated'] as $key => $value ) {
            $a = $b = $c = $d = 0;
            foreach ( preg_split( '//', $value ) as $char ) {
                switch ( $char ) {
                    case '[':
                        $a++;
                        break;
                    case ']':
                        $b++;
                        break;
                    case '{':
                        $c++;
                        break;
                    case '}':
                        $d++;
                        break;
                }
            }
 
            if ( $a !== $b || $c !== $d ) {
                $messages[$key] = "$a, $b, $c, $d";
            }
        }
 
        return $messages;
    }
 
    public function getUntranslatedNamespaces( $code ) {
        $this->loadFile( 'en' );
        $this->loadFile( $code );
        $namespacesDiff = array_diff_key( $this->mNamespaceNames['en'], $this->mNamespaceNames[$code] );
        if ( isset( $namespacesDiff[NS_MAIN] ) ) {
            unset( $namespacesDiff[NS_MAIN] );
        }
 
        return $namespacesDiff;
    }
 
    public function getProblematicProjectTalks( $code ) {
        $this->loadFile( $code );
        $namespaces = [];
 
        # Check default namespace name
        if ( isset( $this->mNamespaceNames[$code][NS_PROJECT_TALK] ) ) {
            $default = $this->mNamespaceNames[$code][NS_PROJECT_TALK];
            if ( strpos( $default, '$1' ) === false ) {
                $namespaces[$default] = 'default';
            }
        }
 
        # Check namespace aliases
        foreach ( $this->mNamespaceAliases[$code] as $key => $value ) {
            if ( $value == NS_PROJECT_TALK && strpos( $key, '$1' ) === false ) {
                $namespaces[$key] = '';
            }
        }
 
        return $namespaces;
    }
 
    public function getUntranslatedMagicWords( $code ) {
        $this->loadFile( 'en' );
        $this->loadFile( $code );
        $magicWords = [];
        foreach ( $this->mMagicWords['en'] as $key => $value ) {
            if ( !isset( $this->mMagicWords[$code][$key] ) ) {
                $magicWords[$key] = $value[1];
            }
        }
 
        return $magicWords;
    }
 
    public function getObsoleteMagicWords( $code ) {
        $this->loadFile( 'en' );
        $this->loadFile( $code );
        $magicWords = [];
        foreach ( $this->mMagicWords[$code] as $key => $value ) {
            if ( !isset( $this->mMagicWords['en'][$key] ) ) {
                $magicWords[$key] = $value[1];
            }
        }
 
        return $magicWords;
    }
 
    public function getOverridingMagicWords( $code ) {
        $this->loadFile( 'en' );
        $this->loadFile( $code );
        $magicWords = [];
        foreach ( $this->mMagicWords[$code] as $key => $local ) {
            if ( !isset( $this->mMagicWords['en'][$key] ) ) {
                # Unrecognized magic word
                continue;
            }
            $en = $this->mMagicWords['en'][$key];
            array_shift( $local );
            array_shift( $en );
            foreach ( $en as $word ) {
                if ( !in_array( $word, $local ) ) {
                    $magicWords[$key] = $word;
                    break;
                }
            }
        }
 
        return $magicWords;
    }
 
    public function getCaseMismatchMagicWords( $code ) {
        $this->loadFile( 'en' );
        $this->loadFile( $code );
        $magicWords = [];
        foreach ( $this->mMagicWords[$code] as $key => $local ) {
            if ( !isset( $this->mMagicWords['en'][$key] ) ) {
                # Unrecognized magic word
                continue;
            }
            if ( $local[0] != $this->mMagicWords['en'][$key][0] ) {
                $magicWords[$key] = $local[0];
            }
        }
 
        return $magicWords;
    }
 
    public function getUntraslatedSpecialPages( $code ) {
        $this->loadFile( 'en' );
        $this->loadFile( $code );
        $specialPageAliases = [];
        foreach ( $this->mSpecialPageAliases['en'] as $key => $value ) {
            if ( !isset( $this->mSpecialPageAliases[$code][$key] ) ) {
                $specialPageAliases[$key] = $value[0];
            }
        }
 
        return $specialPageAliases;
    }
 
    public function getObsoleteSpecialPages( $code ) {
        $this->loadFile( 'en' );
        $this->loadFile( $code );
        $specialPageAliases = [];
        foreach ( $this->mSpecialPageAliases[$code] as $key => $value ) {
            if ( !isset( $this->mSpecialPageAliases['en'][$key] ) ) {
                $specialPageAliases[$key] = $value[0];
            }
        }
 
        return $specialPageAliases;
    }
}
 
class ExtensionLanguages extends Languages {
    private $mMessageGroup;
 
    function __construct( MessageGroup $group ) {
        $this->mMessageGroup = $group;
 
        $this->mIgnoredMessages = $this->mMessageGroup->getIgnored();
        $this->mOptionalMessages = $this->mMessageGroup->getOptional();
    }
 
    public function name() {
        return $this->mMessageGroup->getLabel();
    }
 
    protected function loadFile( $code ) {
        if ( !isset( $this->mRawMessages[$code] ) ) {
            $this->mRawMessages[$code] = $this->mMessageGroup->load( $code );
            if ( empty( $this->mRawMessages[$code] ) ) {
                $this->mRawMessages[$code] = [];
            }
        }
    }
}