PHP Master | Erstellen Sie die Automatisierung mit Komponistenskripten

Nach der Einführung von Alexander Caneau in das Abhängigkeitsmanagement mit Komponisten Sie wissen jetzt, dass Composer ein Resolver für die Verwaltung externer Projektabhängigkeiten und Versionungsbeschränkungen ist. Aber ist das alles, was es tut? In diesem Artikel werde ich Ihnen zeigen, wie Komponist auch als grundlegendes Build -Automatisierungswerkzeug verwendet werden kann.

Key Takeaways

• Komponist, abgesehen davon, dass sie ein Resolver für die Verwaltung externer Projektabhängigkeiten und -versionsbeschränkungen sind, kann auch als grundlegendes Build -Automatisierungswerkzeug verwendet werden. Es enthüllt Pre
• und post
• Installieren/Aktualisieren/Deinstallieren von Ereignishaken während der Ausführung, die für eine Reihe von automatisierten Aufgaben geschrieben werden kann.

Komponistskripte

Jedes Build -Automatisierungswerkzeug, das sein Salz wert ist, muss eine Reihe automatisierter Aufgaben entstellen - vom Erstellen, Verpackung und Ausführen von Testsuiten bis hin zur Bereitstellung von Staging- und Produktionssystemen. Phing basiert beispielsweise auf ANT und erlaubt Ihnen, solche Aufgaben in XML -Build -Dateien zu definieren. Der Komponist unterscheidet sich in dieser Hinsicht darin, dass es keine Annahmen darüber macht, welche Aufgaben sie sind oder ob sie überhaupt ausgeführt werden sollen. Was der Komponist stattdessen tut, ist seine Vor- und Nach- und Post-Installations-/Update-/Deinstallationsereignishaken während der Ausführung, die Sie mit „Skripten“ zurückrufen können, genauso wie Pyrus die Möglichkeit bietet, benutzerdefinierte Befehle im paket.xml über die zu definieren -Plugugin-Option zu den Befehlen Installation, Upgrade und Deinstallation. Die Skripteigenschaft ist im Root JSON -Objekt des Composer.json des Root -Pakets definiert Datei. Sie können eine beliebige Anzahl von statischen PHP-Methoden (die durch den Autoloadermechanismus des Komponisten automatisch laden), Befehlszeilen ausführbare oder eine Kombination aus beiden definieren. Alle benutzerdefinierten Code- oder paketspezifischen Befehle, die von diesen Skripten definiert wurden, werden dann während des Ausführungsprozesses des Komponisten aufgerufen. Die Einschränkung ist, dass nur die im Komponisten des Stammpakets definierten Skripte ausgeführt werden. Der Komponist führt keine Skripte aus, die in einer Abhängigkeit des Stammpakets angegeben sind. Die folgenden Ereignisse werden während des Komponistenausführungsprozesses abgefeuert:

• vorinstallieren-cmd-tritt vor, bevor der Installationsbefehl ausgeführt wird
• nach der Installation CMD-tritt nach Ausführung des Installationsbefehls
auf
pre-update-cmd-tritt vor, bevor der Aktualisierungsbefehl ausgeführt wird
post-update-cmd-tritt nach, nachdem der Aktualisierungsbefehl ausgeführt wurde
Vorpackungstall-tritt vor, bevor ein Paket installiert ist
Post-Package-Installation-tritt nach der Installation eines Pakets auf
Vorverpackung-tritt vor, bevor ein Paket aktualisiert wird
postpackage-update-tritt nach, nachdem ein Paket aktualisiert wurde
Vorpackung-Uninstall-tritt vor, bevor ein Paket deinstalliert wird
Nach-Package-Uninstall-tritt auf, nachdem ein Paket deinstalliert wurde

Diese sind ziemlich selbsterklärend, und ich denke, Sie werden zustimmen, dass die Schönheit in ihrer Einfachheit liegt. Aber um zu veranschaulichen, finden Sie hier ein Beispiel Root -Paket Composer.json:

