| New file |
|---|
| 0,0 → 1,2095 |
|---|
| <?php |
| // Encodage : UTF-8 |
| // +-------------------------------------------------------------------------------------------------------------------+ |
| /** |
| * Tests de référentiels de nomenclature et taxonomie |
| * |
| * Description : classe permettant de tester les référentiels selon le manuel technique |
| * Utilisation : php script.php tests -p bdnff -a tout |
| * |
| //Auteur original : |
| * @author Jean-Pascal MILCENT <jpm@tela-botanica.org> |
| * @copyright Tela-Botanica 1999-2010 |
| * @link http://www.tela-botanica.org/wikini/RTaxMethodo/wakka.php?wiki=MaNuel |
| * @licence GPL v3 & CeCILL v2 |
| * @version $Id$ |
| */ |
| // +-------------------------------------------------------------------------------------------------------------------+ |
| // TODO : supprimer l'utilisation du paramêtres 'p' et chercher les infos depuis la bdd |
| class Tests extends ScriptCommande { |
| |
| const SCRIPT_NOM = 'tests'; |
| const MANUEL_VERSION = '4.4'; |
| |
| private $projet = null; |
| private $traitement = null; |
| |
| private $manuel = null; |
| private $manuel_nom = null; |
| private $manuel_chemin = null; |
| private $tests = null; |
| private $colonnes = null; |
| private $analyses = null; |
| private $noms = null; |
| private $erreurs = array(); |
| |
| private $resultatDao = null; |
| private $traitementDao = null; |
| private $tableStructureDao = null; |
| private $referentielDao = null; |
| |
| public function executer() { |
| $this->manuel_nom = 'mtpr_v'.str_replace('.', '_', self::MANUEL_VERSION).'.pdf'; |
| $this->manuel_chemin = Config::get('chemin_appli').DS.'..'.DS.'configurations'.DS; |
| |
| $manuel_config_nom = 'referentiel_v'.self::MANUEL_VERSION.'.ini'; |
| $this->manuel = parse_ini_file($this->manuel_chemin.$manuel_config_nom); |
| |
| $this->definirConstantes(); |
| $this->tests = parse_ini_file($this->getModuleChemin().DS.'configurations'.DS.'tests.ini', true); |
| |
| $this->resultatDao = new ResultatDao(); |
| $this->traitementDao = new TraitementDao(); |
| Debug::printr('Dans le script test'); |
| // Récupération du dernier traitement demandé |
| $this->traitement = $this->traitementDao->getDernierTraitement('tout', self::SCRIPT_NOM); |
| if (isset($this->traitement)) { |
| $this->projet = $this->traitement['referentiel_code']; // Récupération du nom de projet |
| Debug::printr($this->traitement); |
| // Écriture de la date de début du traitement |
| Debug::printr('Debute:'.$this->traitementDao->debuterTraitement($this->traitement['id_traitement'])); |
| |
| // Nettoyage des traitements obsolètes |
| $traitements_obsoletes = $this->traitementDao->getTraitementsObsoletes($this->projet, self::SCRIPT_NOM); |
| if (isset($traitements_obsoletes)) { |
| Debug::printr('Supp. obsoletes:'.$this->traitementDao->supprimer($traitements_obsoletes)); |
| } |
| |
| $this->tableStructureDao = new TableStructureDao(); |
| $this->referentielDao = new ReferentielDao(); |
| |
| // Lancement du test demandé |
| $cmd = $this->getParam('a'); |
| switch ($cmd) { |
| case 'tout' : |
| Debug::printr('Départ lancement test:'); |
| $this->recupererDonnees(); |
| $this->lancerTestsAuto(); |
| break; |
| case 'test14' : |
| $this->recupererDonnees(); |
| Debug::printr('Départ lancement test 14 :'); |
| $this->testerClassificationRang(); |
| break; |
| default : |
| $this->traiterErreur('Erreur : la commande "%s" n\'existe pas!', array($cmd)); |
| } |
| // Écriture de la date de fin du traitement |
| Debug::printr('Termine:'.$this->traitementDao->terminerTraitement($this->traitement['id_traitement'])); |
| } else { |
| Debug::printr("Aucun dernier traitement trouvé pour le script '".self::SCRIPT_NOM."' !"); |
| } |
| } |
| |
| /** |
| * Cette méthode définie des constantes qui peuvent ensuite être utilisée dans les fichier ini. |
| * Surtout utile pour le fichier tests.ini |
| */ |
| private function definirConstantes() { |
| define('RANG_GENRE', $this->manuel['rang_genre']); |
| define('RANG_SP', $this->manuel['rang_sp']); |
| date_default_timezone_set('Europe/Berlin'); |
| define('ANNEE_EN_COURS', date('Y')); |
| define('ANNEE_MINIMUM', 1753); |
| } |
| |
| public function recupererDonnees() { |
| // Récupération des données à tester |
| $this->colonnes = $this->tableStructureDao->getColonnes($this->projet); |
| $this->analyses = $this->tableStructureDao->getAnalyse($this->projet); |
| $this->noms = $this->referentielDao->getTout($this->projet); |
| Debug::printr('Nbre noms :'.count($this->noms)); |
| } |
| |
| public function lancerTestsAuto() { |
| $resultats = array(); |
| |
| // Lancement des tests unitaires |
| Debug::printr('Lancement des tests unitaires'); |
| $tests_numeros = array_keys($this->tests); |
| Debug::printr($tests_numeros); |
| foreach ($tests_numeros as &$numero) { |
| $info = $this->getInfosTest($numero); |
| |
| if ($numero < 5) { |
| // Tests spéciaux vérifiant la structure de la table |
| $resultats[] = $this->lancerTestUnitaire($info); |
| } else if ($numero >= 5 && $this->verifierResultats($resultats)) { |
| // Si la structure est bonne nous lançons les autres tests |
| $this->lancerTestUnitaire($info); |
| } |
| } |
| |
| $info = $this->construireTotalErreur(); |
| $this->traiterResultatTest($info); |
| } |
| |
| private function getInfosTest($numero) { |
| $info = $this->tests[$numero]; |
| $info['methode'] = 'tester'.implode('', explode(' ', ucwords($info['abr']))); |
| $info['numero'] = $numero; |
| $info['nom'] = '#'.$numero.' - '.$info['nom']; |
| $info['resultat'] = false; |
| return $info; |
| } |
| |
| |
| public function lancerTestUnitaire($info) { |
| Debug::printr($info['numero'].'::'.$info['methode']); |
| $methodeDeTest = $info['methode']; |
| $erreurs = $this->$methodeDeTest(); |
| |
| // Analyse des résultats |
| if (isset($erreurs['special'])) { |
| $info = $erreurs; |
| } else { |
| $info = $this->construireResultatErreur($erreurs, $info); |
| } |
| |
| $this->traiterResultatTest($info); |
| |
| if ($info['numero'] < 5) { |
| return ($info['resultat'] ? '1' : '0'); |
| } |
| } |
| private function ajouterNumNomErreursTest($num_nom) { |
| if (count($this->erreurs) < 1000) { |
| if (isset($this->erreurs[$num_nom])) { |
| $this->erreurs[$num_nom] += 1; |
| } else { |
| $this->erreurs[$num_nom] = 1; |
| } |
| } |
| } |
| |
| |
| private function construireResultatErreur($erreurs, $info) { |
| if (count($erreurs) > 0) { |
| $info['message']['entete'] = explode(',', $info['entete']); |
| if (isset($info['title'])) { |
| $info['message']['title'] = explode(';', $info['title']); |
| } |
| $info['message']['lignes'] = $erreurs; |
| unset($erreurs); |
| } else { |
| $info['resultat'] = true; |
| } |
| return $info; |
| } |
| |
| private function construireTotalErreur() { |
| if (count($this->erreurs) > 0) { |
| arsort($this->erreurs); |
| $info['abr'] = "erreurs par num_nom"; |
| $info['nom'] = "erreurs -> num_nom"; |
| $info['description'] = "nombre d'erreurs détecté par num_nom"; |
| $info['numero'] = "0"; |
| $info['message']['entete'] = array('num_nom', "nombre d'erreurs"); |
| foreach ($this->erreurs as $num_nom=>$nombre) { |
| $erreurs[] = array(0 => $num_nom, 1 => $nombre); |
| } |
| $info['message']['lignes'] = $erreurs; |
| unset($this->erreurs); |
| } else { |
| $info['resultat'] = true; |
| } |
| return $info; |
| } |
| |
| private function verifierResultats(&$resultats) { |
| $ok = true; |
| foreach ($resultats as $resultat) { |
| if ($resultat == '0') { |
| $ok = false; |
| break; |
| } |
| } |
| return $ok; |
| } |
| |
| private function traiterResultatTest($info) { |
| if (isset($info['message'])) { |
| if (is_array($info['message'])) { |
| $erreurs_nbre = count($info['message']['lignes']); |
| $erreurs_max = 1000; |
| if ($erreurs_nbre > $erreurs_max) { |
| $info['message']['lignes'] = array_slice($info['message']['lignes'], 0, $erreurs_max); |
| $info['erreur'] = "$erreurs_nbre erreurs ont été détectées seules les $erreurs_max premières sont affichées"; |
| } |
| $info['message'] = $this->getVue('tests/squelettes/message_table', $info); |
| } else { |
| $info['message'] = $this->getVue('tests/squelettes/message_p', $info); |
| } |
| } |
| Debug::printr($this->resultatDao->ajouter($this->traitement['id_traitement'], $info)); |
| $info = null; |
| } |
| |
| //+--------------------------------------------------------------------------------------------------------------+// |
| // TESTS |
| |
| /** |
| * Test #01 |
| */ |
| private function testerNombreDeChamps() { |
| $info = $this->getInfosTest(1); |
| $info['special'] = true; |
| |
| $nbre_colonnes = count($this->colonnes); |
| $info['message'] = $nbre_colonnes; |
| if ($nbre_colonnes >= 37) { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| /** |
| * Test #02 |
| */ |
| private function testerNomDesChamps() { |
| $info = $this->getInfosTest(2); |
| $info['special'] = true; |
| |
| $champs_attendus = explode(',', $this->manuel['champs']); |
| $champs_presents = array(); |
| foreach ($this->colonnes as &$colonne) { |
| $champs_presents[$colonne['Field']] = $colonne; |
| } |
| |
| $ok = true; |
| $champs_manquant = array(); |
| foreach ($champs_attendus as &$champ_attendu) { |
| if (!isset($champs_presents[$champ_attendu])) { |
| $champs_manquant[] = $champ_attendu; |
| $ok = false; |
| } |
| } |
| |
| $info['resultat'] = $ok; |
| if (!$ok) { |
| $info['message'] = sprintf($info['message'], implode(', ', $champs_manquant)); |
| } |
| |
| return $info; |
| } |
| |
| /** |
| * Test #03 |
| */ |
| private function testerTypeDesChamps() { |
| $champs_attendus = explode(',', $this->manuel['champs_type']); |
| $champs_presents = array(); |
| foreach ($this->colonnes as &$colonne) { |
| $champs_presents[$colonne['Field']] = $colonne['Type']; |
| } |
| |
| // Recercherche des erreurs |
| $champs_erreur = array(); |
| foreach ($champs_attendus as &$champ_attendu) { |
| list($champ_attendu_nom, $champ_attendu_type_taille) = explode('=', trim($champ_attendu)); |
| list($champ_attendu_type, $champ_attendu_taille) = explode('|', trim($champ_attendu_type_taille)); |
| |
| if (isset($champs_presents[$champ_attendu_nom])) { |
| $champs_present_type = $champs_presents[$champ_attendu_nom]; |
| |
| if (($champ_attendu_type == 'VARCHAR' && strstr($champs_present_type, 'varchar') === false) |
| || ($champ_attendu_type == 'TEXT' && strstr($champs_present_type, 'text') === false) |
| || ($champ_attendu_type == 'INT' && strstr($champs_present_type, 'int') === false) |
| || ($champ_attendu_type == 'BOOL' && preg_match('/(?:bool|boolean|tinyint\(1\))/i', $champs_present_type) === false)) { |
| $champs_erreur[] = array($champ_attendu, $champ_attendu_type, $champs_present_type); |
| } |
| } |
| } |
| return $champs_erreur; |
| } |
| |
| /** |
| * Test #04 |
| */ |
| private function testerNumNomClePrimaire() { |
| $info = $this->getInfosTest(4); |
| $info['special'] = true; |
| |
| foreach ($this->colonnes as &$colonne) { |
| if ($colonne['Field'] == 'num_nom' && $colonne['Key'] == 'PRI') { |
| $info['resultat'] = true; |
| break; |
| } |
| } |
| return $info; |
| } |
| |
| |
| /** |
| * Test #05 |
| */ |
| private function testerTailleDesChamps() { |
| $tailles_champs_maxi = array(); |
| foreach ($this->colonnes as &$colonne) { |
| if (preg_match('/^varchar\(([0-9]+)\)$/', $colonne['Type'], $match)) { |
| $tailles_champs_maxi[$colonne['Field']] = $match[1]; |
| } |
| } |
| |
| $tailles_trouvees = array(); |
| foreach ($this->analyses as &$analyse) { |
| if (preg_match('/\.([^.]+)$/', $analyse['Field_name'], $match)) { |
| $tailles_trouvees[$match[1]] = $analyse['Max_length']; |
| } |
| } |
| |
| $champs_erreur = array(); |
| $champs_attendus = explode(',', $this->manuel['champs']); |
| foreach ($champs_attendus as &$champ_attendu) { |
| if (isset($tailles_champs_maxi[$champ_attendu]) && isset($tailles_trouvees[$champ_attendu])) { |
| if ($tailles_champs_maxi[$champ_attendu] == $tailles_trouvees[$champ_attendu]) { |
| $champs_erreur[] = array($champ_attendu, $tailles_champs_maxi[$champ_attendu], $tailles_trouvees[$champ_attendu]); |
| } |
| } |
| } |
| return $champs_erreur; |
| } |
| |
| /** |
| * Test #06 |
| */ |
| private function testerNumNomSuperieurAZero() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['num_nom'] <= 0) { |
| $noms_erreur[] = array($nom['num_nom']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #07 |
| */ |
| private function testerNumNomRetenuSuperieurAZero() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['num_nom_retenu'] != '' && $nom['num_nom_retenu'] <= 0) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| |
| /** |
| * Test #08 |
| */ |
| private function testerExistenceNumNomRetenu() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['num_nom_retenu'] != '' && $nom['num_nom_retenu'] != $nom['num_nom']) { |
| if ($nom['num_nom_retenu'] != 0 && !isset($this->noms[$nom['num_nom_retenu']])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #09 |
| */ |
| private function testerTransmissionNumNomRetenu() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['num_nom_retenu'] != $nom['num_nom'] && $nom['exclure_taxref'] == 0) { |
| if ($nom['num_nom_retenu'] != 0 && isset($this->noms[$nom['num_nom_retenu']])) { |
| if ($this->noms[$nom['num_nom_retenu']]['exclure_taxref'] != 0) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $this->noms[$nom['num_nom_retenu']]['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #10 |
| */ |
| private function testerSynonymeNumNomRetenu() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['num_nom_retenu'] != $nom['num_nom']) { |
| if ($nom['num_nom_retenu'] != 0 && isset($this->noms[$nom['num_nom_retenu']])) { |
| if ($this->noms[$nom['num_nom_retenu']]['num_nom'] != $this->noms[$nom['num_nom_retenu']]['num_nom_retenu']) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $this->noms[$nom['num_nom_retenu']]['num_nom_retenu']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #11 |
| */ |
| private function testerDoublonsNomSci() { |
| $noms_erreur = array(); |
| $noms_complets = array(); |
| foreach ($this->noms as &$nom) { |
| $a = $nom['nom_sci']." ".$nom['auteur']." ".$nom['nom_addendum']." ".$nom['biblio_origine']; |
| if (isset($noms_complets[$a])) { |
| $noms_erreur[] = array($nom['num_nom'], $a, $noms_complets[$a], $nom['exclure_taxref'], $nom['homonyme']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } else { |
| $noms_complets[$a] = $nom['num_nom']; |
| } |
| |
| } |
| return $noms_erreur; |
| } |
| |
| |
| /** |
| * Test #12 |
| */ |
| private function testerNumTaxSupEgalZeroUnique() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if (preg_match('/^0$/', $nom['num_tax_sup'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| // Ce test est spécial car le nombre de noms en erreurs doit être supérieur à 1 et non à 0 pour être KO. |
| if (count($noms_erreur) == 1) { |
| $noms_erreur = array(); |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #13 |
| */ |
| private function testerTaxSupPourTaxon() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['num_nom_retenu'] != $nom['num_nom'] && $nom['num_tax_sup'] != '') { |
| $noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #14 |
| */ |
| private function testerExistenceTaxonSuperieur() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['num_nom_retenu'] == $nom['num_nom']) { |
| if ($nom['num_tax_sup'] != 0 && !isset($this->noms[$nom['num_tax_sup']])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #15 |
| */ |
| private function testerClassificationEspece() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['num_nom_retenu'] == $nom['num_nom'] && $nom['rang'] == 290) { |
| if (isset($this->noms[$nom['num_tax_sup']])) { |
| $nom_sup = $this->noms[$nom['num_tax_sup']]; |
| if ($nom_sup['rang'] != 220 ) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['rang'], $nom_sup['num_nom'], $nom_sup['rang'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #16 |
| */ |
| private function testerTransmissionTaxonSuperieur() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['num_nom_retenu'] == $nom['num_nom'] && $nom['exclure_taxref'] == 0) { |
| if ($nom['num_tax_sup'] != 0 && isset($this->noms[$nom['num_tax_sup']])) { |
| if ($this->noms[$nom['num_tax_sup']]['exclure_taxref'] != 0) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['num_tax_sup'], $this->noms[$nom['num_tax_sup']]['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| |
| /** |
| * Test #17 |
| */ |
| private function testerClassificationRang() { |
| $noms_erreur = array(); |
| //$rangs = explode(',', $this->manuel['rangs']); |
| foreach ($this->noms as &$nom) { |
| if ($nom['num_nom_retenu'] == $nom['num_nom']) { |
| if (isset($this->noms[$nom['num_tax_sup']])) { |
| $nom_sup = $this->noms[$nom['num_tax_sup']]; |
| //$num_rang = array_search($nom['rang'], $rangs); |
| if ($nom_sup['rang'] >= $nom['rang']) { |
| //if ($nom_sup['rang'] != $rangs[$num_rang-1] ) { |
| // Prise en compte de l'exception des clades |
| if (! ($nom_sup['rang'] == 70 && $nom['rang'] == 70)) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['rang'], $nom_sup['num_nom'], $nom_sup['rang'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #18 |
| */ |
| private function testerClassification() { |
| $noms_erreur = array(); |
| $this->noms_ok = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['num_nom_retenu'] == $nom['num_nom']) { |
| if (isset($this->noms_ok[$nom['num_tax_sup']])) { |
| $this->noms_ok[$nom['num_nom']] = true; |
| } else { |
| $this->detection_boucle_infini = array(); |
| $classif_ok = $this->remonterClassif($nom); |
| unset($this->detection_boucle_infini); |
| |
| if ($classif_ok === true) { |
| $this->noms_ok[$nom['num_nom']] = $classif_ok; |
| } else { |
| $noms_erreur[] = array($nom['num_nom'], $classif_ok, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| } |
| unset($this->noms_ok); |
| return $noms_erreur; |
| } |
| |
| private function remonterClassif(&$nom) { |
| $this->detection_boucle_infini[$nom['num_nom']] = true; |
| if (preg_match('/^[0-9]*$/', $nom['num_tax_sup'])) { |
| if (isset($this->noms_ok[$nom['num_tax_sup']])) { |
| $this->noms_ok[$nom['num_nom']] = true; |
| return true; |
| } else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] == '0') { |
| $this->noms_ok[$nom['num_nom']] = true; |
| return true; |
| } else if (!isset($this->noms[$nom['num_tax_sup']]) && $nom['num_tax_sup'] != '0') { |
| return 'Hiérarchie avec le taxon #'.$nom['num_nom'].' ayant un taxon superieur #'.$nom['num_tax_sup'].' inexistant'; |
| } else if (isset($this->detection_boucle_infini[$nom['num_tax_sup']])) { |
| return 'Boucle infinie pour le taxon #'.$nom['num_tax_sup']; |
| } else { |
| $retour = $this->remonterClassif($this->noms[$nom['num_tax_sup']]); |
| if ($retour === true) { |
| $this->noms_ok[$nom['num_tax_sup']] = true; |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| return $retour; |
| } |
| } else { |
| return 'Valeur num_tax_sup incorrecte : '.$nom['num_tax_sup']; |
| } |
| } |
| |
| /** |
| * Test #19 |
| */ |
| private function testerRang() { |
| $rangs = array_flip(explode(',', $this->manuel['rangs'])); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if (!isset($rangs[$nom['rang']])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['rang'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #20 |
| */ |
| private function testerNomCompletSupraGenerique() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['rang'] < $this->manuel['rang_genre']) { |
| $suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom); |
| $nom_sci_ideal = $this->formaterStyleNomGenre($nom['nom_supra_generique']); |
| $nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : ''); |
| if ($nom['nom_sci'] != $nom_sci_ideal) { |
| $nom_sci_traite = $this->repererEspace($nom['nom_sci']); |
| $noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #21 |
| */ |
| private function testerNomCompletGenre() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['rang'] == $this->manuel['rang_genre']) { |
| $suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom); |
| $nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']); |
| $nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : ''); |
| if ($nom['nom_sci'] != $nom_sci_ideal) { |
| $nom_sci_traite = $this->repererEspace($nom['nom_sci']); |
| $noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #22 |
| */ |
| private function testerNomCompletInfraGenre() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['rang'] > $this->manuel['rang_genre'] && $nom['rang'] < $this->manuel['rang_sp']) { |
| $suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom); |
| $nom_sci_ideal = ''; |
| if ($nom['type_epithete'] == 'agg.') { |
| $nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']).' '. |
| $this->formaterStyleNomGenre($nom['epithete_infra_generique']).' '. |
| $nom['type_epithete']; |
| } else { |
| $nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']).' '. |
| $nom['type_epithete'].' '. |
| $this->formaterStyleNomGenre($nom['epithete_infra_generique']); |
| } |
| $nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : ''); |
| if ($nom['nom_sci'] != $nom_sci_ideal) { |
| $nom_sci_traite = $this->repererEspace($nom['nom_sci']); |
| $noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #23 |
| */ |
| private function testerNomCompletEspece() { |
| $noms_erreur = array(); |
| $erreur = ''; |
| foreach ($this->noms as &$nom) { |
| if ($nom['rang'] == $this->manuel['rang_sp']) { |
| $suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom); |
| $nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']).' '; |
| if (strstr($nom['nom_sci'] , ' x ') != false) { |
| list($nom_sci_ideal, $erreur) = $this->formaterStyleEpitheteSpHybride($nom_sci_ideal, $nom['epithete_sp']); |
| } else { |
| $nom_sci_ideal .= utf8_encode(strtolower(utf8_decode($nom['epithete_sp']))); |
| } |
| $nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : ''); |
| $nom_sci_ideal = trim($nom_sci_ideal); |
| if ($nom['nom_sci'] != $nom_sci_ideal) { |
| $nom_sci_traite = $this->repererEspace($nom['nom_sci']); |
| $noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $erreur, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #24 |
| */ |
| private function testerNomCompletInfraSpecifique() { |
| $noms_erreur = array(); |
| $erreur = null; |
| foreach ($this->noms as &$nom) { |
| if ($nom['rang'] > $this->manuel['rang_sp']) { |
| $nom_sci_ideal = $this->formaterStyleNomGenre($nom['genre']).' '. |
| utf8_encode(strtolower(utf8_decode($nom['epithete_sp']))).' '. |
| utf8_encode(strtolower(utf8_decode($nom['type_epithete']))).' '; |
| $suffixe_plte_cultivee = $this->construireSuffixeNomPltCultivee($nom); |
| if (strstr($nom['nom_sci'] , ' x ') != false) { |
| list($nom_sci_ideal, $erreur) = $this->formaterStyleEpitheteInfraSpHybride($nom_sci_ideal, $nom['epithete_infra_sp'], $nom['genre']); |
| } else { |
| $nom_sci_ideal .= utf8_encode(strtolower(utf8_decode($nom['epithete_infra_sp']))); |
| } |
| $nom_sci_ideal = trim($nom_sci_ideal); |
| $nom_sci_ideal .= ($suffixe_plte_cultivee != '' ? ' '.$suffixe_plte_cultivee : ''); |
| if ($nom['nom_sci'] != $nom_sci_ideal) { |
| $nom_sci_traite = $this->repererEspace($nom['nom_sci']); |
| $noms_erreur[] = array($nom['num_nom'], $nom_sci_traite, $nom_sci_ideal, $erreur, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #25 |
| */ |
| private function testerNomSupraGeneriqueEspaces() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['nom_supra_generique'] != '') { |
| if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s+$)/', $nom['nom_supra_generique'])) { |
| $nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']); |
| $noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #26 |
| */ |
| private function testerNomSupraGeneriqueSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['nom_supra_generique'] != '') { |
| if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+$/', $nom['nom_supra_generique'])) { |
| $nom_supra_generique_traite = $this->repererEspace($nom['nom_supra_generique']); |
| $noms_erreur[] = array($nom['num_nom'], $nom_supra_generique_traite, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #27 |
| */ |
| private function testerNomSupraGeneriqueRang() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['nom_supra_generique'] != '') { |
| if ($nom['rang'] >= $this->manuel['rang_genre']) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #28 |
| */ |
| private function testerGenreEspaces() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['genre'] != '') { |
| if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['genre'])) { |
| $nom_traite = $this->repererEspace($nom['genre']); |
| $noms_erreur[] = array($nom['num_nom'], $nom_traite, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #29 |
| */ |
| private function testerGenreSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['genre'] != '') { |
| $mots = explode(' ', $nom['genre']); |
| foreach ($mots as $mot) { |
| if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteGenre($mot))) { |
| $nom_traite = $this->repererEspace($nom['genre']); |
| $noms_erreur[] = array($nom['num_nom'], $nom_traite, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| break; |
| } |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #30 |
| */ |
| private function testerGenreRang() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['genre'] != '') { |
| if ($nom['rang'] < $this->manuel['rang_genre']) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #31 |
| */ |
| private function testerEpitheteInfraGeneriqueSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['epithete_infra_generique'] != '') { |
| if (!preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+/', $nom['epithete_infra_generique'])) { |
| $epithete_traite = $this->repererEspace($nom['epithete_infra_generique']); |
| $noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #32 |
| */ |
| private function testerEpitheteInfraGeneriqueRang() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['epithete_infra_generique'] != '') { |
| if ($nom['rang'] <= $this->manuel['rang_genre'] || $nom['rang'] >= $this->manuel['rang_sp']) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #33 |
| */ |
| private function testerEpitheteInfraGeneriqueEspaces() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['epithete_infra_generique'] != '') { |
| if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_generique'])) { |
| $epithete_traite = $this->repererEspace($nom['epithete_infra_generique']); |
| $noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #34 |
| */ |
| private function testerEpitheteSpEspaces() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['epithete_sp'] != '') { |
| if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_sp'])) { |
| $epithete_traite = $this->repererEspace($nom['epithete_sp']); |
| $noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #35 |
| */ |
| private function testerEpitheteSpSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['epithete_sp'] != '') { |
| $formule_hybridite = (strpos($nom['epithete_sp'], ' x ') !== false); |
| $mots = explode(' ', $nom['epithete_sp']); |
| foreach ($mots as $mot) { |
| // TODO: créer un test qui vérifie la formule d'hybridité en la reconstruisant à partir des parents |
| // afin que seuls des formules valides parviennent à la fonction |
| if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpitheteSp($mot) || |
| ($formule_hybridite && $this->verifierEpitheteGenre($mot) && !$this->verifierEstAbbreviationInfraSp($mot)))) { |
| $epithete_traite = $this->repererEspace($nom['epithete_sp']); |
| $noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| break; |
| } |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #36 |
| */ |
| private function testerEpitheteSpRang() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['epithete_sp'] != '') { |
| if ($nom['rang'] < $this->manuel['rang_sp']) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #37 |
| */ |
| private function testerTypeEpitheteEspaces() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['type_epithete'] != '') { |
| if (preg_match('/\s+/', $nom['type_epithete'])) { |
| $valeur_traitee = $this->repererEspace($nom['epithete_sp']); |
| $noms_erreur[] = array($nom['num_nom'], $valeur_traitee, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #38 |
| */ |
| private function testerTypeEpitheteSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['type_epithete'] != '') { |
| if (!$this->verifierTypeEpithete($nom['type_epithete'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['type_epithete'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #39 |
| */ |
| private function testerTypeEpitheteHybridite() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['type_epithete'] != '') { |
| if (preg_match('/^(?:n-|notho-)/', $nom['type_epithete'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['type_epithete'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #40 |
| */ |
| private function testerEpitheteInfraSpEspaces() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['epithete_infra_sp'] != '') { |
| if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s{2,}(?!:\s+)|(?!:\s+)\s+$)/', $nom['epithete_infra_sp'])) { |
| $epithete_traite = $this->repererEspace($nom['epithete_infra_sp']); |
| $noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #41 |
| */ |
| private function testerEpitheteInfraSpSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['epithete_infra_sp'] != '') { |
| $mots = explode(' ', $nom['epithete_infra_sp']); |
| $hybride_contient_abbreviation_infra_sp = false; |
| $formule_hybridite = (strpos($nom['epithete_infra_sp'], ' x ') !== false); |
| foreach ($mots as $mot) { |
| if($formule_hybridite && $this->verifierEstAbbreviationInfraSp($mot)) { |
| $hybride_contient_abbreviation_infra_sp = true; |
| } |
| $formule_hybridite_valide = $this->verifierEpitheteGenre($mot) || $this->verifierEpitheteSp($mot) || $hybride_contient_abbreviation_infra_sp; |
| if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot) || $this->verifierEpitheteSp($mot) || |
| $formule_hybridite_valide)) { |
| $epithete_traite = $this->repererEspace($nom['epithete_infra_sp']); |
| $noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| break; |
| } |
| } |
| |
| if($formule_hybridite && !$hybride_contient_abbreviation_infra_sp) { |
| $epithete_traite = $this->repererEspace($nom['epithete_infra_sp']); |
| $noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #42 |
| */ |
| private function testerEpitheteInfraSpRang() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['epithete_infra_sp'] != '') { |
| if ($nom['rang'] < $this->manuel['rang_sp']) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #43 |
| */ |
| private function testerGroupeCultivarSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['cultivar_groupe'] != '') { |
| if (!$this->verifierEpitheteGroupeCultivar($nom['cultivar_groupe'])) { |
| $epithete_traite = $this->repererEspace($nom['cultivar_groupe']); |
| $noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #44 |
| */ |
| private function testerGroupeCultivarRang() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['cultivar_groupe'] != '') { |
| if ($nom['rang'] < $this->manuel['rang_genre']) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #45 |
| */ |
| private function testerCultivarSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['cultivar'] != '') { |
| if (!$this->verifierEpitheteCultivar($nom['cultivar'])) { |
| $epithete_traite = $this->repererEspace($nom['cultivar']); |
| $noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #46 |
| */ |
| private function testerCultivarRang() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['cultivar'] != '') { |
| if ($nom['rang'] < $this->manuel['rang_genre']) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['rang'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #47 |
| */ |
| private function testerNomCommercialSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['nom_commercial'] != '') { |
| if (!$this->verifierNomCommercial($nom['nom_commercial'])) { |
| $epithete_traite = $this->repererEspace($nom['nom_commercial']); |
| $noms_erreur[] = array($nom['num_nom'], $epithete_traite, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #48 |
| */ |
| private function testerNomCommercialPresenceCultivar() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ((isset($nom['nom_commercial']) && $nom['nom_commercial'] != '') && ($nom['cultivar'] == '' && $nom['cultivar_groupe'] == '')) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #49 |
| */ |
| private function testerAuteurSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['auteur'] != '') { |
| if (!$this->verifierAuteur($nom['auteur'])) { |
| $intitule_traite = $this->repererEspace($nom['auteur']); |
| $noms_erreur[] = array($nom['num_nom'], $intitule_traite, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #50 |
| */ |
| private function testerAnneeSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['annee'] != '') { |
| if (!$this->verifierAnnee($nom['annee'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['annee'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #51 |
| */ |
| private function testerBiblioOrigineSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['biblio_origine'] != '') { |
| if (!$this->verifierBiblioOrigine($nom['biblio_origine'])) { |
| $biblio_traite = $this->repererEspace($nom['biblio_origine']); |
| $noms_erreur[] = array($nom['num_nom'], $biblio_traite, $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #52 |
| */ |
| private function testerHomonymieSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['homonyme'] != '') { |
| if (!$this->verifierBooleen($nom['homonyme'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['homonyme'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #53 |
| */ |
| private function testerHomonymieExistence() { |
| $noms_homonymie = $this->classerNomsParNomComplet(); |
| |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['homonyme'] != '0' && $nom['homonyme'] != '') { |
| if ($noms_homonymie[$nom['nom_sci']] <= 1) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| $noms_homonymie = null; |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #54 |
| */ |
| private function testerBasionymeSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['num_basionyme'] != '') { |
| if (!$this->verifierNombre($nom['num_basionyme'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['num_basionyme'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #55 |
| */ |
| private function testerBasionymeExistence() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['num_basionyme'] != '') { |
| if (!isset($this->noms[$nom['num_basionyme']])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['num_basionyme'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #56 |
| */ |
| private function testerSynonymeProparteSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['synonyme_proparte'] != '') { |
| if (!$this->verifierNombreSuite($nom['synonyme_proparte'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['synonyme_proparte'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #57 |
| */ |
| private function testerSynonymeProparteExistence() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['synonyme_proparte'] != '') { |
| $num_nom_a_verifier = explode(',', $nom['synonyme_proparte']); |
| $num_nom_en_erreur = array(); |
| foreach ($num_nom_a_verifier as $num_nom) { |
| if (!isset($this->noms[$num_nom])) { |
| $num_nom_en_erreur[] = $num_nom; |
| } |
| } |
| if (count($num_nom_en_erreur) > 0) { |
| $noms_erreur[] = array($nom['num_nom'], implode(',', $num_nom_en_erreur), $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #58 |
| */ |
| private function testerSynonymeDouteuxSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['synonyme_douteux'] != '') { |
| if (!$this->verifierBooleen($nom['synonyme_douteux'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #59 |
| */ |
| private function testerSynonymeDouteuxNumNomRetenu() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['synonyme_douteux'] == 1 && !$this->verifierNombre($nom['num_nom_retenu'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['synonyme_douteux'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #60 |
| */ |
| private function testerSynonymeDouteuxSynonyme() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['synonyme_douteux'] == 1 && $nom['num_nom'] == $nom['num_nom_retenu']) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $nom['synonyme_douteux'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #61 |
| */ |
| private function testerSynonymeMalAppliqueSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['synonyme_mal_applique'] != '') { |
| if (!$this->verifierBooleen($nom['synonyme_mal_applique'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['synonyme_mal_applique'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #62 |
| */ |
| private function testerSynonymeMalAppliqueChampsAnnexe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['synonyme_mal_applique'] == 1) { |
| $erreur = true; |
| $erreur = ($nom['annee'] == "") ? false : $erreur; |
| $erreur = ($nom['biblio_origine'] == "") ? false : $erreur; |
| $erreur = (strpos($nom['auteur'], "sensu") === 0) ? $erreur : false; |
| if ($erreur == false) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['auteur'], $nom['annee'], $nom['biblio_origine'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #63 |
| */ |
| private function testerSynonymeMalAppliqueSynonyme() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['synonyme_mal_applique'] == 1 && $nom['num_nom'] == $nom['num_nom_retenu']) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['num_nom_retenu'], $nom['synonyme_mal_applique'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #64 |
| */ |
| private function testerSynonymeOrthographiqueSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as $nom) { |
| if ($nom['synonyme_orthographique'] != '') { |
| if (!$this->verifierNombre($nom['synonyme_orthographique'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #65 |
| */ |
| private function testerSynonymeOrthographiqueExistence() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['synonyme_orthographique'] != '') { |
| if (!isset($this->noms[$nom['synonyme_orthographique']])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['synonyme_orthographique'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #66 |
| */ |
| private function testerHybrideParent01Syntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['hybride_parent_01'] != '') { |
| if (!$this->verifierNombre($nom['hybride_parent_01'])) { |
| $noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #67 |
| */ |
| private function testerHybrideParent01Existence() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['hybride_parent_01'] != '' && $nom['hybride_parent_01'] != '0') { |
| if (!isset($this->noms[$nom['hybride_parent_01']])) { |
| $noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_01']), $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #68 |
| */ |
| private function testerHybrideParent02Syntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['hybride_parent_02'] != '') { |
| if (!$this->verifierNombre($nom['hybride_parent_02'])) { |
| $noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #69 |
| */ |
| private function testerHybrideParent02Existence() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['hybride_parent_02'] != '') { |
| if (!isset($this->noms[$nom['hybride_parent_02']]) && $nom['hybride_parent_02'] != '0') { |
| $noms_erreur[] = array($nom['num_nom'], $this->repererEspace($nom['hybride_parent_02']), $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #70 |
| */ |
| private function testerNumTypeSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['num_type'] != '') { |
| if (!$this->verifierNombre($nom['num_type'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['num_type'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #71 |
| */ |
| private function testerNumTypeExistence() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['num_type'] != '') { |
| if (!isset($this->noms[$nom['num_type']])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['num_type'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #72 |
| */ |
| private function testerPresenceSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['presence'] != '') { |
| if (!$this->verifierPresence($nom['presence'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['presence'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #73 |
| */ |
| private function testerPresenceExistence() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['num_nom_retenu'] == $nom['num_nom'] && $nom['exclure_taxref'] == 0) { |
| if ($nom['presence'] == "") { |
| $noms_erreur[] = array($nom['num_nom'],$nom['num_nom_retenu'], $nom['presence'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #74 |
| */ |
| private function testerStatutOrigineSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['statut_origine'] != '') { |
| if (!$this->verifierStatutOrigine($nom['statut_origine'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['statut_origine'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #75 |
| */ |
| private function testerStatutIntroductionSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['statut_introduction'] != '') { |
| if (!$this->verifierStatutIntroduction($nom['statut_introduction'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['statut_introduction'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #76 |
| */ |
| private function testerStatutCultureSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['statut_culture'] != '') { |
| if (!$this->verifierStatutCulture($nom['statut_culture'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['statut_culture'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #77 |
| */ |
| private function testerExclureTaxRefSyntaxe() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['exclure_taxref'] != '' && $nom['exclure_taxref'] != null) { |
| if (!preg_match('/^(?:0|1|9)$/', $nom['exclure_taxref'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['exclure_taxref']); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #78 |
| */ |
| private function testerNomFrancaisUnique() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| if ($nom['nom_francais'] != '' && $nom['nom_francais'] != null) { |
| if (strpbrk($nom['nom_francais'],',;')) { |
| $noms_erreur[] = array($nom['num_nom'], $this->repererCaracteresInvalidesNomFrancais($nom['nom_francais'])); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| /** |
| * Test #79 |
| */ |
| private function testerExclureTaxRefPresence() { |
| $noms_erreur = array(); |
| foreach ($this->noms as &$nom) { |
| // On vérifie tous les noms retenu nom exclus de taxref de rang inférieur ou égal à l'espèce |
| if ($nom['num_nom_retenu'] == $nom['num_nom'] && $nom['exclure_taxref'] == 0 && $nom['rang'] >= 240) { |
| if($nom['presence'] == '' || !$this->verifierPresence($nom['presence'])) { |
| if(($nom['statut_origine'] == '' || !$this->verifierStatutOrigine($nom['statut_origine'])) && |
| ($nom['statut_introduction'] == '' || !$this->verifierStatutIntroduction($nom['statut_introduction'])) && |
| ($nom['statut_culture'] == '' || !$this->verifierStatutCulture($nom['statut_culture']))) |
| { |
| $noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], |
| $this->mettreEnValeurAvertissement($nom['presence']), |
| $this->mettreEnValeurAvertissement($nom['statut_origine']), |
| $this->mettreEnValeurAvertissement($nom['statut_introduction']), |
| $this->mettreEnValeurAvertissement($nom['statut_culture']) |
| ); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } else { |
| //TODO: le comportement est identique mais il faudrait pouvoir afficher un avertissement |
| // si le champ présence n'est pas rempli mais que l'une des colonne de statut l'est |
| $noms_erreur[] = array($nom['num_nom'], $nom['nom_sci'], |
| $nom['presence'], |
| $this->mettreEnValeurAvertissement($nom['statut_origine']), |
| $this->mettreEnValeurAvertissement($nom['statut_introduction']), |
| $this->mettreEnValeurAvertissement($nom['statut_culture']) |
| ); |
| $this->ajouterNumNomErreursTest($nom['num_nom']); |
| } |
| } |
| } |
| } |
| return $noms_erreur; |
| } |
| |
| |
| //+--------------------------------------------------------------------------------------------------------------+// |
| // MÉTHODES COMMUNES aux TESTS |
| |
| private function verifierPresence(&$valeur) { |
| $codes = $this->manuel['codes_presence']; |
| $ok = $this->verifierStatuts($valeur, $codes); |
| return $ok; |
| } |
| |
| private function verifierStatutOrigine(&$valeur) { |
| $codes = $this->manuel['codes_statuts_origine']; |
| $ok = $this->verifierStatuts($valeur, $codes); |
| return $ok; |
| } |
| |
| private function verifierStatutIntroduction(&$valeur) { |
| $codes = $this->manuel['codes_statuts_introduction']; |
| $ok = $this->verifierStatuts($valeur, $codes); |
| return $ok; |
| } |
| |
| private function verifierStatutCulture(&$valeur) { |
| $codes = $this->manuel['codes_statuts_culture']; |
| $ok = $this->verifierStatuts($valeur, $codes); |
| return $ok; |
| } |
| |
| private function verifierStatuts(&$valeur, &$codes) { |
| $ok = true; |
| if (!preg_match("/^(?:|-|[$codes](?:-[A-Z])?)$/", $valeur)) { |
| $ok = false; |
| } |
| return $ok; |
| } |
| |
| private function verifierBooleen(&$valeur) { |
| $ok = true; |
| if (!preg_match('/^1$/', $valeur)) { |
| $ok = false; |
| } |
| return $ok; |
| } |
| |
| private function verifierNombre(&$valeur) { |
| $ok = true; |
| if (!preg_match('/^[0-9]+$/', $valeur)) { |
| $ok = false; |
| } |
| return $ok; |
| } |
| |
| private function verifierNombreSuite(&$valeur) { |
| $ok = true; |
| if (!preg_match('/^(?:[0-9]+, ?)*[0-9]+$/', $valeur)) { |
| $ok = false; |
| } |
| return $ok; |
| } |
| |
| private function verifierTypeEpithete(&$type) { |
| $ok = false; |
| $rejetes = $this->manuel['type_epithete_rejetes']; |
| if (preg_replace("/^(?:$rejetes)$/", '', $type) == '') { |
| $ok = false; |
| } else if (preg_match('/^[a-z][-a-z]*[.]?$/', $type)) { |
| $ok = true; |
| } |
| return $ok; |
| } |
| |
| private function verifierBiblioOrigine(&$intitule) { |
| $ok = true; |
| if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) { |
| $ok = false;// Contient des espaces en trop |
| } else if (!preg_match('/^(?:in [^;]+[;]|)[^,]+?(?:[,][^:]+|)(?:[:].+|)$/', $intitule)) { |
| $ok = false; |
| } else if (preg_match('/(?:(?:^|[,:])\s*(?:[:,]|$))/', $intitule)) { |
| $ok = false;// Contient une mauvaise suite de caractères |
| } |
| return $ok; |
| } |
| |
| private function verifierAnnee(&$annee) { |
| $ok = true; |
| if (!preg_match('/^[0-9]{4}$/', $annee)) { |
| $ok = false; |
| } else if ($annee < ANNEE_MINIMUM) { |
| $ok = false; |
| } else if ($annee > ANNEE_EN_COURS) { |
| $ok = false; |
| } |
| return $ok; |
| } |
| |
| private function verifierAuteur(&$intitule) { |
| $ok = true; |
| $acceptes = $this->manuel['auteur_acceptes']; |
| if (!preg_match("/^(?:$acceptes)$/", $intitule)) { |
| if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $intitule)) { |
| $ok = false;// Contient des espaces en trop |
| } else { |
| $mots_rejetes = $this->manuel['auteur_mots_rejetes']; |
| $mots = explode(' ', $intitule); |
| foreach ($mots as $position => $mot) { |
| if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) { |
| $ok = false;// Mot rejeté |
| } else if (preg_match("/^(?:(?:\p{L}|[.'\(\),-])+|[&])$/u", $mot)) { |
| continue;// Mot de l'intitulé auteur |
| } else { |
| $ok = false; |
| } |
| } |
| } |
| } |
| return $ok; |
| } |
| |
| private function verifierNomCommercial(&$epithete) { |
| $ok = false; |
| if (preg_match("/^[[:upper:][:punct:][:digit:][:space:]]+$/", $epithete)) { |
| $ok = true; |
| } |
| return $ok; |
| } |
| |
| private function verifierEpitheteCultivar(&$epithete) { |
| $ok = true; |
| $acceptes = $this->manuel['cultivar_acceptes']; |
| if (!preg_match("/^(?:$acceptes)$/", $epithete)) { |
| if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) { |
| $ok = false;// Contient des espaces en trop |
| } else { |
| $mots_rejetes = $this->manuel['cultivar_mots_rejetes']; |
| $mots_mineurs = $this->manuel['mots_mineurs']; |
| $mots = explode(' ', $epithete); |
| foreach ($mots as $position => $mot) { |
| if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) { |
| $ok = false;// Mot rejeté |
| } else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) { |
| continue;// Mot mineur en minuscule qui n'est pas en 1ère position |
| } else { |
| $mots_tiret = explode('-', $mot); |
| foreach ($mots_tiret as $position_tiret => $mot_tiret) { |
| if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) { |
| continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position |
| } else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) { |
| continue;//Mot (ou 'mot-tiret') avec lettre initiale majuscule |
| } else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) { |
| continue;//Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation |
| } else { |
| $ok = false; |
| } |
| } |
| } |
| } |
| } |
| } |
| return $ok; |
| } |
| |
| private function verifierEpitheteGroupeCultivar(&$epithete) { |
| $ok = true; |
| $acceptes = $this->manuel['cultivar_gp_acceptes']; |
| if (!preg_match("/^(?:$acceptes)$/", $epithete)) { |
| if (preg_match('/(?:^\s+|\s{2,}|\s+$)/', $epithete)) { |
| $ok = false;// Contient des espaces en trop |
| } else { |
| $mots_acceptes = $this->manuel['cultivar_gp_mots_acceptes']; |
| $mots_rejetes = $this->manuel['cultivar_gp_mots_rejetes']; |
| $mots_mineurs = $this->manuel['mots_mineurs']; |
| $mots = explode(' ', $epithete); |
| foreach ($mots as $position => $mot) { |
| if (preg_match("/^(?:$mots_acceptes)$/i", $mot)) { |
| continue;// Mot accepté |
| } else if (preg_match("/^(?:$mots_rejetes)$/i", $mot)) { |
| $ok = false;// Mot rejeté |
| } else if ($position > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot)) { |
| continue;// Mot mineur en minuscule qui n'est pas en 1ère position |
| } else { |
| $mots_tiret = explode('-', $mot); |
| foreach ($mots_tiret as $position_tiret => $mot_tiret) { |
| if ($position_tiret > 0 && preg_match("/^(?:$mots_mineurs)$/", $mot_tiret)) { |
| continue;// Mot-tiret mineur en minuscule qui n'est pas en 1ère position dans le mot |
| } else if (preg_match('/^[[:upper:]][[:lower:]]+$/', $mot_tiret)) { |
| continue;// Mot (ou 'mot-tiret') avec lettre initiale majuscule |
| } else if ($position_tiret == count($mots_tiret) && preg_match('/^[:upper:][:lower:]+[:punct:]?$/', $mot_tiret)) { |
| continue;// Dernier mot (ou 'mot-tiret') avec lettre initiale majuscule, suivi d'un éventuel signe de ponctuation |
| } else { |
| $ok = false; |
| } |
| } |
| } |
| } |
| } |
| } |
| return $ok; |
| } |
| |
| private function verifierEpitheteSp(&$epithete) { |
| $ok = false; |
| if (preg_match('/^[a-zäëḧïöẗüẅẍÿ][-a-zäëḧïöẗüẅẍÿ]+$/', $epithete)) { |
| $ok = true; |
| } else if (preg_match('/^sp\.(?:[A-Z]|[1-9][0-9]*)$/', $epithete)) { |
| $ok = true; |
| } |
| return $ok; |
| } |
| |
| private function verifierEpitheteGenre(&$epithete) { |
| $ok = false; |
| if (preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ](?:[-a-zäëḧïöẗüẅẍÿ]+|[a-zäëḧïöẗüẅẍÿ]+-[A-ZÄËḦÏÖÜẄẌŸ][a-zäëḧïöẗüẅẍÿ]+)$/', $epithete)) { |
| $ok = true; |
| } |
| return $ok; |
| } |
| |
| private function verifierEstAbbreviationInfraSp($mot) { |
| $ok = false; |
| if(preg_match($this->manuel['abbr_rangs_infra_specifique'], $mot)) { |
| $ok = true; |
| } |
| return $ok; |
| } |
| |
| private function formaterStyleNomGenre(&$genre) { |
| $genre_fmt = ''; |
| if (preg_match('/^\s*([x+])\s+(.+)$/i', $genre, $match)) { |
| $genre_fmt = utf8_encode(strtolower(utf8_decode($match[1]))).' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[2])))); |
| } elseif (preg_match('/^(.+)\s+([x+])\s+(.+)$/i', $genre, $match)) { |
| $genre_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($match[1])))).' '. |
| utf8_encode(strtolower(utf8_decode($match[2]))).' '.utf8_encode(ucfirst(strtolower(utf8_decode($match[3])))); |
| } else { |
| $genre_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($genre)))); |
| } |
| return $genre_fmt; |
| } |
| |
| private function formaterStyleEpitheteSpHybride(&$genre, &$epithete) { |
| $nom_fmt = ''; |
| $erreur = ''; |
| if (trim($genre) == '') { |
| if ($epithete != '') { |
| $nom_fmt = $this->formaterFormuleHybridite($epithete); |
| } else { |
| $erreur = "Formule d'hybridité sans épithéte spécifique"; |
| } |
| } else { |
| $nom_fmt = $this->formaterNomHybride($genre, $epithete); |
| } |
| return array($nom_fmt, $erreur); |
| } |
| |
| private function formaterStyleEpitheteInfraSpHybride(&$nom_sci, &$infra, &$genre = null) { |
| $nom_fmt = ''; |
| $erreur = ''; |
| if (trim($genre) == '') { |
| if (trim($nom_sci) == '') { |
| if (trim($infra) != '') { |
| $nom_fmt = $this->formaterFormuleHybridite($infra); |
| } else { |
| $erreur = "Formule d'hybridité sans épithéte infraspécifique"; |
| } |
| } else { |
| $erreur = "Formule d'hybridité avec épithéte spécifique"; |
| } |
| } else { |
| $nom_fmt = $this->formaterNomHybride($nom_sci, $infra); |
| } |
| return array($nom_fmt, $erreur); |
| } |
| |
| private function formaterNomHybride(&$nom_sci, &$epithete) { |
| if (preg_match('/^(.+)\s+([x+])\s+(.+)$/i', $epithete, $match) != '') { |
| $nom_fmt = $nom_sci.utf8_encode(ucfirst(strtolower(utf8_decode($match[1])))).' '. |
| utf8_encode(strtolower(utf8_decode($match[2]))).' '. |
| utf8_encode(ucfirst(strtolower(utf8_decode($match[3])))); |
| } elseif (preg_match('/^([x+])\s+(.+)$/i', $epithete, $match) != '') { |
| $nom_fmt = $nom_sci.utf8_encode(strtolower(utf8_decode($match[1]))).' '. |
| utf8_encode(strtolower(utf8_decode($match[2]))); |
| } else { |
| $nom_fmt = $nom_sci.utf8_encode(strtolower(utf8_decode($epithete))); |
| } |
| return $nom_fmt; |
| } |
| |
| private function formaterFormuleHybridite(&$epithete) { |
| $liste_parents = explode(' x ', $epithete); |
| if (count($liste_parents) == 2) { |
| $nom_fmt = utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[0])))).' x '. |
| utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[1])))); |
| } else { |
| for ($i=0; $i<count($liste_parents); $i++) { |
| if (strstr(trim($liste_parents[$i]), ' ') == false) { |
| $nom[] = utf8_encode(ucfirst(strtolower(utf8_decode(trim($liste_parents[$i]))))).' x '. |
| utf8_encode(strtolower(utf8_decode(trim($liste_parents[$i+1])))); |
| $i++; |
| } else { |
| $nom[] = utf8_encode(ucfirst(strtolower(utf8_decode($liste_parents[$i])))); |
| } |
| } |
| $nom_fmt = implode(' x ', $nom); |
| } |
| return $nom_fmt; |
| } |
| |
| private function repererEspace($nom_sci) { |
| $nom_sci = str_replace(' ', '<span class="espace"> </span>', $nom_sci); |
| return $nom_sci; |
| } |
| |
| private function repererCaracteresInvalidesNomFrancais($nom_verna) { |
| $nom_verna = str_replace(',', '<span class="espace">,</span>', $nom_verna); |
| $nom_verna = str_replace(';', '<span class="espace">;</span>', $nom_verna); |
| return $nom_verna; |
| } |
| |
| private function mettreEnValeurAvertissement($chaine) { |
| $chaine = '<span class="espace">'.$chaine.'</span>'; |
| return $chaine; |
| } |
| |
| private function construireSuffixeNomPltCultivee(&$nom) { |
| $suffixe = array(); |
| $suffixe[] = $this->construireNomCultivarGroupe($nom); |
| $suffixe[] = $this->construireNomCommercial($nom); |
| $suffixe[] = $this->construireNomCultivar($nom); |
| $suffixe = array_filter($suffixe); |
| return implode(' ', $suffixe); |
| } |
| |
| private function construireNomCultivarGroupe(&$nom) { |
| $nom_groupe_cultivar = ''; |
| if ($nom['cultivar_groupe'] != '') { |
| if (preg_match('/ gx$/', $nom['cultivar_groupe'])) { |
| $nom_groupe_cultivar = '('.$nom['cultivar_groupe'].')'; |
| } else { |
| $nom_groupe_cultivar = '('.$nom['cultivar_groupe'].' Gp)'; |
| } |
| } |
| return $nom_groupe_cultivar; |
| } |
| |
| private function construireNomCommercial(&$nom) { |
| $nom_commercial = ''; |
| if ($nom['nom_commercial'] != '') { |
| $nom_commercial = strtoupper($nom['nom_commercial']); |
| } |
| return $nom_commercial; |
| } |
| |
| private function construireNomCultivar(&$nom) { |
| $nom_cultivar = ''; |
| if ($nom['cultivar'] != '') { |
| $nom_cultivar = "'".$nom['cultivar']."'"; |
| } |
| return $nom_cultivar; |
| } |
| |
| private function classerNomsParNomComplet() { |
| $noms_classes = array(); |
| foreach ($this->noms as &$nom) { |
| if (!isset($noms_classes[$nom['nom_sci']])) { |
| $noms_classes[$nom['nom_sci']] = 1; |
| } else { |
| $noms_classes[$nom['nom_sci']]++; |
| } |
| } |
| return $noms_classes; |
| } |
| } |
| ?> |