Composer/For extensions

From MediaWiki.org
Jump to: navigation, search

As of MediaWiki 1.22, you can use Composer[1] to install MediaWiki extensions which include a composer.json manifest and are published on the Packagist package repository.

Composer requires shell access. If you do not have shell access to the server of your website, it is also possible to set up MediaWiki and Composer on a local computer, for instance using an AMP package, and transfer the installed files to the remote server.

What is Composer[edit]

Composer is a dependency manager that automates many of the tasks one has to deal with when installing extensions. The following points no longer have to be dealt with if you install extensions with Composer:

  • Where do I download it from, and how? (A: this depends on the extension and can vary a lot)
  • Where do I put it, and how do I load it? (A: editing a PHP file and adding a PHP includes into it)
  • What other extensions or libraries are needed? (A: it depends, and often this is not well documented)
  • What versions of those extensions are compatible? (A: it depends, and rarely is well documented)
  • In what order do I need to include the extensions? (A: indeed, it depends, and is often not well documented)

Current status[edit]

Composer managed extension installation in MediaWiki is only possible since version 1.22. If you have an older version of MediaWiki, you can use the Extension Installer extension to achieve the same capabilities.[2]

In order for an extension to be installable with Composer, it needs to provide certain details. As a result, most MediaWiki extensions are not currently installable with Composer. You can look at the list of packages tagged with "MediaWiki" on Packagist to find the extensions that can already be installed via Composer.

In April 2015[3], an RfC to make Composer based extension management the preferred method of managing all MediaWiki extensions was pulled from discussion. This was motivated by the seemingly intractable problem of managing extensions for a Wikifarm when using Composer. A Composer managed extension can only be disabled by removing the extension entirely due to the manner in which these extensions ensure that their entry point file is loaded. Support for use of Composer for those not running wiki farms has not been removed from Composer or MediaWiki as a result, but it is possible that it may be at some point in the future if it conflicts with the newer extension registration system. Such a decision would likely provide a migration path for those who had been using Composer to manage their extensions.

User manual[edit]

Installing Composer[edit]

Download Composer. See the instructions on that download page for all options. Important to note is that one can simply get the composer.phar file and run Composer via this file.

wget https://getcomposer.org/composer.phar
php composer.phar someCommand

This is equivalent to doing an actual installation of Composer and then running

composer someCommand

Specify the extensions to be installed[edit]

Since MediaWiki 1.25, MediaWiki itself uses Composer to manage external library dependencies. In order to allow inter-operation with using Composer to install extensions, a special plugin for Composer named composer-merge-plugin was developed[4]. This plugin and the MediaWiki core composer.json configuration allow a local deployment to add required extensions and libraries to a file composer.local.json inside the root MediaWiki directory. When using versions of MediaWiki prior to 1.25 the changes described below should be made to the composer.json file instead.

In this file, add the extensions you want to install in the "require" section. See "declaring dependencies" and "package setup". Or have a look at the examples below.

This example specifies that the SubPageList extension should be installed. It also specifies that you want version 1.0 or above.

{
    "require": {
        "mediawiki/sub-page-list": ">=1.0"
    }
}

For each additional extension you need, a new line is added. This example also adds Semantic MediaWiki, and specifies that you are happy with the latest version compatible with your setup.

{
    "require": {
        "mediawiki/sub-page-list": ">=1.0",
        "mediawiki/semantic-media-wiki": "*"
    }
}

Each line, except the last one, should have a comma at the end. Also note that you only need to specify the extensions you need, and do not have to bother with their dependencies. For instance, if you want to install Semantic Maps, Composer will automatically install its dependencies, such as Maps and Semantic MediaWiki, for you.

Installing and upgrading extensions[edit]

Once you specified the extensions you want to install, run "composer update". To verify installation was successful, hit Special:Version and see if the desired extensions are listed.

When you want a new version of an extension, update the versions in the composer.local.json file, and run "composer update".

Upgrading extensions not using Composer yet[edit]

If you are upgrading an extension from a version that does not use Composer to one that does, you will first need to (partially) remove the extension, and then follow the standard installation instructions. A step by step tutorial can be found here.

Removing a package[edit]

Simply remove the extension from your composer.local.json file, and run composer update

Common problems[edit]

Your requirements could not be resolved to an installable set of packages.

  Problem 1
    - Installation request for mediawiki/semantic-mediawiki dev-master -> satisfiable by mediawiki/semantic-mediawiki[dev-master].
    - mediawiki/semantic-mediawiki dev-master requires param-processor/param-processor dev-master -> no matching package found.

If you run into this error, first double check that there is no typo in any of the package names. In case the names are all correct, there might be a dependency that has no matching stable release. You can specify that Composer is allowed to install packages still in development state by adding the "minimum-stability" flag to your composer.local.json file. Example:

{
    "require": {
        "php": ">=5.3.2",
        "mediawiki/sub-page-list": ">=1.0"
    },
    "minimum-stability" : "dev"
}

Developer resources[edit]

A more up to date list of instructions can be found in Introduction to Composer for MediaWiki developers.

On packagist.org[edit]

Packagist.org is the central composer package repository.

A "mediawiki" user exists on Packagist to have GitHub notify packagist whenever a new commit land in the repository. The credentials for the mediawiki user are only accessible to Wikimedia Foundation Operations team (they used to be on fenari:/home/wikipedia/doc/packagist.org but got moved RT #6665). Legoktm has access to the account, so poke him if you want a package added.

composer.json[edit]

You want to add a composer.json file in your extension. Here is an example from Translate:

{
	"name": "mediawiki/translate",
	"type": "mediawiki-extension",   
	"description": "Let your user translate any kind of text",
	"homepage": "http://www.mediawiki.org/wiki/Extension:Translate",
	"license" : "GPL-2.0+",

	"require": {
		"composer/installers": ">=1.0.1",
	},
	"suggest": {
		"mediawiki/translation-notifications": "Manage communication with translators"
	}
}

More examples can be found at Manual:composer.json best practices.

Then we check the syntax to avoid mistakes:

$ composer validate
./composer.json is valid

Test composer.json[edit]

Before you commit your composer.json, you should test it. There is a chicken-and-egg problem here. You must commit your extension's composer.json before you publish the extension in packagist. To solve this problem, you can use a local repository of type "artifact" instead of packagist.

First create the composer artifact repository in your main MediaWiki directory:

cd <your main MediaWiki directory>
mkdir composer_artifacts

Next, edit the composer.json file in your main MediaWiki directory and add this repository:

    "repositories": [
        {
            "type": "artifact",
            "url": "composer_artifacts"
        }
    ],

You can then put a zipped version of your extension in this local repository like this:

cd <your extension dir>
zip -r your-extension.zip *
mv your-extension.zip ../../composer_artifacts

There is a catch. When composer uses an artifact type repository you must add the package version in your extension's composer.json (because composer cannot infer the version number from some place like a git tag in this case).

For testing, you may add version information to your extension composer.json like this:

"version": "dev-master",

Since you should not commit your extension's composer.json with version information in it, a good practice is to only add the version information in the zipped version (not the original).

To test your extension's installation, add the extension with a version of "dev-master" to your composer.local.json.

Publish extension in packagist[edit]

See Manual:Developing libraries#Packagist guidelines for information on how to add your extension to packagist.org.

See also[edit]

References[edit]