Merge branch 'ayabust-feat/error-handling'

Author: upskaling

src/error.rs

@@ -0,0 +1,51 @@
+//! Module d'erreurs personnalisées pour GSP
+//!
+//! Ce module définit les types d'erreurs utilisés dans l'ensemble du projet.
+
+use std::fmt;
+use std::io;
+
+/// Type d'erreur personnalisé pour GSP
+#[derive(Debug)]
+#[allow(dead_code)]
+pub enum GspError {
+    /// Erreur lors de la récupération du texte
+    TextRetrieval(String),
+    /// Erreur d'entrée/sortie
+    Io(io::Error),
+    /// Erreur de traduction
+    Translation(String),
+    /// Erreur TTS (Text-To-Speech)
+    Tts(String),
+    /// Erreur de processus
+    Process(String),
+    /// Erreur de fichier
+    File(String),
+    /// Erreur de configuration
+    Config(String),
+}
+
+impl fmt::Display for GspError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            GspError::TextRetrieval(msg) => write!(f, "Erreur de récupération de texte: {}", msg),
+            GspError::Io(err) => write!(f, "Erreur I/O: {}", err),
+            GspError::Translation(msg) => write!(f, "Erreur de traduction: {}", msg),
+            GspError::Tts(msg) => write!(f, "Erreur TTS: {}", msg),
+            GspError::Process(msg) => write!(f, "Erreur de processus: {}", msg),
+            GspError::File(msg) => write!(f, "Erreur de fichier: {}", msg),
+            GspError::Config(msg) => write!(f, "Erreur de configuration: {}", msg),
+        }
+    }
+}
+
+impl std::error::Error for GspError {}
+
+impl From<io::Error> for GspError {
+    fn from(err: io::Error) -> Self {
+        GspError::Io(err)
+    }
+}
+
+/// Alias de Result utilisant GspError
+pub type GspResult<T> = Result<T, GspError>;

src/input/clipboard.rs

@@ -1,12 +1,29 @@
+//! Module de lecture du presse-papiers
+//!
+//! Implémentation du trait InputEngine pour le presse-papiers.
+
 use super::InputEngine;
 use cli_clipboard::{ClipboardContext, ClipboardProvider};
 
+/// Lecteur du presse-papiers
 pub struct Clipboard {}
 
 impl InputEngine for Clipboard {
     fn input(&self) -> String {
-        let mut ctx: ClipboardContext = ClipboardProvider::new().unwrap();
+        let mut ctx: ClipboardContext = match ClipboardProvider::new() {
+            Ok(ctx) => ctx,
+            Err(e) => {
+                eprintln!("Erreur lors de l'accès au presse-papiers: {}", e);
+                return String::new();
+            }
+        };
 
-        ctx.get_contents().unwrap()
+        match ctx.get_contents() {
+            Ok(contents) => contents,
+            Err(e) => {
+                eprintln!("Erreur lors de la lecture du presse-papiers: {}", e);
+                String::new()
+            }
+        }
     }
 }

src/input/ocr/cuneiform.rs

@@ -1,26 +1,57 @@
+//! Module de reconnaissance OCR avec Cuneiform
+//!
+//! Interface pour l'outil de reconnaissance Cuneiform.
+
 use std::process::Command;
 
-// cuneiform -l fra /tmp/screenshot.png
+/// Exécute Cuneiform OCR sur une image
+///
+/// # Arguments
+/// * `screenshooter` - Chemin vers le fichier image
+/// * `lang` - Code de langue
+///
+/// # Retour
+/// Le texte reconnu, ou une chaîne vide en cas d'erreur
 pub fn cuneiform(screenshooter: &str, lang: &str) -> String {
-    let screenshot = "/dev/shm/screenshot.txt";
+    let screenshot_output = "/dev/shm/screenshot.txt";
 
-    let mut child = Command::new("cuneiform")
+    let mut child = match Command::new("cuneiform")
         .arg("-l")
         .arg(lang)
         .arg("-o")
-        .arg(screenshot)
+        .arg(screenshot_output)
         .arg(screenshooter)
         .spawn()
-        .expect("failed to execute process");
-    child.wait().expect("failed to wait on child");
+    {
+        Ok(child) => child,
+        Err(e) => {
+            eprintln!("Erreur lors de l'exécution de Cuneiform: {}", e);
+            return String::new();
+        }
+    };
+
+    if let Err(e) = child.wait() {
+        eprintln!("Erreur lors de l'attente de Cuneiform: {}", e);
+        return String::new();
+    }
 
-    let output = std::fs::read_to_string(screenshot)
-        .unwrap()
-        .trim()
-        .to_string()
-        .replace(['\n', '\r'], " ");
+    match std::fs::read_to_string(screenshot_output) {
+        Ok(content) => {
+            let output = content.trim().to_string().replace(['\n', '\r'], " ");
 
-    std::fs::remove_file(screenshot).unwrap();
+            // Nettoyage du fichier temporaire
+            if let Err(e) = std::fs::remove_file(screenshot_output) {
+                eprintln!(
+                    "Avertissement: impossible de supprimer le fichier temporaire: {}",
+                    e
+                );
+            }
 
-    output
+            output
+        }
+        Err(e) => {
+            eprintln!("Erreur lors de la lecture du résultat Cuneiform: {}", e);
+            String::new()
+        }
+    }
 }

