¿Cómo se pasa un argumento a un script de compositor desde la línea de comandos?

Estoy tratando de ejecutar un script de compositor personalizado a través de cli así:

composer custom_script_cli --custom_argument

Lo que sucede es que el compositor cree que le estoy preguntando al compositor si quiero pasar ese argumento al compositor en lugar del script personalizado.

¿Hay alguna manera de hacer esto sin agregarlo a la fuerza al script personalizado?

Lo único que encontré relevante para este tema fue un edición de git de 2013 que en ese momento dice que no es posible. No estoy seguro si este sigue siendo el caso 4 años después.

Se puede pasar cualquier tipo de argumento a los scripts personalizados del compositor simplemente agregándolos en la línea de comandos como de costumbre, pero después de un --
(es decir, el operador de separación de argumento especial, que no se pasa a los scripts en sí).

Sin embargo, no es necesario utilizar el -- operador de separación de argumentos cuando NINGUNO de los argumentos comienza con guiones (es decir, lo que generalmente se denominan opciones de línea de comandos, como -o o --option) demás composer los trataría como una opción para composer en sí mismo, y no en el guión.

Si la definición de secuencia de comandos personalizada ejecuta varios comandos, los argumentos pasados ​​se agregarán a cada comando. Además, no puede usar convenciones de programación de shell como $2 para referirse a argumentos individuales.

Si la secuencia de comandos personalizada es manejada por una devolución de llamada, es responsabilidad de la secuencia de comandos analizar las opciones de los argumentos. Desde la perspectiva de la devolución de llamada, cosas como -c y --option=B son argumentos.

Ejemplo

Dado un composer.json con los siguientes contenidos:

{
    "autoload": { "psr-4": { "MyVendor\\": "./" } },
    "scripts": {
        "pass-args-to-callback": [
            "MyVendor\\MyClass::myCallback"
        ],
        "pass-args-to-commands": [
            "echo one",
            "echo two",
            "@other-command"
        ],
        "other-command": [
            "echo three"
        ]
    }
}

Y dado un archivo MyClass.php con los siguientes contenidos:

<?php
namespace MyVendor;

use Composer\Script\Event;
use Composer\Installer\PackageEvent;

class MyClass {
    public static function myCallback(Event $event) {
        var_dump($event->getArguments());
    }
}

Paso 0: Volcar Autoloader para reconocer MyClass

$ composer dump-autoload
Generating autoload files

Prueba 1: Muestre lo que sucede sin el operador de separación de argumentos

$ composer pass-args-to-callback A --option=B -C


  [Symfony\Component\Console\Exception\RuntimeException]
  The "--option" option does not exist.


pass-args-to-callback [--dev] [--no-dev] [--] [<args>]...

Prueba 2: muestra cómo aparecen los argumentos y las opciones en la devolución de llamada

$ composer pass-args-to-callback -- A --option=B -C
> MyVendor\MyClass::myCallback
array(3) {
  [0]=>
  string(1) "A"
  [1]=>
  string(10) "--option=B"
  [2]=>
  string(2) "-C"
}

Prueba 3: Muestre cómo se agregan argumentos y opciones a los comandos

$ composer pass-args-to-commands -- A --option=B -C
> echo one 'A' '--option=B' '-C'
one A --option=B -C
> echo two 'A' '--option=B' '-C'
two A --option=B -C
> echo three 'A' '--option=B' '-C'
three A --option=B -C

Referencia: https://getcomposer.org/doc/articles/scripts.md

Puede agregar los guiones dobles -- hasta el final de la(s) entrada(s) del script.

De esta manera, puede pasar argumentos/opciones adicionales al script subyacente.

{
    "scripts": {
        "test": "phpunit",
        "test-single": "phpunit --"
    }
}

para ejecutar el test-single script con un filtro phpunit personalizado:

composer test-single --filter test_function

Puede pasar argumentos justo al final, así que:

composer custom_script_cli [--dev] [--no-dev] [--] [<args>]...

Lo que significa algo como esto

composer custom_script_cli argument1 argument2

Y luego puede obtenerlo en su secuencia de comandos de esta manera:

public static function commandcode(Event $event) {
   $event->getArguments(); ...
}

Eso a lo que te refieres se llama opción.