includes/api/ApiParamInfo.php

   1 <?php
   2 /**
   3  * Copyright © 2008 Roan Kattouw "<Firstname>.<Lastname>@gmail.com"
   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  */
  22
  23 /**
  24  * @ingroup API
  25  */
  26 class ApiParamInfo extends ApiBase {
  27
  28         private $helpFormat;
  29         private $context;
  30
  31         public function __construct( ApiMain $main, $action ) {
  32                 parent::__construct( $main, $action );
  33         }
  34
  35         public function execute() {
  36                 // Get parameters
  37                 $params = $this->extractRequestParams();
  38
  39                 $this->helpFormat = $params['helpformat'];
  40                 $this->context = new RequestContext;
  41                 $this->context->setUser( new User ); // anon to avoid caching issues
  42                 $this->context->setLanguage( $this->getMain()->getLanguage() );
  43
  44                 if ( is_array( $params['modules'] ) ) {
  45                         $modules = [];
  46                         foreach ( $params['modules'] as $path ) {
  47                                 if ( $path === '*' || $path === '**' ) {
  48                                         $path = "main+$path";
  49                                 }
  50                                 if ( substr( $path, -2 ) === '+*' || substr( $path, -2 ) === ' *' ) {
  51                                         $submodules = true;
  52                                         $path = substr( $path, 0, -2 );
  53                                         $recursive = false;
  54                                 } elseif ( substr( $path, -3 ) === '+**' || substr( $path, -3 ) === ' **' ) {
  55                                         $submodules = true;
  56                                         $path = substr( $path, 0, -3 );
  57                                         $recursive = true;
  58                                 } else {
  59                                         $submodules = false;
  60                                 }
  61
  62                                 if ( $submodules ) {
  63                                         try {
  64                                                 $module = $this->getModuleFromPath( $path );
  65                                         } catch ( ApiUsageException $ex ) {
  66                                                 foreach ( $ex->getStatusValue()->getErrors() as $error ) {
  67                                                         $this->addWarning( $error );
  68                                                 }
  69                                                 continue;
  70                                         }
  71                                         $submodules = $this->listAllSubmodules( $module, $recursive );
  72                                         if ( $submodules ) {
  73                                                 $modules = array_merge( $modules, $submodules );
  74                                         } else {
  75                                                 $this->addWarning( [ 'apierror-badmodule-nosubmodules', $path ], 'badmodule' );
  76                                         }
  77                                 } else {
  78                                         $modules[] = $path;
  79                                 }
  80                         }
  81                 } else {
  82                         $modules = [];
  83                 }
  84
  85                 if ( is_array( $params['querymodules'] ) ) {
  86                         $queryModules = $params['querymodules'];
  87                         foreach ( $queryModules as $m ) {
  88                                 $modules[] = 'query+' . $m;
  89                         }
  90                 } else {
  91                         $queryModules = [];
  92                 }
  93
  94                 if ( is_array( $params['formatmodules'] ) ) {
  95                         $formatModules = $params['formatmodules'];
  96                         foreach ( $formatModules as $m ) {
  97                                 $modules[] = $m;
  98                         }
  99                 } else {
 100                         $formatModules = [];
 101                 }
 102
 103                 $modules = array_unique( $modules );
 104
 105                 $res = [];
 106
 107                 foreach ( $modules as $m ) {
 108                         try {
 109                                 $module = $this->getModuleFromPath( $m );
 110                         } catch ( ApiUsageException $ex ) {
 111                                 foreach ( $ex->getStatusValue()->getErrors() as $error ) {
 112                                         $this->addWarning( $error );
 113                                 }
 114                                 continue;
 115                         }
 116                         $key = 'modules';
 117
 118                         // Back compat
 119                         $isBCQuery = false;
 120                         if ( $module->getParent() && $module->getParent()->getModuleName() == 'query' &&
 121                                 in_array( $module->getModuleName(), $queryModules )
 122                         ) {
 123                                 $isBCQuery = true;
 124                                 $key = 'querymodules';
 125                         }
 126                         if ( in_array( $module->getModuleName(), $formatModules ) ) {
 127                                 $key = 'formatmodules';
 128                         }
 129
 130                         $item = $this->getModuleInfo( $module );
 131                         if ( $isBCQuery ) {
 132                                 $item['querytype'] = $item['group'];
 133                         }
 134                         $res[$key][] = $item;
 135                 }
 136
 137                 $result = $this->getResult();
 138                 $result->addValue( [ $this->getModuleName() ], 'helpformat', $this->helpFormat );
 139
 140                 foreach ( $res as $key => $stuff ) {
 141                         ApiResult::setIndexedTagName( $res[$key], 'module' );
 142                 }
 143
 144                 if ( $params['mainmodule'] ) {
 145                         $res['mainmodule'] = $this->getModuleInfo( $this->getMain() );
 146                 }
 147
 148                 if ( $params['pagesetmodule'] ) {
 149                         $pageSet = new ApiPageSet( $this->getMain()->getModuleManager()->getModule( 'query' ) );
 150                         $res['pagesetmodule'] = $this->getModuleInfo( $pageSet );
 151                         unset( $res['pagesetmodule']['name'] );
 152                         unset( $res['pagesetmodule']['path'] );
 153                         unset( $res['pagesetmodule']['group'] );
 154                 }
 155
 156                 $result->addValue( null, $this->getModuleName(), $res );
 157         }
 158
 159         /**
 160          * List all submodules of a module
 161          * @param ApiBase $module
 162          * @param bool $recursive
 163          * @return string[]
 164          */
 165         private function listAllSubmodules( ApiBase $module, $recursive ) {
 166                 $manager = $module->getModuleManager();
 167                 if ( $manager ) {
 168                         $paths = [];
 169                         $names = $manager->getNames();
 170                         sort( $names );
 171                         foreach ( $names as $name ) {
 172                                 $submodule = $manager->getModule( $name );
 173                                 $paths[] = $submodule->getModulePath();
 174                                 if ( $recursive && $submodule->getModuleManager() ) {
 175                                         $paths = array_merge( $paths, $this->listAllSubmodules( $submodule, $recursive ) );
 176                                 }
 177                         }
 178                 }
 179                 return $paths;
 180         }
 181
 182         /**
 183          * @param array &$res Result array
 184          * @param string $key Result key
 185          * @param Message[] $msgs
 186          * @param bool $joinLists
 187          */
 188         protected function formatHelpMessages( array &$res, $key, array $msgs, $joinLists = false ) {
 189                 switch ( $this->helpFormat ) {
 190                         case 'none':
 191                                 break;
 192
 193                         case 'wikitext':
 194                                 $ret = [];
 195                                 foreach ( $msgs as $m ) {
 196                                         $ret[] = $m->setContext( $this->context )->text();
 197                                 }
 198                                 $res[$key] = implode( "\n\n", $ret );
 199                                 if ( $joinLists ) {
 200                                         $res[$key] = preg_replace( '!^(([*#:;])[^\n]*)\n\n(?=\2)!m', "$1\n", $res[$key] );
 201                                 }
 202                                 break;
 203
 204                         case 'html':
 205                                 $ret = [];
 206                                 foreach ( $msgs as $m ) {
 207                                         $ret[] = $m->setContext( $this->context )->parseAsBlock();
 208                                 }
 209                                 $ret = implode( "\n", $ret );
 210                                 if ( $joinLists ) {
 211                                         $ret = preg_replace( '!\s*</([oud]l)>\s*<\1>\s*!', "\n", $ret );
 212                                 }
 213                                 $res[$key] = Parser::stripOuterParagraph( $ret );
 214                                 break;
 215
 216                         case 'raw':
 217                                 $res[$key] = [];
 218                                 foreach ( $msgs as $m ) {
 219                                         $a = [
 220                                                 'key' => $m->getKey(),
 221                                                 'params' => $m->getParams(),
 222                                         ];
 223                                         ApiResult::setIndexedTagName( $a['params'], 'param' );
 224                                         if ( $m instanceof ApiHelpParamValueMessage ) {
 225                                                 $a['forvalue'] = $m->getParamValue();
 226                                         }
 227                                         $res[$key][] = $a;
 228                                 }
 229                                 ApiResult::setIndexedTagName( $res[$key], 'msg' );
 230                                 break;
 231                 }
 232         }
 233
 234         /**
 235          * @param ApiBase $module
 236          * @return array
 237          */
 238         private function getModuleInfo( $module ) {
 239                 $ret = [];
 240                 $path = $module->getModulePath();
 241
 242                 $ret['name'] = $module->getModuleName();
 243                 $ret['classname'] = get_class( $module );
 244                 $ret['path'] = $path;
 245                 if ( !$module->isMain() ) {
 246                         $ret['group'] = $module->getParent()->getModuleManager()->getModuleGroup(
 247                                 $module->getModuleName()
 248                         );
 249                 }
 250                 $ret['prefix'] = $module->getModulePrefix();
 251
 252                 $sourceInfo = $module->getModuleSourceInfo();
 253                 if ( $sourceInfo ) {
 254                         $ret['source'] = $sourceInfo['name'];
 255                         if ( isset( $sourceInfo['namemsg'] ) ) {
 256                                 $ret['sourcename'] = $this->context->msg( $sourceInfo['namemsg'] )->text();
 257                         } else {
 258                                 $ret['sourcename'] = $ret['source'];
 259                         }
 260
 261                         $link = SpecialPage::getTitleFor( 'Version', 'License/' . $sourceInfo['name'] )->getFullURL();
 262                         if ( isset( $sourceInfo['license-name'] ) ) {
 263                                 $ret['licensetag'] = $sourceInfo['license-name'];
 264                                 $ret['licenselink'] = (string)$link;
 265                         } elseif ( SpecialVersion::getExtLicenseFileName( dirname( $sourceInfo['path'] ) ) ) {
 266                                 $ret['licenselink'] = (string)$link;
 267                         }
 268                 }
 269
 270                 $this->formatHelpMessages( $ret, 'description', $module->getFinalDescription() );
 271
 272                 foreach ( $module->getHelpFlags() as $flag ) {
 273                         $ret[$flag] = true;
 274                 }
 275
 276                 $ret['helpurls'] = (array)$module->getHelpUrls();
 277                 if ( isset( $ret['helpurls'][0] ) && $ret['helpurls'][0] === false ) {
 278                         $ret['helpurls'] = [];
 279                 }
 280                 ApiResult::setIndexedTagName( $ret['helpurls'], 'helpurl' );
 281
 282                 if ( $this->helpFormat !== 'none' ) {
 283                         $ret['examples'] = [];
 284                         $examples = $module->getExamplesMessages();
 285                         foreach ( $examples as $qs => $msg ) {
 286                                 $item = [
 287                                         'query' => $qs
 288                                 ];
 289                                 $msg = ApiBase::makeMessage( $msg, $this->context, [
 290                                         $module->getModulePrefix(),
 291                                         $module->getModuleName(),
 292                                         $module->getModulePath()
 293                                 ] );
 294                                 $this->formatHelpMessages( $item, 'description', [ $msg ] );
 295                                 if ( isset( $item['description'] ) ) {
 296                                         if ( is_array( $item['description'] ) ) {
 297                                                 $item['description'] = $item['description'][0];
 298                                         } else {
 299                                                 ApiResult::setSubelementsList( $item, 'description' );
 300                                         }
 301                                 }
 302                                 $ret['examples'][] = $item;
 303                         }
 304                         ApiResult::setIndexedTagName( $ret['examples'], 'example' );
 305                 }
 306
 307                 $ret['parameters'] = [];
 308                 $params = $module->getFinalParams( ApiBase::GET_VALUES_FOR_HELP );
 309                 $paramDesc = $module->getFinalParamDescription();
 310                 foreach ( $params as $name => $settings ) {
 311                         if ( !is_array( $settings ) ) {
 312                                 $settings = [ ApiBase::PARAM_DFLT => $settings ];
 313                         }
 314
 315                         $item = [
 316                                 'name' => $name
 317                         ];
 318                         if ( isset( $paramDesc[$name] ) ) {
 319                                 $this->formatHelpMessages( $item, 'description', $paramDesc[$name], true );
 320                         }
 321
 322                         $item['required'] = !empty( $settings[ApiBase::PARAM_REQUIRED] );
 323
 324                         if ( !empty( $settings[ApiBase::PARAM_DEPRECATED] ) ) {
 325                                 $item['deprecated'] = true;
 326                         }
 327
 328                         if ( $name === 'token' && $module->needsToken() ) {
 329                                 $item['tokentype'] = $module->needsToken();
 330                         }
 331
 332                         if ( !isset( $settings[ApiBase::PARAM_TYPE] ) ) {
 333                                 $dflt = isset( $settings[ApiBase::PARAM_DFLT] )
 334                                         ? $settings[ApiBase::PARAM_DFLT]
 335                                         : null;
 336                                 if ( is_bool( $dflt ) ) {
 337                                         $settings[ApiBase::PARAM_TYPE] = 'boolean';
 338                                 } elseif ( is_string( $dflt ) || is_null( $dflt ) ) {
 339                                         $settings[ApiBase::PARAM_TYPE] = 'string';
 340                                 } elseif ( is_int( $dflt ) ) {
 341                                         $settings[ApiBase::PARAM_TYPE] = 'integer';
 342                                 }
 343                         }
 344
 345                         if ( isset( $settings[ApiBase::PARAM_DFLT] ) ) {
 346                                 switch ( $settings[ApiBase::PARAM_TYPE] ) {
 347                                         case 'boolean':
 348                                                 $item['default'] = (bool)$settings[ApiBase::PARAM_DFLT];
 349                                                 break;
 350                                         case 'string':
 351                                         case 'text':
 352                                         case 'password':
 353                                                 $item['default'] = strval( $settings[ApiBase::PARAM_DFLT] );
 354                                                 break;
 355                                         case 'integer':
 356                                         case 'limit':
 357                                                 $item['default'] = intval( $settings[ApiBase::PARAM_DFLT] );
 358                                                 break;
 359                                         case 'timestamp':
 360                                                 $item['default'] = wfTimestamp( TS_ISO_8601, $settings[ApiBase::PARAM_DFLT] );
 361                                                 break;
 362                                         default:
 363                                                 $item['default'] = $settings[ApiBase::PARAM_DFLT];
 364                                                 break;
 365                                 }
 366                         }
 367
 368                         $item['multi'] = !empty( $settings[ApiBase::PARAM_ISMULTI] );
 369                         if ( $item['multi'] ) {
 370                                 $item['lowlimit'] = !empty( $settings[ApiBase::PARAM_ISMULTI_LIMIT1] )
 371                                         ? $settings[ApiBase::PARAM_ISMULTI_LIMIT1]
 372                                         : ApiBase::LIMIT_SML1;
 373                                 $item['highlimit'] = !empty( $settings[ApiBase::PARAM_ISMULTI_LIMIT2] )
 374                                         ? $settings[ApiBase::PARAM_ISMULTI_LIMIT2]
 375                                         : ApiBase::LIMIT_SML2;
 376                                 $item['limit'] = $this->getMain()->canApiHighLimits()
 377                                         ? $item['highlimit']
 378                                         : $item['lowlimit'];
 379                         }
 380
 381                         if ( !empty( $settings[ApiBase::PARAM_ALLOW_DUPLICATES] ) ) {
 382                                 $item['allowsduplicates'] = true;
 383                         }
 384
 385                         if ( isset( $settings[ApiBase::PARAM_TYPE] ) ) {
 386                                 if ( $settings[ApiBase::PARAM_TYPE] === 'submodule' ) {
 387                                         if ( isset( $settings[ApiBase::PARAM_SUBMODULE_MAP] ) ) {
 388                                                 ksort( $settings[ApiBase::PARAM_SUBMODULE_MAP] );
 389                                                 $item['type'] = array_keys( $settings[ApiBase::PARAM_SUBMODULE_MAP] );
 390                                                 $item['submodules'] = $settings[ApiBase::PARAM_SUBMODULE_MAP];
 391                                         } else {
 392                                                 $item['type'] = $module->getModuleManager()->getNames( $name );
 393                                                 sort( $item['type'] );
 394                                                 $prefix = $module->isMain()
 395                                                         ? '' : ( $module->getModulePath() . '+' );
 396                                                 $item['submodules'] = [];
 397                                                 foreach ( $item['type'] as $v ) {
 398                                                         $item['submodules'][$v] = $prefix . $v;
 399                                                 }
 400                                         }
 401                                         if ( isset( $settings[ApiBase::PARAM_SUBMODULE_PARAM_PREFIX] ) ) {
 402                                                 $item['submoduleparamprefix'] = $settings[ApiBase::PARAM_SUBMODULE_PARAM_PREFIX];
 403                                         }
 404
 405                                         $deprecatedSubmodules = [];
 406                                         foreach ( $item['submodules'] as $v => $submodulePath ) {
 407                                                 try {
 408                                                         $submod = $this->getModuleFromPath( $submodulePath );
 409                                                         if ( $submod && $submod->isDeprecated() ) {
 410                                                                 $deprecatedSubmodules[] = $v;
 411                                                         }
 412                                                 } catch ( ApiUsageException $ex ) {
 413                                                         // Ignore
 414                                                 }
 415                                         }
 416                                         if ( $deprecatedSubmodules ) {
 417                                                 $item['type'] = array_merge(
 418                                                         array_diff( $item['type'], $deprecatedSubmodules ),
 419                                                         $deprecatedSubmodules
 420                                                 );
 421                                                 $item['deprecatedvalues'] = $deprecatedSubmodules;
 422                                         }
 423                                 } elseif ( $settings[ApiBase::PARAM_TYPE] === 'tags' ) {
 424                                         $item['type'] = ChangeTags::listExplicitlyDefinedTags();
 425                                 } else {
 426                                         $item['type'] = $settings[ApiBase::PARAM_TYPE];
 427                                 }
 428                                 if ( is_array( $item['type'] ) ) {
 429                                         // To prevent sparse arrays from being serialized to JSON as objects
 430                                         $item['type'] = array_values( $item['type'] );
 431                                         ApiResult::setIndexedTagName( $item['type'], 't' );
 432                                 }
 433
 434                                 // Add 'allspecifier' if applicable
 435                                 if ( $item['type'] === 'namespace' ) {
 436                                         $allowAll = true;
 437                                         $allSpecifier = ApiBase::ALL_DEFAULT_STRING;
 438                                 } else {
 439                                         $allowAll = isset( $settings[ApiBase::PARAM_ALL] )
 440                                                 ? $settings[ApiBase::PARAM_ALL]
 441                                                 : false;
 442                                         $allSpecifier = ( is_string( $allowAll ) ? $allowAll : ApiBase::ALL_DEFAULT_STRING );
 443                                 }
 444                                 if ( $allowAll && $item['multi'] &&
 445                                         ( is_array( $item['type'] ) || $item['type'] === 'namespace' ) ) {
 446                                         $item['allspecifier'] = $allSpecifier;
 447                                 }
 448
 449                                 if ( $item['type'] === 'namespace' &&
 450                                         isset( $settings[ApiBase::PARAM_EXTRA_NAMESPACES] ) &&
 451                                         is_array( $settings[ApiBase::PARAM_EXTRA_NAMESPACES] )
 452                                 ) {
 453                                         $item['extranamespaces'] = $settings[ApiBase::PARAM_EXTRA_NAMESPACES];
 454                                         ApiResult::setArrayType( $item['extranamespaces'], 'array' );
 455                                         ApiResult::setIndexedTagName( $item['extranamespaces'], 'ns' );
 456                                 }
 457                         }
 458                         if ( isset( $settings[ApiBase::PARAM_MAX] ) ) {
 459                                 $item['max'] = $settings[ApiBase::PARAM_MAX];
 460                         }
 461                         if ( isset( $settings[ApiBase::PARAM_MAX2] ) ) {
 462                                 $item['highmax'] = $settings[ApiBase::PARAM_MAX2];
 463                         }
 464                         if ( isset( $settings[ApiBase::PARAM_MIN] ) ) {
 465                                 $item['min'] = $settings[ApiBase::PARAM_MIN];
 466                         }
 467                         if ( !empty( $settings[ApiBase::PARAM_RANGE_ENFORCE] ) ) {
 468                                 $item['enforcerange'] = true;
 469                         }
 470                         if ( isset( $settings[self::PARAM_MAX_BYTES] ) ) {
 471                                 $item['maxbytes'] = $settings[self::PARAM_MAX_BYTES];
 472                         }
 473                         if ( isset( $settings[self::PARAM_MAX_CHARS] ) ) {
 474                                 $item['maxchars'] = $settings[self::PARAM_MAX_CHARS];
 475                         }
 476                         if ( !empty( $settings[ApiBase::PARAM_DEPRECATED_VALUES] ) ) {
 477                                 $deprecatedValues = array_keys( $settings[ApiBase::PARAM_DEPRECATED_VALUES] );
 478                                 if ( is_array( $item['type'] ) ) {
 479                                         $deprecatedValues = array_intersect( $deprecatedValues, $item['type'] );
 480                                 }
 481                                 if ( $deprecatedValues ) {
 482                                         $item['deprecatedvalues'] = array_values( $deprecatedValues );
 483                                         ApiResult::setIndexedTagName( $item['deprecatedvalues'], 'v' );
 484                                 }
 485                         }
 486
 487                         if ( !empty( $settings[ApiBase::PARAM_HELP_MSG_INFO] ) ) {
 488                                 $item['info'] = [];
 489                                 foreach ( $settings[ApiBase::PARAM_HELP_MSG_INFO] as $i ) {
 490                                         $tag = array_shift( $i );
 491                                         $info = [
 492                                                 'name' => $tag,
 493                                         ];
 494                                         if ( count( $i ) ) {
 495                                                 $info['values'] = $i;
 496                                                 ApiResult::setIndexedTagName( $info['values'], 'v' );
 497                                         }
 498                                         $this->formatHelpMessages( $info, 'text', [
 499                                                 $this->context->msg( "apihelp-{$path}-paraminfo-{$tag}" )
 500                                                         ->numParams( count( $i ) )
 501                                                         ->params( $this->context->getLanguage()->commaList( $i ) )
 502                                                         ->params( $module->getModulePrefix() )
 503                                         ] );
 504                                         ApiResult::setSubelementsList( $info, 'text' );
 505                                         $item['info'][] = $info;
 506                                 }
 507                                 ApiResult::setIndexedTagName( $item['info'], 'i' );
 508                         }
 509
 510                         $ret['parameters'][] = $item;
 511                 }
 512                 ApiResult::setIndexedTagName( $ret['parameters'], 'param' );
 513
 514                 $dynamicParams = $module->dynamicParameterDocumentation();
 515                 if ( $dynamicParams !== null ) {
 516                         if ( $this->helpFormat === 'none' ) {
 517                                 $ret['dynamicparameters'] = true;
 518                         } else {
 519                                 $dynamicParams = ApiBase::makeMessage( $dynamicParams, $this->context, [
 520                                         $module->getModulePrefix(),
 521                                         $module->getModuleName(),
 522                                         $module->getModulePath()
 523                                 ] );
 524                                 $this->formatHelpMessages( $ret, 'dynamicparameters', [ $dynamicParams ] );
 525                         }
 526                 }
 527
 528                 return $ret;
 529         }
 530
 531         public function isReadMode() {
 532                 return false;
 533         }
 534
 535         public function getAllowedParams() {
 536                 // back compat
 537                 $querymodules = $this->getMain()->getModuleManager()
 538                         ->getModule( 'query' )->getModuleManager()->getNames();
 539                 sort( $querymodules );
 540                 $formatmodules = $this->getMain()->getModuleManager()->getNames( 'format' );
 541                 sort( $formatmodules );
 542
 543                 return [
 544                         'modules' => [
 545                                 ApiBase::PARAM_ISMULTI => true,
 546                         ],
 547                         'helpformat' => [
 548                                 ApiBase::PARAM_DFLT => 'none',
 549                                 ApiBase::PARAM_TYPE => [ 'html', 'wikitext', 'raw', 'none' ],
 550                         ],
 551
 552                         'querymodules' => [
 553                                 ApiBase::PARAM_DEPRECATED => true,
 554                                 ApiBase::PARAM_ISMULTI => true,
 555                                 ApiBase::PARAM_TYPE => $querymodules,
 556                         ],
 557                         'mainmodule' => [
 558                                 ApiBase::PARAM_DEPRECATED => true,
 559                         ],
 560                         'pagesetmodule' => [
 561                                 ApiBase::PARAM_DEPRECATED => true,
 562                         ],
 563                         'formatmodules' => [
 564                                 ApiBase::PARAM_DEPRECATED => true,
 565                                 ApiBase::PARAM_ISMULTI => true,
 566                                 ApiBase::PARAM_TYPE => $formatmodules,
 567                         ]
 568                 ];
 569         }
 570
 571         protected function getExamplesMessages() {
 572                 return [
 573                         'action=paraminfo&modules=parse|phpfm|query%2Ballpages|query%2Bsiteinfo'
 574                                 => 'apihelp-paraminfo-example-1',
 575                         'action=paraminfo&modules=query%2B*'
 576                                 => 'apihelp-paraminfo-example-2',
 577                 ];
 578         }
 579
 580         public function getHelpUrls() {
 581                 return 'https://www.mediawiki.org/wiki/Special:MyLanguage/API:Parameter_information';
 582         }
 583 }