<span>{
</span>    <span>"name": "MyProject",
</span>    <span>"description": "An example to demonstrate the use of Composer scripts",
</span>    <span>"version": "1.0.0",
</span>    <span>"require": {
</span>        <span>"php": ">=5.3",
</span>        <span>"ext-xsl": "*",
</span>        <span>"ext-imap": "*",
</span>        <span>"ext-gd": "*"
</span>      <span>},
</span>
    <span>"autoload": {
</span>        <span>"psr-0": {
</span>            <span>"MyProject": "src/"
</span>        <span>}
</span>    <span>},
</span>
    <span>"scripts": {
</span>        <span>"pre-install-cmd": "MyProject\Installer::preInstall",
</span>        <span>"post-install-cmd": [
</span>            <span>"MyProject\Installer::postInstall"
</span>        <span>],
</span>        <span>"post-package-install": [
</span>            <span>"MyProject\Installer::postPackageInstall",
</span>            <span>"phpunit -c /tests",
</span>            <span>"./bin/install.sh"
</span>        <span>]
</span>    <span>}
</span><span>}</span>

Ich habe einige Skripte für die Ereignisse vor der Installation von CMD-, Post-Installation-CMD- und Post-Package-Installation definiert. Wie Sie sehen können, können wir eine beliebige Kombination statischer PHP-Methoden und ausführbaren Befehlszeilen definieren. Im Fall des Ereignisses nach dem Package-Installation werden auch einige Unit-Tests und ein benutzerdefiniertes Installationsskript ausgeführt. So sieht unser Beispielskript aus:

