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:

<?php
// 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():

<?php
$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 :

<?php
$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 3ème paramètre de constructeur :

<?php
// 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:

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

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

<?php
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.

Note: Notez bien que quelle que soit la méthode que vous utilisez pour spécifier vos règles dans l'inflecteur, leur ordre est très important. Vous devez ajouter de la règle la plus spécifique, à la plus générique. Par exemple, 2 règles nommées "moduleDir" et "module", la règle "moduleDir" devrait être ajoutée avant la règle "module", car cette dernière est contenue dans "moduleDir".

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

// ici des opérations ...
// changement de la règle:
$inflector->setStaticRule('suffix', 'php');
?>

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

<?php
$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()
));
?>

<?php
// 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.

• setPluginLoader() peut être utile si vous avez configuré votre propre chargeur de plugins (plugin loader) et que vous voulez l'utiliser avec Zend_Filter_Inflector ; getPluginLoader() retourne cette valeur.

• setThrowTargetExceptionsOn() accepte un booléen. Ceci spécifie qu'une exception doit être lancée si une variable est toujours présente dans la cible après le passage de l'inflecteur. Par défaut, ça n'est pas le cas. isThrowTargetExceptionsOn() retourne la valeur actuelle.

• getRules($spec = null) récupère toutes les règles, ou les règles d'une certaine variable.

• getRule($spec, $index) récupère une règle précise, même dans une chaine de filtre.$index doit être précisé.

• clearRules() va effacer toutes les règles fixées préalablement.

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 setConfig():

• target définit la cible de l'inflecteur.

• filterPrefixPath définit le préfixe/chemins des filtres.

• throwTargetExceptionsOn est un booléen. Ceci spécifie qu'une exception doit être lancée si une variable est toujours présente dans la cible après le passage de l'inflecteur.

• targetReplacementIdentifier spécifie le caractère à utiliser pour définir les variables de remplacement.

• rules spécifie un tableau de règles, comme accepté par addRules().

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

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