maintenance/convertExtensionToRegistration.php

   1 <?php
   2
   3 require_once __DIR__ . '/Maintenance.php';
   4
   5 class ConvertExtensionToRegistration extends Maintenance {
   6
   7         protected $custom = [
   8                 'MessagesDirs' => 'handleMessagesDirs',
   9                 'ExtensionMessagesFiles' => 'handleExtensionMessagesFiles',
  10                 'AutoloadClasses' => 'removeAbsolutePath',
  11                 'ExtensionCredits' => 'handleCredits',
  12                 'ResourceModules' => 'handleResourceModules',
  13                 'ResourceModuleSkinStyles' => 'handleResourceModules',
  14                 'Hooks' => 'handleHooks',
  15                 'ExtensionFunctions' => 'handleExtensionFunctions',
  16                 'ParserTestFiles' => 'removeAutodiscoveredParserTestFiles',
  17         ];
  18
  19         /**
  20          * Things that were formerly globals and should still be converted
  21          *
  22          * @var string[]
  23          */
  24         protected $formerGlobals = [
  25                 'TrackingCategories',
  26         ];
  27
  28         /**
  29          * No longer supported globals (with reason) should not be converted and emit a warning
  30          *
  31          * @var string[]
  32          */
  33         protected $noLongerSupportedGlobals = [
  34                 'SpecialPageGroups' => 'deprecated', // Deprecated 1.21, removed in 1.26
  35         ];
  36
  37         /**
  38          * Keys that should be put at the top of the generated JSON file (T86608)
  39          *
  40          * @var string[]
  41          */
  42         protected $promote = [
  43                 'name',
  44                 'namemsg',
  45                 'version',
  46                 'author',
  47                 'url',
  48                 'description',
  49                 'descriptionmsg',
  50                 'license-name',
  51                 'type',
  52         ];
  53
  54         private $json, $dir, $hasWarning = false;
  55
  56         public function __construct() {
  57                 parent::__construct();
  58                 $this->addDescription( 'Converts extension entry points to the new JSON registration format' );
  59                 $this->addArg( 'path', 'Location to the PHP entry point you wish to convert',
  60                         /* $required = */ true );
  61                 $this->addOption( 'skin', 'Whether to write to skin.json', false, false );
  62                 $this->addOption( 'config-prefix', 'Custom prefix for configuration settings', false, true );
  63         }
  64
  65         protected function getAllGlobals() {
  66                 $processor = new ReflectionClass( ExtensionProcessor::class );
  67                 $settings = $processor->getProperty( 'globalSettings' );
  68                 $settings->setAccessible( true );
  69                 return array_merge( $settings->getValue(), $this->formerGlobals );
  70         }
  71
  72         public function execute() {
  73                 // Extensions will do stuff like $wgResourceModules += array(...) which is a
  74                 // fatal unless an array is already set. So set an empty value.
  75                 // And use the weird $__settings name to avoid any conflicts
  76                 // with real poorly named settings.
  77                 $__settings = array_merge( $this->getAllGlobals(), array_keys( $this->custom ) );
  78                 foreach ( $__settings as $var ) {
  79                         $var = 'wg' . $var;
  80                         $$var = [];
  81                 }
  82                 unset( $var );
  83                 $arg = $this->getArg( 0 );
  84                 if ( !is_file( $arg ) ) {
  85                         $this->fatalError( "$arg is not a file." );
  86                 }
  87                 require $arg;
  88                 unset( $arg );
  89                 // Try not to create any local variables before this line
  90                 $vars = get_defined_vars();
  91                 unset( $vars['this'] );
  92                 unset( $vars['__settings'] );
  93                 $this->dir = dirname( realpath( $this->getArg( 0 ) ) );
  94                 $this->json = [];
  95                 $globalSettings = $this->getAllGlobals();
  96                 $configPrefix = $this->getOption( 'config-prefix', 'wg' );
  97                 if ( $configPrefix !== 'wg' ) {
  98                         $this->json['config']['_prefix'] = $configPrefix;
  99                 }
 100                 foreach ( $vars as $name => $value ) {
 101                         $realName = substr( $name, 2 ); // Strip 'wg'
 102                         if ( $realName === false ) {
 103                                 continue;
 104                         }
 105
 106                         // If it's an empty array that we likely set, skip it
 107                         if ( is_array( $value ) && count( $value ) === 0 && in_array( $realName, $__settings ) ) {
 108                                 continue;
 109                         }
 110
 111                         if ( isset( $this->custom[$realName] ) ) {
 112                                 call_user_func_array( [ $this, $this->custom[$realName] ],
 113                                         [ $realName, $value, $vars ] );
 114                         } elseif ( in_array( $realName, $globalSettings ) ) {
 115                                 $this->json[$realName] = $value;
 116                         } elseif ( array_key_exists( $realName, $this->noLongerSupportedGlobals ) ) {
 117                                 $this->output( 'Warning: Skipped global "' . $name . '" (' .
 118                                         $this->noLongerSupportedGlobals[$realName] . '). ' .
 119                                         "Please update the entry point before convert to registration.\n" );
 120                                 $this->hasWarning = true;
 121                         } elseif ( strpos( $name, $configPrefix ) === 0 ) {
 122                                 // Most likely a config setting
 123                                 $this->json['config'][substr( $name, strlen( $configPrefix ) )] = [ 'value' => $value ];
 124                         } elseif ( $configPrefix !== 'wg' && strpos( $name, 'wg' ) === 0 ) {
 125                                 // Warn about this
 126                                 $this->output( 'Warning: Skipped global "' . $name . '" (' .
 127                                         'config prefix is "' . $configPrefix . '"). ' .
 128                                         "Please check that this setting isn't needed.\n" );
 129                         }
 130                 }
 131
 132                 // check, if the extension requires composer libraries
 133                 if ( $this->needsComposerAutoloader( dirname( $this->getArg( 0 ) ) ) ) {
 134                         // set the load composer autoloader automatically property
 135                         $this->output( "Detected composer dependencies, setting 'load_composer_autoloader' to true.\n" );
 136                         $this->json['load_composer_autoloader'] = true;
 137                 }
 138
 139                 // Move some keys to the top
 140                 $out = [];
 141                 foreach ( $this->promote as $key ) {
 142                         if ( isset( $this->json[$key] ) ) {
 143                                 $out[$key] = $this->json[$key];
 144                                 unset( $this->json[$key] );
 145                         }
 146                 }
 147                 // Set a requirement on the MediaWiki version that the current MANIFEST_VERSION
 148                 // was introduced in.
 149                 $out['requires'] = [
 150                         ExtensionRegistry::MEDIAWIKI_CORE => ExtensionRegistry::MANIFEST_VERSION_MW_VERSION
 151                 ];
 152                 $out += $this->json;
 153                 // Put this at the bottom
 154                 $out['manifest_version'] = ExtensionRegistry::MANIFEST_VERSION;
 155                 $type = $this->hasOption( 'skin' ) ? 'skin' : 'extension';
 156                 $fname = "{$this->dir}/$type.json";
 157                 $prettyJSON = FormatJson::encode( $out, "\t", FormatJson::ALL_OK );
 158                 file_put_contents( $fname, $prettyJSON . "\n" );
 159                 $this->output( "Wrote output to $fname.\n" );
 160                 if ( $this->hasWarning ) {
 161                         $this->output( "Found warnings! Please resolve the warnings and rerun this script.\n" );
 162                 }
 163         }
 164
 165         protected function handleExtensionFunctions( $realName, $value ) {
 166                 foreach ( $value as $func ) {
 167                         if ( $func instanceof Closure ) {
 168                                 $this->fatalError( "Error: Closures cannot be converted to JSON. " .
 169                                         "Please move your extension function somewhere else."
 170                                 );
 171                         }
 172                         // check if $func exists in the global scope
 173                         if ( function_exists( $func ) ) {
 174                                 // @phan-suppress-next-next-line PhanTypeSuspiciousStringExpression
 175                                 $this->fatalError( "Error: Global functions cannot be converted to JSON. " .
 176                                         "Please move your extension function ($func) into a class."
 177                                 );
 178                         }
 179                 }
 180
 181                 $this->json[$realName] = $value;
 182         }
 183
 184         protected function handleMessagesDirs( $realName, $value ) {
 185                 foreach ( $value as $key => $dirs ) {
 186                         foreach ( (array)$dirs as $dir ) {
 187                                 $this->json[$realName][$key][] = $this->stripPath( $dir, $this->dir );
 188                         }
 189                 }
 190         }
 191
 192         protected function handleExtensionMessagesFiles( $realName, $value, $vars ) {
 193                 foreach ( $value as $key => $file ) {
 194                         $strippedFile = $this->stripPath( $file, $this->dir );
 195                         if ( isset( $vars['wgMessagesDirs'][$key] ) ) {
 196                                 $this->output(
 197                                         "Note: Ignoring PHP shim $strippedFile. " .
 198                                         "If your extension no longer supports versions of MediaWiki " .
 199                                         "older than 1.23.0, you can safely delete it.\n"
 200                                 );
 201                         } else {
 202                                 $this->json[$realName][$key] = $strippedFile;
 203                         }
 204                 }
 205         }
 206
 207         private function stripPath( $val, $dir ) {
 208                 if ( $val === $dir ) {
 209                         $val = '';
 210                 } elseif ( strpos( $val, $dir ) === 0 ) {
 211                         // +1 is for the trailing / that won't be in $this->dir
 212                         $val = substr( $val, strlen( $dir ) + 1 );
 213                 }
 214
 215                 return $val;
 216         }
 217
 218         protected function removeAbsolutePath( $realName, $value ) {
 219                 $out = [];
 220                 foreach ( $value as $key => $val ) {
 221                         $out[$key] = $this->stripPath( $val, $this->dir );
 222                 }
 223                 $this->json[$realName] = $out;
 224         }
 225
 226         protected function removeAutodiscoveredParserTestFiles( $realName, $value ) {
 227                 $out = [];
 228                 foreach ( $value as $key => $val ) {
 229                         $path = $this->stripPath( $val, $this->dir );
 230                         // When path starts with tests/parser/ the file would be autodiscovered with
 231                         // extension registry, so no need to add it to extension.json
 232                         if ( substr( $path, 0, 13 ) !== 'tests/parser/' || substr( $path, -4 ) !== '.txt' ) {
 233                                 $out[$key] = $path;
 234                         }
 235                 }
 236                 // in the best case all entries are filtered out
 237                 if ( $out ) {
 238                         $this->json[$realName] = $out;
 239                 }
 240         }
 241
 242         protected function handleCredits( $realName, $value ) {
 243                 $keys = array_keys( $value );
 244                 $this->json['type'] = $keys[0];
 245                 $values = array_values( $value );
 246                 foreach ( $values[0][0] as $name => $val ) {
 247                         if ( $name !== 'path' ) {
 248                                 $this->json[$name] = $val;
 249                         }
 250                 }
 251         }
 252
 253         public function handleHooks( $realName, $value ) {
 254                 foreach ( $value as $hookName => &$handlers ) {
 255                         if ( $hookName === 'UnitTestsList' ) {
 256                                 $this->output( "Note: the UnitTestsList hook is no longer necessary as " .
 257                                         "long as your tests are located in the \"tests/phpunit/\" directory. " .
 258                                         "Please see <https://www.mediawiki.org/wiki/Manual:PHP_unit_testing/" .
 259                                         "Writing_unit_tests_for_extensions#Register_your_tests> for more details.\n"
 260                                 );
 261                         }
 262                         foreach ( $handlers as $func ) {
 263                                 if ( $func instanceof Closure ) {
 264                                         $this->fatalError( "Error: Closures cannot be converted to JSON. " .
 265                                                 "Please move the handler for $hookName somewhere else."
 266                                         );
 267                                 }
 268                                 // Check if $func exists in the global scope
 269                                 if ( function_exists( $func ) ) {
 270                                         $this->fatalError( "Error: Global functions cannot be converted to JSON. " .
 271                                                 "Please move the handler for $hookName inside a class."
 272                                         );
 273                                 }
 274                         }
 275                         if ( count( $handlers ) === 1 ) {
 276                                 $handlers = $handlers[0];
 277                         }
 278                 }
 279                 $this->json[$realName] = $value;
 280         }
 281
 282         protected function handleResourceModules( $realName, $value ) {
 283                 $defaults = [];
 284                 $remote = $this->hasOption( 'skin' ) ? 'remoteSkinPath' : 'remoteExtPath';
 285                 foreach ( $value as $name => $data ) {
 286                         if ( isset( $data['localBasePath'] ) ) {
 287                                 $data['localBasePath'] = $this->stripPath( $data['localBasePath'], $this->dir );
 288                                 if ( !$defaults ) {
 289                                         $defaults['localBasePath'] = $data['localBasePath'];
 290                                         unset( $data['localBasePath'] );
 291                                         if ( isset( $data[$remote] ) ) {
 292                                                 $defaults[$remote] = $data[$remote];
 293                                                 unset( $data[$remote] );
 294                                         }
 295                                 } else {
 296                                         if ( $data['localBasePath'] === $defaults['localBasePath'] ) {
 297                                                 unset( $data['localBasePath'] );
 298                                         }
 299                                         if ( isset( $data[$remote] ) && isset( $defaults[$remote] )
 300                                                 && $data[$remote] === $defaults[$remote]
 301                                         ) {
 302                                                 unset( $data[$remote] );
 303                                         }
 304                                 }
 305                         }
 306
 307                         $this->json[$realName][$name] = $data;
 308                 }
 309                 if ( $defaults ) {
 310                         $this->json['ResourceFileModulePaths'] = $defaults;
 311                 }
 312         }
 313
 314         protected function needsComposerAutoloader( $path ) {
 315                 $path .= '/composer.json';
 316                 if ( file_exists( $path ) ) {
 317                         // assume, that the composer.json file is in the root of the extension path
 318                         $composerJson = new ComposerJson( $path );
 319                         // check, if there are some dependencies in the require section
 320                         if ( $composerJson->getRequiredDependencies() ) {
 321                                 return true;
 322                         }
 323                 }
 324                 return false;
 325         }
 326 }
 327
 328 $maintClass = ConvertExtensionToRegistration::class;
 329 require_once RUN_MAINTENANCE_IF_MAIN;