<span><span><?php
</span></span><span><span>namespace MyProject;
</span></span><span><span>use ComposerScriptEvent;
</span></span><span>
</span><span><span>class Installer
</span></span><span><span>{
</span></span><span>    <span>public static function preInstall(Event $event) {
</span></span><span>        <span>// provides access to the current ComposerIOConsoleIO
</span></span><span>        <span>// stream for terminal input/output
</span></span><span>        <span>$io = $event->getIO();
</span></span><span>        <span>if ($io->askConfirmation("Are you sure you want to proceed? ", false)) {
</span></span><span>            <span>// ok, continue on to composer install
</span></span><span>            <span>return true;
</span></span><span>        <span>}
</span></span><span>        <span>// exit composer and terminate installation process
</span></span><span>        <span>exit;
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public static function postInstall(Event $event) {
</span></span><span>        <span>// provides access to the current Composer instance
</span></span><span>        <span>$composer = $event->getComposer();
</span></span><span>        <span>// run any post install tasks here
</span></span><span>    <span>}
</span></span><span>
</span><span>    <span>public static function postPackageInstall(Event $event) {
</span></span><span>        <span>$installedPackage = $event->getComposer()->getPackage();
</span></span><span>        <span>// any tasks to run after the package is installed?
</span></span><span>    <span>}
</span></span><span><span>}</span></span>

Wenn jedes dieser Ereignisse abgefeuert wird, übergibt der interne Ereignishandler des Komponisten ein CompoSserscripeVent -Objekt als erstes (und einziges) Argument für jedes der Rückrufe. Die Veranstaltung Das Objekt setzt den folgenden Getters anderen Komponisten -Objekten Ihrem Rückruf aus:

• getComposer () - Gibt die aktuelle Instanz von CompoSerComposer
zurück
• getName () - Gibt den Namen des Ereignisses zurück
getio () - Gibt den aktuellen Eingangs-/Ausgabestream zurück, der CompoSerioIOnterface zum Lesen/Schreiben in die Konsole

implementiert

Sie können sich auf die Komponist -API -Dokumentation für jede der Methodensignaturen und für die anderen Methoden beziehen, die jede dieser Objekte enthüllt - insbesondere die Komponistinstanz und die IO -Schnittstelle. Während diese scheinbar rudimentäre Implementierung möglicherweise nicht so „mächtig“ erscheint wie PHING -Definitionen, widerlegt seine Einfachheit der unglaublichen Flexibilität. Es nutzt Ihre vorhandenen Wissensinvestitionen in PHP. Mit ein wenig Kreativität und Vorstellungskraft können Sie die Abhängigkeitsresösung von Composers Abhängigkeit und native PHP-Skripten verwenden, um einige ziemlich komplexe Build- und Stimmaufgaben zu erstellen. Sie könnten dies sogar in Jenkins für die kontinuierliche Integration integrieren.

Zusammenfassung In diesem Artikel habe ich ein rudimentäres Beispiel dafür vorgestellt, wie Komponisten -Skripte zur Durchführung von Build -Automatisierung verwendet werden können. Diese Aufgaben können so einfach oder komplex sein, wie Sie benötigen, da sie Ihre vorhandenen Wissensinvestitionen in PHP nutzen. Und hoffentlich wird Sie in diesem Artikel dazu inspirieren, Composer für mehr als nur das Abhängigkeitsmanagement zu verwenden. Weitere Informationen zur Verwendung von Composer -Skripten finden Sie unter GetComposer.org/doc/articles/Scripts.md. Bild über Fotolien

häufig gestellte Fragen (FAQs) zur Build -Automatisierung mit Composer -Skripten

Was ist die primäre Funktion des Komponisten in der PHP -Entwicklung? Sie können die Bibliotheken erklären, von denen Ihr Projekt abhängt, und es wird für Sie verwaltet (installieren/aktualisieren). Komponist ist kein Paketmanager im gleichen Sinne wie Yum oder Apt. Ja, es handelt sich um „Pakete“ oder Bibliotheken, verwaltet sie jedoch projektbasis und installiert sie in einem Verzeichnis (z. B. Anbieter) in Ihrem Projekt.

Wie kann ich Aufgaben mithilfe von Composer -Skripten automatisieren? Sie sind in der Datei composer.json definiert und können mit dem Befehl "Composer Run-Script" aus der Befehlszeile ausgeführt werden. Skripte können verwendet werden, um Aufgaben wie Tests, Erstellen und Bereitstellungen zu automatisieren. Sie können auch verwendet werden, um benutzerdefinierten PHP -Code auszuführen.

Kann ich Composer -Skripte zum Testen verwenden? Sie können ein Skript in Ihrer Composer.json -Datei definieren, in der Ihre Tests ausgeführt werden. Sie können beispielsweise ein Skript mit dem Namen "Test" definieren, das Phpunit ausführt. Anschließend können Sie Ihre Tests aus der Befehlszeile mit dem Befehl 'Composer Run-Script-Test' ausführen. Durch Definieren eines Skripts in Ihrer Composer.json -Datei, in der die erforderlichen Schritte zur Bereitstellung Ihrer Anwendung ausgeführt werden. Dies kann Aufgaben wie das Kompilieren von Assets, das Optimieren von Code und das Hochladen von Dateien auf einen Server umfassen. Sobald das Skript definiert ist, können Sie es aus der Befehlszeile mit dem Befehl 'Composer Run-script' ausführen. Benutzerdefinierte PHP -Code. Sie können ein Skript in Ihrer Composer.json -Datei definieren, in der eine PHP -Datei ausgeführt wird. Die PHP -Datei kann jeden gewünschten Code enthalten. Wenn Sie das Skript mit dem Befehl 'Composer Run-script' ausführen, wird der PHP-Code ausgeführt.

Wie kann ich Skripte in Composer verwalten? .Json -Datei. Jedes Skript wird als ein Schlüsselwertepaar definiert, wobei der Schlüssel der Name des Skripts und der Wert ist, der der zu ausgeführte Befehl ist. Sie können Skripte hinzufügen, ändern oder entfernen, indem Sie die Datei composer.json bearbeiten. . Durch das Definieren von Skripten in Ihrer Composer.json -Datei können Sie Aufgaben wie das Kompilieren von Code, das Minimieren von Assets und das Generieren von Dokumentationen automatisieren. Diese Skripte können dann mit dem Befehl 'Composer Run-script' aus der Befehlszeile ausgeführt werden. Ihr Entwicklungsprozess effizienter. Durch die Automatisierung von Wiederholungsaufgaben können Sie Zeit sparen und das Fehlerrisiko verringern. Composer -Skripte machen Ihren Build -Prozess auch konsistenter, da dieselben Aufgaben jedes Mal auf die gleiche Weise ausgeführt werden.

Kann ich Composer -Skripte in Verbindung mit anderen Tools verwenden? kann in Verbindung mit anderen Werkzeugen verwendet werden. Beispielsweise können Sie ein Komponisten -Skript verwenden, um eine Gulp -Aufgabe auszuführen oder eine Phpunit -Testsuite auszuführen. Auf diese Weise können Sie die Funktionen anderer Tools nutzen und gleichzeitig von der Automatisierung von Composer -Skripten profitieren.

Wie kann ich mehr über die Verwendung von Composer -Skripten zur Automatisierung erfahren? Die offizielle Dokumentation des Komponisten ist ein großartiger Ausgangspunkt. Es gibt auch viele Tutorials und Blog -Beiträge online verfügbar, die Beispiele und Best Practices für die Verwendung von Komponistenskripten enthalten.

Das obige ist der detaillierte Inhalt vonPHP Master | Erstellen Sie die Automatisierung mit Komponistenskripten. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!