Subversion Repositories Applications.referentiel

Rev

Rev 183 | Rev 186 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
20 jpm 1
<?php
2
// Encodage : UTF-8
3
// +-------------------------------------------------------------------------------------------------------------------+
4
/**
5
* Tests de référentiels de nomenclature et taxonomie
6
*
7
* Description : classe permettant de tester les référentiels selon le manuel technique
8
* Utilisation : php script.php tests -p bdnff -a tout
9
*
10
//Auteur original :
11
* @author       Jean-Pascal MILCENT <jpm@tela-botanica.org>
12
* @copyright	Tela-Botanica 1999-2010
13
* @link			http://www.tela-botanica.org/wikini/RTaxMethodo/wakka.php?wiki=MaNuel
14
* @licence		GPL v3 & CeCILL v2
15
* @version		$Id$
16
*/
17
// +-------------------------------------------------------------------------------------------------------------------+
38 jpm 18
// TODO : supprimer l'utilisation du paramêtres 'p' et chercher les infos depuis la bdd
20 jpm 19
class Tests extends ScriptCommande {
20
 
42 jpm 21
	const SCRIPT_NOM = 'tests';
22
 
20 jpm 23
	private $projet = null;
30 jpm 24
	private $traitement = null;
20 jpm 25
 
26
	private $manuel = null;
171 jpm 27
	private $tests = null;
167 jpm 28
	private $colonnes = null;
29
	private $analyses = null;
64 jpm 30
	private $noms = null;
20 jpm 31
 
30 jpm 32
	private $resultatDao = null;
33
	private $traitementDao = null;
34
	private $tableStructureDao = null;
35
	private $referentielDao = null;
36
 
20 jpm 37
	public function executer() {
150 jpm 38
		$this->manuel = parse_ini_file(Config::get('chemin_appli').DS.'..'.DS.'configurations'.DS.'referentiel_v4.1.ini');
176 jpm 39
		$this->definirConstantes();
171 jpm 40
		$this->tests = parse_ini_file($this->getModuleChemin().DS.'configurations'.DS.'tests.ini', true);
20 jpm 41
 
30 jpm 42
		$this->resultatDao = new ResultatDao();
43
		$this->traitementDao = new TraitementDao();
97 jpm 44
		Debug::printr('Dans le script test');
30 jpm 45
		// Récupération du dernier traitement demandé
142 delphine 46
		$this->traitement = $this->traitementDao->getDernierTraitement('tout', self::SCRIPT_NOM);
42 jpm 47
		if (isset($this->traitement)) {
142 delphine 48
			$this->projet = $this->traitement['referentiel_code']; // Récupération du nom de projet
38 jpm 49
			Debug::printr($this->traitement);
50
			// Écriture de la date de début du traitement
51
			Debug::printr('Debute:'.$this->traitementDao->debuterTraitement($this->traitement['id_traitement']));
52
 
53
			// Nettoyage des traitements obsolètes
42 jpm 54
			$traitements_obsoletes = $this->traitementDao->getTraitementsObsoletes($this->projet, self::SCRIPT_NOM);
55
			if (isset($traitements_obsoletes)) {
56
				Debug::printr('Supp. obsoletes:'.$this->traitementDao->supprimer($traitements_obsoletes));
57
			}
38 jpm 58
 
165 delphine 59
			$this->tableStructureDao = new TableStructureDao();
60
			$this->referentielDao = new ReferentielDao();
61
 
38 jpm 62
			// Lancement du test demandé
63
			$cmd = $this->getParam('a');
64
	    	switch ($cmd) {
65
				case 'tout' :
66
					Debug::printr('Départ lancement test:');
165 delphine 67
					$this->recupererDonnees();
177 jpm 68
					$this->lancerTestsAuto();
38 jpm 69
					break;
165 delphine 70
				case 'test11' :
71
					$this->recupererDonnees();
72
					Debug::printr('Départ lancement test 11 :');
73
					$this->testerClassificationRang();
74
					break;
38 jpm 75
				default :
76
					$this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd));
77
			}
78
			// Écriture de la date de fin du traitement
79
			Debug::printr('Termine:'.$this->traitementDao->terminerTraitement($this->traitement['id_traitement']));
97 jpm 80
		} else {
142 delphine 81
			Debug::printr("Aucun dernier traitement trouvé pour le script '".self::SCRIPT_NOM."' !");
20 jpm 82
		}
83
    }
165 delphine 84
 
176 jpm 85
    /**
86
     * Cette méthode définie des constantes qui peuvent ensuite être utilisée dans les fichier ini.
87
     * Surtout utile pour le fichier tests.ini
88
     */
89
    private function definirConstantes() {
90
    	define('RANG_GENRE', $this->manuel['rang_genre']);
91
    	define('RANG_SP', $this->manuel['rang_sp']);
92
    }
93
 
165 delphine 94
    public function recupererDonnees() {
20 jpm 95
		// Récupération des données à tester
167 jpm 96
		$this->colonnes = $this->tableStructureDao->getColonnes($this->projet);
97
		$this->analyses = $this->tableStructureDao->getAnalyse($this->projet);
64 jpm 98
		$this->noms = $this->referentielDao->getTout($this->projet);
99
		Debug::printr('Nbre noms :'.count($this->noms));
165 delphine 100
    }
101
 
175 jpm 102
    public function lancerTestsAuto() {
103
		$resultats = array();
104
 
105
		// Lancement des tests unitaires
177 jpm 106
		Debug::printr('Lancement des tests unitaires');
183 jpm 107
		$tests_numeros = array_keys($this->tests);
108
		Debug::printr($tests_numeros);
109
    	foreach ($tests_numeros as $numero) {
175 jpm 110
			$info = $this->getInfosTest($numero);
111
 
112
    		if ($numero < 5) {
113
    			// Tests spéciaux vérifiant la structure de la table
114
    			$resultats[] = $this->lancerTestUnitaire($info);
115
    		} else if ($numero >= 5 && $this->verifierResultats($resultats)) {
116
				// Si la structure est bonne nous lançons les autres tests
177 jpm 117
				$this->lancerTestUnitaire($info);
175 jpm 118
    		}
119
		}
120
    }
183 jpm 121
 
122
    private function getInfosTest($numero) {
123
		$info = $this->tests[$numero];
124
		$info['methode'] = 'tester'.implode('', explode(' ', ucwords($info['abr'])));
125
		$info['numero'] = $numero;
126
		$info['nom'] = '#'.$numero.' - '.$info['nom'];
127
		$info['resultat'] = false;
128
		return $info;
129
	}
175 jpm 130
 
131
    public function lancerTestUnitaire($info) {
177 jpm 132
		Debug::printr($info['numero'].'::'.$info['methode']);
133
    	$methodeDeTest = $info['methode'];
134
    	$erreurs = $this->$methodeDeTest();
175 jpm 135
 
136
    	// Analyse des résultats
137
    	if (isset($erreurs['special'])) {
138
    		$info = $erreurs;
139
    	} else {
176 jpm 140
    		if (count($erreurs) > 0) {
175 jpm 141
				$info['message']['entete'] = explode(',', $info['entete']);
183 jpm 142
				if (isset($info['title'])) {
143
					$info['message']['title'] = explode(';', $info['title']);
144
				}
175 jpm 145
				$info['message']['lignes'] = $erreurs;
176 jpm 146
				unset($erreurs);
175 jpm 147
			} else {
148
				$info['resultat'] = true;
149
			}
150
    	}
151
 
152
		$this->traiterResultatTest($info);
153
 
154
		if ($info['numero'] < 5) {
155
			return ($info['resultat'] ? '1' : '0');
156
		}
157
    }
64 jpm 158
 
159
	private function verifierResultats($resultats) {
160
		$ok = true;
161
		foreach ($resultats as $resultat) {
162
			if ($resultat == '0') {
163
				$ok = false;
164
				break;
165
			}
166
		}
167
		return $ok;
168
	}
20 jpm 169
 
30 jpm 170
	private function traiterResultatTest($info) {
171
		if (isset($info['message'])) {
172
			if (is_array($info['message'])) {
183 jpm 173
				$erreurs_nbre = count($info['message']['lignes']);
174
				$erreurs_max = 1000;
175
				if ($erreurs_nbre > $erreurs_max) {
176
					$info['message']['lignes'] = array_slice($info['message']['lignes'], 0, $erreurs_max);
177
					$info['erreur'] = "$erreurs_nbre erreurs ont été détectées seules les $erreurs_max premières sont affichées";
178
				}
31 jpm 179
				$info['message'] = $this->getVue('tests/squelettes/message_table', $info);
180
			} else {
181
				$info['message'] = $this->getVue('tests/squelettes/message_p', $info);
30 jpm 182
			}
183
		}
183 jpm 184
		Debug::printr($this->resultatDao->ajouter($this->traitement['id_traitement'], $info));
64 jpm 185
		$info = null;
30 jpm 186
	}