src/input/ocr/mod.rs

@@ -1,3 +1,7 @@
+//! Module de reconnaissance optique de caractères (OCR)
+//!
+//! Fournit une interface unifiée pour les différents moteurs OCR.
+
 mod cuneiform;
 mod screenshot;
 mod tesseract;
@@ -6,6 +10,7 @@ use self::{cuneiform::cuneiform, tesseract::tesseract};
 use super::InputEngine;
 use which::which;
 
+/// Configuration pour la reconnaissance OCR
 pub struct Ocr {
     pub lang: String,
 }
@@ -20,10 +25,16 @@ impl InputEngine for Ocr {
         } else if which("cuneiform").is_ok() {
             input = cuneiform(&screenshooter, &self.lang);
         } else {
-            println!("Aucun outil de reconnaissance d'écriture n'est installé");
+            eprintln!("Aucun outil de reconnaissance d'écriture n'est installé");
         }
 
-        std::fs::remove_file(screenshooter).unwrap();
+        // Nettoyage du fichier temporaire avec gestion d'erreur
+        if let Err(e) = std::fs::remove_file(&screenshooter) {
+            eprintln!(
+                "Avertissement: impossible de supprimer le fichier temporaire: {}",
+                e
+            );
+        }
 
         input
     }

src/input/ocr/screenshot/gnome_screenshot.rs

@@ -1,11 +1,24 @@
+//! Module de capture d'écran avec gnome-screenshot
+//!
+//! Interface pour l'outil de capture gnome-screenshot.
+
 use std::process::{Command, Stdio};
 
-// gnome-screenshot --area --file=/tmp/screenshot.png
+/// Capture une zone de l'écran avec gnome-screenshot
+///
+/// # Arguments
+/// * `screenshooter` - Chemin où sauvegarder la capture
 pub fn gnome_screenshot_area(screenshooter: &str) {
-    Command::new("gnome-screenshot")
+    let result = Command::new("gnome-screenshot")
         .arg("--area")
         .arg(format!("--file={}", screenshooter))
         .stdout(Stdio::piped())
-        .output()
-        .expect("failed to execute process");
+        .output();
+
+    if let Err(e) = result {
+        eprintln!(
+            "Erreur lors de la capture d'écran (gnome-screenshot): {}",
+            e
+        );
+    }
 }

src/input/ocr/screenshot/mod.rs

@@ -1,27 +1,40 @@
+//! Module de capture d'écran pour l'OCR
+//!
+//! Fournit une interface unifiée pour les différents outils de capture.
+
 mod gnome_screenshot;
 mod xfce4_screenshooter;
 
 use self::xfce4_screenshooter::xfce4_screenshooter_region;
 use which::which;
 
+/// Capture d'écran pour l'OCR
 pub struct Screenshot {
     pub path: String,
 }
 
