Can set options to spellcheck

src/lib.rs

@@ -1,6 +1,197 @@
 use std::collections::HashMap;
 use std::error::Error;
 
+/// Spell check options
+#[derive(Hash, Debug, Eq, PartialEq)]
+pub enum GramOpt {
+    /// Signes typographiques
+    SignesTypographiques,
+    /// Apostrophes typographiques
+    ///
+    /// Correction des apostrophes droites. Automatisme possible dans le menu Outils > Options d’autocorrection > Options linguistiques > Guillemets simples > Remplacer (à cocher)
+    ApostropheTypographique,
+    /// Ecriture épicène
+    ///
+    /// Normalisation de l’écriture épicène avec points médians.
+    EcritureEpicene,
+    /// Espaces surnuméraires
+    ///
+    /// Signale les espaces inutiles entre les mots, en début et en fin de ligne.
+    EspacesSurnumeraires,
+    /// Tabulations surnuméraires
+    ///
+    /// Signale les tabulations inutiles en début et en fin de ligne.
+    TabulationsSurnumeraires,
+    /// Espaces insécables
+    ///
+    /// Vérifie les espaces insécables avec les ponctuations « ! ? : ; » (à désactiver si vous utilisez une police Graphite)
+    EspacesInsecables,
+    /// Majuscules
+    ///
+    /// Vérifie l’utilisation des majuscules et des minuscules (par exemple, « la raison d’État », « les Européens »).
+    Majuscules,
+    /// Majuscules pour ministères
+    ///
+    /// Majuscules pour les intitulés des ministères.
+    MajusuculesMinisteres,
+    /// Virgules
+    ///
+    /// Vérifie s’il manque une ponctuation finale au paragraphe (seulement pour les paragraphes constitués de plusieurs phrases).
+    Virgules,
+    /// Ponctuation finale [!]
+    ///
+    /// Vérifie s’il manque une ponctuation finale au paragraphe (seulement pour les paragraphes constitués de plusieurs phrases).
+    PonctuationFinale,
+    /// Traits d’union et soudures
+    ///
+    /// Cherche les traits d’union manquants ou inutiles.
+    TraitsUnionEtSoudures,
+    /// Nombres
+    ///
+    /// Espaces insécables avant unités de mesure
+    Nombres,
+    /// Espaces insécables avant unités de mesure
+    EspaceInsecableAvantUniteDeMesure,
+    /// Normes françaises
+    NormesFrancaises,
+    /// Signaler ligatures typographiques
+    ///
+    /// Ligatures de fi, fl, ff, ffi, ffl, ft, st.
+    LigaturesTypographiques,
+    /// Apostrophe manquante après lettres isolées [!]
+    ///
+    /// Apostrophe manquante après les lettres l d s n c j m t ç. Cette option sert surtout à repérer les défauts de numérisation des textes et est déconseillée pour les textes scientifiques.
+    ApostropheManquanteApresLettreIsolee,
+    /// Chimie
+    ///
+    /// Typographie des composés chimiques (H₂O, CO₂, etc.).
+    Chimie,
+    /// Erreurs de numérisation (OCR)
+    ///
+    /// Erreurs de reconnaissance optique des caractères. Beaucoup de faux positifs.
+    ErreurNumerisation,
+    /// Noms et adjectifs
+    Gramm,
+    /// Confusions et faux-amis
+    ///
+    /// Cherche des erreurs souvent dues à l’homonymie (par exemple, les confusions entre « faîte » et « faite »).
+    ConfusionFauxAmis,
+    /// Locutions
+    ///
+    /// Écriture des locutions usuelles.
+    Locutions,
+    /// Accords (genre et nombre)
+    ///
+    /// Accords des noms et des adjectifs.
+    AccordsGenreEtNombre,
+    /// Verbes
+    Verbes,
+    /// Conjugaisons
+    ///
+    /// Accord des verbes avec leur sujet.
+    Conjugaisons,
+    /// Infinitif
+    ///
+    /// Confusion entre l’infinitif et d’autres formes.
+    Infinitif,
+    /// Impératif
+    ///
+    /// Vérifie notamment la deuxième personne du singulier (par exemple, les erreurs : « vas… », « prend… », « manges… »).
+    Imperatif,
+    /// Interrogatif
+    ///
+    /// Vérifie les formes interrogatives et suggère de lier les pronoms personnels avec les verbes.
+    Interrogatif,
+    /// Participes passés, adjectifs
+    ParticipePassesEtAdjectifs,
+    /// Modes verbaux
+    ModesVerbaux,
+    /// Style
+    Style,
+    /// Populaire
+    ///
+    /// Souligne un langage courant considéré comme erroné, comme « malgré que ».
+    Populaire,
+    /// Pléonasmes
+    ///
+    /// Repère des redondances sémantiques, comme « au jour d’aujourd’hui », « monter en haut », etc.
+    Pleonasmes,
+    /// Élisions et euphonies
+    ///
+    /// Signale les élisions incorrectes et les tournures dysphoniques.
+    ElisisonsEtEuphonies,
+    /// Adverge de négation [!}
+    ///
+    /// Ne … pas, ne … jamais, etc.
+    AdverbesNegation,
+    /// Répétitions dans le paragraphe [!]
+    ///
+    /// Sont exclus les mots grammaticaux, ceux commençant par une majuscule, ainsi que “être” et “avoir”.
+    RepetitionsDansParagraphe,
+    /// Répétitions dans la phrase [!]
+    ///
+    /// Sont exclus les mots grammaticaux, ainsi que “être” et “avoir”.
+    RepetitionDansPhrase,
+    /// Divers
+    Misc,
+    /// Mots composés [!]
+    MotsComposes,
+    /// Validation des dates
+    Date,
+    /// Debugagge
+    Debug,
+    /// Affiche l’identifiant de la règle de contrôle dans les messages d’erreur.
+    IdControlRule,
+}
+
+impl GramOpt {
+    pub fn id(&self) -> &'static str {
+        match self {
+            GramOpt::SignesTypographiques => "typo",
+            GramOpt::ApostropheTypographique => "apos",
+            GramOpt::EcritureEpicene => "eepi",
+            GramOpt::EspacesSurnumeraires => "esp",
+            GramOpt::TabulationsSurnumeraires => "tab",
+            GramOpt::EspacesInsecables => "nbsp",
+            GramOpt::Majuscules => "maj",
+            GramOpt::MajusuculesMinisteres => "minis",
+            GramOpt::Virgules => "virg",
+            GramOpt::PonctuationFinale => "poncfin",
+            GramOpt::TraitsUnionEtSoudures => "tu",
+            GramOpt::Nombres => "num",
+            GramOpt::EspaceInsecableAvantUniteDeMesure => "unit",
+            GramOpt::NormesFrancaises => "nf",
+            GramOpt::LigaturesTypographiques => "liga",
+            GramOpt::ApostropheManquanteApresLettreIsolee => "mapos",
+            GramOpt::Chimie => "chim",
+            GramOpt::ErreurNumerisation => "ocr",
+            GramOpt::Gramm => "gramm",
+            GramOpt::ConfusionFauxAmis => "conf",
+            GramOpt::Locutions => "loc",
+            GramOpt::AccordsGenreEtNombre => "gn",
+            GramOpt::Verbes => "verbs",
+            GramOpt::Conjugaisons => "conj",
+            GramOpt::Infinitif => "infi",
+            GramOpt::Imperatif => "imp",
+            GramOpt::Interrogatif => "inte",
+            GramOpt::ParticipePassesEtAdjectifs => "ppas",
+            GramOpt::ModesVerbaux => "vmode",
+            GramOpt::Style => "style",
+            GramOpt::Populaire => "bs",
+            GramOpt::Pleonasmes => "pleo",
+            GramOpt::ElisisonsEtEuphonies => "eleu",
+            GramOpt::AdverbesNegation => "neg",
+            GramOpt::RepetitionsDansParagraphe => "redon1",
+            GramOpt::RepetitionDansPhrase => "redon2",
+            GramOpt::Misc => "misc",
+            GramOpt::MotsComposes => "mc",
+            GramOpt::Date => "date",
+            GramOpt::Debug => "debug",
+            GramOpt::IdControlRule => "idrule",
+        }
+    }
+}
+
 /// Check spelling result
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct CheckResult {
@@ -84,11 +275,27 @@ impl GrammalecteClient {
 
     /// Run spell check on text
     pub async fn spell_check(&self, text: &str) -> Result<CheckResult, Box<dyn Error>> {
+        self.spell_check_with_options(text, HashMap::new()).await
+    }
+
+    /// Run spell check with custom options
+    pub async fn spell_check_with_options(
+        &self,
+        text: &str,
+        options: HashMap<GramOpt, bool>,
+    ) -> Result<CheckResult, Box<dyn Error>> {
         let url = format!("{}/gc_text/fr", self.base_url);
         log::debug!("Will use URL {} for spell check", url);
 
+        let options = options
+            .into_iter()
+            .map(|t| (t.0.id(), t.1))
+            .collect::<HashMap<_, _>>();
+        let options = serde_json::to_string(&options)?;
+
         let mut params = HashMap::new();
         params.insert("text", text);
+        params.insert("options", &options);
 
         let result = reqwest::Client::new()
             .post(url)
@@ -121,7 +328,8 @@ impl GrammalecteClient {
 
 #[cfg(test)]
 mod test {
-    use crate::GrammalecteClient;
+    use crate::{GramOpt, GrammalecteClient};
+    use std::collections::HashMap;
 
     #[tokio::test]
     async fn simple_correction() {
@@ -132,6 +340,21 @@ mod test {
         println!("RESULT = {:#?}", res);
     }
 
+    #[tokio::test]
+    async fn customize_options() {
+        let _ = env_logger::builder().is_test(true).try_init();
+
+        let msg = "Bonjour !";
+        let mut opts = HashMap::new();
+        opts.insert(GramOpt::EspacesInsecables, false);
+        let res = GrammalecteClient::default()
+            .spell_check_with_options(msg, opts)
+            .await
+            .unwrap();
+        println!("RESULT = {:#?}", res);
+        assert!(res.paragraphs.is_empty());
+    }
+
     #[tokio::test]
     async fn simple_suggestion() {
         let _ = env_logger::builder().is_test(true).try_init();