187
 
188
	//+--------------------------------------------------------------------------------------------------------------+//
20 jpm 189
	// TESTS
190
 
171 jpm 191
	/**
192
	 * Test #01
193
	 */
175 jpm 194
	private function testerNombreDeChamps() {
171 jpm 195
		$info = $this->getInfosTest(1);
175 jpm 196
		$info['special'] = true;
20 jpm 197
 
175 jpm 198
		$nbre_colonnes = count($this->colonnes);
171 jpm 199
		$info['message'] = $nbre_colonnes;
200
		if ($nbre_colonnes >= 35) {
201
			$info['resultat'] = true;
202
		}
175 jpm 203
 
204
		return $info;
171 jpm 205
	}
206
 
207
	/**
208
	 * Test #02
209
	 */
175 jpm 210
	private function testerNomDesChamps() {
171 jpm 211
		$info = $this->getInfosTest(2);
175 jpm 212
		$info['special'] = true;
171 jpm 213
 
214
		$champs_attendus = explode(',', $this->manuel['champs']);
215
		$champs_presents = array();
175 jpm 216
		foreach ($this->colonnes as $colonne) {
171 jpm 217
			$champs_presents[$colonne['Field']] = $colonne;
218
		}
219
 
220
		$ok = true;
221
		$champs_manquant = array();
222
		foreach ($champs_attendus as $champ_attendu) {
223
			if (!isset($champs_presents[$champ_attendu])) {
224
				$champs_manquant[] = $champ_attendu;
225
				$ok = false;
226
			}
227
		}
175 jpm 228
 
171 jpm 229
		$info['resultat'] = $ok;
230
		if (!$ok) {
231
			$info['message'] = sprintf($info['message'], implode(', ', $champs_manquant));
232
		}
233
 
175 jpm 234
		return $info;
171 jpm 235
	}
236
 
237
	/**
238
	 * Test #03
239
	 */
175 jpm 240
	private function testerTypeDesChamps() {
171 jpm 241
		$champs_attendus = explode(',', $this->manuel['champs_type']);
242
		$champs_presents = array();
175 jpm 243
		foreach ($this->colonnes as $colonne) {
171 jpm 244
			$champs_presents[$colonne['Field']] = $colonne['Type'];
245
		}
246
 
247
		// Recercherche des erreurs
248
		$champs_erreur = array();
249
		foreach ($champs_attendus as $champ_attendu) {
250
			list($champ_attendu_nom, $champ_attendu_type_taille) = explode('=', trim($champ_attendu));
251
			list($champ_attendu_type, $champ_attendu_taille) = explode('|', trim($champ_attendu_type_taille));
252
 
253
			if (isset($champs_presents[$champ_attendu_nom])) {
254
				$champs_present_type = $champs_presents[$champ_attendu_nom];
255
 
256
				if (($champ_attendu_type == 'VARCHAR' && strstr($champs_present_type, 'varchar') === false)
257
					|| ($champ_attendu_type == 'TEXT' && strstr($champs_present_type, 'text') === false)
258
					|| ($champ_attendu_type == 'INT' && strstr($champs_present_type, 'int') === false)
259
					|| ($champ_attendu_type == 'BOOL' && preg_match('/(?:bool|boolean|tinyint\(1\))/i', $champs_present_type) === false)) {
175 jpm 260
					$champs_erreur[] = array($champ_attendu, $champ_attendu_type, $champs_present_type);
171 jpm 261
				}
262
			}
263
		}
175 jpm 264
		return $champs_erreur;
171 jpm 265
	}
266
 
267
	/**
268
	 * Test #04
269
	 */
175 jpm 270
	private function testerNumNomClePrimaire() {
171 jpm 271
		$info = $this->getInfosTest(4);
175 jpm 272
		$info['special'] = true;
171 jpm 273
 
175 jpm 274
		foreach ($this->colonnes as $colonne) {
171 jpm 275
			if ($colonne['Field'] == 'num_nom' && $colonne['Key'] == 'PRI') {
276
				$info['resultat'] = true;
277
			}
278
		}
175 jpm 279
		return $info;
171 jpm 280
	}
281
 
282
 
283
	/**
284
	 * Test #05
285
	 */
175 jpm 286
	private function testerTailleDesChamps() {
171 jpm 287
		$tailles_champs_maxi = array();
175 jpm 288
		foreach ($this->colonnes as $colonne) {
171 jpm 289
			if (preg_match('/^varchar\(([0-9]+)\)$/', $colonne['Type'], $match)) {
290
				$tailles_champs_maxi[$colonne['Field']] = $match[1];
291
			}
292
		}
293
 
294
		$tailles_trouvees = array();
175 jpm 295
		foreach ($this->analyses as $analyse) {
171 jpm 296
			if (preg_match('/\.([^.]+)$/', $analyse['Field_name'], $match)) {
297
				$tailles_trouvees[$match[1]] = $analyse['Max_length'];
298
			}
299
		}
300
 
301
		$champs_erreur = array();
302
		$champs_attendus = explode(',', $this->manuel['champs']);
303
		foreach ($champs_attendus as $champ_attendu) {
304
			if (isset($tailles_champs_maxi[$champ_attendu]) && isset($tailles_trouvees[$champ_attendu])) {
305
				if ($tailles_champs_maxi[$champ_attendu] == $tailles_trouvees[$champ_attendu]) {
175 jpm 306
					$champs_erreur[] = array($champ_attendu, $tailles_champs_maxi[$champ_attendu], $tailles_trouvees[$champ_attendu]);
171 jpm 307
				}
308
			}
309
		}
175 jpm 310
		return $champs_erreur;
171 jpm 311
	}
312
 
313
	/**
314
	 * Test #06
315
	 */
316
	private function testerNumNomSuperieurAZero() {
20 jpm 317
		$noms_erreur = array();
64 jpm 318
		foreach ($this->noms as &$nom) {
171 jpm 319
			if ($nom['num_nom'] <= 0) {
175 jpm 320
				$noms_erreur[] = array($nom['num_nom']);
20 jpm 321
			}
322
		}
175 jpm 323
		return $noms_erreur;
20 jpm 324
	}
325
 
171 jpm 326
	/**
327
	 * Test #07
328
	 */
329
	private function testerNumNomRetenuSuperieurAZero() {
20 jpm 330
		$noms_erreur = array();
64 jpm 331
		foreach ($this->noms as &$nom) {
171 jpm 332
			if ($nom['num_nom_retenu'] != '' && $nom['num_nom_retenu'] <= 0) {
175 jpm 333
				$noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu']);
20 jpm 334
			}
335
		}
176 jpm 336
		return $noms_erreur;
20 jpm 337
	}
338
 
171 jpm 339
	/**
340
	 * Test #08
341
	 */
342
	private function testerNumTaxSupEgalZeroUnique() {
20 jpm 343
		$noms_erreur = array();
64 jpm 344
		foreach ($this->noms as &$nom) {
171 jpm 345
			if (preg_match('/^0$/', $nom['num_tax_sup'])) {
175 jpm 346
				$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup']);
20 jpm 347
			}
348
		}
176 jpm 349
		// Ce test est spécial car le nombre de noms en erreurs doit être supérieur à 1 et non à 0 pour être KO.
350
		if (count($noms_erreur) == 1) {
177 jpm 351
			$noms_erreur = array();
20 jpm 352
		}
176 jpm 353
		return $noms_erreur;
20 jpm 354
	}
355
 
171 jpm 356
	/**
357
	 * Test #09
358
	 */
359
	private function testerTaxSupPourTaxon() {
20 jpm 360
		$noms_erreur = array();
64 jpm 361
		foreach ($this->noms as &$nom) {
171 jpm 362
			if ($nom['num_nom_retenu'] != $nom['num_nom'] && $nom['num_tax_sup'] != '') {
183 jpm 363
				$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup'], $nom['exclure_taxref']);
20 jpm 364
			}
365
		}
176 jpm 366
		return $noms_erreur;
20 jpm 367
	}
368
 
171 jpm 369
	/**
370
	 * Test #10
371
	 */
