languages.inc

Go to the documentation of this file.

<?php
class languages {
    protected $mLanguages; # List of languages

    protected $mRawMessages; # Raw list of the messages in each language
    protected $mMessages; # Messages in each language (except for English), divided to groups
    protected $mFallback; # Fallback language in each language
    protected $mGeneralMessages; # General messages in English, divided to groups
    protected $mIgnoredMessages; # All the messages which should be exist only in the English file
    protected $mOptionalMessages; # All the messages which may be translated or not, depending on the language

    protected $mNamespaceNames; # Namespace names
    protected $mNamespaceAliases; # Namespace aliases
    protected $mMagicWords; # Magic words
    protected $mSpecialPageAliases; # Special page aliases

    function __construct( $exif = true ) {
        require __DIR__ . '/messageTypes.inc';
        $this->mIgnoredMessages = $wgIgnoredMessages;
        if ( $exif ) {
            $this->mOptionalMessages = array_merge( $wgOptionalMessages );
        } else {
            $this->mOptionalMessages = array_merge( $wgOptionalMessages, $wgEXIFMessages );
        }

        $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] = array();
        $this->mFallback[$code] = '';
        $this->mNamespaceNames[$code] = array();
        $this->mNamespaceAliases[$code] = array();
        $this->mMagicWords[$code] = array();
        $this->mSpecialPageAliases[$code] = array();
        $filename = Language::getMessagesFileName( $code );
        if ( file_exists( $filename ) ) {
            require $filename;
            if ( isset( $messages ) ) {
                $this->mRawMessages[$code] = $messages;
            }
            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'] = array();
        $this->mMessages[$code]['optional'] = array();
        $this->mMessages[$code]['obsolete'] = array();
        $this->mMessages[$code]['translated'] = array();
        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'] = array();
        $this->mGeneralMessages['optional'] = array();
        $this->mGeneralMessages['ignored'] = array();
        $this->mGeneralMessages['translatable'] = array();
        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 = array();
        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 = array( '\$1', '\$2', '\$3', '\$4', '\$5', '\$6', '\$7', '\$8', '\$9' );
        $mismatchMessages = array();
        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 = array();
        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 = array();
        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 = array();
        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 = array(
            '<hr *\\?>',
            '<br *\\?>',
            '<hr/>',
            '<br/>',
            '<hr>',
            '<br>',
        );
        $wrongPhrases = '~(' . implode( '|', $wrongPhrases ) . ')~sDu';
        $nonXHTMLMessages = array();
        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 = array(
            '[LRM]' => "\xE2\x80\x8E",
            '[RLM]' => "\xE2\x80\x8F",
            '[LRE]' => "\xE2\x80\xAA",
            '[RLE]' => "\xE2\x80\xAB",
            '[POP]' => "\xE2\x80\xAC",
            '[LRO]' => "\xE2\x80\xAD",
            '[RLO]' => "\xE2\x80\xAB",
            '[ZWSP]' => "\xE2\x80\x8B",
            '[NBSP]' => "\xC2\xA0",
            '[WJ]' => "\xE2\x81\xA0",
            '[BOM]' => "\xEF\xBB\xBF",
            '[FFFD]' => "\xEF\xBF\xBD",
        );
        $wrongRegExp = '/(' . implode( '|', array_values( $wrongChars ) ) . ')/sDu';
        $wrongCharsMessages = array();
        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 = array();
        foreach ( $this->mMessages[$code]['translated'] as $key => $value ) {
            $matches = array();
            preg_match_all( "/\[\[([{$tc}]+)(?:\\|(.+?))?]]/sDu", $value, $matches );
            for ( $i = 0; $i < count( $matches[0] ); $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 = array();
        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 = array();

        # 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 = array();
        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 = array();
        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 = array();
        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 = array();
        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 = array();
        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 = array();
        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] = array();
            }
        }
    }
}