pendragon

Cargo.lock

@@ -3,5 +3,5 @@
 version = 3
 
 [[package]]
-name = "sophie"
+name = "pendragon"
 version = "0.1.0"

Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "sophie"
+name = "pendragon"
 version = "0.1.0"
 edition = "2021"
 

src/main.rs

@@ -1,23 +1,23 @@
 use std::env;
 use std::fs;
 
-mod sophie;
+mod pendragon;
-use sophie::*;
+use pendragon::*;
 
 fn main() {
 	let arguments: Vec<String> = env::args().collect();
 
 	if arguments.len() < 2 {
-		eprintln!("Utilisation : sophie <FILE>");
+		eprintln!("Utilisation : pendragon <FILE>");
 		return
 	}
 
 	let chemin_de_fichier = &arguments[1];
-	let mut sophie = Sophie::new();
+	let mut pendragon = Pendragon::new();
 	
 	match fs::read_to_string(chemin_de_fichier) {
 		Ok(contenu) => {
-			let _ = sophie.execute(contenu);
+			let _ = pendragon.execute(contenu);
 		}
 		Err(raison) => {
 			eprintln!("Fichier illisible : {}", raison);

src/pendragon/booleen.rs

@@ -1,13 +1,13 @@
-use super::Sophie;
+use super::Pendragon;
-use super::ErreurSophie;
+use super::ErreurPendragon;
 use super::Element;
 
-impl Sophie {
+impl Pendragon {
-	pub fn condition(&self, arguments: &str) -> Result<bool, ErreurSophie> {
+	pub fn condition(&self, arguments: &str) -> Result<bool, ErreurPendragon> {
 		self.condition_elementaire(arguments)
 	}
 	
-	pub fn condition_elementaire(&self, texte: &str) -> Result<bool, ErreurSophie> {
+	pub fn condition_elementaire(&self, texte: &str) -> Result<bool, ErreurPendragon> {
 		let mut expression: Vec<String> = texte.split(" ").map(String::from).collect();
 		
 		let mut index = 0;
@@ -17,7 +17,7 @@ impl Sophie {
 				continue;
 			}
 			if index == expression.len() - 1 {
-				return Err(ErreurSophie::ManqueArgument);
+				return Err(ErreurPendragon::ManqueArgument);
 			}
 			let a = self.texte_comme_booleen(&expression[index + 1])?;
 			expression[index] = booleen_comme_texte(!a);
@@ -30,7 +30,7 @@ impl Sophie {
 				continue;
 			}
 			if index == 0 || index == expression.len() - 1 {
-				return Err(ErreurSophie::ManqueArgument);
+				return Err(ErreurPendragon::ManqueArgument);
 			}
 			let a = self.texte_comme_booleen(&expression[index - 1])?;
 			let b = self.texte_comme_booleen(&expression[index + 1])?;
@@ -46,7 +46,7 @@ impl Sophie {
 				continue;
 			}
 			if index == 0 || index == expression.len() - 1 {
-				return Err(ErreurSophie::ManqueArgument);
+				return Err(ErreurPendragon::ManqueArgument);
 			}
 			let a = self.texte_comme_booleen(&expression[index - 1])?;
 			let b = self.texte_comme_booleen(&expression[index + 1])?;
@@ -56,20 +56,20 @@ impl Sophie {
 			expression.remove(index + 1);
 		}
 		if expression.len() > 1 {
-			return Err(ErreurSophie::MauvaisArgument("expression booléenne".to_string()))
+			return Err(ErreurPendragon::MauvaisArgument("expression booléenne".to_string()))
 		}
 		self.texte_comme_booleen(&expression[0])
 	}
 	
-	pub fn texte_comme_booleen(&self, texte: &str) -> Result<bool, ErreurSophie> {
+	pub fn texte_comme_booleen(&self, texte: &str) -> Result<bool, ErreurPendragon> {
 		if texte.chars().next().map_or(false, |c| c.is_uppercase()) {
 			if self.variables.contains_key(texte) {
 				let Element::Booleen(booleen) = self.variables[texte] else {
-					return Err(ErreurSophie::MauvaisType(texte.into(), self.variables[texte].type_element().nom(), "booleen".into()))
+					return Err(ErreurPendragon::MauvaisType(texte.into(), self.variables[texte].type_element().nom(), "booleen".into()))
 				};
 				return Ok(booleen);
 			} else {
-				return Err(ErreurSophie::VariableInconnue(texte.to_string()))
+				return Err(ErreurPendragon::VariableInconnue(texte.to_string()))
 			}
 		}
 		texte_comme_booleen(texte)
@@ -84,10 +84,10 @@ pub fn booleen_comme_texte(booleen: bool) -> String {
 	}
 }
 
-pub fn texte_comme_booleen(texte: &str) -> Result<bool, ErreurSophie> {
+pub fn texte_comme_booleen(texte: &str) -> Result<bool, ErreurPendragon> {
 	match texte {
 		"vrai" => Ok(true),
 		"faux" => Ok(false),
-		_ => Err(ErreurSophie::BooleenInvalide(texte.into())),
+		_ => Err(ErreurPendragon::BooleenInvalide(texte.into())),
 	}
 }

src/pendragon/mod.rs

@@ -10,23 +10,23 @@ use structure::*;
 #[cfg(test)]
 mod tests;
 
-pub struct Sophie {
+pub struct Pendragon {
 	variables: HashMap<String, Element>,
 }
 
-impl Sophie {
+impl Pendragon {
 	pub fn new() -> Self {
 		Self {
 			variables: HashMap::new(),
 		}
 	}
-	pub fn execute(&mut self, contenu: String) -> Result<(), ErreurSophie> {
+	pub fn execute(&mut self, contenu: String) -> Result<(), ErreurPendragon> {
 		let contenu_propre = contenu.replace("\n", "");
 		let mut texte: Vec<&str> = contenu_propre.split('.').collect();
-		let reste = texte.pop(); // remove empty phrase after last dot
+		let reste = texte.pop();
 		if reste != Some("") {
 			eprintln!("Erreur phrase {} : Il manque un point.", texte.len() + 1);
-			return Err(ErreurSophie::ManquePoint)
+			return Err(ErreurPendragon::ManquePoint)
 		}
 		for (index_phrase, phrase) in texte.iter().enumerate() {
 			match self.execute_phrase(phrase) {
@@ -40,16 +40,16 @@ impl Sophie {
 		Ok(())
 	}
 
-	fn execute_phrase(&mut self, phrase: &str) -> Result<(), ErreurSophie> {
+	fn execute_phrase(&mut self, phrase: &str) -> Result<(), ErreurPendragon> {
 		let phrase = phrase.trim();
 		let parties: Vec<&str> = phrase.splitn(2, ' ').collect();
 
 		if parties.is_empty() {
-			return Err(ErreurSophie::PhraseVide)
+			return Err(ErreurPendragon::PhraseVide)
 		}
 
 		if parties.len() == 1 {
-			return Err(ErreurSophie::ManqueArgument)
+			return Err(ErreurPendragon::ManqueArgument)
 		}
 
 		match parties[0] {
@@ -66,26 +66,26 @@ impl Sophie {
 				self.demande(parties[1])?;
 			}
 			autre_commande => {
-				return Err(ErreurSophie::CommandeInconnue(autre_commande.to_string()))
+				return Err(ErreurPendragon::CommandeInconnue(autre_commande.to_string()))
 			}
 		};
 		Ok(())
 	}
 
-	fn affiche(&self, arguments: &str) -> Result<(), ErreurSophie> {
+	fn affiche(&self, arguments: &str) -> Result<(), ErreurPendragon> {
 		println!("{}", self.texte(arguments)?);
 		Ok(())
 	}
 	
-	fn definie(&mut self, arguments: &str) -> Result<(), ErreurSophie> {
+	fn definie(&mut self, arguments: &str) -> Result<(), ErreurPendragon> {
 		let (variable_nom, variable_type) = self.nom_de_variable(arguments, "comme")?;
 		
 		let possible_variable = self.recupere_variable(&variable_nom);
 		
 		let Err(raison) = possible_variable else {
-			return Err(ErreurSophie::MauvaisArgument(format!("la variable \"{}\" existe déjà", variable_nom)))
+			return Err(ErreurPendragon::MauvaisArgument(format!("la variable \"{}\" existe déjà", variable_nom)))
 		};
-		let ErreurSophie::VariableInconnue(_) = raison else {
+		let ErreurPendragon::VariableInconnue(_) = raison else {
 			return Err(raison)
 		};
 	
@@ -93,14 +93,14 @@ impl Sophie {
 			"entier" => Element::Entier(0),
 			"texte" => Element::Texte("".to_string()),
 			"booléen" => Element::Booleen(false),
-			_ => return Err(ErreurSophie::MauvaisArgument(format!("type de variable \"{}\" inconnu", variable_type))),
+			_ => return Err(ErreurPendragon::MauvaisArgument(format!("type de variable \"{}\" inconnu", variable_type))),
 		};
 	
 		self.variables.insert(variable_nom, contenu);
 		Ok(())
 	}
 	
-	fn modifie(&mut self, arguments: &str) -> Result<(), ErreurSophie> {
+	fn modifie(&mut self, arguments: &str) -> Result<(), ErreurPendragon> {
 		let (variable_nom, contenu) = self.nom_de_variable(arguments, "avec")?;
 		let variable = self.recupere_variable(&variable_nom)?;
 
@@ -114,7 +114,7 @@ impl Sophie {
 		Ok(())
 	}
 
-	fn demande(&mut self, arguments: &str) -> Result<(), ErreurSophie> {
+	fn demande(&mut self, arguments: &str) -> Result<(), ErreurPendragon> {
 		let (variable_nom, _) = self.nom_de_variable(arguments, "")?;
 		
 		let _ = self.recupere_variable(&variable_nom)?;
@@ -122,7 +122,7 @@ impl Sophie {
 		println!("Quelle valeur pour {} ?", variable_nom);
 		let mut reponse: String = String::new();
 		if let Err(_) = io::stdin().read_line(&mut reponse) {
-			return Err(ErreurSophie::ProblemeTerminal("lecture d'entrées utilisateur impossible".into()))
+			return Err(ErreurPendragon::ProblemeTerminal("lecture d'entrées utilisateur impossible".into()))
 		}
 		
 		let contenu = reponse.trim();
@@ -137,20 +137,20 @@ impl Sophie {
 		Ok(())
 	}
 	
-	fn recupere_variable(&self, nom: &str) -> Result<Element, ErreurSophie> {
+	fn recupere_variable(&self, nom: &str) -> Result<Element, ErreurPendragon> {
 		let Some(first_char) = nom.chars().next() else {
-			return Err(ErreurSophie::MauvaisArgument("il n'y a pas de variable".to_string()))
+			return Err(ErreurPendragon::MauvaisArgument("il n'y a pas de variable".to_string()))
 		};
 		if !first_char.is_uppercase() {
-			return Err(ErreurSophie::MauvaisArgument("il manque une majuscule à la variable".to_string()))
+			return Err(ErreurPendragon::MauvaisArgument("il manque une majuscule à la variable".to_string()))
 		}
 		if !self.variables.contains_key(nom) {
-			return Err(ErreurSophie::VariableInconnue(nom.into()))
+			return Err(ErreurPendragon::VariableInconnue(nom.into()))
 		}
 		Ok(self.variables[nom].clone())
 	}
 	
-	fn nom_de_variable(&self, arguments: &str, separateur: &str) -> Result<(String, String), ErreurSophie> {
+	fn nom_de_variable(&self, arguments: &str, separateur: &str) -> Result<(String, String), ErreurPendragon> {
 		let parties = if separateur == "" {
 			vec![arguments, ""]
 		} else {
@@ -160,7 +160,7 @@ impl Sophie {
 		let nom_variable = parties[0].trim().to_string();
 		
 		if parties.len() == 1 {
-			return Err(ErreurSophie::ManqueArgument)
+			return Err(ErreurPendragon::ManqueArgument)
 		}
 		Ok((nom_variable, parties[1].trim().to_string()))
 	}

src/pendragon/nombre.rs

@@ -1,5 +1,5 @@
-use super::ErreurSophie;
+use super::ErreurPendragon;
-use super::Sophie;
+use super::Pendragon;
 use super::Element;
 
 const NOMS_UNITES: [&str; 10] = ["", "un", "deux", "trois", "quatre", "cinq", "six", "sept", "huit", "neuf"];
@@ -8,8 +8,8 @@ const NOMS_DIZAINES: [&str; 9] = ["", "dix", "vingt", "trente", "quarante", "cin
 const NOMS_SEPARATEURS: [&str; 7] = ["", "mille", "million", "milliard", "billion", "billiard", "trillion"];
 const UNION: &str = "-";
 
-impl Sophie {
+impl Pendragon {
-	pub fn operation(&self, arguments: &str) -> Result<usize, ErreurSophie> {
+	pub fn operation(&self, arguments: &str) -> Result<usize, ErreurPendragon> {
 		//return self.operation_elementaire(arguments);
 		let texte = arguments
 					.replace("ouvre la parenthèse", "ouvre-la-parenthese")
@@ -30,10 +30,10 @@ impl Sophie {
 				}
 			}
 			let Some(index_ouverture) = ouverture else {
-				return Err(ErreurSophie::DesequilibreParenthese);
+				return Err(ErreurPendragon::DesequilibreParenthese);
 			};
 			let Some(index_fermeture) = fermeture else {
-				return Err(ErreurSophie::DesequilibreParenthese);
+				return Err(ErreurPendragon::DesequilibreParenthese);
 			};
 			let contenu: String = expression[(index_ouverture+1)..(index_fermeture)].join(" ");
 			let nombre = self.operation_elementaire(&contenu)?;
@@ -44,12 +44,12 @@ impl Sophie {
 			}
 		}
 		if expression.contains(&"ferme-la-parenthese".to_string()) {
-			return Err(ErreurSophie::DesequilibreParenthese);
+			return Err(ErreurPendragon::DesequilibreParenthese);
 		}
 		self.operation_elementaire(&expression.join(" "))
 	}
 
-	pub fn operation_elementaire(&self, arguments: &str) -> Result<usize, ErreurSophie> {
+	pub fn operation_elementaire(&self, arguments: &str) -> Result<usize, ErreurPendragon> {
 		let texte = arguments.replace("divisé par", "divise-par");
 		let mut expression: Vec<String> = texte.split(" ").map(String::from).collect();
 
@@ -60,7 +60,7 @@ impl Sophie {
 				continue;
 			}
 			if index == 0 || index == expression.len() - 1 {
-				return Err(ErreurSophie::ManqueArgument);
+				return Err(ErreurPendragon::ManqueArgument);
 			}
 			let a = self.texte_comme_nombre(&expression[index - 1])?;
 			let b = self.texte_comme_nombre(&expression[index + 1])?;
@@ -79,7 +79,7 @@ impl Sophie {
 				continue;
 			}
 			if index == 0 || index == expression.len() - 1 {
-				return Err(ErreurSophie::ManqueArgument);
+				return Err(ErreurPendragon::ManqueArgument);
 			}
 			let a = self.texte_comme_nombre(&expression[index - 1])?;
 			let b = self.texte_comme_nombre(&expression[index + 1])?;
@@ -92,20 +92,20 @@ impl Sophie {
 		}
 
 		if expression.len() > 1 {
-			return Err(ErreurSophie::MauvaisArgument("expression mathématique".to_string()))
+			return Err(ErreurPendragon::MauvaisArgument("expression mathématique".to_string()))
 		}
 		self.texte_comme_nombre(&expression[0])
 	}
 
-	pub fn texte_comme_nombre(&self, texte: &str) -> Result<usize, ErreurSophie> {
+	pub fn texte_comme_nombre(&self, texte: &str) -> Result<usize, ErreurPendragon> {
 		if texte.chars().next().map_or(false, |c| c.is_uppercase()) {
 			if self.variables.contains_key(texte) {
 				let Element::Entier(nombre) = self.variables[texte] else {
-					return Err(ErreurSophie::MauvaisType(texte.into(), self.variables[texte].type_element().nom(), "entier".into()))
+					return Err(ErreurPendragon::MauvaisType(texte.into(), self.variables[texte].type_element().nom(), "entier".into()))
 				};
 				return Ok(nombre);
 			} else {
-				return Err(ErreurSophie::VariableInconnue(texte.to_string()))
+				return Err(ErreurPendragon::VariableInconnue(texte.to_string()))
 			}
 		}
 		texte_comme_nombre(texte)
@@ -198,7 +198,7 @@ fn petit_nombre_comme_texte(nombre: usize) -> String {
 	format!("{}{}{}{}{}", centaine_texte, dizaine_union, dizaine_texte, séparation, unité_texte)
 }
 
-pub fn texte_comme_nombre(texte: &str) -> Result<usize, ErreurSophie> {
+pub fn texte_comme_nombre(texte: &str) -> Result<usize, ErreurPendragon> {
 	if texte == "zéro" {
 		return Ok(0)
 	}
@@ -215,7 +215,7 @@ pub fn texte_comme_nombre(texte: &str) -> Result<usize, ErreurSophie> {
 		}
 		let texte_separe: Vec<&str> = texte_modifie.split(separateur_texte).collect();
 		if texte_separe.len() > 2 {
-			return Err(ErreurSophie::NombreInvalide(texte.to_string()))
+			return Err(ErreurPendragon::NombreInvalide(texte.to_string()))
 		}
 		if texte_separe.len() > 1 {
 			let petit_nombre_texte = texte_separe[0]
@@ -246,7 +246,7 @@ pub fn texte_comme_nombre(texte: &str) -> Result<usize, ErreurSophie> {
 	Ok(nombre)
 }
 
-fn texte_comme_petit_nombre(texte: &str) -> Result<usize, ErreurSophie> {
+fn texte_comme_petit_nombre(texte: &str) -> Result<usize, ErreurPendragon> {
 	let elements: Vec<&str> = texte.split(UNION).collect();
 
 	let mut nombre = 0;
@@ -258,7 +258,7 @@ fn texte_comme_petit_nombre(texte: &str) -> Result<usize, ErreurSophie> {
 				nombre = 1;
 			}
 			if nombre >= 100 {
-				return Err(ErreurSophie::NombreInvalide(texte.to_string()))
+				return Err(ErreurPendragon::NombreInvalide(texte.to_string()))
 			}
 			nombre *= 100;
 			dernier_chiffre_texte = chiffre_texte;
@@ -270,12 +270,12 @@ fn texte_comme_petit_nombre(texte: &str) -> Result<usize, ErreurSophie> {
 				dernier_chiffre_texte = chiffre_texte;
 				continue
 			} else {
-				return Err(ErreurSophie::NombreInvalide(texte.to_string()))
+				return Err(ErreurPendragon::NombreInvalide(texte.to_string()))
 			}
 		}
 		if let Some(chiffre) = NOMS_UNITES.iter().position(|&s| s == chiffre_texte) {
 			if nombre%10 > 0 {
-				return Err(ErreurSophie::NombreInvalide(texte.to_string()))
+				return Err(ErreurPendragon::NombreInvalide(texte.to_string()))
 			}
 			nombre += chiffre;
 			dernier_chiffre_texte = chiffre_texte;
@@ -283,7 +283,7 @@ fn texte_comme_petit_nombre(texte: &str) -> Result<usize, ErreurSophie> {
 		}
 		if let Some(chiffre) = NOMS_DIZAINES.iter().position(|&s| s == chiffre_texte) {
 			if nombre%100 > 0 && chiffre != 1 {
-				return Err(ErreurSophie::NombreInvalide(texte.to_string()))
+				return Err(ErreurPendragon::NombreInvalide(texte.to_string()))
 			}
 			nombre += chiffre*10;
 			dernier_chiffre_texte = chiffre_texte;
@@ -291,7 +291,7 @@ fn texte_comme_petit_nombre(texte: &str) -> Result<usize, ErreurSophie> {
 		}
 		if let Some(chiffre) = NOMS_UNITES_DIX.iter().position(|&s| s == chiffre_texte) {
 			if nombre%10 > 0 {
-				return Err(ErreurSophie::NombreInvalide(texte.to_string()))
+				return Err(ErreurPendragon::NombreInvalide(texte.to_string()))
 			}
 			nombre += 10 + chiffre;
 			dernier_chiffre_texte = chiffre_texte;
@@ -300,7 +300,7 @@ fn texte_comme_petit_nombre(texte: &str) -> Result<usize, ErreurSophie> {
 		if chiffre_texte == "et" {
 			continue
 		}
-		return Err(ErreurSophie::NombreInvalide(texte.to_string()))
+		return Err(ErreurPendragon::NombreInvalide(texte.to_string()))
 	}
 
 	Ok(nombre)

src/pendragon/structure.rs

@@ -20,10 +20,10 @@ impl Expression {
 			contenu: vec![]
 		}
 	}
-	fn ajoute(&mut self, element: Element) -> Result<(), ErreurSophie> {
+	fn ajoute(&mut self, element: Element) -> Result<(), ErreurPendragon> {
 		let type_element = element.type_element();
 		if self.type_expression != type_element {
-			return Err(ErreurSophie::MauvaisType("inconnue".into(), type_element.nom(), self.type_expression.nom()))
+			return Err(ErreurPendragon::MauvaisType("inconnue".into(), type_element.nom(), self.type_expression.nom()))
 		}
 		self.contenu.push(element);
 		Ok(())
@@ -70,7 +70,7 @@ impl Element {
 	}
 }
 
-pub enum ErreurSophie {
+pub enum ErreurPendragon {
 	CommandeInconnue(String),
 	PhraseVide,
 	ManqueArgument,
@@ -85,7 +85,7 @@ pub enum ErreurSophie {
 	ManquePoint,
 }
 
-impl fmt::Display for ErreurSophie {
+impl fmt::Display for ErreurPendragon {
 	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {//'
 		match self {
 			Self::CommandeInconnue(commande) => write!(f, "La commande \"{}\" est inconnue.", commande),

src/pendragon/tests.rs

@@ -20,7 +20,7 @@ fn teste_somme() {
 	for (a, b) in [(0, 0), (5, 7), (1467,45678), (1001, 0), (72_036_854_775_807usize, 14_036_567_775_807usize)] {
 		let texte_a = nombre::nombre_comme_texte(a);
 		let texte_b = nombre::nombre_comme_texte(b);
-		let sophie = Sophie::new();
+		let sophie = Pendragon::new();
 		let resultat = sophie.operation(&format!("{} plus {}", texte_a, texte_b));
 		match resultat { // Convert text back to number
 			Ok(nombre) => {
@@ -35,7 +35,7 @@ fn teste_somme() {
 
 #[test]
 fn teste_definition_variable() {
-	let mut sophie = Sophie::new();
+	let mut sophie = Pendragon::new();
 	let resultat = sophie.execute_phrase("Définis Element comme entier");
 	match resultat {
 		Ok(_) => {
@@ -49,7 +49,7 @@ fn teste_definition_variable() {
 
 #[test]
 fn teste_modification_variable() {
-	let mut sophie = Sophie::new();
+	let mut sophie = Pendragon::new();
 	if let Err(raison) = sophie.execute_phrase("Définis Element comme entier") {
 		panic!("Définition de variable échouée : {}", raison);
 	}
@@ -67,7 +67,7 @@ fn teste_modification_variable() {
 
 #[test]
 fn teste_operation_variable() {
-	let mut sophie = Sophie::new();
+	let mut sophie = Pendragon::new();
 	if let Err(raison) = sophie.execute_phrase("Définis Element comme entier") {
 		panic!("Définition de variable échouée : {}", raison);
 	}
@@ -89,7 +89,7 @@ fn teste_operation_variable() {
 
 #[test]
 fn teste_maths() {
-	let sophie = Sophie::new();
+	let sophie = Pendragon::new();
 	let a = 2345678;
 	let b = 987654;
 	let c = 34523456;
@@ -113,7 +113,7 @@ fn teste_maths() {
 
 #[test]
 fn teste_texte() {
-	let mut sophie = Sophie::new();
+	let mut sophie = Pendragon::new();
 	if let Err(raison) = sophie.execute_phrase("Définis A comme entier") {
 		panic!("Définition de variable échouée : {}", raison);
 	}
@@ -139,14 +139,14 @@ fn teste_texte() {
 
 #[test]
 fn teste_redefinition_variable() {
-	let mut sophie = Sophie::new();
+	let mut sophie = Pendragon::new();
 	if let Err(raison) = sophie.execute_phrase("Définis Element comme entier") {
 		panic!("Définition de variable échouée : {}", raison);
 	};
 	let Err(raison) = sophie.execute_phrase("Définis Element comme texte") else {
 		panic!("Ne devrais pas pouvoir redéfinir une variable");
 	};
-	if let ErreurSophie::MauvaisArgument(ref texte) = raison {
+	if let ErreurPendragon::MauvaisArgument(ref texte) = raison {
 		assert_eq!(texte, "la variable \"Element\" existe déjà", "Définition échouée avec erreur imprévue : {}", raison);
 	} else {
 		panic!("Définition échouée avec erreur imprévue : {}", raison);
@@ -155,12 +155,12 @@ fn teste_redefinition_variable() {
 
 #[test]
 fn teste_echec_modification() {
-	let mut sophie = Sophie::new();
+	let mut sophie = Pendragon::new();
 	let resultat = sophie.execute_phrase("Modifie Element avec deux");
 	let Err(raison) = resultat else {
 		panic!("Ne devrais pas pouvoir modifier une variable non définie");
 	};
-	if let ErreurSophie::VariableInconnue(nom) = raison {
+	if let ErreurPendragon::VariableInconnue(nom) = raison {
 		assert_eq!(nom, "Element", "Mauvais nom de variable reconnu : {}", nom);
 	} else {
 		panic!("Modification échouée avec erreur imprévue : {}", raison);
@@ -169,12 +169,12 @@ fn teste_echec_modification() {
 
 #[test]
 fn teste_majuscule_variable() {
-	let mut sophie = Sophie::new();
+	let mut sophie = Pendragon::new();
 	let resultat = sophie.execute_phrase("Définis variable comme entier");
 	let Err(raison) = resultat else {
 		panic!("Ne devrais pas pouvoir definir une variable sans majuscule");
 	};
-	if let ErreurSophie::MauvaisArgument(explication) = raison {
+	if let ErreurPendragon::MauvaisArgument(explication) = raison {
 		assert_eq!(explication, "il manque une majuscule à la variable", "Mauvaise explication : {}", explication);
 	} else {
 		panic!("Définition échouée avec erreur imprévue : {}", raison);
@@ -183,12 +183,12 @@ fn teste_majuscule_variable() {
 
 #[test]
 fn teste_point_phrase() {
-	let mut sophie = Sophie::new();
+	let mut sophie = Pendragon::new();
 	let resultat = sophie.execute("Définis Element comme entier".into());
 	let Err(raison) = resultat else {
 		panic!("Ne devrais pas pouvoir faire de commande sans point à la fin");
 	};
-	let ErreurSophie::ManquePoint = raison else {
+	let ErreurPendragon::ManquePoint = raison else {
 		panic!("Définition échouée avec erreur imprévue : {}", raison);
 	};
 }

src/pendragon/texte.rs

@@ -1,11 +1,11 @@
-use super::Sophie;
+use super::Pendragon;
-use super::ErreurSophie;
+use super::ErreurPendragon;
 use super::Element;
 use super::nombre;
 use super::booleen;
 
-impl Sophie {
+impl Pendragon {
-	pub fn texte(&self, arguments: &str) -> Result<String, ErreurSophie> {
+	pub fn texte(&self, arguments: &str) -> Result<String, ErreurPendragon> {
 		let liste_arguments: Vec<&str> = arguments.split(',').collect();
 
 		let mut texte = "".to_string();
@@ -16,7 +16,7 @@ impl Sophie {
 				if argument.ends_with('"') {
 					texte += &argument[1..argument.len()-1];
 				} else {
-					return Err(ErreurSophie::TexteInvalide("guillemet mal refermé".into()))
+					return Err(ErreurPendragon::TexteInvalide("guillemet mal refermé".into()))
 				}
 				continue;
 			}			
@@ -34,7 +34,7 @@ impl Sophie {
 			let variable = self.recupere_variable(argument)?;
 			
 			let Element::Texte(contenu) = variable else {
-				return Err(ErreurSophie::MauvaisType(argument.into(), variable.type_element().nom(), "texte".into()))
+				return Err(ErreurPendragon::MauvaisType(argument.into(), variable.type_element().nom(), "texte".into()))
 			};
 			
 			texte += &contenu;