source: spip-zone/_plugins_/saisies/trunk/balise/saisie.php @ 87651

Last change on this file since 87651 was 87651, checked in by marcimat@…, 6 years ago
  • PHPDoc en plus à certains endroits
  • Pas de fermeture de php sur les fichiers php
  • Le phpdoc nécessite 2 étoiles
  • Les pipelines simplement déclarés (et non utilisés dans saisis) le sont dans paquet.xml directement
File size: 7.5 KB
Line 
1<?php
2
3/**
4 * Déclaration de la classe `Pile` et de la balise `#SAISIE`
5 *
6 * @package SPIP\Saisies\Balises
7**/
8
9if (!defined("_ECRIRE_INC_VERSION")) return;
10
11// pour ne pas interferer avec d'eventuelles futures fonctions du core
12// on met le tout dans une classe ; les fonctions sont autonomes.
13
14/**
15 * Conteneur pour modifier les arguments d'une balise SPIP (de classe Champ) à compiler
16 *
17 * @note
18 *     Ces fonctions visent à modifier l'AST (Arbre de Syntaxe Abstraite) issues
19 *     de l'analyse du squelette. Très utile pour créer des balises qui
20 *     transmettent des arguments supplémentaires automatiquement, à des balises
21 *     déjà existantes.
22 *     Voir un exemple d'utilisation dans `balise_SAISIE_dist()`.
23 *
24 * @note
25 *     Les arguments sont stockés sont dans l'entree 0 de la propriété `param`
26 *     dans l'objet Champ (représenté par `$p`), donc dans `$p->param[0]`.
27 *
28 *     `param[0][0]` vaut toujours '' (ou presque ?)
29 *
30 * @see balise_SAISIE_dist() Pour un exemple d'utilisation
31**/
32class Pile {
33
34
35        /**
36         * Récupère un argument de balise
37         *
38         * @param int $pos
39         * @param Champ $p
40         * @return mixed|null Élément de l'AST représentant l'argument s'il existe
41        **/
42        static function recuperer_argument_balise($pos, $p) {
43                if (!isset($p->param[0])) {
44                        return null;
45                }
46                if (!isset($p->param[0][$pos])) {
47                        return null;
48                }
49                return $p->param[0][$pos];
50        }
51
52        /**
53         * Supprime un argument de balise
54         *
55         * @param int $pos
56         * @param Champ $p
57         * @return Champ
58        **/
59        static function supprimer_argument_balise($pos, $p) {
60                if (!isset($p->param[0])) {
61                        return null;
62                }
63                if (!isset($p->param[0][$pos])) {
64                        return null;
65                }       
66                if ($pos == 0) {
67                        array_shift($p->param[0]);
68                } else {
69                        $debut = array_slice($p->param[0], 0, $pos);
70                        $fin   = array_slice($p->param[0], $pos+1);
71                        $p->param[0] = array_merge($debut, $fin);
72                }
73                return $p;
74        }
75
76
77        /**
78         * Retourne un argument de balise, et le supprime de la liste des arguments
79         *
80         * @uses Pile\recuperer_argument_balise()
81         * @uses Pile\supprimer_argument_balise()
82         *
83         * @param int $pos
84         * @param Champ $p
85         * @return mixed|null Élément de l'AST représentant l'argument s'il existe
86        **/
87        static function recuperer_et_supprimer_argument_balise($pos, &$p) {
88                $arg = Pile::recuperer_argument_balise($pos, $p);
89                $p   = Pile::supprimer_argument_balise($pos, $p);
90                return $arg;
91        }
92
93
94        /**
95         * Ajoute un argument de balise
96         *
97         * Empile l'argument à la suite des arguments déjà existants pour la balise
98         *
99         * @param mixed $element Élément de l'AST représentant l'argument à ajouter
100         * @param Champ $p
101         * @return Champ
102        **/
103        static function ajouter_argument_balise($element, $p) {
104                if (isset($p->param[0][0])) {
105                        $zero = array_shift($p->param[0]);
106                        array_unshift($p->param[0], $element);
107                        array_unshift($p->param[0], $zero);
108                } else {
109                        if (!is_array($p->param[0])) {
110                                $p->param[0] = array();
111                        }
112                        array_unshift($p->param[0], $element);
113                }
114                return $p;
115        }
116
117
118        /**
119         * Crée l'élément de l'AST représentant un argument de balise.
120         *
121         * @example
122         *     ```
123         *     $nom = Pile::creer_argument_balise(nom);           // {nom}
124         *     $nom = Pile::creer_argument_balise(nom, 'coucou'); // {nom=coucou}
125         *     
126         *     $balise = Pile::creer_balise('BALISE');
127         *     $nom = Pile::creer_argument_balise(nom, $balise);  // {nom=#BALISE}
128         *     ```
129         *
130         * @param string $nom
131         *     Nom de l'argument
132         * @param string|object $valeur
133         *     Valeur de l'argument. Peut être une chaîne de caractère ou un autre élément d'AST
134         * @return array
135        **/
136        static function creer_argument_balise($nom, $valeur = null) {
137                include_spip('public/interfaces');
138                $s = new Texte;
139                $s->texte = $nom;
140                $s->ligne=0;
141               
142                // si #BALISE cree avec Pile::creer_balise(), le mettre en array, comme les autres
143                if (is_object($valeur)) {
144                        $valeur = array($valeur);
145                }
146               
147                $res = null;
148               
149                // {nom}
150                if (is_null($valeur)) {
151                        $res = array($s);
152                } 
153                // {nom=coucou}
154                elseif (is_string($valeur)) {
155                        $s->texte .= "=$valeur";
156                        $res = array($s);
157                }
158                // {nom=#BALISE}
159                elseif (is_array($valeur)) {
160                        $s->texte .= "="; // /!\ sans cette toute petite chose, ça ne fait pas d'egalite :)
161                        $res = array_merge(array($s), $valeur);
162                }
163
164                return $res;
165        }
166
167
168        /**
169         * Crée et ajoute un argument à une balise
170         *
171         * @uses Pile\creer_argument_balise()
172         * @uses Pile\ajouter_argument_balise()
173         *
174         * @param Champ $p
175         * @param string $nom
176         *     Nom de l'argument
177         * @param string|object $valeur
178         *     Valeur de l'argument. Peut être une chaîne de caractère ou un autre élément d'AST
179         * @return Champ
180        **/
181        static function creer_et_ajouter_argument_balise($p, $nom, $valeur = null) {
182                $new = Pile::creer_argument_balise($nom, $valeur); 
183                return Pile::ajouter_argument_balise($new, $p);
184        }
185
186
187
188        /**
189         * Crée l'AST d'une balise
190         *
191         * @example
192         *     ```
193         *     // Crée : #ENV*{titre}
194         *     $titre = Pile::recuperer_argument_balise(1, $p); // $titre, 1er argument de la balise actuelle
195         *     $env = Pile::creer_balise('ENV', array('param' => array($titre), 'etoile' => '*'));
196         *     ```
197         *
198         * @param string $nom
199         *     Nom de la balise
200         * @param array $opt
201         *     Options (remplira les propriétés correspondantes de l'objet Champ)
202         * @return Champ
203        **/
204        static function creer_balise($nom, $opt = array()) {
205                include_spip('public/interfaces');
206                $b = new Champ;
207                $b->nom_champ = strtoupper($nom);
208                $vars = get_class_vars('Champ'); // property_exists($b, $o); est en php 5
209                foreach ($opt as $o=>$val) {
210                        #if (property_exists($b,$o)) {
211                        if (array_key_exists($o, $vars)) {
212                                if ($o == 'param') {
213                                        array_unshift($val, '');
214                                        $b->$o = array($val);
215                                } else {
216                                        $b->$o = $val;
217                                }
218                        }
219                }
220                return $b;
221        }
222}
223
224
225
226/**
227 * Compile la balise `#SAISIE` qui retourne le code HTML de la saisie de formulaire indiquée.
228 *
229 * Cette balise incluera le squelette `saisies/_base.html` et lui-même `saisies/{type}.html`
230 *
231 * La balise `#SAISIE` est un raccourci pour une écriture plus compliquée de la balise `#INCLURE`.
232 * La balise calcule une série de paramètre récupérer et à transmettre à `#INCLURE`,
233 * en fonction des valeurs des 2 premiers paramètres transmis.
234 *
235 * Les autres arguments sont transmis tels quels à la balise `#INCLURE`.
236 *
237 * Ainsi `#SAISIE{input,nom,label=Nom,...}` exécutera l'équivalent de
238 * `#INCLURE{nom=nom,valeur=#ENV{nom},type_saisie=input,erreurs,fond=saisies/_base,label=Nom,...}`
239 *
240 * @syntaxe `#SAISIE{type,nom[,option=xx,...]}`
241 *
242 * @param Champ $p
243 * @return Champ
244 */
245function balise_SAISIE_dist ($p) {
246
247        // on recupere les parametres sans les traduire en code d'execution php
248        $type_saisie = Pile::recuperer_et_supprimer_argument_balise(1, $p); // $type
249        $titre       = Pile::recuperer_et_supprimer_argument_balise(1, $p); // $titre
250
251        // creer #ENV*{$titre} (* pour les cas de tableau serialises par exemple, que l'on veut reutiliser)
252        $env_titre   = Pile::creer_balise('ENV', array('param' => array($titre), 'etoile' => '*')); // #ENV*{titre}
253
254        // on modifie $p pour ajouter des arguments
255        // {nom=$titre, valeur=#ENV{$titre}, erreurs, type_saisie=$type, fond=saisies/_base}
256        $p = Pile::creer_et_ajouter_argument_balise($p, 'nom', $titre);
257        $p = Pile::creer_et_ajouter_argument_balise($p, 'valeur', $env_titre);
258        $p = Pile::creer_et_ajouter_argument_balise($p, 'type_saisie', $type_saisie);
259        $p = Pile::creer_et_ajouter_argument_balise($p, 'erreurs');
260        $p = Pile::creer_et_ajouter_argument_balise($p, 'fond', 'saisies/_base');
261
262        // on appelle la balise #INCLURE
263        // avec les arguments ajoutes
264        if (function_exists('balise_INCLURE'))
265                return balise_INCLURE($p);
266        else
267                return balise_INCLURE_dist($p); 
268}
269
270
Note: See TracBrowser for help on using the repository browser.