+impl Default for Screenshot {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl Screenshot {
+    /// Crée une nouvelle configuration de capture d'écran
     pub fn new() -> Self {
         Screenshot {
             path: "/dev/shm/screenshot.png".to_string(),
         }
     }
 
+    /// Capture une région de l'écran et retourne le chemin du fichier
     pub fn capture(&self) -> String {
         if which("xfce4-screenshooter").is_ok() {
             xfce4_screenshooter_region(&self.path);
         } else if which("gnome-screenshot").is_ok() {
             gnome_screenshot::gnome_screenshot_area(&self.path);
         } else {
-            panic!("No screenshot tool found");
+            eprintln!("Aucun outil de capture d'écran trouvé");
         }
 
         self.path.clone()

src/input/ocr/screenshot/xfce4_screenshooter.rs

@@ -1,13 +1,25 @@
+//! Module de capture d'écran avec xfce4-screenshooter
+//!
+//! Interface pour l'outil de capture xfce4-screenshooter.
+
 use std::process::{Command, Stdio};
 
-// Take a screenshot of a region of the screen
-// xfce4-screenshooter --region --save /tmp/screenshot.png
+/// Capture une région de l'écran avec xfce4-screenshooter
+///
+/// # Arguments
+/// * `screenshooter` - Chemin où sauvegarder la capture
 pub fn xfce4_screenshooter_region(screenshooter: &str) {
-    Command::new("xfce4-screenshooter")
+    let result = Command::new("xfce4-screenshooter")
         .arg("--region")
         .arg("--save")
         .arg(screenshooter)
         .stdout(Stdio::piped())
-        .output()
-        .expect("failed to execute process");
+        .output();
+
+    if let Err(e) = result {
+        eprintln!(
+            "Erreur lors de la capture d'écran (xfce4-screenshooter): {}",
+            e
+        );
+    }
 }

src/input/ocr/tesseract.rs

@@ -1,6 +1,17 @@
+//! Module de reconnaissance OCR avec Tesseract
+//!
+//! Interface pour l'outil de reconnaissance Tesseract.
+
 use std::process::{Command, Stdio};
 
-// tesseract /tmp/screenshot.png -l fra stdout
+/// Exécute Tesseract OCR sur une image
+///
+/// # Arguments
+/// * `screenshooter` - Chemin vers le fichier image
+/// * `lang` - Code de langue (ex: "fr-FR", "en-US")
+///
+/// # Retour
+/// Le texte reconnu, ou une chaîne vide en cas d'erreur
 pub fn tesseract(screenshooter: &str, lang: &str) -> String {
     let lang = match lang {
         "de-DE" => "deu",
@@ -11,16 +22,18 @@ pub fn tesseract(screenshooter: &str, lang: &str) -> String {
         _ => "eng",
     };
 
-    let command = Command::new("tesseract")
+    match Command::new("tesseract")
         .arg(screenshooter)
         .arg("stdout")
         .arg("-l")
         .arg(lang)
         .stderr(Stdio::null())
         .output()
-        .expect("failed to execute process");
-
-    let stdout = String::from_utf8_lossy(&command.stdout);
-
-    stdout.to_string()
+    {
+        Ok(output) => String::from_utf8_lossy(&output.stdout).to_string(),
+        Err(e) => {
+            eprintln!("Erreur lors de l'exécution de Tesseract: {}", e);
+            String::new()
+        }
+    }
 }

src/input/selection.rs

@@ -1,22 +1,46 @@
+//! Module de lecture de la sélection X11
+//!
+//! Implémentation du trait InputEngine pour la sélection X11.
+
 use crate::input::InputEngine;
 use std::time::Duration;
 use x11_clipboard::Clipboard;
 
+/// Lecteur de la sélection X11
 pub struct Selection {}
 
 impl InputEngine for Selection {
     fn input(&self) -> String {
-        let clipboard = Clipboard::new().unwrap();
+        let clipboard = match Clipboard::new() {
+            Ok(cb) => cb,
+            Err(e) => {
+                eprintln!(
+                    "Erreur lors de l'initialisation du presse-papiers X11: {}",
+                    e
+                );
+                return String::new();
+            }
+        };
 
-        let selection = clipboard
-            .load(
-                clipboard.setter.atoms.primary,
-                clipboard.setter.atoms.utf8_string,
-                clipboard.setter.atoms.property,
-                Duration::from_secs(3),
-            )
-            .unwrap();
+        let selection = match clipboard.load(
+            clipboard.setter.atoms.primary,
+            clipboard.setter.atoms.utf8_string,
+            clipboard.setter.atoms.property,
+            Duration::from_secs(3),
+        ) {
+            Ok(s) => s,
+            Err(e) => {
+                eprintln!("Erreur lors de la lecture de la sélection X11: {}", e);
+                return String::new();
+            }
+        };
 
-        String::from_utf8(selection).unwrap()
+        match String::from_utf8(selection) {
+            Ok(s) => s,
+            Err(e) => {
+                eprintln!("Erreur lors de la conversion UTF-8: {}", e);
+                String::new()
+            }
+        }
     }
 }