372
	private function testerExitenceTaxonSuperieur() {
20 jpm 373
		$noms_erreur = array();
64 jpm 374
		foreach ($this->noms as &$nom) {
171 jpm 375
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
376
				if ($nom['num_tax_sup'] != 0 && !isset($this->noms[$nom['num_tax_sup']])) {
183 jpm 377
					$noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup'], $nom['exclure_taxref']);
171 jpm 378
				}
20 jpm 379
			}
380
		}
176 jpm 381
		return $noms_erreur;
20 jpm 382
	}
383
 
171 jpm 384
	/**
385
	 * Test #11
386
	 */
387
	private function testerClassificationRang() {
20 jpm 388
		$noms_erreur = array();
64 jpm 389
		foreach ($this->noms as &$nom) {
171 jpm 390
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
391
				if (isset($this->noms[$nom['num_tax_sup']])) {
392
					$nom_sup = $this->noms[$nom['num_tax_sup']];
393
					if ($nom_sup['rang'] >= $nom['rang']) {
394
						// Prise en compte de l'exception des clades
395
						if (! ($nom_sup['rang'] == 70 && $nom['rang'] == 70)) {
183 jpm 396
							$noms_erreur[] = array($nom['num_nom'], $nom['rang'], $nom_sup['num_nom'], $nom_sup['rang'], $nom['exclure_taxref']);
171 jpm 397
						}
398
					}
20 jpm 399
				}
400
			}
401
		}
176 jpm 402
		return $noms_erreur;
20 jpm 403
	}
404
 
171 jpm 405
	/**
406
	 * Test #12
407
	 */
408
	private function testerClassification() {
20 jpm 409
		$noms_erreur = array();
171 jpm 410
		$this->noms_ok = array();
64 jpm 411
		foreach ($this->noms as &$nom) {
171 jpm 412
			if ($nom['num_nom_retenu'] == $nom['num_nom']) {
413
				if (isset($this->noms_ok[$nom['num_tax_sup']])) {
414
					$this->noms_ok[$nom['num_nom']] = true;
415
				} else {
416
					$this->detection_boucle_infini = array();
417
					$classif_ok = $this->remonterClassif($nom);
418
					unset($this->detection_boucle_infini);
419
 
175 jpm 420
					if ($classif_ok === true) {
421
						$this->noms_ok[$nom['num_nom']] = $classif_ok;
171 jpm 422
					} else {
183 jpm 423
						$noms_erreur[] = array($nom['num_nom'], $classif_ok, $nom['exclure_taxref']);
171 jpm 424
					}
20 jpm 425
				}
426
			}
427
		}
171 jpm 428
		unset($this->noms_ok);
176 jpm 429
		return $noms_erreur;
20 jpm 430
	}
431
 
171 jpm 432
	private function remonterClassif(&$nom) {
433
		$this->detection_boucle_infini[$nom['num_nom']] = true;
434
		if (preg_match('/^[0-9]*$/', $nom['num_tax_sup'])) {
435
			if (isset($this->noms_ok[$nom['num_tax_sup']])) {
436
				$this->noms_ok[$nom['num_nom']] = true;
437
				return true;
438
			} else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] == '0') {
439
				$this->noms_ok[$nom['num_nom']] = true;
440
				return true;
441
			} else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] != '0') {
175 jpm 442
				return 'Hiérarchie avec le taxon #'.$nom['num_nom'].' ayant un taxon superieur #'.$nom['num_tax_sup'].' inexistant';
171 jpm 443
			} else if (isset($this->detection_boucle_infini[$nom['num_tax_sup']])) {
175 jpm 444
				return 'Boucle infinie pour le taxon #'.$nom['num_tax_sup'];
171 jpm 445
			} else {
446
				$retour = $this->remonterClassif($this->noms[$nom['num_tax_sup']]);
447
				if ($retour === true) {
448
					$this->noms_ok[$nom['num_tax_sup']] = true;
449
				}
450
				return $retour;
451
			}
452
		} else {
175 jpm 453
			return 'Valeur num_tax_sup incorrecte : '.$nom['num_tax_sup'];
171 jpm 454
		}
455
	}
456
 
457
	/**
458
	 * Test #13
459
	 */
460
	private function testerRang() {
461
		$rangs = array_flip(explode(',', $this->manuel['rangs']));
462
 
20 jpm 463
		// Réalisation du test
464
		$noms_erreur = array();
64 jpm 465
		foreach ($this->noms as &$nom) {
171 jpm 466
			if (!isset($rangs[$nom['rang']])) {
183 jpm 467
				$noms_erreur[] = array($nom['num_nom'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 468
			}
469
		}
176 jpm 470
		return $noms_erreur;
20 jpm 471
	}
472
 
171 jpm 473
	/**
474
	 * Test #14
475
	 */
476
	private function testerNomCompletSupraGenerique() {
20 jpm 477
		$noms_erreur = array();
64 jpm 478
		foreach ($this->noms as &$nom) {
171 jpm 479
			if ($nom['rang'] < $this->manuel['rang_genre']) {
480
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
481
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['nom_supra_generique']);
482
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
483
				if ($nom['nom_sci'] != $nom_sci_ideal) {
484
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 485
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
20 jpm 486
				}
487
			}
488
		}
176 jpm 489
		return $noms_erreur;
20 jpm 490
	}
491
 
171 jpm 492
	/**
493
	 * Test #15
494
	 */
495
	private function testerNomCompletGenre() {
20 jpm 496
		$noms_erreur = array();
171 jpm 497
		foreach ($this->noms as &$nom) {
498
			if ($nom['rang'] == $this->manuel['rang_genre']) {
499
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
500
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
501
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
502
				if ($nom['nom_sci'] != $nom_sci_ideal) {
503
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 504
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
20 jpm 505
				}
506
			}
507
		}
176 jpm 508
		return $noms_erreur;
20 jpm 509
	}
510
 
171 jpm 511
	/**
512
	 * Test #16
513
	 */
514
	private function testerNomCompletInfraGenre() {
20 jpm 515
		$noms_erreur = array();
64 jpm 516
		foreach ($this->noms as &$nom) {
171 jpm 517
			if ($nom['rang'] > $this->manuel['rang_genre'] && $nom['rang'] < $this->manuel['rang_sp']) {
518
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
519
				$nom_sci_ideal = '';
520
				if ($nom['type_epithete'] == 'agg.') {
521
					$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
522
					$nom_sci_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
523
					$nom_sci_ideal .= ' '.$nom['type_epithete'];
524
				} else {
525
					$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
526
					$nom_sci_ideal .= ' '.$nom['type_epithete'];
527
					$nom_sci_ideal .= ' '.$this->formaterStyleNomGenre($nom['epithete_infra_generique']);
20 jpm 528
				}
171 jpm 529
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
530
				if ($nom['nom_sci'] != $nom_sci_ideal) {
531
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 532
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
171 jpm 533
				}
20 jpm 534
			}
535
		}
176 jpm 536
		return $noms_erreur;
20 jpm 537
	}
538
 
171 jpm 539
	/**
540
	 * Test #17
541
	 */
542
	private function testerNomCompletEspece() {
20 jpm 543
		$noms_erreur = array();
64 jpm 544
		foreach ($this->noms as &$nom) {
171 jpm 545
			if ($nom['rang'] == $this->manuel['rang_sp']) {
546
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
547
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
548
				$nom_sci_ideal .= ' '.strtolower($nom['epithete_sp']);
549
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
550
				if ($nom['nom_sci'] != $nom_sci_ideal) {
551
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 552
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
20 jpm 553
				}
554
			}
555
		}
176 jpm 556
		return $noms_erreur;
20 jpm 557
	}
558
 
171 jpm 559
	/**
560
	 * Test #18
561
	 */
562
	private function testerNomCompletInfraSpecifique() {
158 delphine 563
		$noms_erreur = array();
564
		foreach ($this->noms as &$nom) {
171 jpm 565
			if ($nom['rang'] > $this->manuel['rang_sp']) {
566
				$suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom);
567
				$nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']);
568
				$nom_sci_ideal .= ' '.strtolower($nom['epithete_sp']);
569
				$nom_sci_ideal .= ' '.strtolower($nom['type_epithete']);
570
				$nom_sci_ideal .= ' '.strtolower($nom['epithete_infra_sp']);
571
				$nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : '');
572
				if ($nom['nom_sci'] != $nom_sci_ideal) {
573
					$nom_sci_traite = $this->repererEspace($nom['nom_sci']);
183 jpm 574
					$noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']);
171 jpm 575
				}
158 delphine 576
			}
577
		}
176 jpm 578
		return $noms_erreur;
158 delphine 579
	}
580
 
171 jpm 581
	/**
582
	 * Test #19
583
	 */
