owl_spell/

engine.rs

use crate::ignorefile;
use regex::Regex;
use serde::{Deserialize, Serialize};
use std::collections::HashSet;
use std::env;
use std::fs;
use std::path::{Path, PathBuf};
use std::vec::Vec;

#[derive(Deserialize, Debug, Serialize, Default)]
pub struct Config {
    #[serde(default = "default_lang")]
    pub lang: String,
    #[serde(default = "default_fts")]
    pub extensions: Vec<String>,
}

fn default_lang() -> String {
    "en".to_string()
}

fn default_fts() -> Vec<String> {
    vec!["md".to_string()]
}

#[derive(PartialEq)]
pub enum Status {
    Ignored,
    GlobalIgnored,
    Misspelled,
}

impl Status {
    pub fn as_str(&self) -> &'static str {
        match self {
            Status::Ignored => "ignored",
            Status::GlobalIgnored => "global_ignored",
            Status::Misspelled => "misspelled",
        }
    }
}

/// Result of a spell check
pub struct WordBad {
    pub word: String,
    pub file: String,
    #[allow(dead_code)] // for now
    pub line_num: usize,
}

// keep URLs intact & don't spell check them
const WORD_PATTERN: &str = r"https?://[^\s]+|\b[a-zA-Z]+(?:[''][a-zA-Z]+)*\b";

fn is_url(s: &str) -> bool {
    s.starts_with("http://") || s.starts_with("https://")
}

pub fn get_home_dir() -> PathBuf {
    let owl_dir = env::home_dir()
        .expect("no home directory?")
        .join(".config/owl");
    let dict_dir = owl_dir.join("dicts");
    // create ~/.config/owl/dicts/ and all parent dirs
    fs::create_dir_all(&dict_dir).expect("could not create home dir");

    owl_dir
}

fn load_config() -> Config {
    let path = get_home_dir().join("config.toml");
    let maybe_config = fs::read_to_string(path);

    match maybe_config {
        Ok(config_content) => toml::from_str(&config_content).unwrap_or_default(),
        _ => Config::default(),
    }
}

#[derive(Debug)]
pub struct Engine {
    dict: spellbook::Dictionary,               // star of the show
    pub extensions: Vec<String>,               // extensions to scan
    pub word_regex: Regex,                     // for splitting words
    pub local_ignore_file: PathBuf,            // .spellignore
    pub local_ignored_words: HashSet<String>,  //
    pub global_ignore_file: PathBuf,           // ~/.config/owl/owlignore
    pub global_ignored_words: HashSet<String>, //
}

impl Engine {
    /// Instantiate owl engine for checking words with ignores.
    ///
    /// ## Panics
    #[must_use]
    pub fn new(path: &Path) -> Engine {
        const DICT_MSG: &str = "\nRun with `--init en` to download a dictionary.";
        let home_dir = get_home_dir();

        let local_ignore_file = ignorefile::get_ignorefile(path);
        let local_ignored_words = ignorefile::load_words(&local_ignore_file);
        let global_ignore_file = home_dir.join("spellignore").clone();
        let global_ignored_words = ignorefile::load_words(&global_ignore_file);

        let dict_dir = home_dir.join("dicts");

        let cfg = load_config();

        let aff_path = dict_dir.join(format!("{}.aff", cfg.lang));
        let aff = std::fs::read_to_string(&aff_path);
        let dic_path = dict_dir.join(format!("{}.dic", cfg.lang));
        let dic = std::fs::read_to_string(&dic_path);
        let dict = match (aff, dic) {
            (Err(err), _) => {
                panic!("Could not load {}: {err}\n{DICT_MSG}", aff_path.display());
            }
            (_, Err(err)) => {
                panic!("Could not load {}: {err}\n{DICT_MSG}", dic_path.display());
            }
            (Ok(aff_txt), Ok(dic_txt)) => match spellbook::Dictionary::new(&aff_txt, &dic_txt) {
                Ok(dict) => dict,
                Err(err) => {
                    panic!(
                        "Could not load dictionary {} {}: {err}\n{DICT_MSG}",
                        aff_path.display(),
                        dic_path.display()
                    );
                }
            },
        };

        Self {
            word_regex: Regex::new(WORD_PATTERN).expect("Invalid hard-coded regex!"),
            extensions: cfg.extensions,
            dict,
            global_ignore_file,
            global_ignored_words,
            local_ignore_file,
            local_ignored_words,
        }
    }

    /// Run spellcheck on file, returning `WordBad` per match.
    ///
    /// Return values are not deduped yet.
    ///
    /// ## Panics
    ///
    ///   - no dictionary
    #[must_use]
    pub fn get_misspelled(&self, path: &str) -> Vec<WordBad> {
        let content = fs::read_to_string(path).expect("Cannot read file");
        let lines: Vec<_> = content
            .lines()
            .map(std::string::ToString::to_string)
            .collect();
        self.get_misspelled_from_lines(&lines, path)
    }

    pub fn get_misspelled_from_lines(&self, lines: &[String], filename: &str) -> Vec<WordBad> {
        let mut bad = vec![];
        for (line_num, line) in lines.iter().enumerate() {
            for word in self.word_regex.find_iter(line) {
                if !is_url(word.as_str()) && !self.dict.check(word.as_str()) {
                    bad.push(WordBad {
                        word: word.as_str().to_string(),
                        line_num,
                        file: filename.to_string(),
                    });
                }
            }
        }
        bad
    }

    /// Check if a word is ignored.
    ///
    #[must_use]
    pub fn get_ignore_status(&self, word: &str) -> Status {
        if self.local_ignored_words.contains(word) {
            Status::Ignored
        } else if self.global_ignored_words.contains(word) {
            Status::GlobalIgnored
        } else {
            Status::Misspelled
        }
    }

    /// Make suggestions using underlying library.
    ///
    /// TODO: incorporate ignores?
    pub fn suggest(&self, word: &str, suggestions: &mut Vec<String>) {
        self.dict.suggest(word, suggestions);
    }

    #[must_use]
    pub fn check(&self, word: &str) -> bool {
        self.dict.check(word)
    }
}