penwing/Pendragon
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

in progress of restructure

Browse source
This commit is contained in:
WanderingPenwing 2024-12-09 13:44:46 +01:00
parent 62513b59a3
commit 797b9991ea
4 changed files with 170 additions and 162 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/main.rs
View file

@ -17,7 +17,7 @@ fn main() {
match fs::read_to_string(chemin_de_fichier) {
Ok(contenu) => {
let _ = pendragon.execute(contenu);
let _ = pendragon.compile(contenu);
}
Err(raison) => {
eprintln!("Fichier illisible : {}", raison);

54
src/pendragon/mod.rs
View file

@ -20,7 +20,7 @@ impl Pendragon {
variables: HashMap::new(),
}
}
pub fn execute(&mut self, contenu: String) -> Result<(), ErreurPendragon> {
pub fn compile(&mut self, contenu: String) -> Result<Vec<Commande>, ErreurPendragon> {
let contenu_propre = contenu.replace("\n", "");
let mut texte: Vec<&str> = contenu_propre.split('.').collect();
let reste = texte.pop();
@ -28,56 +28,50 @@ impl Pendragon {
eprintln!("Erreur phrase {} : Il manque un point.", texte.len() + 1);
return Err(ErreurPendragon::ManquePoint)
}
let mut liste_commandes = Vec<Commande> = vec![];
for (index_phrase, phrase) in texte.iter().enumerate() {
match self.execute_phrase(phrase) {
Ok(_) => {},
match self.compile_phrase(phrase) {
Ok(commande) => {liste_commandes.push(commande)},
Err(raison) => {
eprintln!("Erreur phrase {} : {}", index_phrase + 1, raison);
return Err(raison)
}
}
}
Ok(())
Ok(liste_commande)
}
fn execute_phrase(&mut self, phrase: &str) -> Result<(), ErreurPendragon> {
fn compile_phrase(&self, phrase: &str) -> Result<Commande, ErreurPendragon> {
let phrase = phrase.trim();
let parties: Vec<&str> = phrase.splitn(2, ' ').collect();
if parties.is_empty() {
return Err(ErreurPendragon::PhraseVide)
}
if parties.len() == 1 {
return Err(ErreurPendragon::ManqueArgument)
}
match parties[0] {
"Définis" => {
self.definie(parties[1])?;
}
self.definis(parties[1])
},
"Modifie" => {
self.modifie(parties[1])?;
self.modifie(parties[1])
},
"Affiche" => {
self.affiche(parties[1])?;
self.affiche(parties[1])
},
"Demande" => {
self.demande(parties[1])?;
self.demande(parties[1])
}
autre_commande => {
return Err(ErreurPendragon::CommandeInconnue(autre_commande.to_string()))
}
};
Ok(())
}
}
fn affiche(&self, arguments: &str) -> Result<(), ErreurPendragon> {
fn affiche(&self, arguments: &str) -> Result<Commande, ErreurPendragon> {
println!("{}", self.texte(arguments)?);
Ok(())
let commande = Affiche(Expression::avec_arguments(TypeElement::Texte, arguments)?)
Ok(commande)
}
fn definie(&mut self, arguments: &str) -> Result<(), ErreurPendragon> {
fn definis(&mut self, arguments: &str) -> Result<Commande, ErreurPendragon> {
let (variable_nom, variable_type) = self.nom_de_variable(arguments, "comme")?;
let possible_variable = self.recupere_variable(&variable_nom);
@ -97,10 +91,12 @@ impl Pendragon {
};
self.variables.insert(variable_nom, contenu);
Ok(())
let commande = Definis(variable_nom.into(), contenu.type_element());
Ok(commande)
}
fn modifie(&mut self, arguments: &str) -> Result<(), ErreurPendragon> {
fn modifie(&mut self, arguments: &str) -> Result<Commande, ErreurPendragon> {
let (variable_nom, contenu) = self.nom_de_variable(arguments, "avec")?;
let variable = self.recupere_variable(&variable_nom)?;
@ -111,10 +107,11 @@ impl Pendragon {
};
self.variables.insert(variable_nom, valeur);
Ok(())
let commande = Modifie(variable_nom, Expression::avec_arguments(variable.type_element(), arguments)?),
Ok(commande)
}
fn demande(&mut self, arguments: &str) -> Result<(), ErreurPendragon> {
fn demande(&mut self, arguments: &str) -> Result<Commande, ErreurPendragon> {
let (variable_nom, _) = self.nom_de_variable(arguments, "")?;
let _ = self.recupere_variable(&variable_nom)?;
@ -134,7 +131,8 @@ impl Pendragon {
};
self.variables.insert(variable_nom, valeur);
Ok(())
let commande = Demande(variable_nom.into());
Ok(commande)
}
fn recupere_variable(&self, nom: &str) -> Result<Element, ErreurPendragon> {

10
src/pendragon/structure.rs
View file

@ -20,6 +20,16 @@ impl Expression {
contenu: vec![]
}
}
fn avec_arguments(type_expression: TypeElement, arguments: &str) -> Result<Self, ErreurPendragon> {
let expression = Self {
type_expression,
contenu: vec![]
}
Ok(expression)
}
fn ajoute(&mut self, element: Element) -> Result<(), ErreurPendragon> {
let type_element = element.type_element();
if self.type_expression != type_element {

262
src/pendragon/tests.rs
View file

@ -33,59 +33,59 @@ fn teste_somme() {
}
}
#[test]
fn teste_definition_variable() {
let mut sophie = Pendragon::new();
let resultat = sophie.execute_phrase("Définis Element comme entier");
match resultat {
Ok(_) => {
assert_eq!(sophie.variables["Element"], Element::Entier(0), "Element mal définie");
}
Err(raison) => {
panic!("Définition de variable échouée : {}", raison);
}
}
}
#[test]
fn teste_modification_variable() {
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 a = 2345678;
let resultat = sophie.execute_phrase(&format!("Modifie Element avec {} ", nombre::nombre_comme_texte(a)));
match resultat {
Ok(_) => {
assert_eq!(sophie.variables["Element"], Element::Entier(a), "Element mal modifiée");
}
Err(raison) => {
panic!("Modification de variable échouée : {}", raison);
}
}
}
#[test]
fn teste_operation_variable() {
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 a = 2345678;
if let Err(raison) = sophie.execute_phrase(&format!("Modifie Element avec {} ", nombre::nombre_comme_texte(a))) {
panic!("Modification de variable échouée : {}", raison);
}
let b = 987654;
let resultat = sophie.operation(&format!("Element plus {}", nombre::nombre_comme_texte(b)));
match resultat {
Ok(nombre) => {
assert_eq!(nombre, a+b, "Echec de la somme d'un entier et d'une variable, attendais {}, a reçu {}", a+b, nombre);
}
Err(raison) => {
panic!("Opération de variable échouée : {}", raison);
}
}
}
//#[test]
//fn teste_definition_variable() {
// let mut sophie = Pendragon::new();
// let resultat = sophie.execute_phrase("Définis Element comme entier");
// match resultat {
// Ok(_) => {
// assert_eq!(sophie.variables["Element"], Element::Entier(0), "Element mal définie");
// }
// Err(raison) => {
// panic!("Définition de variable échouée : {}", raison);
// }
// }
//}
//
//#[test]
//fn teste_modification_variable() {
// 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 a = 2345678;
// let resultat = sophie.execute_phrase(&format!("Modifie Element avec {} ", nombre::nombre_comme_texte(a)));
// match resultat {
// Ok(_) => {
// assert_eq!(sophie.variables["Element"], Element::Entier(a), "Element mal modifiée");
// }
// Err(raison) => {
// panic!("Modification de variable échouée : {}", raison);
// }
// }
//}
//
//#[test]
//fn teste_operation_variable() {
// 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 a = 2345678;
// if let Err(raison) = sophie.execute_phrase(&format!("Modifie Element avec {} ", nombre::nombre_comme_texte(a))) {
// panic!("Modification de variable échouée : {}", raison);
// }
// let b = 987654;
// let resultat = sophie.operation(&format!("Element plus {}", nombre::nombre_comme_texte(b)));
// match resultat {
// Ok(nombre) => {
// assert_eq!(nombre, a+b, "Echec de la somme d'un entier et d'une variable, attendais {}, a reçu {}", a+b, nombre);
// }
// Err(raison) => {
// panic!("Opération de variable échouée : {}", raison);
// }
// }
//}
#[test]
fn teste_maths() {
@ -111,84 +111,84 @@ fn teste_maths() {
}
}
#[test]
fn teste_texte() {
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);
}
let a = 2345678;
if let Err(raison) = sophie.execute_phrase(&format!("Modifie A avec {} ", nombre::nombre_comme_texte(a))) {
panic!("Modification de variable échouée : {}", raison);
}
if let Err(raison) = sophie.execute_phrase("Définis B comme texte") {
panic!("Définition de variable échouée : {}", raison);
}
if let Err(raison) = sophie.execute_phrase("Modifie B avec \"hello there\", \" general\", \" Kenobi\"") {
panic!("Modification de variable échouée : {}", raison);
}
let resultat = sophie.texte("\"Combo : \", B, \" / \", A plus ouvre la parenthèse un plus cinq ferme la parenthèse fois ouvre la parenthèse huit moins un ferme la parenthèse");
match resultat {
Ok(texte) => assert_eq!(texte, "Combo : hello there general Kenobi / deux-millions-trois-cent-quarante-cinq-mille-sept-cent-vingt", "Texte mal calculé"),
Err(raison) => panic!("Calcul de texte échoué : {}", raison),
}
}
//#[test]
//fn teste_texte() {
// 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);
// }
// let a = 2345678;
// if let Err(raison) = sophie.execute_phrase(&format!("Modifie A avec {} ", nombre::nombre_comme_texte(a))) {
// panic!("Modification de variable échouée : {}", raison);
// }
// if let Err(raison) = sophie.execute_phrase("Définis B comme texte") {
// panic!("Définition de variable échouée : {}", raison);
// }
// if let Err(raison) = sophie.execute_phrase("Modifie B avec \"hello there\", \" general\", \" Kenobi\"") {
// panic!("Modification de variable échouée : {}", raison);
// }
// let resultat = sophie.texte("\"Combo : \", B, \" / \", A plus ouvre la parenthèse un plus cinq ferme la parenthèse fois ouvre la parenthèse huit moins un ferme la parenthèse");
//
// match resultat {
// Ok(texte) => assert_eq!(texte, "Combo : hello there general Kenobi / deux-millions-trois-cent-quarante-cinq-mille-sept-cent-vingt", "Texte mal calculé"),
// Err(raison) => panic!("Calcul de texte échoué : {}", raison),
// }
//}
// --------------------------------------------- anti-test
#[test]
fn teste_redefinition_variable() {
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 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);
}
}
#[test]
fn teste_echec_modification() {
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 ErreurPendragon::VariableInconnue(nom) = raison {
assert_eq!(nom, "Element", "Mauvais nom de variable reconnu : {}", nom);
} else {
panic!("Modification échouée avec erreur imprévue : {}", raison);
}
}
#[test]
fn teste_majuscule_variable() {
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 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);
}
}
#[test]
fn teste_point_phrase() {
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 ErreurPendragon::ManquePoint = raison else {
panic!("Définition échouée avec erreur imprévue : {}", raison);
};
}
//#[test]
//fn teste_redefinition_variable() {
// 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 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);
// }
//}
//
//#[test]
//fn teste_echec_modification() {
// 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 ErreurPendragon::VariableInconnue(nom) = raison {
// assert_eq!(nom, "Element", "Mauvais nom de variable reconnu : {}", nom);
// } else {
// panic!("Modification échouée avec erreur imprévue : {}", raison);
// }
//}
//
//#[test]
//fn teste_majuscule_variable() {
// 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 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);
// }
//}
//
//#[test]
//fn teste_point_phrase() {
// 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 ErreurPendragon::ManquePoint = raison else {
// panic!("Définition échouée avec erreur imprévue : {}", raison);
// };
//}