Un inflector requiere un destino y una o más reglas. Un destino es básicamente una cadena que define marcadores de posición para las variables que desea sustituir. Estos se especifican con el prefijo ':': :script.

Al llamar a filter(), usted pasa un array de pares clave y valor correspondientes a las variables del destino.

Cada variable del destino puede tener cero o más reglas asociadas a ella. Las reglas pueden ser estáticas o hacer referencia a una clase Zend_Filter. Las reglas estáticas sustituirán por el texto proporcionado. En caso contrario, se usará una clase que coincida con la regla proporcionada para inflexionar el texto. Las clases se especifican típicamente usando un nombre corto que indica el nombre del filtro sin ningún prefijo común.

Por ejemplo, puede usar cualquier implementación concreta de Zend_Filter; sin embargo, en lugar de referirse a ellas como 'Zend_Filter_Alpha' o 'Zend_Filter_StringToLower', debe especificar únicamente 'Alpha' o 'StringToLower'.

Zend_Filter_Inflector usa Zend_Loader_PluginLoader para gestionar la carga de filtros a usar con la inflexión. Por defecto, cualquier filtro con el prefijo Zend_Filter estará disponible. Para acceder a filtros con ese prefijo pero que se encuentran más profundamente en la jerarquía, como los distintos filtros Word, simplemente elimine el prefijo Zend_Filter:

// use Zend_Filter_Word_CamelCaseToDash as a rule
$inflector->addRules(array('script' => 'Word_CamelCaseToDash'));

Para establecer rutas alternativas, Zend_Filter_Inflector tiene un método de utilidad que actúa como proxy hacia el cargador de plugins, addFilterPrefixPath():

$inflector->addFilterPrefixPath('My_Filter', 'My/Filter/');

Alternativamente, puede recuperar el cargador de plugins del inflector, e interactuar con él directamente:

$loader = $inflector->getPluginLoader();
$loader->addPrefixPath('My_Filter', 'My/Filter/');

Para más opciones sobre cómo modificar las rutas a los filtros, consulte la documentación de PluginLoader.

El destino del inflector es una cadena con algunos marcadores de posición para variables. Los marcadores de posición toman la forma de un identificador, un signo de dos puntos (':') por defecto, seguido de un nombre de variable: ':script', ':path', etc. El método filter() busca el identificador seguido del nombre de variable que se va a sustituir.

Puede cambiar el identificador usando el método setTargetReplacementIdentifier(), o pasándolo como tercer argumento al constructor:

// Via constructor:
$inflector = new Zend_Filter_Inflector('#foo/#bar.#sfx', null, '#');

// Via accessor:
$inflector->setTargetReplacementIdentifier('#');

Normalmente, establecerá el destino a través del constructor. Sin embargo, puede que desee volver a establecer el destino más adelante (por ejemplo, para modificar el inflector predeterminado en componentes principales, como ViewRenderer o Zend_Layout). setTarget() se puede usar para este propósito:

$inflector = $layout->getInflector();
$inflector->setTarget('layouts/:script.phtml');

Además, puede que desee tener un miembro de clase para su clase que pueda usar para mantener actualizado el destino del inflector -- sin necesidad de actualizar directamente el destino cada vez (ahorrando así llamadas a métodos). setTargetReference() le permite hacer esto:

class Foo
{
    /**
     * @var string Inflector target
     */
    protected $_target = 'foo/:bar/:baz.:suffix';

    /**
     * Constructor
     * @return void
     */
    public function __construct()
    {
        $this->_inflector = new Zend_Filter_Inflector();
        $this->_inflector->setTargetReference($this->_target);
    }

    /**
     * Set target; updates target in inflector
     *
     * @param  string $target
     * @return Foo
     */
    public function setTarget($target)
    {
        $this->_target = $target;
        return $this;
    }
}

Como se mencionó en la introducción, hay dos tipos de reglas: estáticas y basadas en filtros.

Nota

Es importante tener en cuenta que, independientemente del método con el que agregue reglas al inflector, ya sea una por una o todas a la vez, el orden es muy importante. Los nombres más específicos, o los nombres que puedan contener otros nombres de regla, deben agregarse antes que los nombres menos específicos. Por ejemplo, suponiendo los dos nombres de regla 'moduleDir' y 'module', la regla 'moduleDir' debe aparecer antes que 'module', ya que 'module' está contenido dentro de 'moduleDir'. Si 'module' se agregara antes que 'moduleDir', 'module' coincidiría con parte de 'moduleDir' y lo procesaría, dejando 'Dir' dentro del destino sin inflexionar.

$inflector = new Zend_Filter_Inflector(':script.:suffix');
$inflector->setStaticRule('suffix', 'phtml');

// change it later:
$inflector->setStaticRule('suffix', 'php');

class Foo
{
    /**
     * @var string Suffix
     */
    protected $_suffix = 'phtml';

    /**
     * Constructor
     * @return void
     */
    public function __construct()
    {
        $this->_inflector = new Zend_Filter_Inflector(':script.:suffix');
        $this->_inflector->setStaticRuleReference('suffix', $this->_suffix);
    }

    /**
     * Set suffix; updates suffix static rule in inflector
     *
     * @param  string $suffix
     * @return Foo
     */
    public function setSuffix($suffix)
    {
        $this->_suffix = $suffix;
        return $this;
    }
}

$inflector = new Zend_Filter_Inflector(':script.:suffix');

// Set rule to use Zend_Filter_Word_CamelCaseToDash filter
$inflector->setFilterRule('script', 'Word_CamelCaseToDash');

// Add rule to lowercase string
$inflector->addFilterRule('script', new Zend_Filter_StringToLower());

// Set rules en-masse
$inflector->setFilterRule('script', array(
    'Word_CamelCaseToDash',
    new Zend_Filter_StringToLower()
));

// Could also use setRules() with this notation:
$inflector->addRules(array(
    // filter rules:
    ':controller' => array('CamelCaseToUnderscore','StringToLower'),
    ':action'     => array('CamelCaseToUnderscore','StringToLower'),

    // Static rule:
    'suffix'      => 'phtml'
));

Zend_Filter_Inflector tiene una serie de métodos de utilidad para obtener y establecer el cargador de plugins, manipular y recuperar reglas, y controlar si se lanzan excepciones y cuándo.

Puede usar Zend_Config para establecer reglas, rutas de prefijo de filtro, y otros estados del objeto en sus inflectores, ya sea pasando un objeto Zend_Config al constructor o a setOptions(). Se pueden especificar los siguientes ajustes:

// With the constructor:
$config    = new Zend_Config($options);
$inflector = new Zend_Filter_Inflector($config);

// Or with setOptions():
$inflector = new Zend_Filter_Inflector();
$inflector->setOptions($config);