584
	private function testerNomSupraGeneriqueEspaces() {
20 jpm 585
		$noms_erreur = array();
64 jpm 586
		foreach ($this->noms as &$nom) {
171 jpm 587
			if ($nom['nom_supra_generique'] != '') {
588
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s+$)/', $nom['nom_supra_generique'])) {
589
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
183 jpm 590
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite, $nom['exclure_taxref']);
20 jpm 591
				}
592
			}
593
		}
176 jpm 594
		return $noms_erreur;
20 jpm 595
	}
596
 
171 jpm 597
	/**
598
	 * Test #20
599
	 */
600
	private function testerNomSupraGeneriqueSyntaxe() {
20 jpm 601
		$noms_erreur = array();
64 jpm 602
		foreach ($this->noms as &$nom) {
171 jpm 603
			if ($nom['nom_supra_generique'] != '') {
604
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+$/', $nom['nom_supra_generique'])) {
605
					$nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']);
183 jpm 606
					$noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite, $nom['exclure_taxref']);
20 jpm 607
				}
608
			}
609
		}
177 jpm 610
		return $noms_erreur;
20 jpm 611
	}
612
 
171 jpm 613
	/**
614
	 * Test #21
615
	 */
616
	private function testerNomSupraGeneriqueRang() {
20 jpm 617
		$noms_erreur = array();
64 jpm 618
		foreach ($this->noms as &$nom) {
171 jpm 619
			if ($nom['nom_supra_generique'] != '') {
620
				if ($nom['rang'] >= $this->manuel['rang_genre']) {
183 jpm 621
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 622
				}
623
			}
624
		}
177 jpm 625
		return $noms_erreur;
20 jpm 626
	}
627
 
171 jpm 628
	/**
629
	 * Test #22
630
	 */
631
	private function testerGenreEspaces() {
20 jpm 632
		$noms_erreur = array();
64 jpm 633
		foreach ($this->noms as &$nom) {
171 jpm 634
			if ($nom['genre'] != '') {
635
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['genre'])) {
636
					$nom_traite = $this->repererEspace($nom['genre']);
183 jpm 637
					$noms_erreur[] = array($nom['num_nom'], $nom_traite, $nom['exclure_taxref']);
20 jpm 638
				}
639
			}
640
		}
177 jpm 641
		return $noms_erreur;
20 jpm 642
	}
643
 
171 jpm 644
	/**
645
	 * Test #23
646
	 */
647
	private function testerGenreSyntaxe() {
20 jpm 648
		$noms_erreur = array();
64 jpm 649
		foreach ($this->noms as &$nom) {
171 jpm 650
			if ($nom['genre'] != '') {
651
				$mots = explode(' ', $nom['genre']);
652
				foreach ($mots as $mot) {
653
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteGenre($mot))) {
654
						$nom_traite = $this->repererEspace($nom['genre']);
183 jpm 655
						$noms_erreur[] = array($nom['num_nom'], $nom_traite, $nom['exclure_taxref']);
171 jpm 656
					}
20 jpm 657
				}
658
			}
659
		}
177 jpm 660
		return $noms_erreur;
20 jpm 661
	}
662
 
171 jpm 663
	/**
664
	 * Test #24
665
	 */
666
	private function testerGenreRang() {
20 jpm 667
		$noms_erreur = array();
64 jpm 668
		foreach ($this->noms as &$nom) {
171 jpm 669
			if ($nom['genre'] != '') {
670
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 671
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 672
				}
673
			}
674
		}
177 jpm 675
		return $noms_erreur;
20 jpm 676
	}
677
 
171 jpm 678
	/**
679
	 * Test #25
680
	 */
681
	private function testerEpitheteInfraGeneriqueSyntaxe() {
20 jpm 682
		$noms_erreur = array();
64 jpm 683
		foreach ($this->noms as &$nom) {
171 jpm 684
			if ($nom['epithete_infra_generique'] != '') {
685
				if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+/', $nom['epithete_infra_generique'])) {
686
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
183 jpm 687
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 688
				}
689
			}
690
		}
177 jpm 691
		return $noms_erreur;
20 jpm 692
	}
693
 
171 jpm 694
	/**
695
	 * Test #26
696
	 */
697
	private function testerEpitheteInfraGeneriqueRang() {
20 jpm 698
		$noms_erreur = array();
64 jpm 699
		foreach ($this->noms as &$nom) {
171 jpm 700
			if ($nom['epithete_infra_generique'] != '') {
701
				if ($nom['rang'] <= $this->manuel['rang_genre'] || $nom['rang'] >= $this->manuel['rang_sp']) {
183 jpm 702
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 703
				}
704
			}
705
		}
177 jpm 706
		return $noms_erreur;
20 jpm 707
	}
708
 
171 jpm 709
	/**
710
	 * Test #27
711
	 */
712
	private function testerEpitheteInfraGeneriqueEspaces() {
20 jpm 713
		$noms_erreur = array();
64 jpm 714
		foreach ($this->noms as &$nom) {
171 jpm 715
			if ($nom['epithete_infra_generique'] != '') {
716
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_generique'])) {
717
					$epithete_traite = $this->repererEspace($nom['epithete_infra_generique']);
183 jpm 718
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 719
				}
720
			}
721
		}
177 jpm 722
		return $noms_erreur;
20 jpm 723
	}
724
 
171 jpm 725
	/**
726
	 * Test #28
727
	 */
728
	private function testerEpitheteSpEspaces() {
20 jpm 729
		$noms_erreur = array();
64 jpm 730
		foreach ($this->noms as &$nom) {
171 jpm 731
			if ($nom['epithete_sp'] != '') {
732
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_sp'])) {
733
					$epithete_traite = $this->repererEspace($nom['epithete_sp']);
183 jpm 734
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 735
				}
736
			}
737
		}
177 jpm 738
		return $noms_erreur;
20 jpm 739
	}
740
 
171 jpm 741
	/**
742
	 * Test #29
743
	 */
744
	private function testerEpitheteSpSyntaxe() {
20 jpm 745
		$noms_erreur = array();
64 jpm 746
		foreach ($this->noms as &$nom) {
171 jpm 747
			if ($nom['epithete_sp'] != '') {
748
				$mots = explode(' ', $nom['epithete_sp']);
749
				foreach ($mots as $mot) {
750
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteSp($mot))) {
751
						$epithete_traite = $this->repererEspace($nom['epithete_sp']);
183 jpm 752
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
171 jpm 753
					}
754
				}
20 jpm 755
			}
756
		}
177 jpm 757
		return $noms_erreur;
20 jpm 758
	}
759
 
171 jpm 760
	/**
761
	 * Test #30
762
	 */
763
	private function testerEpitheteSpRang() {
20 jpm 764
		$noms_erreur = array();
64 jpm 765
		foreach ($this->noms as &$nom) {
171 jpm 766
			if ($nom['epithete_sp'] != '') {
767
				if ($nom['rang'] < $this->manuel['rang_sp']) {
183 jpm 768
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 769
				}
770
			}
771
		}
177 jpm 772
		return $noms_erreur;
20 jpm 773
	}
774
 
171 jpm 775
	/**
776
	 * Test #31
777
	 */
778
	private function testerTypeEpitheteEspaces() {
20 jpm 779
		$noms_erreur = array();
64 jpm 780
		foreach ($this->noms as &$nom) {
171 jpm 781
			if ($nom['type_epithete'] != '') {
782
				if (preg_match('/\s+/', $nom['type_epithete'])) {
783
					$valeur_traitee = $this->repererEspace($nom['epithete_sp']);
183 jpm 784
					$noms_erreur[] = array($nom['num_nom'], $valeur_traitee, $nom['exclure_taxref']);
20 jpm 785
				}
786
			}
787
		}
177 jpm 788
		return $noms_erreur;
20 jpm 789
	}
790
 
171 jpm 791
	/**
792
	 * Test #32
793
	 */
794
	private function testerTypeEpitheteSyntaxe() {
20 jpm 795
		$noms_erreur = array();
64 jpm 796
		foreach ($this->noms as &$nom) {
171 jpm 797
			if ($nom['type_epithete'] != '') {
798
				if (!$this->verifierTypeEpithete($nom['type_epithete'])) {
183 jpm 799
					$noms_erreur[] = array($nom['num_nom'],  $nom['type_epithete'], $nom['exclure_taxref']);
20 jpm 800
				}
801
			}
802
		}
177 jpm 803
		return $noms_erreur;
20 jpm 804
	}
805
 
171 jpm 806
	/**
807
	 * Test #33
808
	 */
