| 52,12 → 52,15 |
|---|
| $noms = $this->classerNoms($noms); |
| |
| // Lancement des tests unitaires |
| /* |
| $donnees['tests'][] = $this->testerNombreDeChamps($colonnes); |
| $donnees['tests'][] = $this->testerNomDesChamps($colonnes); |
| $donnees['tests'][] = $this->testerTypeDesChamps($colonnes); |
| $donnees['tests'][] = $this->testerTailleDesChamps($colonnes, $analyses); |
| $donnees['tests'][] = $this->testerNumNomClePrimaire($colonnes); |
| |
| $donnees['tests'][] = $this->testerNumNomSuperieurAZero($noms); |
| |
| $donnees['tests'][] = $this->testerNumNomRetenuSuperieurAZero($noms); |
| $donnees['tests'][] = $this->testerNumTaxSupEgalZeroUnique($noms); |
| $donnees['tests'][] = $this->testerTaxSupPourTaxon($noms); |
| 64,27 → 67,253 |
|---|
| $donnees['tests'][] = $this->testerExitenceTaxonSuperieur($noms); |
| $donnees['tests'][] = $this->testerClassificationRang($noms); |
| $donnees['tests'][] = $this->testerClassification($noms); |
| |
| $donnees['tests'][] = $this->testerRang($noms); |
| |
| $donnees['tests'][] = $this->testerNomCompletSupraGenerique($noms); |
| $donnees['tests'][] = $this->testerNomCompletGenre($noms); |
| $donnees['tests'][] = $this->testerNomCompletInfraGenre($noms); |
| $donnees['tests'][] = $this->testerNomCompletEspece($noms); |
| $donnees['tests'][] = $this->testerNomCompletInfraSpecifique($noms); |
| $donnees['tests'][] = $this->testerNomSupraGeneriqueMotUnique($noms); |
| |
| $donnees['tests'][] = $this->testerNomSupraGeneriqueEspaces($noms); |
| $donnees['tests'][] = $this->testerNomSupraGeneriqueSyntaxe($noms); |
| $donnees['tests'][] = $this->testerNomSupraGeneriqueRang($noms); |
| |
| $donnees['tests'][] = $this->testerGenreEspaces($noms); |
| $donnees['tests'][] = $this->testerGenreSyntaxe($noms); |
| $donnees['tests'][] = $this->testerGenreRang($noms); |
| |
| $donnees['tests'][] = $this->testerEpitheteInfraGeneriqueEspaces($noms); |
| $donnees['tests'][] = $this->testerEpitheteInfraGeneriqueSyntaxe($noms); |
| $donnees['tests'][] = $this->testerEpitheteInfraGeneriqueRang($noms); |
| |
| $donnees['tests'][] = $this->testerEpitheteSpEspaces($noms); |
| $donnees['tests'][] = $this->testerEpitheteSpSyntaxe($noms); |
| $donnees['tests'][] = $this->testerEpitheteSpRang($noms); |
| |
| $donnees['tests'][] = $this->testerTypeEpitheteEspaces($noms); |
| $donnees['tests'][] = $this->testerTypeEpitheteSyntaxe($noms); |
| $donnees['tests'][] = $this->testerTypeEpitheteHybridite($noms); |
| |
| $donnees['tests'][] = $this->testerEpitheteInfraSpEspaces($noms); |
| $donnees['tests'][] = $this->testerEpitheteInfraSpSyntaxe($noms); |
| $donnees['tests'][] = $this->testerEpitheteInfraSpRang($noms); |
| */ |
| $donnees['tests'][] = $this->testerGroupeCultivarSyntaxe($noms); |
| |
| //Debug::printr($this->manuel); |
| $this->setSortie(self::RENDU_CORPS, $this->getVue('test', $donnees)); |
| } |
| |
| private function classerNoms($noms) { |
| $noms_classes = array(); |
| //+--------------------------------------------------------------------------------------------------------------+// |
| // TESTS |
| |
| private function testerGroupeCultivarSyntaxe($noms) { |
| $info = array('titre' => 'groupe_cultivar -> syntaxe', |
| 'description' => "Le champ groupe_cultivar doit contenir un nom de groupe de cultivar conforme aux règles ". |
| "du code des plantes cultivées qui se compose de caractères alphanumériques (A-Z,a-z et 0-9) incluant ". |
| "signes diacritiques et marques de ponctuations.\n". |
| "Il ne doit pas contenir le mot Groupe, l'abbréviation «gp» ou des parenthèses.\n". |
| "Il peut contir à la fin l'abréviation «gx» pour distinguer les groupes des grex.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($noms as $nom) { |
| $noms_classes[$nom['num_nom']] = $nom; |
| if ($nom['groupe_cultivar'] != '') { |
| $mots = explode(' ', $nom['groupe_cultivar']); |
| foreach ($mots as $mot) { |
| if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot)|| $this->verifierEpithteSp($mot))) { |
| $epithete_traite = $this->repererEspace($nom['epithete_infra_sp']); |
| $noms_erreur[] = array($nom['num_nom'], $epithete_traite); |
| } |
| } |
| } |
| } |
| return $noms_classes; |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'epithete_infra_sp erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| private function testerEpitheteInfraSpEspaces($noms) { |
| $info = array('titre' => 'epithete_infra_sp -> espaces en trop', |
| 'description' => "Le champ epithete_infra_sp ne doit pas contenir d'espace avant ou aprés le nom.\n". |
| "Si des espaces sont compris dans la valeur du champ, il ne doit pas y avoir plusieurs espaces consécutifs.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($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); |
| } |
| } |
| } |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'epithete_infra_sp erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| private function testerEpitheteInfraSpSyntaxe($noms) { |
| $info = array('titre' => 'epithete_infra_sp -> syntaxe', |
| 'description' => "Le champ epithete_infra_sp peut contenir :\n". |
| " - un mot unique composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n". |
| " Il commence par une lettre minuscule (avec ou sans tréma).\n". |
| " Il peut être précédé par le signe + ou la lettre x suivi d'un espace.\n". |
| " - une formule d'hybridité composée d'une série de noms d'espèce ou d'infra espèce (au moins 2) séparés entre eux \n". |
| " par la lettre x entourée de caractères espaces.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($noms as $nom) { |
| if ($nom['epithete_infra_sp'] != '') { |
| $mots = explode(' ', $nom['epithete_infra_sp']); |
| foreach ($mots as $mot) { |
| if (!(preg_match('/^[+x]$/', $mot) || $this->verifierTypeEpithete($mot)|| $this->verifierEpithteSp($mot))) { |
| $epithete_traite = $this->repererEspace($nom['epithete_infra_sp']); |
| $noms_erreur[] = array($nom['num_nom'], $epithete_traite); |
| } |
| } |
| } |
| } |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'epithete_infra_sp erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| private function testerEpitheteInfraSpRang($noms) { |
| $info = array('titre' => "epithete_infra_sp -> rang > {$this->manuel['rang_sp']}", |
| 'description' => "Si le champ epithete_infra_sp n'est pas vide alors le rang du nom doit être supérieur à {$this->manuel['rang_sp']}.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($noms as $nom) { |
| if ($nom['epithete_infra_sp'] != '') { |
| if ($nom['rang'] < $this->manuel['rang_sp']) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']); |
| } |
| } |
| } |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| private function testerTypeEpitheteEspaces($noms) { |
| $info = array('titre' => 'type_epithete -> espaces en trop', |
| 'description' => "Le champ type_epithete ne doit pas contenir d'espace.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($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); |
| } |
| } |
| } |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'type_epithete erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| private function testerTypeEpitheteSyntaxe($noms) { |
| $info = array('titre' => 'type_epithete -> syntaxe', |
| 'description' => "Le champ type_epithete doit contenir un mot unique composé de lettres minuscules sans ". |
| " accents et de tirets (-). Il commence par une lettre minuscule sans accent.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($noms as $nom) { |
| if ($nom['type_epithete'] != '') { |
| if (!preg_match('/^[a-z][-a-z]*[.]?$/', $nom['type_epithete'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['type_epithete']); |
| } |
| } |
| } |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'type_epithete erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| private function testerTypeEpitheteHybridite($noms) { |
| $info = array('titre' => 'type_epithete -> hybridité', |
| 'description' => "Le champ type_epithete ne doit pas contenir de préfixe indiquant l'hybridité comme : \n". |
| " - «n-» \n". |
| " - «notho-» \n", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($noms as $nom) { |
| if ($nom['type_epithete'] != '') { |
| if (preg_match('/^(?:n-|notho-)/', $nom['type_epithete'])) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['type_epithete']); |
| } |
| } |
| } |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'type_epithete erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| private function testerNombreDeChamps($colonnes) { |
| $info = array('titre' => 'Structure -> nombre de champs : %s', |
| 'description' => 'Le nombre de champs présent dans la table doit être supérieur ou égal à 35.', |
| 594,9 → 823,9 |
|---|
| return $info; |
| } |
| |
| private function testerNomSupraGeneriqueMotUnique($noms) { |
| $info = array('titre' => 'nom_supra_generique -> plusieurs mots', |
| 'description' => "Le champ nom_supra_generique doit contenir un seul mot.", |
| private function testerNomSupraGeneriqueEspaces($noms) { |
| $info = array('titre' => 'nom_supra_generique -> espaces en trop', |
| 'description' => "Le champ nom_supra_generique ne doit pas contenir d'espace avant ou aprés le nom.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| 603,8 → 832,7 |
|---|
| $noms_erreur = array(); |
| foreach ($noms as $nom) { |
| if ($nom['nom_supra_generique'] != '') { |
| $mots = explode(' ', trim($nom['nom_supra_generique'])); |
| if (count($mots) > 1) { |
| 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); |
| } |
| 622,9 → 850,10 |
|---|
| return $info; |
| } |
| |
| private function testerNomSupraGeneriqueEspaces($noms) { |
| $info = array('titre' => 'nom_supra_generique -> espaces en trop', |
| 'description' => "Le champ nom_supra_generique ne doit pas contenir d'espace avant ou aprés le nom.", |
| private function testerNomSupraGeneriqueSyntaxe($noms) { |
| $info = array('titre' => 'nom_supra_generique -> syntaxe', |
| 'description' => "Le champ nom_supra_generique contient un mot composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n". |
| "La première lettre (avec ou sans tréma) du mot doit être en majuscule.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| 631,7 → 860,7 |
|---|
| $noms_erreur = array(); |
| foreach ($noms as $nom) { |
| if ($nom['nom_supra_generique'] != '') { |
| if (preg_match('/(?:^\s+(?!:\s+)|(?!:\s+)\s+$)/', $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); |
| } |
| 649,6 → 878,314 |
|---|
| return $info; |
| } |
| |
| private function testerNomSupraGeneriqueRang($noms) { |
| $info = array('titre' => "nom_supra_generique -> rang < {$this->manuel['rang_genre']}", |
| 'description' => "Si le champ nom_supra_generique n'est pas vide alors le rang du nom doit être inférieur à {$this->manuel['rang_genre']}.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($noms as $nom) { |
| if ($nom['nom_supra_generique'] != '') { |
| if ($nom['rang'] >= $this->manuel['rang_genre']) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']); |
| } |
| } |
| } |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| private function testerGenreEspaces($noms) { |
| $info = array('titre' => 'genre -> espaces en trop', |
| 'description' => "Le champ genre ne doit pas contenir d'espace avant ou aprés le nom.\n". |
| "Si des espaces sont compris dans la valeur du champ, il ne doit pas y avoir plusieurs espaces consécutifs.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($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); |
| } |
| } |
| } |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'genre erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| private function testerGenreSyntaxe($noms) { |
| $info = array('titre' => 'genre -> syntaxe', |
| 'description' => "Le champ genre peut contenir :\n". |
| " - un mot unique composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n". |
| " Il commence par une lettre majuscule (avec ou sans tréma).". |
| " Il peut être précédé par le signe + ou la lettre x suivi d'un espace.\n". |
| " - une formule d'hybridité composée d'une série de noms de genre (au moins 2) séparés entre eux \n". |
| " par la lettre x entourée de caractères espaces.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($noms as $nom) { |
| if ($nom['genre'] != '') { |
| $mots = explode(' ', $nom['genre']); |
| foreach ($mots as $mot) { |
| if (!(preg_match('/^[+x]$/', $mot) || preg_match('/^[A-ZÄËḦÏÖÜẄẌŸ][-a-zäëḧïöẗüẅẍÿ]+/', $mot))) { |
| $nom_traite = $this->repererEspace($nom['genre']); |
| $noms_erreur[] = array($nom['num_nom'], $nom_traite); |
| } |
| } |
| } |
| } |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'genre erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| private function testerGenreRang($noms) { |
| $info = array('titre' => "genre -> rang >= {$this->manuel['rang_genre']}", |
| 'description' => "Si le champ genre n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_genre']}.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($noms as $nom) { |
| if ($nom['genre'] != '') { |
| if ($nom['rang'] < $this->manuel['rang_genre']) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']); |
| } |
| } |
| } |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| private function testerEpitheteInfraGeneriqueSyntaxe($noms) { |
| $info = array('titre' => 'epithete_infra_generique -> syntaxe', |
| 'description' => "Le champ epithete_infra_generique est composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n". |
| "La première lettre (avec ou sans tréma) doit être en majuscule.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($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); |
| } |
| } |
| } |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'epithete_infra_generique erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| private function testerEpitheteInfraGeneriqueRang($noms) { |
| $info = array('titre' => "epithete_infra_generique -> {$this->manuel['rang_genre']} < rang < {$this->manuel['rang_sp']}", |
| 'description' => "Si le champ epithete_infra_generique n'est pas vide alors le rang du nom doit être compris \n". |
| "entre {$this->manuel['rang_genre']} et {$this->manuel['rang_sp']}.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($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_complet'], $nom['rang']); |
| } |
| } |
| } |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| private function testerEpitheteInfraGeneriqueEspaces($noms) { |
| $info = array('titre' => 'epithete_infra_generique -> espaces en trop', |
| 'description' => "Le champ epithete_infra_generique ne doit pas contenir d'espace avant ou aprés sa valeur.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($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); |
| } |
| } |
| } |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'epithete_infra_generique erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| private function testerEpitheteSpEspaces($noms) { |
| $info = array('titre' => 'epithete_sp -> espaces en trop', |
| 'description' => "Le champ epithete_sp ne doit pas contenir d'espace avant ou aprés le nom.\n". |
| "Si des espaces sont compris dans la valeur du champ, il ne doit pas y avoir plusieurs espaces consécutifs.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($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); |
| } |
| } |
| } |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'epithete_sp erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| private function testerEpitheteSpSyntaxe($noms) { |
| $info = array('titre' => 'epithete_sp -> syntaxe', |
| 'description' => "Le champ epithete_sp peut contenir :\n". |
| " - un mot unique composé de lettres minuscules avec ou sans tréma (¨) et de tirets (-). \n". |
| " Il commence par une lettre minuscule (avec ou sans tréma).\n". |
| " Il peut être précédé par le signe + ou la lettre x suivi d'un espace.\n". |
| " - un mot contenant sp. suivi d'un ou plusieurs caractères numériques (1-9) ou d'un seul caractère majuscule (A-Z) \n". |
| " - une formule d'hybridité composée d'une série de noms d'espèce (au moins 2) séparés entre eux \n". |
| " par la lettre x entourée de caractères espaces.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($noms as $nom) { |
| if ($nom['epithete_sp'] != '') { |
| $mots = explode(' ', $nom['epithete_sp']); |
| foreach ($mots as $mot) { |
| if (!(preg_match('/^[+x]$/', $mot) || $this->verifierEpithteSp($mot))) { |
| $epithete_traite = $this->repererEspace($nom['epithete_sp']); |
| $noms_erreur[] = array($nom['num_nom'], $epithete_traite); |
| } |
| } |
| } |
| } |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'epithete_sp erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| private function testerEpitheteSpRang($noms) { |
| $info = array('titre' => "epithete_sp -> rang >= {$this->manuel['rang_sp']}", |
| 'description' => "Si le champ epithete_sp n'est pas vide alors le rang du nom doit être supérieur ou égal à {$this->manuel['rang_sp']}.", |
| 'resultat' => false); |
| |
| // Réalisation du test |
| $noms_erreur = array(); |
| foreach ($noms as $nom) { |
| if ($nom['epithete_sp'] != '') { |
| if ($nom['rang'] < $this->manuel['rang_sp']) { |
| $noms_erreur[] = array($nom['num_nom'], $nom['nom_complet'], $nom['rang']); |
| } |
| } |
| } |
| |
| // Analyse des résultats |
| if (count($noms_erreur) > 0) { |
| $info['message']['entete'] = array('num_nom', 'nom_complet', 'rang erroné'); |
| $info['message']['lignes'] = $noms_erreur; |
| } else { |
| $info['resultat'] = true; |
| } |
| |
| return $info; |
| } |
| |
| //+--------------------------------------------------------------------------------------------------------------+// |
| // MÉTHODES COMMUNES aux TESTS |
| |
| private function verifierTypeEpithete($type) { |
| $ok = true; |
| if (!preg_match('/^[a-z][-a-z]*[.]?$/', $type)) { |
| $ok = false; |
| } |
| return $ok; |
| } |
| |
| private function verifierEpithteSp($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 formaterStyleNomGenre($genre) { |
| $genre_fmt = ''; |
| if (preg_match('/^\s*([x+])\s+(.+)$/i', $genre, $match)) { |
| 701,5 → 1238,12 |
|---|
| return $nom_cultivar; |
| } |
| |
| private function classerNoms($noms) { |
| $noms_classes = array(); |
| foreach ($noms as $nom) { |
| $noms_classes[$nom['num_nom']] = $nom; |
| } |
| return $noms_classes; |
| } |
| } |
| ?> |