Expert PHP

Le chapitre de la documentation du Zend Framework traitant du composant Zend_Form est intéressant, mais reste incomplet quant à l’utilisation des fichiers de configuration (.ini) pour l’initialisation des formulaires.
Nous allons donc dans un premier temps approfondir ce premier point (initialisation d’un formulaire avec un fichier de configuration), puis nous chercherons à aller plus loin dans l’utilisation et la configuration des formulaires.

Rappels

Zend_Form

Le composant Zend_Form permet de créer et de valider un formulaire, en maîtrisant de bout en bout la chaîne de traitement.
La syntaxe de base est on ne peut plus simple :

$form = new Zend_Form() ;

Ajouter un élément au formulaire est tout aussi rapide :

$form->addElement(new Zend_Form_Element_Text('login'));

Mais configurer de part en part un formulaire peut vite s’avérer long et fastidieux, selon le nombre de champs à insérer, les validateurs et filtres mis en place, et selon le nombre de formulaires que comporte votre application.
Il est cependant possible de simplifier la mise en place de formulaires et de rendre cette opération sinon ludique, tout au moins moins fastidieuse, en faisant appel au composant Zend_Config_Ini.
Cette méthode vous permettra également de modifier vos formulaires plus rapidement, et oblige à une réflexion et à une rationalisation du processus de création des formulaires.

Zend_Config_Ini

Le composant Zend_Config_Ini permet de stocker des informations sous forme de fichier texte et d’y accéder en tant qu’objet. Pour apprendre à manipuler ce composant, vous vous réfèrerez au guide de référence du framework, à la page dédiée au composant Zend_Config_Ini.

Le fichier de configuration

Nous commencerons par configurer le formulaire :

action = "module/controller/action/"
method = "post"
; Si besoin est (téléchargement de fichiers par exemple)
enctype = "multipart/form-data"

Pour chaque élément, nous créerons une entrée elements :

elements.

Où nous indiquerons le nom (balises name) :

elements.nom

Puis le type d’élément :

elements.nom.type = text

Nous retrouvons ici les types classiques d’un champ de formulaire : input, select, textarea, radio, checkbox…
Une fois ces informations données, nous pourrons enrichir notre élément en lui ajoutant des options : filtres, validateurs, classe, attributs… :

elements.nom.options.

Voici une liste (non exhaustive) des options possibles :

; required
[...].validators.required.validator = "NotEmpty"
[...].validators.required.breakChainOnFailure = true
; strlen
[...].options.validators.strlen.validator = "StringLength"
[...].options.validators.strlen.options.min = 3
[...].options.validators.strlen.options.max = 9
; alnum
[...].options.validators.alnum.validator = "Alnum"
;select / multiselect / radio  elements
[...].options.multioptions.val1 = "valeur 1"
[...].options.multioptions.val2 = "valeur 2"
; en vrac
[...].options.class = class_name
[...].options.id = id_name
[...].options.label = "Code Postal :"
[...].options.onclick = "javascript:alert('click!');"
[...].options.filters.lower.filter = "StringToLower"

Pour finir, en fin de formulaire, nous ajouterons nos boutons submit et reset :

elements.envoyer.type = submit
elements.effacer.type = reset

Vous noterez que pour ces deux éléments il n’est pas besoin de préciser l’option value, le nom de l’élément sert de value dans le formulaire.

Cas particulier : la balise input type="image"...

Le type image est une variante du type submit. Pour en spécifier les attributs src et éventuellement alt, nous procèderons comme suit :

; déclaration du type
elements.envoyer.type = image
; l'attribut src
elements.envoyer.options.image = "images/envoyer.png"
; l'attribut alt
elements.envoyer.options.label = "soumettre le formulaire"

Les options

L’option la plus connue et la plus utilisée est certainement required, qui rend obligatoire la saisie du champ.

elements.nom.options.required = true

Initialisation du formulaire

Deux lignes suffisent à initialiser un formulaire :

$formConfig = new Zend_Config_Ini('configs/forms/form.ini');
$form = new Zend_Form($formConfig);

Votre formulaire est prêt à être utilisé, pour l’affichage ou pour traitement…

Aller plus loin

Utiliser une architecture modulaire

Quand le formulaire est un des composants majeurs de votre application, il peut s’avérer intéressant en terme de productivité de gérer vos fichiers de configuration en suivant l’architecture générale des modules. Dans le répertoire application/configs/, créez un répertoire forms, dans lequel vous reproduirez le schéma de vos modules.

.application
	.configs
		.forms
			.admin
				.utilisateurs
				 ajouter.ini
				 modifier.ini
			.default
				.index
				.login
				 login.ini

Si vous souhaitez en apprendre plus ou comprendre les modules sous Zend Framework, reportez-vous à l’article Créer une application Zend Framework avec modules.

Créer une méthode statique d’initialisation

Utiliser une architecture modulaire pour vos fichiers de configuration vous permet de mettre en œuvre très facilement une méthode statique d’initialisation :

class My_Setters {
	public static function setForm($request) {
		$filename = APPLICATION_PATH . '/configs/forms/'
					. $request->getModuleName() . '/'
					. $request->getControllerName() . '/'
					. $request->getActionName() . '.ini';
			$formConfig = new Zend_Config_Ini($filename);
			$form = new Zend_Form($formConfig);
			return $form;
		}
}

Que vous appellerez via :

My_Settters::setForm($this->_request);

Bien sûr, il est possible d’aller plus loin encore, en internationalisant ses formulaires, ou de suivre d’autres pistes, en créant par exemple un helper d’action pour initialiser ses formulaires…
Il est également possible comme pour tout fichier de configuration de créer des sections, pour des formulaires ayant un tronc commun et des différences minimes selon éventuellement les droits, le pays, l’âge ou le sexe. Mais vous êtes armés, vous saurez aller plus loin…