809
	private function testerTypeEpitheteHybridite() {
20 jpm 810
		$noms_erreur = array();
64 jpm 811
		foreach ($this->noms as &$nom) {
171 jpm 812
			if ($nom['type_epithete'] != '') {
813
				if (preg_match('/^(?:n-|notho-)/', $nom['type_epithete'])) {
183 jpm 814
					$noms_erreur[] = array($nom['num_nom'], $nom['type_epithete'], $nom['exclure_taxref']);
20 jpm 815
				}
816
			}
817
		}
177 jpm 818
		return $noms_erreur;
20 jpm 819
	}
820
 
171 jpm 821
	/**
822
	 * Test #34
823
	 */
64 jpm 824
	private function testerEpitheteInfraSpEspaces() {
20 jpm 825
		$noms_erreur = array();
64 jpm 826
		foreach ($this->noms as &$nom) {
20 jpm 827
			if ($nom['epithete_infra_sp'] != '') {
828
				if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_sp'])) {
829
					$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
183 jpm 830
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 831
				}
832
			}
833
		}
177 jpm 834
		return $noms_erreur;
20 jpm 835
	}
836
 
171 jpm 837
	/**
838
	 * Test #35
839
	 */
64 jpm 840
	private function testerEpitheteInfraSpSyntaxe() {
20 jpm 841
		$noms_erreur = array();
64 jpm 842
		foreach ($this->noms as &$nom) {
20 jpm 843
			if ($nom['epithete_infra_sp'] != '') {
844
				$mots = explode(' ', $nom['epithete_infra_sp']);
845
				foreach ($mots as $mot) {
846
					if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot)|| $this->verifierEpitheteSp($mot))) {
847
						$epithete_traite = $this->repererEspace($nom['epithete_infra_sp']);
183 jpm 848
						$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 849
					}
850
				}
851
			}
852
		}
177 jpm 853
		return $noms_erreur;
20 jpm 854
	}
855
 
171 jpm 856
	/**
857
	 * Test #36
858
	 */
64 jpm 859
	private function testerEpitheteInfraSpRang() {
20 jpm 860
		$noms_erreur = array();
64 jpm 861
		foreach ($this->noms as &$nom) {
20 jpm 862
			if ($nom['epithete_infra_sp'] != '') {
863
				if ($nom['rang'] < $this->manuel['rang_sp']) {
183 jpm 864
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 865
				}
866
			}
867
		}
177 jpm 868
		return $noms_erreur;
20 jpm 869
	}
870
 
173 jpm 871
	/**
872
	 * Test #37
873
	 */
874
	private function testerGroupeCultivarSyntaxe() {
20 jpm 875
		$noms_erreur = array();
64 jpm 876
		foreach ($this->noms as &$nom) {
173 jpm 877
			if ($nom['cultivar_groupe'] != '') {
878
				if (!$this->verifierEpitheteGroupeCultivar($nom['cultivar_groupe'])) {
879
					$epithete_traite = $this->repererEspace($nom['cultivar_groupe']);
183 jpm 880
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 881
				}
882
			}
883
		}
177 jpm 884
		return $noms_erreur;
20 jpm 885
	}
886
 
173 jpm 887
	/**
888
	 * Test #38
889
	 */
890
	private function testerGroupeCultivarRang() {
20 jpm 891
		$noms_erreur = array();
64 jpm 892
		foreach ($this->noms as &$nom) {
173 jpm 893
			if ($nom['cultivar_groupe'] != '') {
894
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 895
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
20 jpm 896
				}
897
			}
898
		}
177 jpm 899
		return $noms_erreur;
20 jpm 900
	}
901
 
173 jpm 902
	/**
903
	 * Test #39
904
	 */
905
	private function testerCultivarSyntaxe() {
20 jpm 906
		$noms_erreur = array();
64 jpm 907
		foreach ($this->noms as &$nom) {
173 jpm 908
			if ($nom['cultivar'] != '') {
909
				if (!$this->verifierEpitheteCultivar($nom['cultivar'])) {
910
					$epithete_traite = $this->repererEspace($nom['cultivar']);
183 jpm 911
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
20 jpm 912
				}
913
			}
914
		}
177 jpm 915
		return $noms_erreur;
20 jpm 916
	}
917
 
173 jpm 918
	/**
919
	 * Test #40
920
	 */
921
	private function testerCultivarRang() {
20 jpm 922
		$noms_erreur = array();
64 jpm 923
		foreach ($this->noms as &$nom) {
173 jpm 924
			if ($nom['cultivar'] != '') {
925
				if ($nom['rang'] < $this->manuel['rang_genre']) {
183 jpm 926
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']);
171 jpm 927
				}
20 jpm 928
			}
929
		}
177 jpm 930
		return $noms_erreur;
20 jpm 931
	}
932
 
173 jpm 933
	/**
934
	 * Test #41
935
	 */
936
	private function testerNomCommercialSyntaxe() {
20 jpm 937
		$noms_erreur = array();
64 jpm 938
		foreach ($this->noms as &$nom) {
173 jpm 939
			if ($nom['nom_commercial'] != '') {
940
				if (!$this->verifierNomCommercial($nom['nom_commercial'])) {
941
					$epithete_traite = $this->repererEspace($nom['nom_commercial']);
183 jpm 942
					$noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']);
171 jpm 943
				}
20 jpm 944
			}
945
		}
177 jpm 946
		return $noms_erreur;
20 jpm 947
	}
948
 
173 jpm 949
	/**
950
	 * Test #42
951
	 */
952
	private function testerNomCommercialPresenceCultivar() {
20 jpm 953
		$noms_erreur = array();
64 jpm 954
		foreach ($this->noms as &$nom) {
173 jpm 955
			if ((isset($nom['nom_commercial']) && $nom['nom_commercial'] != '') && ($nom['cultivar'] == '' && $nom['cultivar_groupe'] == '')) {
183 jpm 956
				$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['exclure_taxref']);
20 jpm 957
			}
958
		}
177 jpm 959
		return $noms_erreur;
20 jpm 960
	}
961
 
173 jpm 962
	/**
963
	 * Test #43
964
	 */
965
	private function testerAuteurSyntaxe() {
20 jpm 966
		$noms_erreur = array();
64 jpm 967
		foreach ($this->noms as &$nom) {
173 jpm 968
			if ($nom['auteur'] != '') {
969
				if (!$this->verifierAuteur($nom['auteur'])) {
970
					$intitule_traite = $this->repererEspace($nom['auteur']);
183 jpm 971
					$noms_erreur[] = array($nom['num_nom'], $intitule_traite, $nom['exclure_taxref']);
171 jpm 972
				}
20 jpm 973
			}
974
		}
177 jpm 975
		return $noms_erreur;
20 jpm 976
	}
977
 
173 jpm 978
	/**
979
	 * Test #44
980
	 */
981
	private function testerAnneeSyntaxe() {
20 jpm 982
		$noms_erreur = array();
64 jpm 983
		foreach ($this->noms as &$nom) {
173 jpm 984
			if ($nom['annee'] != '') {
985
				if (!$this->verifierAnnee($nom['annee'])) {
183 jpm 986
					$noms_erreur[] = array($nom['num_nom'], $nom['annee'], $nom['exclure_taxref']);
171 jpm 987
				}
20 jpm 988
			}
989
		}
177 jpm 990
		return $noms_erreur;
20 jpm 991
	}
992
 
173 jpm 993
	/**
994
	 * Test #45
995
	 */
996
	private function testerBiblioOrigineSyntaxe() {
20 jpm 997
		$noms_erreur = array();
64 jpm 998
		foreach ($this->noms as &$nom) {
173 jpm 999
			if ($nom['biblio_origine'] != '') {
1000
				if (!$this->verifierBiblioOrigine($nom['biblio_origine'])) {
1001
					$biblio_traite = $this->repererEspace($nom['biblio_origine']);
183 jpm 1002
					$noms_erreur[] = array($nom['num_nom'], $biblio_traite, $nom['exclure_taxref']);
20 jpm 1003
				}
1004
			}
1005
		}
177 jpm 1006
		return $noms_erreur;
20 jpm 1007
	}
1008
 
173 jpm 1009
	/**
1010
	 * Test #46
1011
	 */
1012
	private function testerHomonymieSyntaxe() {
20 jpm 1013
		$noms_erreur = array();
173 jpm 1014
		foreach ($this->noms as &$nom) {
1015
			if ($nom['homonyme'] != '') {
1016
				if (!$this->verifierBooleen($nom['homonyme'])) {
183 jpm 1017
					$noms_erreur[] = array($nom['num_nom'], $nom['homonyme'], $nom['exclure_taxref']);
161 jpm 1018
				}
20 jpm 1019
			}
1020
		}
177 jpm 1021
		return $noms_erreur;
20 jpm 1022
	}
