php - practices - ¿Cómo crear un paquete compositor monolítico con un plug-in compositor incorporado?

wordpress plugin boilerplate

Question

Quiero que mi paquete se envíe con un complemento de composición incorporado.

Tengo una estructura como esta:

composer.json
src/
...
plugin/
composer.json
src/
...

La raíz composer.json se configura así:

{
"name": "foo/bar",
"type": "library",
"autoload": {
"psr-4": {
"Foo//Bar//": "src/"
}
},
"repositories": [
{
"type": "path",
"url": "./tools",
"options": {
"symlink": false
}
}
],
"require": {
"foo/bar-plugin": "*"
}
}

Y el plugin/composer.json integrado de plug-in- plugin/composer.json esta manera:

{
"name": "foo/bar-plugin",
"type": "composer-plugin",
"require": {
"composer-plugin-api": "^1",
"composer/composer": "^1",
"foo/bar": "*"
},
"autoload": {
"psr-4": {
"Foo//Bar//Plugin//": "src/"
}
},
"extra": {
"class": "Foo//Bar//Plugin//MyComposerPlugin"
}
}

Observe cómo hay una dependencia bidireccional aquí: el complemento depende de foo/bar , y el proyecto en sí depende de foo/bar-plugin .

Aquí es donde se pone raro. Durante una instalación nueva con, por ejemplo, la composer install o la composer update , todo está bien: el complemento hace su función, lo que, en este momento, significa simplemente anunciarse en la consola.

Ahora, después de la instalación, si escribo solo composer , espero ver que el complemento se anuncie a sí mismo, igual que antes, ¿verdad?

En su lugar, genera un "error de clase no encontrada" fatal, tan pronto como intenta hacer referencia a cualquier clase que pertenezca al paquete foo/bar .

Es como si el compositor perdiera la pista del hecho de que foo/bar-plugin requiere foo/bar , y por alguna razón, sus clases no son auto-cargables.

¿Hay alguna razón para que esto no sea posible? Por qué no?

Por supuesto, solo puedo empaquetar esto en un paquete externo separado, pero eso no va a tener mucho sentido, ya que estos paquetes solo van a depender uno del otro, son efectivamente una unidad, un paquete como dos paquetes es el resultado será una gran cantidad de versiones mayores que se incrementan con cada pequeño cambio, ya que básicamente cada versión de foo/bar romperá el foo/bar-plugin .

Idealmente, me gustaría simplemente agregar el plugin composer directamente en el paquete principal, pero parece que no es posible por alguna razón. Solo un paquete con el tipo composer-plugin puede agregar complementos, parece?

Answer 1

Si el complemento es esencialmente una parte de su paquete, no debe usarlo como tal. El compositor ofrece alternativas.

Como mencionó Jens en un comentario a su pregunta, hay una clave de ''scripts'' en composer.json . Puede invocar comandos de shell en el interior, pero también puede llamar a métodos de clase estática.

Acerca de la solución de plugin: el compositor lo menciona explícitamente en su sitio:

Composer no hace suposiciones sobre el estado de sus dependencias antes de instalar o actualizar. Por lo tanto, no debe especificar scripts que requieran dependencias administradas por Composer en los ganchos de eventos pre-update-cmd o pre-install-cmd . Si necesita ejecutar scripts antes de instalar o actualizar, asegúrese de que sean independientes dentro de su paquete raíz.

(Mi nota al margen - esto también se aplica aproximadamente a los complementos).

De todos modos, para proporcionarle una solución: descartar el enfoque del ''complemento''. En su lugar, modifique su archivo composer.json para que se vea como sigue:

compositor.json

{
"name": "foo/bar",
"type": "library",
"autoload": {
"psr-4": {
"Foo//Bar//": "src/"
}
},
"require": {
},
"scripts": {
"post-install-cmd": [
"Foo//Bar//Composer//Plugin::postInstall"
],
"post-update-cmd": [
"Foo//Bar//Composer//Plugin::postUpdate"
]
}
}

Además, en la carpeta src/Composer cree Plugin.php :

src / Composer / Plugin.php

<?php
namespace Foo/Bar/Composer;
use Foo/Bar/Test;
/**
* Composer scripts.
*/
class Plugin
{
public static function postInstall()
{
print_r("POST INSTALL/n");
print_r(Test::TEST_CONST);
print_r("/n");
}
public static function postUpdate()
{
print_r("POST UPDATE/n");
print_r(Test::TEST_CONST);
print_r("/n");
}
}

Como ves, imprime una constante desde la clase Test. Crearlo en src/ :

src / Test.php

<?php
namespace Foo/Bar;
/**
* Test class.
*/
class Test
{
const TEST_CONST = "HERE I AM";
}

Ejecuta esto y comprueba cómo se desarrolla.