maintenance/language/checkLanguage.inc

   1 <?php
   2 /**
   3  * Helper class for checkLanguage.php script.
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along
  16  * with this program; if not, write to the Free Software Foundation, Inc.,
  17  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  18  * http://www.gnu.org/copyleft/gpl.html
  19  *
  20  * @file
  21  * @ingroup MaintenanceLanguage
  22  */
  23
  24 /**
  25  * @ingroup MaintenanceLanguage
  26  */
  27 class CheckLanguageCLI {
  28         protected $code  = null;
  29         protected $level = 2;
  30         protected $doLinks = false;
  31         protected $linksPrefix = '';
  32         protected $wikiCode = 'en';
  33         protected $checkAll = false;
  34         protected $output = 'plain';
  35         protected $checks = array();
  36         protected $L = null;
  37
  38         protected $results = array();
  39
  40         private $includeExif = false;
  41
  42         /**
  43          * Constructor.
  44          * @param $options Options for script.
  45          */
  46         public function __construct( Array $options ) {
  47                 if ( isset( $options['help'] ) ) {
  48                         echo $this->help();
  49                         exit(1);
  50                 }
  51
  52                 if ( isset( $options['lang'] ) ) {
  53                         $this->code = $options['lang'];
  54                 } else {
  55                         global $wgLanguageCode;
  56                         $this->code = $wgLanguageCode;
  57                 }
  58
  59                 if ( isset( $options['level'] ) ) {
  60                         $this->level = $options['level'];
  61                 }
  62
  63                 $this->doLinks = isset( $options['links'] );
  64                 $this->includeExif = !isset( $options['noexif'] );
  65                 $this->checkAll = isset( $options['all'] );
  66
  67                 if ( isset( $options['prefix'] ) ) {
  68                         $this->linksPrefix = $options['prefix'];
  69                 }
  70
  71                 if ( isset( $options['wikilang'] ) ) {
  72                         $this->wikiCode = $options['wikilang'];
  73                 }
  74
  75                 if ( isset( $options['whitelist'] ) ) {
  76                         $this->checks = explode( ',', $options['whitelist'] );
  77                 } elseif ( isset( $options['blacklist'] ) ) {
  78                         $this->checks = array_diff(
  79                                 isset( $options['easy'] ) ? $this->easyChecks() : $this->defaultChecks(),
  80                                 explode( ',', $options['blacklist'] )
  81                         );
  82                 } elseif ( isset( $options['easy'] ) ) {
  83                         $this->checks = $this->easyChecks();
  84                 } else {
  85                         $this->checks = $this->defaultChecks();
  86                 }
  87
  88                 if ( isset( $options['output'] ) ) {
  89                         $this->output = $options['output'];
  90                 }
  91
  92                 $this->L = new languages( $this->includeExif );
  93         }
  94
  95         /**
  96          * Get the default checks.
  97          * @return A list of the default checks.
  98          */
  99         protected function defaultChecks() {
 100                 return array(
 101                         'untranslated', 'duplicate', 'obsolete', 'variables', 'empty', 'plural',
 102                         'whitespace', 'xhtml', 'chars', 'links', 'unbalanced', 'namespace',
 103                         'projecttalk', 'magic', 'magic-old', 'magic-over', 'magic-case',
 104                         'special', 'special-old',
 105                 );
 106         }
 107
 108         /**
 109          * Get the checks which check other things than messages.
 110          * @return A list of the non-message checks.
 111          */
 112         protected function nonMessageChecks() {
 113                 return array(
 114                         'namespace', 'projecttalk', 'magic', 'magic-old', 'magic-over',
 115                         'magic-case', 'special', 'special-old',
 116                 );
 117         }
 118
 119         /**
 120          * Get the checks that can easily be treated by non-speakers of the language.
 121          * @return Array A list of the easy checks.
 122          */
 123         protected function easyChecks() {
 124                 return array(
 125                         'duplicate', 'obsolete', 'empty', 'whitespace', 'xhtml', 'chars', 'magic-old',
 126                         'magic-over', 'magic-case', 'special-old',
 127                 );
 128         }
 129
 130         /**
 131          * Get all checks.
 132          * @return An array of all check names mapped to their function names.
 133          */
 134         protected function getChecks() {
 135                 return array(
 136                         'untranslated' => 'getUntranslatedMessages',
 137                         'duplicate'    => 'getDuplicateMessages',
 138                         'obsolete'     => 'getObsoleteMessages',
 139                         'variables'    => 'getMessagesWithMismatchVariables',
 140                         'plural'       => 'getMessagesWithoutPlural',
 141                         'empty'        => 'getEmptyMessages',
 142                         'whitespace'   => 'getMessagesWithWhitespace',
 143                         'xhtml'        => 'getNonXHTMLMessages',
 144                         'chars'        => 'getMessagesWithWrongChars',
 145                         'links'        => 'getMessagesWithDubiousLinks',
 146                         'unbalanced'   => 'getMessagesWithUnbalanced',
 147                         'namespace'    => 'getUntranslatedNamespaces',
 148                         'projecttalk'  => 'getProblematicProjectTalks',
 149                         'magic'        => 'getUntranslatedMagicWords',
 150                         'magic-old'    => 'getObsoleteMagicWords',
 151                         'magic-over'   => 'getOverridingMagicWords',
 152                         'magic-case'   => 'getCaseMismatchMagicWords',
 153                         'special'      => 'getUntraslatedSpecialPages',
 154                         'special-old'  => 'getObsoleteSpecialPages',
 155                 );
 156         }
 157
 158         /**
 159          * Get total count for each check non-messages check.
 160          * @return An array of all check names mapped to a two-element array:
 161          * function name to get the total count and language code or null
 162          * for checked code.
 163          */
 164         protected function getTotalCount() {
 165                 return array(
 166                         'namespace'    => array( 'getNamespaceNames', 'en' ),
 167                         'projecttalk'  => null,
 168                         'magic'        => array( 'getMagicWords', 'en' ),
 169                         'magic-old'    => array( 'getMagicWords', null ),
 170                         'magic-over'   => array( 'getMagicWords', null ),
 171                         'magic-case'   => array( 'getMagicWords', null ),
 172                         'special'      => array( 'getSpecialPageAliases', 'en' ),
 173                         'special-old'  => array( 'getSpecialPageAliases', null ),
 174                 );
 175         }
 176
 177         /**
 178          * Get all check descriptions.
 179          * @return An array of all check names mapped to their descriptions.
 180          */
 181         protected function getDescriptions() {
 182                 return array(
 183                         'untranslated' => '$1 message(s) of $2 are not translated to $3, but exist in en:',
 184                         'duplicate'    => '$1 message(s) of $2 are translated the same in en and $3:',
 185                         'obsolete'     => '$1 message(s) of $2 do not exist in en or are in the ignore list, but exist in $3:',
 186                         'variables'    => '$1 message(s) of $2 in $3 don\'t match the variables used in en:',
 187                         'plural'       => '$1 message(s) of $2 in $3 don\'t use {{plural}} while en uses:',
 188                         'empty'        => '$1 message(s) of $2 in $3 are empty or -:',
 189                         'whitespace'   => '$1 message(s) of $2 in $3 have trailing whitespace:',
 190                         'xhtml'        => '$1 message(s) of $2 in $3 contain illegal XHTML:',
 191                         'chars'        => '$1 message(s) of $2 in $3 include hidden chars which should not be used in the messages:',
 192                         'links'        => '$1 message(s) of $2 in $3 have problematic link(s):',
 193                         'unbalanced'   => '$1 message(s) of $2 in $3 have unbalanced {[]}:',
 194                         'namespace'    => '$1 namespace name(s) of $2 are not translated to $3, but exist in en:',
 195                         'projecttalk'  => '$1 namespace name(s) and alias(es) in $3 are project talk namespaces without the parameter:',
 196                         'magic'        => '$1 magic word(s) of $2 are not translated to $3, but exist in en:',
 197                         'magic-old'    => '$1 magic word(s) of $2 do not exist in en, but exist in $3:',
 198                         'magic-over'   => '$1 magic word(s) of $2 in $3 do not contain the original en word(s):',
 199                         'magic-case'   => '$1 magic word(s) of $2 in $3 change the case-sensitivity of the original en word:',
 200                         'special'      => '$1 special page alias(es) of $2 are not translated to $3, but exist in en:',
 201                         'special-old'  => '$1 special page alias(es) of $2 do not exist in en, but exist in $3:',
 202                 );
 203         }
 204
 205         /**
 206          * Get help.
 207          * @return The help string.
 208          */
 209         protected function help() {
 210                 return <<<ENDS
 211 Run this script to check a specific language file, or all of them.
 212 Command line settings are in form --parameter[=value].
 213 Parameters:
 214         --help: Show this help.
 215         --lang: Language code (default: the installation default language).
 216         --all: Check all customized languages.
 217         --level: Show the following display level (default: 2):
 218                 * 0: Skip the checks (useful for checking syntax).
 219                 * 1: Show only the stub headers and number of wrong messages, without list of messages.
 220                 * 2: Show only the headers and the message keys, without the message values.
 221                 * 3: Show both the headers and the complete messages, with both keys and values.
 222         --links: Link the message values (default off).
 223         --prefix: prefix to add to links.
 224         --wikilang: For the links, what is the content language of the wiki to display the output in (default en).
 225         --noexif: Don't check for EXIF messages (a bit hard and boring to translate), if you know
 226                 that they are currently not translated and want to focus on other problems (default off).
 227         --whitelist: Do only the following checks (form: code,code).
 228         --blacklist: Don't do the following checks (form: code,code).
 229         --easy: Do only the easy checks, which can be treated by non-speakers of the language.
 230
 231 Check codes (ideally, all of them should result 0; all the checks are executed by default (except language-specific check blacklists in checkLanguage.inc):
 232         * untranslated: Messages which are required to translate, but are not translated.
 233         * duplicate: Messages which translation equal to fallback
 234         * obsolete: Messages which are untranslatable or do not exist, but are translated.
 235         * variables: Messages without variables which should be used, or with variables which shouldn't be used.
 236         * empty: Empty messages and messages that contain only -.
 237         * whitespace: Messages which have trailing whitespace.
 238         * xhtml: Messages which are not well-formed XHTML (checks only few common errors).
 239         * chars: Messages with hidden characters.
 240         * links: Messages which contains broken links to pages (does not find all).
 241         * unbalanced: Messages which contains unequal numbers of opening {[ and closing ]}.
 242         * namespace: Namespace names that were not translated.
 243         * projecttalk: Namespace names and aliases where the project talk does not contain $1.
 244         * magic: Magic words that were not translated.
 245         * magic-old: Magic words which do not exist.
 246         * magic-over: Magic words that override the original English word.
 247         * magic-case: Magic words whose translation changes the case-sensitivity of the original English word.
 248         * special: Special page names that were not translated.
 249         * special-old: Special page names which do not exist.
 250
 251 ENDS;
 252         }
 253
 254         /**
 255          * Execute the script.
 256          */
 257         public function execute() {
 258                 $this->doChecks();
 259                 if ( $this->level > 0 ) {
 260                         switch ( $this->output ) {
 261                                 case 'plain':
 262                                         $this->outputText();
 263                                         break;
 264                                 case 'wiki':
 265                                         $this->outputWiki();
 266                                         break;
 267                                 default:
 268                                         throw new MWException( "Invalid output type $this->output" );
 269                         }
 270                 }
 271         }
 272
 273         /**
 274          * Execute the checks.
 275          */
 276         protected function doChecks() {
 277                 $ignoredCodes = array( 'en', 'enRTL' );
 278
 279                 $this->results = array();
 280                 # Check the language
 281                 if ( $this->checkAll ) {
 282                         foreach ( $this->L->getLanguages() as $language ) {
 283                                 if ( !in_array( $language, $ignoredCodes ) ) {
 284                                         $this->results[$language] = $this->checkLanguage( $language );
 285                                 }
 286                         }
 287                 } else {
 288                         if ( in_array( $this->code, $ignoredCodes ) ) {
 289                                 throw new MWException( "Cannot check code $this->code." );
 290                         } else {
 291                                 $this->results[$this->code] = $this->checkLanguage( $this->code );
 292                         }
 293                 }
 294         }
 295
 296         /**
 297          * Get the check blacklist.
 298          * @return The list of checks which should not be executed.
 299          */
 300         protected function getCheckBlacklist() {
 301                 global $checkBlacklist;
 302                 return $checkBlacklist;
 303         }
 304
 305         /**
 306          * Check a language.
 307          * @param $code The language code.
 308          * @return The results.
 309          */
 310         protected function checkLanguage( $code ) {
 311                 # Syntax check only
 312                 if ( $this->level === 0 ) {
 313                         $this->L->getMessages( $code );
 314                         return;
 315                 }
 316
 317                 $results = array();
 318                 $checkFunctions = $this->getChecks();
 319                 $checkBlacklist = $this->getCheckBlacklist();
 320                 foreach ( $this->checks as $check ) {
 321                         if ( isset( $checkBlacklist[$code] ) &&
 322                                 in_array( $check, $checkBlacklist[$code] ) ) {
 323                                 $results[$check] = array();
 324                                 continue;
 325                         }
 326
 327                         $callback = array( $this->L, $checkFunctions[$check] );
 328                         if ( !is_callable( $callback ) ) {
 329                                 throw new MWException( "Unkown check $check." );
 330                         }
 331                         $results[$check] = call_user_func( $callback, $code );
 332                 }
 333
 334                 return $results;
 335         }
 336
 337         /**
 338          * Format a message key.
 339          * @param $key The message key.
 340          * @param $code The language code.
 341          * @return The formatted message key.
 342          */
 343         protected function formatKey( $key, $code ) {
 344                 if ( $this->doLinks ) {
 345                         $displayKey = ucfirst( $key );
 346                         if ( $code == $this->wikiCode ) {
 347                                 return "[[{$this->linksPrefix}MediaWiki:$displayKey|$key]]";
 348                         } else {
 349                                 return "[[{$this->linksPrefix}MediaWiki:$displayKey/$code|$key]]";
 350                         }
 351                 } else {
 352                         return $key;
 353                 }
 354         }
 355
 356         /**
 357          * Output the checks results as plain text.
 358          * @return The checks results as plain text.
 359          */
 360         protected function outputText() {
 361                 foreach ( $this->results as $code => $results ) {
 362                         $translated = $this->L->getMessages( $code );
 363                         $translated = count( $translated['translated'] );
 364                         foreach ( $results as $check => $messages ) {
 365                                 $count = count( $messages );
 366                                 if ( $count ) {
 367                                         if ( $check == 'untranslated' ) {
 368                                                 $translatable = $this->L->getGeneralMessages();
 369                                                 $total = count( $translatable['translatable'] );
 370                                         } elseif ( in_array( $check, $this->nonMessageChecks() ) ) {
 371                                                 $totalCount = $this->getTotalCount();
 372                                                 $totalCount = $totalCount[$check];
 373                                                 $callback = array( $this->L, $totalCount[0] );
 374                                                 $callCode = $totalCount[1] ? $totalCount[1] : $code;
 375                                                 $total = count( call_user_func( $callback, $callCode ) );
 376                                         } else {
 377                                                 $total = $translated;
 378                                         }
 379                                         $search = array( '$1', '$2', '$3' );
 380                                         $replace = array( $count, $total, $code );
 381                                         $descriptions = $this->getDescriptions();
 382                                         echo "\n" . str_replace( $search, $replace, $descriptions[$check] ) . "\n";
 383                                         if ( $this->level == 1 ) {
 384                                                 echo "[messages are hidden]\n";
 385                                         } else {
 386                                                 foreach ( $messages as $key => $value ) {
 387                                                         if( !in_array( $check, $this->nonMessageChecks() ) ) {
 388                                                                 $key = $this->formatKey( $key, $code );
 389                                                         }
 390                                                         if ( $this->level == 2 || empty( $value ) ) {
 391                                                                 echo "* $key\n";
 392                                                         } else {
 393                                                                 echo "* $key:           '$value'\n";
 394                                                         }
 395                                                 }
 396                                         }
 397                                 }
 398                         }
 399                 }
 400         }
 401
 402         /**
 403          * Output the checks results as wiki text.
 404          * @return The checks results as wiki text.
 405          */
 406         function outputWiki() {
 407                 global $wgContLang;
 408                 $detailText = '';
 409                 $rows[] = '! Language !! Code !! Total !! ' . implode( ' !! ', array_diff( $this->checks, $this->nonMessageChecks() ) );
 410                 foreach ( $this->results as $code => $results ) {
 411                         $detailTextForLang = "==$code==\n";
 412                         $numbers = array();
 413                         $problems = 0;
 414                         $detailTextForLangChecks = array();
 415                         foreach ( $results as $check => $messages ) {
 416                                 if( in_array( $check, $this->nonMessageChecks() ) ) {
 417                                         continue;
 418                                 }
 419                                 $count = count( $messages );
 420                                 if ( $count ) {
 421                                         $problems += $count;
 422                                         $messageDetails = array();
 423                                         foreach ( $messages as $key => $details ) {
 424                                                 $displayKey = $this->formatKey( $key, $code );
 425                                                 $messageDetails[] = $displayKey;
 426                                         }
 427                                         $detailTextForLangChecks[] = "=== $code-$check ===\n* " . implode( ', ', $messageDetails );
 428                                         $numbers[] = "'''[[#$code-$check|$count]]'''";
 429                                 } else {
 430                                         $numbers[] = $count;
 431                                 }
 432
 433                         }
 434
 435                         if ( count( $detailTextForLangChecks ) ) {
 436                                 $detailText .= $detailTextForLang . implode( "\n", $detailTextForLangChecks ) . "\n";
 437                         }
 438
 439                         if ( !$problems ) {
 440                                 # Don't list languages without problems
 441                                 continue;
 442                         }
 443                         $language = $wgContLang->getLanguageName( $code );
 444                         $rows[] = "| $language || $code || $problems || " . implode( ' || ', $numbers );
 445                 }
 446
 447                 $tableRows = implode( "\n|-\n", $rows );
 448
 449                 $version = SpecialVersion::getVersion( 'nodb' );
 450                 echo <<<EOL
 451 '''Check results are for:''' <code>$version</code>
 452
 453
 454 {| class="sortable wikitable" border="2" cellpadding="4" cellspacing="0" style="background-color: #F9F9F9; border: 1px #AAAAAA solid; border-collapse: collapse; clear: both;"
 455 $tableRows
 456 |}
 457
 458 $detailText
 459
 460 EOL;
 461         }
 462
 463         /**
 464          * Check if there are any results for the checks, in any language.
 465          * @return True if there are any results, false if not.
 466          */
 467         protected function isEmpty() {
 468                 foreach( $this->results as $results ) {
 469                         foreach( $results as $messages ) {
 470                                 if( !empty( $messages ) ) {
 471                                         return false;
 472                                 }
 473                         }
 474                 }
 475                 return true;
 476         }
 477 }
 478
 479 /**
 480  * @ingroup MaintenanceLanguage
 481  */
 482 class CheckExtensionsCLI extends CheckLanguageCLI {
 483         private $extensions;
 484
 485         /**
 486          * Constructor.
 487          * @param $options Options for script.
 488          * @param $extension The extension name (or names).
 489          */
 490         public function __construct( Array $options, $extension ) {
 491                 if ( isset( $options['help'] ) ) {
 492                         echo $this->help();
 493                         exit(1);
 494                 }
 495
 496                 if ( isset( $options['lang'] ) ) {
 497                         $this->code = $options['lang'];
 498                 } else {
 499                         global $wgLanguageCode;
 500                         $this->code = $wgLanguageCode;
 501                 }
 502
 503                 if ( isset( $options['level'] ) ) {
 504                         $this->level = $options['level'];
 505                 }
 506
 507                 $this->doLinks = isset( $options['links'] );
 508
 509                 if ( isset( $options['wikilang'] ) ) {
 510                         $this->wikiCode = $options['wikilang'];
 511                 }
 512
 513                 if ( isset( $options['whitelist'] ) ) {
 514                         $this->checks = explode( ',', $options['whitelist'] );
 515                 } elseif ( isset( $options['blacklist'] ) ) {
 516                         $this->checks = array_diff(
 517                                 isset( $options['easy'] ) ? $this->easyChecks() : $this->defaultChecks(),
 518                                 explode( ',', $options['blacklist'] )
 519                         );
 520                 } elseif ( isset( $options['easy'] ) ) {
 521                         $this->checks = $this->easyChecks();
 522                 } else {
 523                         $this->checks = $this->defaultChecks();
 524                 }
 525
 526                 if ( isset( $options['output'] ) ) {
 527                         $this->output = $options['output'];
 528                 }
 529
 530                 # Some additional checks not enabled by default
 531                 if ( isset( $options['duplicate'] ) ) {
 532                         $this->checks[] = 'duplicate';
 533                 }
 534
 535                 $this->extensions = array();
 536                 $extensions = new PremadeMediawikiExtensionGroups();
 537                 $extensions->addAll();
 538                 if ( $extension == 'all' ) {
 539                         foreach ( MessageGroups::singleton()->getGroups() as $group ) {
 540                                 if ( strpos( $group->getId(), 'ext-' ) === 0 && !$group->isMeta() ) {
 541                                         $this->extensions[] = new extensionLanguages( $group );
 542                                 }
 543                         }
 544                 } elseif ( $extension == 'wikimedia' ) {
 545                         $wikimedia = MessageGroups::getGroup( 'ext-0-wikimedia' );
 546                         foreach ( $wikimedia->wmfextensions() as $extension ) {
 547                                 $group = MessageGroups::getGroup( $extension );
 548                                 $this->extensions[] = new extensionLanguages( $group );
 549                         }
 550                 } elseif ( $extension == 'flaggedrevs' ) {
 551                         foreach ( MessageGroups::singleton()->getGroups() as $group ) {
 552                                 if ( strpos( $group->getId(), 'ext-flaggedrevs-' ) === 0 && !$group->isMeta() ) {
 553                                         $this->extensions[] = new extensionLanguages( $group );
 554                                 }
 555                         }
 556                 } else {
 557                         $extensions = explode( ',', $extension );
 558                         foreach ( $extensions as $extension ) {
 559                                 $group = MessageGroups::getGroup( 'ext-' . $extension );
 560                                 if ( $group ) {
 561                                         $extension = new extensionLanguages( $group );
 562                                         $this->extensions[] = $extension;
 563                                 } else {
 564                                         print "No such extension $extension.\n";
 565                                 }
 566                         }
 567                 }
 568         }
 569
 570         /**
 571          * Get the default checks.
 572          * @return A list of the default checks.
 573          */
 574         protected function defaultChecks() {
 575                 return array(
 576                         'untranslated', 'duplicate', 'obsolete', 'variables', 'empty', 'plural',
 577                         'whitespace', 'xhtml', 'chars', 'links', 'unbalanced',
 578                 );
 579         }
 580
 581         /**
 582          * Get the checks which check other things than messages.
 583          * @return A list of the non-message checks.
 584          */
 585         protected function nonMessageChecks() {
 586                 return array();
 587         }
 588
 589         /**
 590          * Get the checks that can easily be treated by non-speakers of the language.
 591          * @return A list of the easy checks.
 592          */
 593         protected function easyChecks() {
 594                 return array(
 595                         'duplicate', 'obsolete', 'empty', 'whitespace', 'xhtml', 'chars',
 596                 );
 597         }
 598
 599         /**
 600          * Get help.
 601          * @return The help string.
 602          */
 603         protected function help() {
 604                 return <<<ENDS
 605 Run this script to check the status of a specific language in extensions, or all of them.
 606 Command line settings are in form --parameter[=value], except for the first one.
 607 Parameters:
 608         * First parameter (mandatory): Extension name, multiple extension names (separated by commas), "all" for all the extensions, "wikimedia" for extensions used by Wikimedia or "flaggedrevs" for all FLaggedRevs extension messages.
 609         * lang: Language code (default: the installation default language).
 610         * help: Show this help.
 611         * level: Show the following display level (default: 2).
 612         * links: Link the message values (default off).
 613         * wikilang: For the links, what is the content language of the wiki to display the output in (default en).
 614         * whitelist: Do only the following checks (form: code,code).
 615         * blacklist: Do not perform the following checks (form: code,code).
 616         * easy: Do only the easy checks, which can be treated by non-speakers of the language.
 617 Check codes (ideally, all of them should result 0; all the checks are executed by default (except language-specific check blacklists in checkLanguage.inc):
 618         * untranslated: Messages which are required to translate, but are not translated.
 619         * duplicate: Messages which translation equal to fallback
 620         * obsolete: Messages which are untranslatable, but translated.
 621         * variables: Messages without variables which should be used, or with variables which should not be used.
 622         * empty: Empty messages.
 623         * whitespace: Messages which have trailing whitespace.
 624         * xhtml: Messages which are not well-formed XHTML (checks only few common errors).
 625         * chars: Messages with hidden characters.
 626         * links: Messages which contains broken links to pages (does not find all).
 627         * unbalanced: Messages which contains unequal numbers of opening {[ and closing ]}.
 628 Display levels (default: 2):
 629         * 0: Skip the checks (useful for checking syntax).
 630         * 1: Show only the stub headers and number of wrong messages, without list of messages.
 631         * 2: Show only the headers and the message keys, without the message values.
 632         * 3: Show both the headers and the complete messages, with both keys and values.
 633
 634 ENDS;
 635         }
 636
 637         /**
 638          * Execute the script.
 639          */
 640         public function execute() {
 641                 $this->doChecks();
 642         }
 643
 644         /**
 645          * Check a language and show the results.
 646          * @param $code The language code.
 647          */
 648         protected function checkLanguage( $code ) {
 649                 foreach( $this->extensions as $extension ) {
 650                         $this->L = $extension;
 651                         $this->results = array();
 652                         $this->results[$code] = parent::checkLanguage( $code );
 653
 654                         if( !$this->isEmpty() ) {
 655                                 echo $extension->name() . ":\n";
 656
 657                                 if( $this->level > 0 ) {
 658                                         switch( $this->output ) {
 659                                                 case 'plain':
 660                                                         $this->outputText();
 661                                                         break;
 662                                                 case 'wiki':
 663                                                         $this->outputWiki();
 664                                                         break;
 665                                                 default:
 666                                                         throw new MWException( "Invalid output type $this->output" );
 667                                         }
 668                                 }
 669
 670                                 echo "\n";
 671                         }
 672                 }
 673         }
 674 }
 675
 676 # Blacklist some checks for some languages
 677 $checkBlacklist = array(
 678 #'code'        => array( 'check1', 'check2' ... )
 679 'az'           => array( 'plural' ),
 680 'bo'           => array( 'plural' ),
 681 'dz'           => array( 'plural' ),
 682 'id'           => array( 'plural' ),
 683 'fa'           => array( 'plural' ),
 684 'gan'          => array( 'plural' ),
 685 'gan-hans'     => array( 'plural' ),
 686 'gan-hant'     => array( 'plural' ),
 687 'gn'           => array( 'plural' ),
 688 'hak'          => array( 'plural' ),
 689 'hu'           => array( 'plural' ),
 690 'ja'           => array( 'plural' ), // Does not use plural
 691 'jv'           => array( 'plural' ),
 692 'ka'           => array( 'plural' ),
 693 'kk-arab'      => array( 'plural' ),
 694 'kk-cyrl'      => array( 'plural' ),
 695 'kk-latn'      => array( 'plural' ),
 696 'km'           => array( 'plural' ),
 697 'kn'           => array( 'plural' ),
 698 'ko'           => array( 'plural' ),
 699 'lzh'          => array( 'plural' ),
 700 'mn'           => array( 'plural' ),
 701 'ms'           => array( 'plural' ),
 702 'my'           => array( 'plural', 'chars' ),  // Uses a lot zwnj
 703 'sah'          => array( 'plural' ),
 704 'sq'           => array( 'plural' ),
 705 'tet'          => array( 'plural' ),
 706 'th'           => array( 'plural' ),
 707 'to'           => array( 'plural' ),
 708 'tr'           => array( 'plural' ),
 709 'vi'           => array( 'plural' ),
 710 'wuu'          => array( 'plural' ),
 711 'xmf'          => array( 'plural' ),
 712 'yo'           => array( 'plural' ),
 713 'yue'          => array( 'plural' ),
 714 'zh'           => array( 'plural' ),
 715 'zh-classical' => array( 'plural' ),
 716 'zh-cn'        => array( 'plural' ),
 717 'zh-hans'      => array( 'plural' ),
 718 'zh-hant'      => array( 'plural' ),
 719 'zh-hk'        => array( 'plural' ),
 720 'zh-sg'        => array( 'plural' ),
 721 'zh-tw'        => array( 'plural' ),
 722 'zh-yue'       => array( 'plural' ),
 723 );