1023
 
173 jpm 1024
	/**
1025
	 * Test #47
1026
	 */
1027
	private function testerHomonymieExistence() {
1028
		$noms_homonymie = $this->classerNomsParNomComplet();
1029
 
20 jpm 1030
		$noms_erreur = array();
64 jpm 1031
		foreach ($this->noms as &$nom) {
173 jpm 1032
			if ($nom['homonyme'] != '0' && $nom['homonyme'] != '') {
1033
				if ($noms_homonymie[$nom['nom_sci']] <= 1) {
183 jpm 1034
					$noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['exclure_taxref']);
171 jpm 1035
				}
20 jpm 1036
			}
1037
		}
173 jpm 1038
		$noms_homonymie = null;
177 jpm 1039
		return $noms_erreur;
20 jpm 1040
	}
1041
 
173 jpm 1042
	/**
1043
	 * Test #48
1044
	 */
1045
	private function testerBasionymeSyntaxe() {
20 jpm 1046
		$noms_erreur = array();
64 jpm 1047
		foreach ($this->noms as &$nom) {
173 jpm 1048
			if ($nom['basionyme'] != '') {
1049
				if (!$this->verifierNombre($nom['basionyme'])) {
183 jpm 1050
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme'], $nom['exclure_taxref']);
20 jpm 1051
				}
1052
			}
1053
		}
177 jpm 1054
		return $noms_erreur;
20 jpm 1055
	}
173 jpm 1056
 
1057
	/**
1058
	 * Test #49
1059
	 */
1060
	private function testerBasionymeExistence() {
20 jpm 1061
		$noms_erreur = array();
64 jpm 1062
		foreach ($this->noms as &$nom) {
173 jpm 1063
			if ($nom['basionyme'] != '') {
1064
				if (!isset($this->noms[$nom['basionyme']])) {
183 jpm 1065
					$noms_erreur[] = array($nom['num_nom'], $nom['basionyme'], $nom['exclure_taxref']);
173 jpm 1066
				}
20 jpm 1067
			}
1068
		}
177 jpm 1069
		return $noms_erreur;
20 jpm 1070
	}
1071
 
173 jpm 1072
	/**
1073
	 * Test #50
1074
	 */
1075
	private function testerSynonymeProparteSyntaxe() {
20 jpm 1076
		$noms_erreur = array();
64 jpm 1077
		foreach ($this->noms as &$nom) {
171 jpm 1078
			if ($nom['synonyme_proparte'] != '') {
173 jpm 1079
				if (!$this->verifierNombreSuite($nom['synonyme_proparte'])) {
183 jpm 1080
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_proparte'], $nom['exclure_taxref']);
20 jpm 1081
				}
1082
			}
1083
		}
177 jpm 1084
		return $noms_erreur;
20 jpm 1085
	}
1086
 
173 jpm 1087
	/**
1088
	 * Test #51
1089
	 */
1090
	private function testerSynonymeProparteExistence() {
20 jpm 1091
		$noms_erreur = array();
64 jpm 1092
		foreach ($this->noms as &$nom) {
171 jpm 1093
			if ($nom['synonyme_proparte'] != '') {
173 jpm 1094
				$num_nom_a_verifier = explode(',', $nom['synonyme_proparte']);
1095
				$num_nom_en_erreur = array();
1096
				foreach ($num_nom_a_verifier as $num_nom) {
1097
					if (!isset($this->noms[$num_nom])) {
1098
						$num_nom_en_erreur[] = $num_nom;
1099
					}
20 jpm 1100
				}
173 jpm 1101
				if (count($nbre_en_erreur) > 0) {
183 jpm 1102
					$noms_erreur[] = array($nom['num_nom'], implode(',', $num_nom_en_erreur), $nom['exclure_taxref']);
173 jpm 1103
				}
20 jpm 1104
			}
1105
		}
177 jpm 1106
		return $noms_erreur;
20 jpm 1107
	}
1108
 
173 jpm 1109
	/**
1110
	 * Test #52
1111
	 */
1112
	private function testerSynonymeDouteuxSyntaxe() {
20 jpm 1113
		$noms_erreur = array();
64 jpm 1114
		foreach ($this->noms as &$nom) {
173 jpm 1115
			if ($nom['synonyme_douteux'] != '') {
1116
				if (!$this->verifierBooleen($nom['synonyme_douteux'])) {
183 jpm 1117
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['exclure_taxref']);
20 jpm 1118
				}
1119
			}
1120
		}
177 jpm 1121
		return $noms_erreur;
20 jpm 1122
	}
1123
 
173 jpm 1124
	/**
1125
	 * Test #53
1126
	 */
1127
	private function testerSynonymeDouteuxNumNomRetenu() {
20 jpm 1128
		$noms_erreur = array();
64 jpm 1129
		foreach ($this->noms as &$nom) {
173 jpm 1130
			if ($nom['synonyme_douteux'] == 1 && $nom['num_nom_retenu'] != ' ') {
183 jpm 1131
				$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['num_nom_retenu'], $nom['exclure_taxref']);
20 jpm 1132
			}
1133
		}
177 jpm 1134
		return $noms_erreur;
20 jpm 1135
	}
1136
 
171 jpm 1137
	/**
173 jpm 1138
	 * Test #54
171 jpm 1139
	 */
173 jpm 1140
	private function testerSynonymeMalAppliqueSyntaxe() {
20 jpm 1141
		$noms_erreur = array();
64 jpm 1142
		foreach ($this->noms as &$nom) {
173 jpm 1143
			if ($nom['synonyme_mal_applique'] != '') {
1144
				if (!$this->verifierBooleen($nom['synonyme_mal_applique'])) {
183 jpm 1145
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_mal_applique'], $nom['exclure_taxref']);
20 jpm 1146
				}
1147
			}
1148
		}
177 jpm 1149
		return $noms_erreur;
20 jpm 1150
	}
1151
 
171 jpm 1152
	/**
173 jpm 1153
	 * Test #55
171 jpm 1154
	 */
173 jpm 1155
	private function testerSynonymeOrthographiqueSyntaxe() {
20 jpm 1156
		$noms_erreur = array();
173 jpm 1157
		foreach ($this->noms as $nom) {
1158
			if ($nom['synonyme_orthographique'] != '') {
1159
				if (!$this->verifierNombre($nom['synonyme_orthographique'])) {
183 jpm 1160
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']);
20 jpm 1161
				}
1162
			}
1163
		}
177 jpm 1164
		return $noms_erreur;
20 jpm 1165
	}
1166
 
171 jpm 1167
	/**
173 jpm 1168
	 * Test #56
171 jpm 1169
	 */
173 jpm 1170
	private function testerSynonymeOrthographiqueExistence() {
20 jpm 1171
		$noms_erreur = array();
64 jpm 1172
		foreach ($this->noms as &$nom) {
173 jpm 1173
			if ($nom['synonyme_orthographique'] != '') {
1174
				if (!isset($this->noms[$nom['synonyme_orthographique']])) {
183 jpm 1175
					$noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']);
20 jpm 1176
				}
1177
			}
1178
		}
177 jpm 1179
		return $noms_erreur;
20 jpm 1180
	}
1181
 
171 jpm 1182
	/**
173 jpm 1183
	 * Test #57
171 jpm 1184
	 */
173 jpm 1185
	private function testerHybrideParent01Syntaxe() {
20 jpm 1186
		$noms_erreur = array();
64 jpm 1187
		foreach ($this->noms as &$nom) {
173 jpm 1188
			if ($nom['hybride_parent_01'] != '') {
1189
				if (!$this->verifierNombre($nom['hybride_parent_01'])) {
183 jpm 1190
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']);
20 jpm 1191
				}
1192
			}
1193
		}
177 jpm 1194
		return $noms_erreur;
20 jpm 1195
	}
1196
 
171 jpm 1197
	/**
173 jpm 1198
	 * Test #58
171 jpm 1199
	 */
173 jpm 1200
	private function testerHybrideParent01Existence() {
20 jpm 1201
		$noms_erreur = array();
64 jpm 1202
		foreach ($this->noms as &$nom) {
173 jpm 1203
			if ($nom['hybride_parent_01'] != '' && $nom['hybride_parent_01'] != '0') {
1204
				if (!isset($this->noms[$nom['hybride_parent_01']])) {
183 jpm 1205
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']);
20 jpm 1206
				}
1207
			}
1208
		}
177 jpm 1209
		return $noms_erreur;
20 jpm 1210
	}
