Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
<?php
|
|
|
|
|
|
2017-04-19 19:37:35 +00:00
|
|
|
use Wikimedia\TestingAccessWrapper;
|
|
|
|
|
|
2018-02-10 06:03:42 +00:00
|
|
|
/**
|
|
|
|
|
* @covers ExtensionProcessor
|
|
|
|
|
*/
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
class ExtensionProcessorTest extends MediaWikiTestCase {
|
|
|
|
|
|
2016-07-22 22:08:21 +00:00
|
|
|
private $dir, $dirname;
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
|
|
|
|
|
public function setUp() {
|
|
|
|
|
parent::setUp();
|
|
|
|
|
$this->dir = __DIR__ . '/FooBar/extension.json';
|
2016-07-22 22:08:21 +00:00
|
|
|
$this->dirname = dirname( $this->dir );
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* 'name' is absolutely required
|
|
|
|
|
*
|
|
|
|
|
* @var array
|
|
|
|
|
*/
|
2016-02-17 09:09:32 +00:00
|
|
|
public static $default = [
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
'name' => 'FooBar',
|
2016-02-17 09:09:32 +00:00
|
|
|
];
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
|
2015-01-13 19:46:53 +00:00
|
|
|
public function testExtractInfo() {
|
|
|
|
|
// Test that attributes that begin with @ are ignored
|
|
|
|
|
$processor = new ExtensionProcessor();
|
2016-02-17 09:09:32 +00:00
|
|
|
$processor->extractInfo( $this->dir, self::$default + [
|
|
|
|
|
'@metadata' => [ 'foobarbaz' ],
|
|
|
|
|
'AnAttribute' => [ 'omg' ],
|
|
|
|
|
'AutoloadClasses' => [ 'FooBar' => 'includes/FooBar.php' ],
|
2018-02-10 06:03:42 +00:00
|
|
|
'SpecialPages' => [ 'Foo' => 'SpecialFoo' ],
|
|
|
|
|
'callback' => 'FooBar::onRegistration',
|
2016-02-17 09:09:32 +00:00
|
|
|
], 1 );
|
2015-01-13 19:46:53 +00:00
|
|
|
|
|
|
|
|
$extracted = $processor->getExtractedInfo();
|
|
|
|
|
$attributes = $extracted['attributes'];
|
|
|
|
|
$this->assertArrayHasKey( 'AnAttribute', $attributes );
|
|
|
|
|
$this->assertArrayNotHasKey( '@metadata', $attributes );
|
2015-05-18 06:22:46 +00:00
|
|
|
$this->assertArrayNotHasKey( 'AutoloadClasses', $attributes );
|
2018-02-10 06:03:42 +00:00
|
|
|
$this->assertSame(
|
|
|
|
|
[ 'FooBar' => 'FooBar::onRegistration' ],
|
|
|
|
|
$extracted['callbacks']
|
|
|
|
|
);
|
|
|
|
|
$this->assertSame(
|
|
|
|
|
[ 'Foo' => 'SpecialFoo' ],
|
|
|
|
|
$extracted['globals']['wgSpecialPages']
|
|
|
|
|
);
|
2015-01-13 19:46:53 +00:00
|
|
|
}
|
|
|
|
|
|
2018-02-10 06:03:42 +00:00
|
|
|
public function testExtractNamespaces() {
|
2017-05-10 16:00:38 +00:00
|
|
|
// Test that namespace IDs can be overwritten
|
|
|
|
|
if ( !defined( 'MW_EXTENSION_PROCESSOR_TEST_EXTRACT_INFO_X' ) ) {
|
|
|
|
|
define( 'MW_EXTENSION_PROCESSOR_TEST_EXTRACT_INFO_X', 123456 );
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$processor = new ExtensionProcessor();
|
|
|
|
|
$processor->extractInfo( $this->dir, self::$default + [
|
|
|
|
|
'namespaces' => [
|
|
|
|
|
[
|
|
|
|
|
'id' => 332200,
|
|
|
|
|
'constant' => 'MW_EXTENSION_PROCESSOR_TEST_EXTRACT_INFO_A',
|
|
|
|
|
'name' => 'Test_A',
|
2018-02-10 06:03:42 +00:00
|
|
|
'defaultcontentmodel' => 'TestModel',
|
|
|
|
|
'gender' => [
|
|
|
|
|
'male' => 'Male test',
|
|
|
|
|
'female' => 'Female test',
|
|
|
|
|
],
|
|
|
|
|
'subpages' => true,
|
|
|
|
|
'content' => true,
|
|
|
|
|
'protection' => 'userright',
|
2017-05-10 16:00:38 +00:00
|
|
|
],
|
|
|
|
|
[ // Test_X will use ID 123456 not 334400
|
|
|
|
|
'id' => 334400,
|
|
|
|
|
'constant' => 'MW_EXTENSION_PROCESSOR_TEST_EXTRACT_INFO_X',
|
|
|
|
|
'name' => 'Test_X',
|
2018-02-10 06:03:42 +00:00
|
|
|
'defaultcontentmodel' => 'TestModel'
|
2017-05-10 16:00:38 +00:00
|
|
|
],
|
|
|
|
|
]
|
|
|
|
|
], 1 );
|
|
|
|
|
|
|
|
|
|
$extracted = $processor->getExtractedInfo();
|
|
|
|
|
|
|
|
|
|
$this->assertArrayHasKey(
|
|
|
|
|
'MW_EXTENSION_PROCESSOR_TEST_EXTRACT_INFO_A',
|
|
|
|
|
$extracted['defines']
|
|
|
|
|
);
|
|
|
|
|
$this->assertArrayNotHasKey(
|
|
|
|
|
'MW_EXTENSION_PROCESSOR_TEST_EXTRACT_INFO_X',
|
|
|
|
|
$extracted['defines']
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
$this->assertSame(
|
|
|
|
|
$extracted['defines']['MW_EXTENSION_PROCESSOR_TEST_EXTRACT_INFO_A'],
|
|
|
|
|
332200
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
$this->assertArrayHasKey( 'ExtensionNamespaces', $extracted['attributes'] );
|
|
|
|
|
$this->assertArrayHasKey( 123456, $extracted['attributes']['ExtensionNamespaces'] );
|
|
|
|
|
$this->assertArrayHasKey( 332200, $extracted['attributes']['ExtensionNamespaces'] );
|
|
|
|
|
$this->assertArrayNotHasKey( 334400, $extracted['attributes']['ExtensionNamespaces'] );
|
|
|
|
|
|
|
|
|
|
$this->assertSame( 'Test_X', $extracted['attributes']['ExtensionNamespaces'][123456] );
|
|
|
|
|
$this->assertSame( 'Test_A', $extracted['attributes']['ExtensionNamespaces'][332200] );
|
2018-02-10 06:03:42 +00:00
|
|
|
$this->assertSame(
|
|
|
|
|
[ 'male' => 'Male test', 'female' => 'Female test' ],
|
|
|
|
|
$extracted['globals']['wgExtraGenderNamespaces'][332200]
|
|
|
|
|
);
|
|
|
|
|
// A has subpages, X does not
|
|
|
|
|
$this->assertTrue( $extracted['globals']['wgNamespacesWithSubpages'][332200] );
|
|
|
|
|
$this->assertArrayNotHasKey( 123456, $extracted['globals']['wgNamespacesWithSubpages'] );
|
2017-05-10 16:00:38 +00:00
|
|
|
}
|
|
|
|
|
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
public static function provideRegisterHooks() {
|
2016-02-17 09:09:32 +00:00
|
|
|
$merge = [ ExtensionRegistry::MERGE_STRATEGY => 'array_merge_recursive' ];
|
2015-05-13 19:30:21 +00:00
|
|
|
// Format:
|
|
|
|
|
// Current $wgHooks
|
|
|
|
|
// Content in extension.json
|
|
|
|
|
// Expected value of $wgHooks
|
2016-02-17 09:09:32 +00:00
|
|
|
return [
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
// No hooks
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
|
|
|
|
[],
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
self::$default,
|
2015-08-01 07:38:27 +00:00
|
|
|
$merge,
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
2016-04-29 21:21:40 +00:00
|
|
|
// No current hooks, adding one for "FooBaz" in string format
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
|
|
|
|
[],
|
|
|
|
|
[ 'Hooks' => [ 'FooBaz' => 'FooBazCallback' ] ] + self::$default,
|
|
|
|
|
[ 'FooBaz' => [ 'FooBazCallback' ] ] + $merge,
|
|
|
|
|
],
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
// Hook for "FooBaz", adding another one
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
|
|
|
|
[ 'FooBaz' => [ 'PriorCallback' ] ],
|
|
|
|
|
[ 'Hooks' => [ 'FooBaz' => 'FooBazCallback' ] ] + self::$default,
|
|
|
|
|
[ 'FooBaz' => [ 'PriorCallback', 'FooBazCallback' ] ] + $merge,
|
|
|
|
|
],
|
2016-04-29 21:21:40 +00:00
|
|
|
// No current hooks, adding one for "FooBaz" in verbose array format
|
|
|
|
|
[
|
|
|
|
|
[],
|
|
|
|
|
[ 'Hooks' => [ 'FooBaz' => [ 'FooBazCallback' ] ] ] + self::$default,
|
|
|
|
|
[ 'FooBaz' => [ 'FooBazCallback' ] ] + $merge,
|
|
|
|
|
],
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
// Hook for "BarBaz", adding one for "FooBaz"
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
|
|
|
|
[ 'BarBaz' => [ 'BarBazCallback' ] ],
|
|
|
|
|
[ 'Hooks' => [ 'FooBaz' => 'FooBazCallback' ] ] + self::$default,
|
|
|
|
|
[
|
|
|
|
|
'BarBaz' => [ 'BarBazCallback' ],
|
|
|
|
|
'FooBaz' => [ 'FooBazCallback' ],
|
|
|
|
|
] + $merge,
|
|
|
|
|
],
|
2015-05-13 19:30:21 +00:00
|
|
|
// Callbacks for FooBaz wrapped in an array
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
|
|
|
|
[],
|
|
|
|
|
[ 'Hooks' => [ 'FooBaz' => [ 'Callback1' ] ] ] + self::$default,
|
|
|
|
|
[
|
|
|
|
|
'FooBaz' => [ 'Callback1' ],
|
|
|
|
|
] + $merge,
|
|
|
|
|
],
|
2015-05-13 19:30:21 +00:00
|
|
|
// Multiple callbacks for FooBaz hook
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
|
|
|
|
[],
|
|
|
|
|
[ 'Hooks' => [ 'FooBaz' => [ 'Callback1', 'Callback2' ] ] ] + self::$default,
|
|
|
|
|
[
|
|
|
|
|
'FooBaz' => [ 'Callback1', 'Callback2' ],
|
|
|
|
|
] + $merge,
|
|
|
|
|
],
|
|
|
|
|
];
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @dataProvider provideRegisterHooks
|
|
|
|
|
*/
|
|
|
|
|
public function testRegisterHooks( $pre, $info, $expected ) {
|
2016-02-17 09:09:32 +00:00
|
|
|
$processor = new MockExtensionProcessor( [ 'wgHooks' => $pre ] );
|
2015-05-20 01:45:10 +00:00
|
|
|
$processor->extractInfo( $this->dir, $info, 1 );
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
$extracted = $processor->getExtractedInfo();
|
|
|
|
|
$this->assertEquals( $expected, $extracted['globals']['wgHooks'] );
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-22 22:08:21 +00:00
|
|
|
public function testExtractConfig1() {
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
$processor = new ExtensionProcessor;
|
2016-02-17 09:09:32 +00:00
|
|
|
$info = [
|
|
|
|
|
'config' => [
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
'Bar' => 'somevalue',
|
|
|
|
|
'Foo' => 10,
|
2015-01-27 07:00:07 +00:00
|
|
|
'@IGNORED' => 'yes',
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
|
|
|
|
] + self::$default;
|
|
|
|
|
$info2 = [
|
|
|
|
|
'config' => [
|
2015-08-23 22:56:59 +00:00
|
|
|
'_prefix' => 'eg',
|
|
|
|
|
'Bar' => 'somevalue'
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
2015-12-30 01:52:11 +00:00
|
|
|
'name' => 'FooBar2',
|
2016-02-17 09:09:32 +00:00
|
|
|
];
|
2015-05-20 01:45:10 +00:00
|
|
|
$processor->extractInfo( $this->dir, $info, 1 );
|
2015-08-23 22:56:59 +00:00
|
|
|
$processor->extractInfo( $this->dir, $info2, 1 );
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
$extracted = $processor->getExtractedInfo();
|
|
|
|
|
$this->assertEquals( 'somevalue', $extracted['globals']['wgBar'] );
|
|
|
|
|
$this->assertEquals( 10, $extracted['globals']['wgFoo'] );
|
2015-01-27 07:00:07 +00:00
|
|
|
$this->assertArrayNotHasKey( 'wg@IGNORED', $extracted['globals'] );
|
2015-08-23 22:56:59 +00:00
|
|
|
// Custom prefix:
|
|
|
|
|
$this->assertEquals( 'somevalue', $extracted['globals']['egBar'] );
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
}
|
|
|
|
|
|
2016-07-22 22:08:21 +00:00
|
|
|
public function testExtractConfig2() {
|
|
|
|
|
$processor = new ExtensionProcessor;
|
|
|
|
|
$info = [
|
|
|
|
|
'config' => [
|
|
|
|
|
'Bar' => [ 'value' => 'somevalue' ],
|
|
|
|
|
'Foo' => [ 'value' => 10 ],
|
|
|
|
|
'Path' => [ 'value' => 'foo.txt', 'path' => true ],
|
2018-02-10 06:03:42 +00:00
|
|
|
'Namespaces' => [
|
|
|
|
|
'value' => [
|
|
|
|
|
'10' => true,
|
|
|
|
|
'12' => false,
|
|
|
|
|
],
|
|
|
|
|
'merge_strategy' => 'array_plus',
|
|
|
|
|
],
|
2016-07-22 22:08:21 +00:00
|
|
|
],
|
|
|
|
|
] + self::$default;
|
|
|
|
|
$info2 = [
|
|
|
|
|
'config' => [
|
|
|
|
|
'Bar' => [ 'value' => 'somevalue' ],
|
|
|
|
|
],
|
|
|
|
|
'config_prefix' => 'eg',
|
|
|
|
|
'name' => 'FooBar2',
|
|
|
|
|
];
|
|
|
|
|
$processor->extractInfo( $this->dir, $info, 2 );
|
|
|
|
|
$processor->extractInfo( $this->dir, $info2, 2 );
|
|
|
|
|
$extracted = $processor->getExtractedInfo();
|
|
|
|
|
$this->assertEquals( 'somevalue', $extracted['globals']['wgBar'] );
|
|
|
|
|
$this->assertEquals( 10, $extracted['globals']['wgFoo'] );
|
|
|
|
|
$this->assertEquals( "{$this->dirname}/foo.txt", $extracted['globals']['wgPath'] );
|
|
|
|
|
// Custom prefix:
|
|
|
|
|
$this->assertEquals( 'somevalue', $extracted['globals']['egBar'] );
|
2018-02-10 06:03:42 +00:00
|
|
|
$this->assertSame(
|
|
|
|
|
[ 10 => true, 12 => false, ExtensionRegistry::MERGE_STRATEGY => 'array_plus' ],
|
|
|
|
|
$extracted['globals']['wgNamespaces']
|
|
|
|
|
);
|
2016-07-22 22:08:21 +00:00
|
|
|
}
|
|
|
|
|
|
2017-08-28 15:03:47 +00:00
|
|
|
/**
|
|
|
|
|
* @expectedException RuntimeException
|
|
|
|
|
*/
|
|
|
|
|
public function testDuplicateConfigKey1() {
|
|
|
|
|
$processor = new ExtensionProcessor;
|
|
|
|
|
$info = [
|
|
|
|
|
'config' => [
|
|
|
|
|
'Bar' => '',
|
|
|
|
|
]
|
|
|
|
|
] + self::$default;
|
|
|
|
|
$info2 = [
|
|
|
|
|
'config' => [
|
|
|
|
|
'Bar' => 'g',
|
|
|
|
|
],
|
|
|
|
|
'name' => 'FooBar2',
|
|
|
|
|
];
|
|
|
|
|
$processor->extractInfo( $this->dir, $info, 1 );
|
|
|
|
|
$processor->extractInfo( $this->dir, $info2, 1 );
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* @expectedException RuntimeException
|
|
|
|
|
*/
|
|
|
|
|
public function testDuplicateConfigKey2() {
|
|
|
|
|
$processor = new ExtensionProcessor;
|
|
|
|
|
$info = [
|
|
|
|
|
'config' => [
|
|
|
|
|
'Bar' => [ 'value' => 'somevalue' ],
|
|
|
|
|
]
|
|
|
|
|
] + self::$default;
|
|
|
|
|
$info2 = [
|
|
|
|
|
'config' => [
|
|
|
|
|
'Bar' => [ 'value' => 'somevalue' ],
|
|
|
|
|
],
|
|
|
|
|
'name' => 'FooBar2',
|
|
|
|
|
];
|
|
|
|
|
$processor->extractInfo( $this->dir, $info, 2 );
|
|
|
|
|
$processor->extractInfo( $this->dir, $info2, 2 );
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-23 03:18:31 +00:00
|
|
|
public static function provideExtractExtensionMessagesFiles() {
|
2015-02-06 23:02:26 +00:00
|
|
|
$dir = __DIR__ . '/FooBar/';
|
2016-02-17 09:09:32 +00:00
|
|
|
return [
|
|
|
|
|
[
|
|
|
|
|
[ 'ExtensionMessagesFiles' => [ 'FooBarAlias' => 'FooBar.alias.php' ] ],
|
|
|
|
|
[ 'wgExtensionMessagesFiles' => [ 'FooBarAlias' => $dir . 'FooBar.alias.php' ] ]
|
|
|
|
|
],
|
|
|
|
|
[
|
|
|
|
|
[
|
|
|
|
|
'ExtensionMessagesFiles' => [
|
2015-02-06 23:02:26 +00:00
|
|
|
'FooBarAlias' => 'FooBar.alias.php',
|
|
|
|
|
'FooBarMagic' => 'FooBar.magic.i18n.php',
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
[
|
|
|
|
|
'wgExtensionMessagesFiles' => [
|
2015-02-06 23:02:26 +00:00
|
|
|
'FooBarAlias' => $dir . 'FooBar.alias.php',
|
|
|
|
|
'FooBarMagic' => $dir . 'FooBar.magic.i18n.php',
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
];
|
2015-02-06 23:02:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2016-02-23 03:18:31 +00:00
|
|
|
* @dataProvider provideExtractExtensionMessagesFiles
|
2015-02-06 23:02:26 +00:00
|
|
|
*/
|
2016-02-23 03:18:31 +00:00
|
|
|
public function testExtractExtensionMessagesFiles( $input, $expected ) {
|
2015-02-06 23:02:26 +00:00
|
|
|
$processor = new ExtensionProcessor();
|
2015-05-20 01:45:10 +00:00
|
|
|
$processor->extractInfo( $this->dir, $input + self::$default, 1 );
|
2015-02-06 23:02:26 +00:00
|
|
|
$out = $processor->getExtractedInfo();
|
|
|
|
|
foreach ( $expected as $key => $value ) {
|
|
|
|
|
$this->assertEquals( $value, $out['globals'][$key] );
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public static function provideExtractMessagesDirs() {
|
2015-01-30 20:56:02 +00:00
|
|
|
$dir = __DIR__ . '/FooBar/';
|
2016-02-17 09:09:32 +00:00
|
|
|
return [
|
|
|
|
|
[
|
|
|
|
|
[ 'MessagesDirs' => [ 'VisualEditor' => 'i18n' ] ],
|
|
|
|
|
[ 'wgMessagesDirs' => [ 'VisualEditor' => [ $dir . 'i18n' ] ] ]
|
|
|
|
|
],
|
|
|
|
|
[
|
|
|
|
|
[ 'MessagesDirs' => [ 'VisualEditor' => [ 'i18n', 'foobar' ] ] ],
|
|
|
|
|
[ 'wgMessagesDirs' => [ 'VisualEditor' => [ $dir . 'i18n', $dir . 'foobar' ] ] ]
|
|
|
|
|
],
|
|
|
|
|
];
|
2015-01-30 20:56:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
2015-02-06 23:02:26 +00:00
|
|
|
* @dataProvider provideExtractMessagesDirs
|
2015-01-30 20:56:02 +00:00
|
|
|
*/
|
2015-02-06 23:02:26 +00:00
|
|
|
public function testExtractMessagesDirs( $input, $expected ) {
|
2015-01-30 20:56:02 +00:00
|
|
|
$processor = new ExtensionProcessor();
|
2015-05-20 01:45:10 +00:00
|
|
|
$processor->extractInfo( $this->dir, $input + self::$default, 1 );
|
2015-01-30 20:56:02 +00:00
|
|
|
$out = $processor->getExtractedInfo();
|
|
|
|
|
foreach ( $expected as $key => $value ) {
|
|
|
|
|
$this->assertEquals( $value, $out['globals'][$key] );
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-30 01:52:11 +00:00
|
|
|
public function testExtractCredits() {
|
|
|
|
|
$processor = new ExtensionProcessor();
|
|
|
|
|
$processor->extractInfo( $this->dir, self::$default, 1 );
|
2018-01-13 00:02:09 +00:00
|
|
|
$this->setExpectedException( Exception::class );
|
2015-12-30 01:52:11 +00:00
|
|
|
$processor->extractInfo( $this->dir, self::$default, 1 );
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-06 09:46:05 +00:00
|
|
|
/**
|
|
|
|
|
* @dataProvider provideExtractResourceLoaderModules
|
|
|
|
|
*/
|
|
|
|
|
public function testExtractResourceLoaderModules( $input, $expected ) {
|
|
|
|
|
$processor = new ExtensionProcessor();
|
2015-05-20 01:45:10 +00:00
|
|
|
$processor->extractInfo( $this->dir, $input + self::$default, 1 );
|
2015-02-06 09:46:05 +00:00
|
|
|
$out = $processor->getExtractedInfo();
|
|
|
|
|
foreach ( $expected as $key => $value ) {
|
|
|
|
|
$this->assertEquals( $value, $out['globals'][$key] );
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public static function provideExtractResourceLoaderModules() {
|
2016-02-16 20:39:34 +00:00
|
|
|
$dir = __DIR__ . '/FooBar';
|
2016-02-17 09:09:32 +00:00
|
|
|
return [
|
2015-02-06 09:46:05 +00:00
|
|
|
// Generic module with localBasePath/remoteExtPath specified
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
2015-02-06 09:46:05 +00:00
|
|
|
// Input
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
|
|
|
|
'ResourceModules' => [
|
|
|
|
|
'test.foo' => [
|
2015-02-06 09:46:05 +00:00
|
|
|
'styles' => 'foobar.js',
|
|
|
|
|
'localBasePath' => '',
|
|
|
|
|
'remoteExtPath' => 'FooBar',
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
],
|
2015-02-06 09:46:05 +00:00
|
|
|
// Expected
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
|
|
|
|
'wgResourceModules' => [
|
|
|
|
|
'test.foo' => [
|
2015-02-06 09:46:05 +00:00
|
|
|
'styles' => 'foobar.js',
|
|
|
|
|
'localBasePath' => $dir,
|
|
|
|
|
'remoteExtPath' => 'FooBar',
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
],
|
2015-02-06 09:46:05 +00:00
|
|
|
// ResourceFileModulePaths specified:
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
2015-02-06 09:46:05 +00:00
|
|
|
// Input
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
|
|
|
|
'ResourceFileModulePaths' => [
|
2018-02-10 06:03:42 +00:00
|
|
|
'localBasePath' => 'modules',
|
|
|
|
|
'remoteExtPath' => 'FooBar/modules',
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
|
|
|
|
'ResourceModules' => [
|
2015-02-06 09:46:05 +00:00
|
|
|
// No paths
|
2016-02-17 09:09:32 +00:00
|
|
|
'test.foo' => [
|
2015-02-06 09:46:05 +00:00
|
|
|
'styles' => 'foo.js',
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
2015-02-06 09:46:05 +00:00
|
|
|
// Different paths set
|
2016-02-17 09:09:32 +00:00
|
|
|
'test.bar' => [
|
2015-02-06 09:46:05 +00:00
|
|
|
'styles' => 'bar.js',
|
|
|
|
|
'localBasePath' => 'subdir',
|
|
|
|
|
'remoteExtPath' => 'FooBar/subdir',
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
2015-02-06 09:46:05 +00:00
|
|
|
// Custom class with no paths set
|
2016-02-17 09:09:32 +00:00
|
|
|
'test.class' => [
|
2015-02-06 09:46:05 +00:00
|
|
|
'class' => 'FooBarModule',
|
|
|
|
|
'extra' => 'argument',
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
2015-02-06 09:46:05 +00:00
|
|
|
// Custom class with a localBasePath
|
2016-02-17 09:09:32 +00:00
|
|
|
'test.class.with.path' => [
|
2015-02-06 09:46:05 +00:00
|
|
|
'class' => 'FooBarPathModule',
|
|
|
|
|
'extra' => 'argument',
|
|
|
|
|
'localBasePath' => '',
|
2016-02-17 09:09:32 +00:00
|
|
|
]
|
|
|
|
|
],
|
|
|
|
|
],
|
2015-02-06 09:46:05 +00:00
|
|
|
// Expected
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
|
|
|
|
'wgResourceModules' => [
|
|
|
|
|
'test.foo' => [
|
2015-02-06 09:46:05 +00:00
|
|
|
'styles' => 'foo.js',
|
2018-02-10 06:03:42 +00:00
|
|
|
'localBasePath' => "$dir/modules",
|
|
|
|
|
'remoteExtPath' => 'FooBar/modules',
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
|
|
|
|
'test.bar' => [
|
2015-02-06 09:46:05 +00:00
|
|
|
'styles' => 'bar.js',
|
2016-02-16 20:39:34 +00:00
|
|
|
'localBasePath' => "$dir/subdir",
|
2015-02-06 09:46:05 +00:00
|
|
|
'remoteExtPath' => 'FooBar/subdir',
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
|
|
|
|
'test.class' => [
|
2015-02-06 09:46:05 +00:00
|
|
|
'class' => 'FooBarModule',
|
|
|
|
|
'extra' => 'argument',
|
2018-02-10 06:03:42 +00:00
|
|
|
'localBasePath' => "$dir/modules",
|
|
|
|
|
'remoteExtPath' => 'FooBar/modules',
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
|
|
|
|
'test.class.with.path' => [
|
2015-02-06 09:46:05 +00:00
|
|
|
'class' => 'FooBarPathModule',
|
|
|
|
|
'extra' => 'argument',
|
|
|
|
|
'localBasePath' => $dir,
|
2018-02-10 06:03:42 +00:00
|
|
|
'remoteExtPath' => 'FooBar/modules',
|
2016-02-17 09:09:32 +00:00
|
|
|
]
|
|
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
],
|
2015-04-02 17:12:52 +00:00
|
|
|
// ResourceModuleSkinStyles with file module paths
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
2015-04-02 17:12:52 +00:00
|
|
|
// Input
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
|
|
|
|
'ResourceFileModulePaths' => [
|
2015-04-02 17:12:52 +00:00
|
|
|
'localBasePath' => '',
|
|
|
|
|
'remoteSkinPath' => 'FooBar',
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
|
|
|
|
'ResourceModuleSkinStyles' => [
|
|
|
|
|
'foobar' => [
|
2015-04-02 17:12:52 +00:00
|
|
|
'test.foo' => 'foo.css',
|
2016-02-17 09:09:32 +00:00
|
|
|
]
|
|
|
|
|
],
|
|
|
|
|
],
|
2015-04-02 17:12:52 +00:00
|
|
|
// Expected
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
|
|
|
|
'wgResourceModuleSkinStyles' => [
|
|
|
|
|
'foobar' => [
|
2015-04-02 17:12:52 +00:00
|
|
|
'test.foo' => 'foo.css',
|
|
|
|
|
'localBasePath' => $dir,
|
|
|
|
|
'remoteSkinPath' => 'FooBar',
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
],
|
2015-04-02 17:12:52 +00:00
|
|
|
// ResourceModuleSkinStyles with file module paths and an override
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
2015-04-02 17:12:52 +00:00
|
|
|
// Input
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
|
|
|
|
'ResourceFileModulePaths' => [
|
2015-04-02 17:12:52 +00:00
|
|
|
'localBasePath' => '',
|
|
|
|
|
'remoteSkinPath' => 'FooBar',
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
|
|
|
|
'ResourceModuleSkinStyles' => [
|
|
|
|
|
'foobar' => [
|
2015-04-02 17:12:52 +00:00
|
|
|
'test.foo' => 'foo.css',
|
|
|
|
|
'remoteSkinPath' => 'BarFoo'
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
],
|
2015-04-02 17:12:52 +00:00
|
|
|
// Expected
|
2016-02-17 09:09:32 +00:00
|
|
|
[
|
|
|
|
|
'wgResourceModuleSkinStyles' => [
|
|
|
|
|
'foobar' => [
|
2015-04-02 17:12:52 +00:00
|
|
|
'test.foo' => 'foo.css',
|
|
|
|
|
'localBasePath' => $dir,
|
|
|
|
|
'remoteSkinPath' => 'BarFoo',
|
2016-02-17 09:09:32 +00:00
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
];
|
2015-02-06 09:46:05 +00:00
|
|
|
}
|
|
|
|
|
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
public static function provideSetToGlobal() {
|
2016-02-17 09:09:32 +00:00
|
|
|
return [
|
|
|
|
|
[
|
|
|
|
|
[ 'wgAPIModules', 'wgAvailableRights' ],
|
|
|
|
|
[],
|
|
|
|
|
[
|
|
|
|
|
'APIModules' => [ 'foobar' => 'ApiFooBar' ],
|
|
|
|
|
'AvailableRights' => [ 'foobar', 'unfoobar' ],
|
|
|
|
|
],
|
|
|
|
|
[
|
|
|
|
|
'wgAPIModules' => [ 'foobar' => 'ApiFooBar' ],
|
|
|
|
|
'wgAvailableRights' => [ 'foobar', 'unfoobar' ],
|
|
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
[
|
|
|
|
|
[ 'wgAPIModules', 'wgAvailableRights' ],
|
|
|
|
|
[
|
|
|
|
|
'wgAPIModules' => [ 'barbaz' => 'ApiBarBaz' ],
|
|
|
|
|
'wgAvailableRights' => [ 'barbaz' ]
|
|
|
|
|
],
|
|
|
|
|
[
|
|
|
|
|
'APIModules' => [ 'foobar' => 'ApiFooBar' ],
|
|
|
|
|
'AvailableRights' => [ 'foobar', 'unfoobar' ],
|
|
|
|
|
],
|
|
|
|
|
[
|
|
|
|
|
'wgAPIModules' => [ 'barbaz' => 'ApiBarBaz', 'foobar' => 'ApiFooBar' ],
|
|
|
|
|
'wgAvailableRights' => [ 'barbaz', 'foobar', 'unfoobar' ],
|
|
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
[
|
|
|
|
|
[ 'wgGroupPermissions' ],
|
|
|
|
|
[
|
|
|
|
|
'wgGroupPermissions' => [
|
|
|
|
|
'sysop' => [ 'delete' ]
|
|
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
[
|
|
|
|
|
'GroupPermissions' => [
|
|
|
|
|
'sysop' => [ 'undelete' ],
|
|
|
|
|
'user' => [ 'edit' ]
|
|
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
[
|
|
|
|
|
'wgGroupPermissions' => [
|
|
|
|
|
'sysop' => [ 'delete', 'undelete' ],
|
|
|
|
|
'user' => [ 'edit' ]
|
|
|
|
|
],
|
|
|
|
|
]
|
|
|
|
|
]
|
|
|
|
|
];
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
}
|
2016-06-10 20:11:01 +00:00
|
|
|
|
2016-12-02 06:02:28 +00:00
|
|
|
/**
|
|
|
|
|
* Attributes under manifest_version 2
|
|
|
|
|
*/
|
|
|
|
|
public function testExtractAttributes() {
|
|
|
|
|
$processor = new ExtensionProcessor();
|
|
|
|
|
// Load FooBar extension
|
|
|
|
|
$processor->extractInfo( $this->dir, [ 'name' => 'FooBar' ], 2 );
|
|
|
|
|
$processor->extractInfo(
|
|
|
|
|
$this->dir,
|
|
|
|
|
[
|
|
|
|
|
'name' => 'Baz',
|
|
|
|
|
'attributes' => [
|
|
|
|
|
// Loaded
|
|
|
|
|
'FooBar' => [
|
|
|
|
|
'Plugins' => [
|
|
|
|
|
'ext.baz.foobar',
|
|
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
// Not loaded
|
|
|
|
|
'FizzBuzz' => [
|
|
|
|
|
'MorePlugins' => [
|
|
|
|
|
'ext.baz.fizzbuzz',
|
|
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
2
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
$info = $processor->getExtractedInfo();
|
|
|
|
|
$this->assertArrayHasKey( 'FooBarPlugins', $info['attributes'] );
|
|
|
|
|
$this->assertSame( [ 'ext.baz.foobar' ], $info['attributes']['FooBarPlugins'] );
|
|
|
|
|
$this->assertArrayNotHasKey( 'FizzBuzzMorePlugins', $info['attributes'] );
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Attributes under manifest_version 1
|
|
|
|
|
*/
|
|
|
|
|
public function testAttributes1() {
|
|
|
|
|
$processor = new ExtensionProcessor();
|
|
|
|
|
$processor->extractInfo(
|
|
|
|
|
$this->dir,
|
|
|
|
|
[
|
|
|
|
|
'name' => 'FooBar',
|
|
|
|
|
'FooBarPlugins' => [
|
|
|
|
|
'ext.baz.foobar',
|
|
|
|
|
],
|
|
|
|
|
'FizzBuzzMorePlugins' => [
|
|
|
|
|
'ext.baz.fizzbuzz',
|
|
|
|
|
],
|
|
|
|
|
],
|
|
|
|
|
1
|
|
|
|
|
);
|
2018-02-10 06:03:42 +00:00
|
|
|
$processor->extractInfo(
|
|
|
|
|
$this->dir,
|
|
|
|
|
[
|
|
|
|
|
'name' => 'FooBar2',
|
|
|
|
|
'FizzBuzzMorePlugins' => [
|
|
|
|
|
'ext.bar.fizzbuzz',
|
|
|
|
|
]
|
|
|
|
|
],
|
|
|
|
|
1
|
|
|
|
|
);
|
2016-12-02 06:02:28 +00:00
|
|
|
|
|
|
|
|
$info = $processor->getExtractedInfo();
|
|
|
|
|
$this->assertArrayHasKey( 'FooBarPlugins', $info['attributes'] );
|
|
|
|
|
$this->assertSame( [ 'ext.baz.foobar' ], $info['attributes']['FooBarPlugins'] );
|
|
|
|
|
$this->assertArrayHasKey( 'FizzBuzzMorePlugins', $info['attributes'] );
|
2018-02-10 06:03:42 +00:00
|
|
|
$this->assertSame(
|
|
|
|
|
[ 'ext.baz.fizzbuzz', 'ext.bar.fizzbuzz' ],
|
|
|
|
|
$info['attributes']['FizzBuzzMorePlugins']
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testAttributes1_notarray() {
|
|
|
|
|
$processor = new ExtensionProcessor();
|
|
|
|
|
$this->setExpectedException(
|
|
|
|
|
InvalidArgumentException::class,
|
|
|
|
|
"The value for 'FooBarPlugins' should be an array (from {$this->dir})"
|
|
|
|
|
);
|
|
|
|
|
$processor->extractInfo(
|
|
|
|
|
$this->dir,
|
|
|
|
|
[
|
|
|
|
|
'FooBarPlugins' => 'ext.baz.foobar',
|
|
|
|
|
] + self::$default,
|
|
|
|
|
1
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-10 06:21:19 +00:00
|
|
|
public function testExtractPathBasedGlobal() {
|
2018-02-10 06:03:42 +00:00
|
|
|
$processor = new ExtensionProcessor();
|
|
|
|
|
$processor->extractInfo(
|
|
|
|
|
$this->dir,
|
|
|
|
|
[
|
|
|
|
|
'ParserTestFiles' => [
|
|
|
|
|
'tests/parserTests.txt',
|
|
|
|
|
'tests/extraParserTests.txt',
|
|
|
|
|
],
|
|
|
|
|
'ServiceWiringFiles' => [
|
|
|
|
|
'includes/ServiceWiring.php'
|
|
|
|
|
],
|
|
|
|
|
] + self::$default,
|
|
|
|
|
1
|
|
|
|
|
);
|
|
|
|
|
$globals = $processor->getExtractedInfo()['globals'];
|
|
|
|
|
$this->assertArrayHasKey( 'wgParserTestFiles', $globals );
|
|
|
|
|
$this->assertSame( [
|
|
|
|
|
"{$this->dirname}/tests/parserTests.txt",
|
|
|
|
|
"{$this->dirname}/tests/extraParserTests.txt"
|
|
|
|
|
], $globals['wgParserTestFiles'] );
|
|
|
|
|
$this->assertArrayHasKey( 'wgServiceWiringFiles', $globals );
|
|
|
|
|
$this->assertSame( [
|
|
|
|
|
"{$this->dirname}/includes/ServiceWiring.php"
|
|
|
|
|
], $globals['wgServiceWiringFiles'] );
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testGetRequirements() {
|
|
|
|
|
$info = self::$default + [
|
|
|
|
|
'requires' => [
|
|
|
|
|
'MediaWiki' => '>= 1.25.0',
|
2018-09-08 00:02:53 +00:00
|
|
|
'platform' => [
|
|
|
|
|
'php' => '>= 5.5.9'
|
|
|
|
|
],
|
2018-02-10 06:03:42 +00:00
|
|
|
'extensions' => [
|
|
|
|
|
'Bar' => '*'
|
|
|
|
|
]
|
|
|
|
|
]
|
|
|
|
|
];
|
|
|
|
|
$processor = new ExtensionProcessor();
|
|
|
|
|
$this->assertSame(
|
|
|
|
|
$info['requires'],
|
|
|
|
|
$processor->getRequirements( $info )
|
|
|
|
|
);
|
|
|
|
|
$this->assertSame(
|
|
|
|
|
[],
|
|
|
|
|
$processor->getRequirements( [] )
|
|
|
|
|
);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public function testGetExtraAutoloaderPaths() {
|
|
|
|
|
$processor = new ExtensionProcessor();
|
|
|
|
|
$this->assertSame(
|
|
|
|
|
[ "{$this->dirname}/vendor/autoload.php" ],
|
|
|
|
|
$processor->getExtraAutoloaderPaths( $this->dirname, [
|
|
|
|
|
'load_composer_autoloader' => true,
|
|
|
|
|
] )
|
|
|
|
|
);
|
2016-12-02 06:02:28 +00:00
|
|
|
}
|
|
|
|
|
|
2017-12-28 08:38:21 +00:00
|
|
|
/**
|
|
|
|
|
* Verify that extension.schema.json is in sync with ExtensionProcessor
|
|
|
|
|
*
|
|
|
|
|
* @coversNothing
|
|
|
|
|
*/
|
2016-06-10 20:11:01 +00:00
|
|
|
public function testGlobalSettingsDocumentedInSchema() {
|
|
|
|
|
global $IP;
|
|
|
|
|
$globalSettings = TestingAccessWrapper::newFromClass(
|
|
|
|
|
ExtensionProcessor::class )->globalSettings;
|
|
|
|
|
|
2016-12-16 19:32:26 +00:00
|
|
|
$version = ExtensionRegistry::MANIFEST_VERSION;
|
2016-06-10 20:11:01 +00:00
|
|
|
$schema = FormatJson::decode(
|
2016-12-16 19:32:26 +00:00
|
|
|
file_get_contents( "$IP/docs/extension.schema.v$version.json" ),
|
2016-06-10 20:11:01 +00:00
|
|
|
true
|
|
|
|
|
);
|
|
|
|
|
$missing = [];
|
|
|
|
|
foreach ( $globalSettings as $global ) {
|
|
|
|
|
if ( !isset( $schema['properties'][$global] ) ) {
|
|
|
|
|
$missing[] = $global;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
$this->assertEquals( [], $missing,
|
|
|
|
|
"The following global settings are not documented in docs/extension.schema.json" );
|
|
|
|
|
}
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
|
* Allow overriding the default value of $this->globals
|
|
|
|
|
* so we can test merging
|
|
|
|
|
*/
|
|
|
|
|
class MockExtensionProcessor extends ExtensionProcessor {
|
2016-02-17 09:09:32 +00:00
|
|
|
public function __construct( $globals = [] ) {
|
Implement extension registration from an extension.json file
Introduces wfLoadExtension()/wfLoadSkin() which should be used in
LocalSettings.php rather than require-ing a PHP entry point.
Extensions and skins would add "extension.json" or "skin.json" files
in their root, which contains all the information typically
present in PHP entry point files (classes to autoload, special pages,
API modules, etc.) A full schema can be found at
docs/extension.schema.json, and a script to validate these to the
schema is provided. An additional script is provided to convert
typical PHP entry point files into their JSON equivalents.
The basic flow of loading an extension goes like:
* Get the ExtensionRegistry singleton instance
* ExtensionRegistry takes a filename, reads the file or tries
to get the parsed JSON from APC if possible.
* The JSON is run through a Processor instance,
which registers things with the appropriate
global settings.
* The output of the processor is cached in APC if possible.
* The extension/skin is marked as loaded in the
ExtensionRegistry and a callback function is executed
if one was specified.
For ideal performance, a batch loading method is also provided:
* The absolute path name to the JSON file is queued
in the ExtensionRegistry instance.
* When loadFromQueue() is called, it constructs a hash
unique to the members of the current queue, and sees
if the queue has been cached in APC. If not, it processes
each file individually, and combines the result of each
Processor into one giant array, which is cached in APC.
* The giant array then sets various global settings,
defines constants, and calls callbacks.
To invalidate the cached processed info, by default the mtime
of each JSON file is checked. However that can be slow if you
have a large number of extensions, so you can set $wgExtensionInfoMTime
to the mtime of one file, and `touch` it whenever you update
your extensions.
Change-Id: I7074b65d07c5c7d4e3f1fb0755d74a0b07ed4596
2014-10-15 00:31:15 +00:00
|
|
|
$this->globals = $globals + $this->globals;
|
|
|
|
|
}
|
|
|
|
|
}
|
