El ejemplo "Hello World" anterior es excelente para comandos simples, pero ¿qué pasa con algo más avanzado? A medida que crecen sus necesidades de scripting y de herramientas, puede que necesite la capacidad de aceptar variables. Al igual que las firmas de funciones tienen parámetros, sus solicitudes de herramientas también pueden aceptar parámetros.

Del mismo modo que cada solicitud de herramienta puede aislarse en un método dentro de una clase, los parámetros de una solicitud de herramienta también pueden aislarse en un lugar muy conocido. Los parámetros de los métodos de acción de un proveedor pueden incluir los mismos parámetros que desea que su cliente utilice al llamar a esa combinación de proveedor y acción. Por ejemplo, si quisiera aceptar un nombre en el ejemplo anterior, probablemente haría esto en código OO:

class My_Component_HelloProvider
    implements Zend_Tool_Framework_Provider_Interface
{
    public function say($name = 'Ralph')
    {
        echo 'Hello' . $name . ', from my provider!';
    }
}

El ejemplo anterior puede entonces llamarse a través de la línea de comandos zf say hello Joe. "Joe" se suministrará al proveedor como un parámetro de la llamada al método. Observe también que, como ve, el parámetro es opcional, lo que significa que también es opcional en la línea de comandos, de modo que zf say hello seguirá funcionando, y usará por defecto el nombre "Ralph".

Hay casos en los que el flujo de trabajo de su proveedor requiere pedir entrada al usuario. Esto puede hacerse solicitando al cliente que pida la entrada adicional requerida llamando a:

class My_Component_HelloProvider
    extends Zend_Tool_Framework_Provider_Abstract
{
    public function say($name = 'Ralph')
    {
        $nameResponse = $this->_registry
                             ->getClient()
                             ->promptInteractiveInput("Whats your name?");
        $name = $nameResponse->getContent();

        echo 'Hello' . $name . ', from my provider!';
    }
}

Este comando lanza una excepción si el cliente actual no es capaz de manejar solicitudes interactivas. En el caso del Console Client predeterminado, sin embargo, se le pedirá que introduzca el nombre.

Otra característica interesante que quizá desee implementar es la pretendability (capacidad de simulación). La pretendability es la capacidad de que su proveedor "simule" que está realizando la combinación de acción y proveedor solicitada, y proporcione al usuario toda la información posible sobre lo que haría, sin hacerlo realmente. Esto puede ser una noción importante al realizar modificaciones intensivas de base de datos o del sistema de archivos que el usuario podría no querer hacer en otro caso.

La pretendability es fácil de implementar. Hay dos partes en esta característica: 1) marcar el proveedor como capaz de "simular", y 2) comprobar la solicitud para asegurarse de que a la solicitud actual efectivamente se le pidió que se "simulara". Esta característica se demuestra en el ejemplo de código a continuación.

class My_Component_HelloProvider
    extends    Zend_Tool_Framework_Provider_Abstract
    implements Zend_Tool_Framework_Provider_Pretendable
{
    public function say($name = 'Ralph')
    {
        if ($this->_registry->getRequest()->isPretend()) {
            echo 'I would say hello to ' . $name . '.';
        } else {
            echo 'Hello' . $name . ', from my provider!';
        }
    }
}

Para ejecutar el proveedor en modo simulado, simplemente llame a:

% zf --pretend say hello Ralph
I would say hello Ralph.

También puede ejecutar las acciones de su proveedor en modos "verbose" o "debug". La semántica respecto a estas acciones debe ser implementada por usted en el contexto de su proveedor. Puede acceder a los modos debug o verbose con:

class My_Component_HelloProvider
    implements Zend_Tool_Framework_Provider_Interface
{
    public function say($name = 'Ralph')
    {
        if($this->_registry->getRequest()->isVerbose()) {
            echo "Hello::say has been called\n";
        }
        if($this->_registry->getRequest()->isDebug()) {
            syslog(LOG_INFO, "Hello::say has been called\n");
        }
    }
}

Usando la variable de entorno ZF_CONFIG_FILE o el archivo .zf.ini de su directorio de inicio, puede inyectar parámetros de configuración en cualquier proveedor de Zend_Tool. El acceso a esta configuración está disponible a través del registry que se pasa a su proveedor si extiende Zend_Tool_Framework_Provider_Abstract.

class My_Component_HelloProvider
    extends Zend_Tool_Framework_Provider_Abstract
{
    public function say()
    {
        $username = $this->_registry->getConfig()->username;
        if(!empty($username)) {
            echo "Hello $username!";
        } else {
            echo "Hello!";
        }
    }
}

La configuración devuelta es del tipo Zend_Tool_Framework_Client_Config, pero internamente los métodos mágicos __get() y __set() redirigen a un Zend_Config del tipo de configuración dado.

El almacenamiento permite guardar datos arbitrarios para referencia posterior. Esto puede ser útil para tareas de procesamiento por lotes o para reejecuciones de sus tareas. Puede acceder al almacenamiento de forma similar a la configuración:

class My_Component_HelloProvider
    extends Zend_Tool_Framework_Provider_Abstract
{
    public function say()
    {
        $aValue = $this->_registry->getStorage()->get("myUsername");
        echo "Hello $aValue!";
    }
}

La API del almacenamiento es muy simple:

class Zend_Tool_Framework_Client_Storage
{
    public function setAdapter($adapter);
    public function isEnabled();
    public function put($name, $value);
    public function get($name, $defaultValue=null);
    public function has($name);
    public function remove($name);
    public function getStreamUri($name);
}