171 jpm 1211
 
1212
	/**
173 jpm 1213
	 * Test #59
171 jpm 1214
	 */
173 jpm 1215
	private function testerHybrideParent02Syntaxe() {
20 jpm 1216
		$noms_erreur = array();
64 jpm 1217
		foreach ($this->noms as &$nom) {
173 jpm 1218
			if ($nom['hybride_parent_02'] != '') {
1219
				if (!$this->verifierNombre($nom['hybride_parent_02'])) {
183 jpm 1220
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']);
173 jpm 1221
				}
20 jpm 1222
			}
1223
		}
177 jpm 1224
		return $noms_erreur;
20 jpm 1225
	}
1226
 
171 jpm 1227
	/**
173 jpm 1228
	 * Test #60
171 jpm 1229
	 */
173 jpm 1230
	private function testerHybrideParent02Existence() {
20 jpm 1231
		$noms_erreur = array();
64 jpm 1232
		foreach ($this->noms as &$nom) {
173 jpm 1233
			if ($nom['hybride_parent_02'] != '') {
1234
				if (!isset($this->noms[$nom['hybride_parent_02']]) && $nom['hybride_parent_02'] != '0') {
183 jpm 1235
					$noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']);
20 jpm 1236
				}
1237
			}
1238
		}
177 jpm 1239
		return $noms_erreur;
20 jpm 1240
	}
1241
 
171 jpm 1242
	/**
173 jpm 1243
	 * Test #61
171 jpm 1244
	 */
173 jpm 1245
	private function testerPresenceSyntaxe() {
20 jpm 1246
		$noms_erreur = array();
64 jpm 1247
		foreach ($this->noms as &$nom) {
173 jpm 1248
			if ($nom['presence'] != '') {
1249
				if (!$this->verifierPresence($nom['presence'])) {
183 jpm 1250
					$noms_erreur[] = array($nom['num_nom'], $nom['presence'], $nom['exclure_taxref']);
20 jpm 1251
				}
1252
			}
1253
		}
177 jpm 1254
		return $noms_erreur;
20 jpm 1255
	}
1256
 
171 jpm 1257
	/**
173 jpm 1258
	 * Test #62
171 jpm 1259
	 */
173 jpm 1260
	private function testerStatutOrigineSyntaxe() {
20 jpm 1261
		$noms_erreur = array();
64 jpm 1262
		foreach ($this->noms as &$nom) {
173 jpm 1263
			if ($nom['statut_origine'] != '') {
1264
				if (!$this->verifierStatutOrigine($nom['statut_origine'])) {
183 jpm 1265
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_origine'], $nom['exclure_taxref']);
20 jpm 1266
				}
1267
			}
1268
		}
177 jpm 1269
		return $noms_erreur;
20 jpm 1270
	}
1271
 
171 jpm 1272
	/**
173 jpm 1273
	 * Test #63
171 jpm 1274
	 */
173 jpm 1275
	private function testerStatutIntroductionSyntaxe() {
20 jpm 1276
		$noms_erreur = array();
64 jpm 1277
		foreach ($this->noms as &$nom) {
173 jpm 1278
			if ($nom['statut_introduction'] != '') {
1279
				if (!$this->verifierStatutIntroduction($nom['statut_introduction'])) {
183 jpm 1280
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_introduction'], $nom['exclure_taxref']);
20 jpm 1281
				}
1282
			}
1283
		}
177 jpm 1284
		return $noms_erreur;
20 jpm 1285
	}
1286
 
171 jpm 1287
	/**
173 jpm 1288
	 * Test #64
171 jpm 1289
	 */
173 jpm 1290
	private function testerStatutCultureSyntaxe() {
20 jpm 1291
		$noms_erreur = array();
64 jpm 1292
		foreach ($this->noms as &$nom) {
173 jpm 1293
			if ($nom['statut_culture'] != '') {
1294
				if (!$this->verifierStatutCulture($nom['statut_culture'])) {
183 jpm 1295
					$noms_erreur[] = array($nom['num_nom'], $nom['statut_culture'], $nom['exclure_taxref']);
20 jpm 1296
				}
1297
			}
1298
		}
177 jpm 1299
		return $noms_erreur;
20 jpm 1300
	}
1301
 
171 jpm 1302
	/**
1303
	 * Test #65
1304
	 */
146 delphine 1305
	private function testerExclureTaxRefSyntaxe() {
1306
		$noms_erreur = array();
1307
		foreach ($this->noms as &$nom) {
1308
			if ($nom['exclure_taxref'] != '' && $nom['exclure_taxref'] != null) {
183 jpm 1309
				if (!preg_match('/^(?:0|1|9)$/', $nom['exclure_taxref'])) {
146 delphine 1310
					$noms_erreur[] = array($nom['num_nom'], $nom['exclure_taxref']);
1311
				}
1312
			}
1313
		}
177 jpm 1314
		return $noms_erreur;
146 delphine 1315
	}
171 jpm 1316
 
1317
 
1318
 
20 jpm 1319
	//+--------------------------------------------------------------------------------------------------------------+//
1320
	// MÉTHODES COMMUNES aux TESTS
1321
 
64 jpm 1322
	private function verifierPresence(&$valeur) {
20 jpm 1323
		$codes = $this->manuel['codes_presence'];
1324
		$ok = $this->verifierStatuts($valeur, $codes);
1325
		return $ok;
1326
	}
1327
 
64 jpm 1328
	private function verifierStatutOrigine(&$valeur) {
20 jpm 1329
		$codes = $this->manuel['codes_statuts_origine'];
1330
		$ok = $this->verifierStatuts($valeur, $codes);
1331
		return $ok;
1332
	}
1333
 
64 jpm 1334
	private function verifierStatutIntroduction(&$valeur) {
20 jpm 1335
		$codes = $this->manuel['codes_statuts_introduction'];
1336
		$ok = $this->verifierStatuts($valeur, $codes);
1337
		return $ok;
1338
	}
1339
 
64 jpm 1340
	private function verifierStatutCulture(&$valeur) {
20 jpm 1341
		$codes = $this->manuel['codes_statuts_culture'];
1342
		$ok = $this->verifierStatuts($valeur, $codes);
1343
		return $ok;
1344
	}
1345
 
64 jpm 1346
	private function verifierStatuts(&$valeur, &$codes) {
20 jpm 1347
		$ok = true;
1348
		if (!preg_match("/^(?:|-|[$codes](?:-[A-Z])?)$/", $valeur)) {
1349
			$ok = false;
1350
		}
1351
		return $ok;
1352
	}
1353
 
64 jpm 1354
	private function verifierBooleen(&$valeur) {
20 jpm 1355
		$ok = true;
1356
		if (!preg_match('/^1$/', $valeur)) {
1357
			$ok = false;
1358
		}
1359
		return $ok;
1360
	}
1361
 
64 jpm 1362
	private function verifierNombre(&$valeur) {
20 jpm 1363
		$ok = true;
1364
		if (!preg_match('/^[0-9]+$/', $valeur)) {
1365
			$ok = false;
1366
		}
1367
		return $ok;
1368
	}
1369
 
64 jpm 1370
	private function verifierNombreSuite(&$valeur) {
20 jpm 1371
		$ok = true;
1372
		if (!preg_match('/^(?:[0-9]+,)*[0-9]+$/', $valeur)) {
1373
			$ok = false;
1374
		}
1375
		return $ok;
1376
	}
1377
 
64 jpm 1378
	private function verifierTypeEpithete(&$type) {
20 jpm 1379
		$ok = false;
1380
		$rejetes = $this->manuel['type_epithete_rejetes'];
1381
		if (preg_replace("/^(?:$rejetes)$/", '', $type) == '') {
1382
			$ok = false;
1383
		} else if (preg_match('/^[a-z][-a-z]*[.]?$/', $type)) {
1384
			$ok = true;
1385
		}
1386
		return $ok;
1387
	}
1388
 
64 jpm 1389
	private function verifierBiblioOrigine(&$intitule) {
20 jpm 1390
		$ok = true;
1391
		if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
1392
			$ok = false;// Contient des espaces en trop
1393
		} else if (!preg_match('/^(?:in [^;]+[;]|)[^,]+?(?:[,][^:]+|)(?:[:].+|)$/', $intitule)) {
1394
			$ok = false;
1395
		} else if (preg_match('/(?:(?:^|[,:])\s*(?:[:,]|$))/', $intitule)) {
1396
			$ok = false;// Contient une mauvaise suite de caractères
1397
		}
