composer/doc/articles/scripts.md

Scripts

What is a script?

A script, in Composer's terms, can either be a PHP callback (defined as a static method) or any command-line executable command. Scripts are useful for executing a package's custom code or package-specific commands during the Composer execution process.

NOTE: Only scripts defined in the root package's composer.json are executed. If a dependency of the root package specifies its own scripts, Composer does not execute those additional scripts.

Event names

Composer fires the following named events during its execution process:

• pre-install-cmd: occurs before the install command is executed.
• post-install-cmd: occurs after the install command is executed.
• pre-update-cmd: occurs before the update command is executed.
• post-update-cmd: occurs after the update command is executed.
• pre-package-install: occurs before a package is installed.
• post-package-install: occurs after a package is installed.
• pre-package-update: occurs before a package is updated.
• post-package-update: occurs after a package is updated.
• pre-package-uninstall: occurs before a package has been uninstalled.
• post-package-uninstall: occurs after a package has been uninstalled.
• post-autoload-dump: occurs after the autoloader is dumped, either during install/update, or via the dump-autoload command.

Defining scripts

The root JSON object in composer.json should have a property called "scripts", which contains pairs of named events and each event's corresponding scripts. An event's scripts can be defined as either as a string (only for a single script) or an array (for single or multiple scripts.)

For any given event:

• Scripts execute in the order defined when their corresponding event is fired.
• An array of scripts wired to a single event can contain both PHP callbacks and command-line executables commands.
• PHP classes containing defined callbacks must be autoloadable via Composer's autoload functionality.

Script definition example:

{
    "scripts": {
        "post-update-cmd": "MyVendor\\MyClass::postUpdate",
        "post-package-install": [
            "MyVendor\\MyClass::postPackageInstall"
        ],
        "post-install-cmd": [
            "MyVendor\\MyClass::warmCache",
            "phpunit -c app/"
        ]
    }
}

Using the previous definition example, here's the class MyVendor\MyClass that might be used to execute the PHP callbacks:

<?php

namespace MyVendor;

use Composer\Script\Event;

class MyClass
{
    public static function postUpdate(Event $event)
    {
        $composer = $event->getComposer();
        // do stuff
    }

    public static function postPackageInstall(Event $event)
    {
        $installedPackage = $event->getOperation()->getPackage();
        // do stuff
    }

    public static function warmCache(Event $event)
    {
        // make cache toasty
    }
}

When an event is fired, Composer's internal event handler receives a Composer\Script\Event object, which is passed as the first argument to your PHP callback. This Event object has getters for other contextual objects:

• getComposer(): returns the current instance of Composer\Composer
• getName(): returns the name of the event being fired as a string
• getIO(): returns the current input/output stream which implements Composer\IO\IOInterface for writing to the console