Un inflecteur a besoin d'une cible et d'une ou plusieurs règles. Une cible est une chaîne dans laquelle des jokers pour les variables à remplacer sont présents. Ils sont préfixés de doubles-points, par exemple :script.

L'appel à filter(), nécessite un tableau de clés/valeurs pour les jokers présents dans la cible.

Chaque variable dans la cible peut avoir zéro ou plusieurs règles associées. Les règles peuvent être statiques ou faire référence à une classe Zend_Filter. Les règles statiques sont des remplacements purs et simples. Sinon, la classe qui correspond à la règle sera utilisée pour analyser le texte. Ces classes sont spécifiées par leur nom (du filtre), non préfixé.

Par exemple, vous pouvez utiliser n'importe quelle instance de Zend_Filter. Cependant, plutôt que d'y faire référence via "Zend_Filter_Alpha" ou "Zend_Filter_StringToLower", vous spécifierez seulement "Alpha" ou encore "StringToLower".

Zend_Filter_Inflector utilise Zend_Loader_PluginLoader pour gérer les filtres chargés. Par défaut, n'importe quel filtre préfixé par Zend_Filter sera disponible. Pour accéder aux filtres ayant d'autres préfixes plus profonds, enlevez leur préfixe "Zend_Filter" tout simplement :

// utilise Zend_Filter_Word_CamelCaseToDash comme règle
$inflector->addRules(array('script' => 'Word_CamelCaseToDash'));

Pour spécifier d'autres chemins, Zend_Filter_Inflector possède une méthode qui proxie vers le plugin loader, addFilterPrefixPath() :

$inflector->addFilterPrefixPath('Mes_Filtres', 'Mes/Filtres/');

Il est possible également de récupérer le plugin loader, et d'intervenir sur son instance de manière directe :

$loader = $inflector->getPluginLoader();
$loader->addPrefixPath('Mes_Filtres', 'Mes/Filtres/');

Pour plus d'informations sur la modification des chemins vers les filtres voyez la documentation de PluginLoader.

La cible de l'inflecteur est un mot joker (ou un identifiant), précédé du caractère spécial, double-point. ":script", ":path", etc. La méthode filter() cherche ces identifiants pour les traiter (les remplacer).

Il est possible de changer le caractère spécial double-point avec setTargetReplacementIdentifier(), ou en troisième paramètre de constructeur :

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

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

En général, concernant la cible, on la passe en constructeur. C'est le cas classique. Il peut être en revanche nécessaire de pouvoir passer une cible après la construction de l'objet. (Par exemple modifier l'inflecteur des composants Zend intégrés tels que ViewRenderer ou Zend_Layout). setTarget() peut vous y aider :

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

De plus, vous pouvez agréger la cible dans un membre de votre classe, si cela vous permet d'éviter trop d'appels de méthodes. setTargetReference() permet ceci :

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;
    }
}

Comme dit en introduction, il existe 2 types de règles : statiques et basées sur des filtres.

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

// ici des opérations ...
// changement de la règle:
$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');

// Affecte une règle pour utiliser le filtre
//Zend_Filter_Word_CamelCaseToDash
$inflector->setFilterRule('script', 'Word_CamelCaseToDash');

// Ajoute une règle vers un filtre de casse minuscule
$inflector->addFilterRule('script', new Zend_Filter_StringToLower());

// Affectation de plusieurs règles d'un coup
$inflector->setFilterRule('script', array(
    'Word_CamelCaseToDash',
    new Zend_Filter_StringToLower()
));

// setRules() accepte la même notation :
$inflector->addRules(array(
    // règles filtres:
    ':controller' => array('CamelCaseToUnderscore','StringToLower'),
    ':action'     => array('CamelCaseToUnderscore','StringToLower'),

    // règles statiques :
    'suffix'      => 'phtml'
));

Zend_Filter_Inflector possède d'autres méthodes pour changer le plugin loader, manipuler des règles, et contrôler les exceptions.

Zend_Config peut être utilisé pour spécifier les règles, les préfixes des filtres et d'autres choses dans vos inflecteurs. Passez un objet Zend_Config au constructeur ou à la méthode setOptions() :

// Par le constructeur :
$config    = new Zend_Config($options);
$inflector = new Zend_Filter_Inflector($config);

// Ou via setOptions() :
$inflector = new Zend_Filter_Inflector();
$inflector->setOptions($config);