1398
		return $ok;
1399
	}
1400
 
64 jpm 1401
	private function verifierAnnee(&$annee) {
20 jpm 1402
		$ok = true;
1403
		if (!preg_match('/^[0-9]{4}$/', $annee)) {
1404
			$ok = false;
1405
		} else if ($annee < 1753) {
1406
			$ok = false;
1407
		}
1408
		return $ok;
1409
	}
1410
 
64 jpm 1411
	private function verifierAuteur(&$intitule) {
20 jpm 1412
		$ok = true;
1413
		$acceptes = $this->manuel['auteur_acceptes'];
1414
		if (!preg_match("/^(?:$acceptes)$/", $intitule)) {
1415
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) {
1416
				$ok = false;// Contient des espaces en trop
1417
			} else {
1418
				$mots_rejetes = $this->manuel['auteur_mots_rejetes'];
1419
				$mots = explode(' ', $intitule);
1420
				foreach ($mots as $position => $mot) {
1421
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1422
						$ok = false;// Mot rejeté
184 jpm 1423
					} else if (preg_match("/^(?:(?:\p{L}|[.'\(\),-])+|[&])$/u", $mot)) {
20 jpm 1424
						continue;// Mot de l'intitulé auteur
1425
					} else {
1426
						$ok = false;
1427
					}
1428
				}
1429
			}
1430
		}
1431
		return $ok;
1432
	}
1433
 
64 jpm 1434
	private function verifierNomCommercial(&$epithete) {
20 jpm 1435
		$ok = false;
1436
		if (preg_match("/^[[:upper:][:punct:][:digit:][:space:]]+$/", $epithete)) {
1437
			$ok = true;
1438
		}
1439
		return $ok;
1440
	}
1441
 
64 jpm 1442
	private function verifierEpitheteCultivar(&$epithete) {
20 jpm 1443
		$ok = true;
1444
		$acceptes = $this->manuel['cultivar_acceptes'];
1445
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
1446
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
1447
				$ok = false;// Contient des espaces en trop
1448
			} else {
1449
				$mots_rejetes = $this->manuel['cultivar_mots_rejetes'];
1450
				$mots_mineurs = $this->manuel['mots_mineurs'];
1451
				$mots = explode(' ', $epithete);
1452
				foreach ($mots as $position => $mot) {
1453
					if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1454
						$ok = false;// Mot rejeté
1455
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
1456
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
1457
					} else {
1458
						$mots_tiret = explode('-', $mot);
1459
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
1460
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
1461
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position
1462
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
1463
								continue;//Mot (ou 'mot-tiret') avec lettre initiale majuscule
1464
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
1465
								continue;//Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
1466
							} else {
1467
								$ok = false;
1468
							}
1469
						}
1470
					}
1471
				}
1472
			}
1473
		}
1474
		return $ok;
1475
	}
1476
 
64 jpm 1477
	private function verifierEpitheteGroupeCultivar(&$epithete) {
20 jpm 1478
		$ok = true;
1479
		$acceptes = $this->manuel['cultivar_gp_acceptes'];
1480
		if (!preg_match("/^(?:$acceptes)$/", $epithete)) {
1481
			if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) {
1482
				$ok = false;// Contient des espaces en trop
1483
			} else {
1484
				$mots_acceptes = $this->manuel['cultivar_gp_mots_acceptes'];
1485
				$mots_rejetes = $this->manuel['cultivar_gp_mots_rejetes'];
1486
				$mots_mineurs = $this->manuel['mots_mineurs'];
1487
				$mots = explode(' ', $epithete);
1488
				foreach ($mots as $position => $mot) {
1489
					if (preg_match("/^(?:$mots_acceptes)$/i", $mot)) {
1490
						continue;// Mot accepté
1491
					} else if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) {
1492
						$ok = false;// Mot rejeté
1493
					} else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) {
1494
						continue;// Mot mineur en minuscule qui n'est pas en 1ère position
1495
					} else {
1496
						$mots_tiret = explode('-', $mot);
1497
						foreach ($mots_tiret as $position_tiret => $mot_tiret) {
1498
							if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) {
1499
								continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position dans le mot
1500
							} else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) {
1501
								continue;// Mot (ou 'mot-tiret') avec lettre initiale majuscule
1502
							} else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) {
1503
								continue;// Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation
1504
							} else {
1505
								$ok = false;
1506
							}
1507
						}
1508
					}
1509
				}
1510
			}
1511
		}
1512
		return $ok;
1513
	}
1514
 
64 jpm 1515
	private function verifierEpitheteSp(&$epithete) {
20 jpm 1516
		$ok = false;
183 jpm 1517
		if (preg_match('/^[a-zäëḧïöẗüẅẍÿ][-a-zäëḧïöẗüẅẍÿ]+$/', $epithete)) {
20 jpm 1518
			$ok = true;
1519
		} else if (preg_match('/^sp\.(?:[A-Z]|[1-9][0-9]*)$/', $epithete)) {
1520
			$ok = true;
1521
		}
1522
		return $ok;
1523
	}
1524
 
64 jpm 1525
	private function verifierEpitheteGenre(&$epithete) {
20 jpm 1526
		$ok = false;
183 jpm 1527
		if (preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ](?:[-a-zäëḧïöẗüẅẍÿ]+|[a-zäëḧïöẗüẅẍÿ]+-[A-ZÄËḦÏÖÜẄẌŸ][a-zäëḧïöẗüẅẍÿ]+)$/', $epithete)) {
20 jpm 1528
			$ok = true;
1529
		}
1530
		return $ok;
1531
	}
1532
 
64 jpm 1533
	private function formaterStyleNomGenre(&$genre) {
20 jpm 1534
		$genre_fmt = '';
1535
		if (preg_match('/^\s*([x+])\s+(.+)$/i', $genre, $match)) {
1536
			$genre_fmt = strtolower($match[1]).' '.ucfirst(strtolower($match[2]));
1537
		} else {
1538
			$genre_fmt = ucfirst(strtolower($genre));
1539
		}
1540
		return $genre_fmt;
1541
	}
1542
 
149 jpm 1543
	private function repererEspace($nom_sci) {
1544
		$nom_sci = str_replace(' ', '<span class="espace">&nbsp;</span>', $nom_sci);
1545
		return $nom_sci;
20 jpm 1546
	}
1547
 
64 jpm 1548
	private function construireSuffixeNomPltCultivee(&$nom) {
20 jpm 1549
		$suffixe = array();
1550
		$suffixe[] = $this->construireNomCultivarGroupe($nom);
1551
		$suffixe[] = $this->construireNomCommercial($nom);
1552
		$suffixe[] = $this->construireNomCultivar($nom);
1553
		$suffixe = array_filter($suffixe);
1554
		return implode(' ', $suffixe);
1555
	}
1556
 
64 jpm 1557
	private function construireNomCultivarGroupe(&$nom) {
20 jpm 1558
		$nom_groupe_cultivar = '';
1559
		if ($nom['cultivar_groupe'] != '') {
1560
			if (preg_match('/ gx$/', $nom['cultivar_groupe'])) {
1561
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].')';
1562
			} else {
1563
				$nom_groupe_cultivar =  '('.$nom['cultivar_groupe'].' Gp)';
1564
			}
1565
		}
1566
		return $nom_groupe_cultivar;
1567
	}
1568
 
64 jpm 1569
	private function construireNomCommercial(&$nom) {
20 jpm 1570
		$nom_commercial = '';
1571
		if ($nom['nom_commercial'] != '') {
1572
			$nom_commercial =  strtoupper($nom['nom_commercial']);
1573
		}
1574
		return $nom_commercial;
1575
	}
1576
 
64 jpm 1577
	private function construireNomCultivar(&$nom) {
20 jpm 1578
		$nom_cultivar = '';
1579
		if ($nom['cultivar'] != '') {
1580
			$nom_cultivar =  "'".$nom['cultivar']."'";
1581
		}
1582
		return $nom_cultivar;
1583
	}
1584
 
64 jpm 1585
	private function classerNomsParNomComplet() {
20 jpm 1586
		$noms_classes = array();
64 jpm 1587
		foreach ($this->noms as &$nom) {
149 jpm 1588
			if (!isset($noms_classes[$nom['nom_sci']])) {
1589
				$noms_classes[$nom['nom_sci']] = 1;
20 jpm 1590
			} else {
149 jpm 1591
				$noms_classes[$nom['nom_sci']]++;
20 jpm 1592
			}
1593
		}
1594
		return $noms_classes;
1595
	}
1596
}
1597
?>