Struct SpellChecker

pub struct SpellChecker { /* private fields */ }

Spell Checker

Checks the spelling of a line.

Example

use ispell::SpellLauncher;
let mut checker = SpellLauncher::new().launch().unwrap();
let errors = checker.check("This should not contain any error").unwrap();
assert!(errors.is_empty());

Implementations

impl SpellChecker

pub fn add_word_to_dictionary(&mut self, word: &str) -> Result<()>

Adds a word to your personal dictionary

The word will be saved to your words file (e.g. ~/.ispell_LANG, ~/.hunspell_LANG, or ~/.aspell.LANG.pws), so it will be memorized next time you use i/a/hun/spell. If you only want to add the word to this current session, use add_word`.

Returns

An error if connection to ispell failed, or word contains multiple words (i.e., spaces).

Note that a successful return of this method doesn’t mean that the word was successfully added, as it is possible that it contains invalid character and ispell will reject it.

Examples

Adding a valid word

use ispell::SpellLauncher;

fn main() {
    let mut checker = SpellLauncher::new()
        .launch()
        .unwrap();
    
    // "rustacean" is not a valid word...
    // (unless you already ran this code example)
    let errors = checker.check("rustacean").unwrap();
    assert_eq!(errors.len(), 1);

    // let's add it to our personal dictionary
    checker.add_word_to_dictionary("rustacean").unwrap();

    // now it is a valid word
    let errors = checker.check("rustacean").unwrap();
    assert!(errors.is_empty());
}

Invalid word: contains spaces

    let mut checker = SpellLauncher::new()
        .launch()
        .unwrap();
    
    let res = checker.add_word_to_dictionary("multiple words");
    assert!(res.is_err());

pub fn add_word(&mut self, word: &str) -> Result<()>

Add a word to current session.

Similar to add_word_to_dictionary, except word won’t be memorized the next time you use i/a/hun/spell.

use ispell::SpellLauncher;

fn main() {
    let mut checker = SpellLauncher::new()
        .launch()
        .unwrap();
    
    // "rustaholic" is not a valid word...
    // (even if you already ran this code example)
    let errors = checker.check("rustaholic").unwrap();
    assert_eq!(errors.len(), 1);

    // let's add it to this session
    checker.add_word("rustaholic").unwrap();

    // now it is a valid word
    let errors = checker.check("rustaholic").unwrap();
    assert!(errors.is_empty());
}

Examples found in repository

examples/dict.rs (line 15)

fn main() {
    let mut checker = SpellLauncher::new()
        .launch()
        .unwrap();
    
    // "foobar" is not a valid word...
    let errors = checker.check("foobar").unwrap();
    println!("errors: {:?}", errors);
    assert_eq!(errors.len(), 1);
    
    // let's add it
    checker.add_word("foobar").unwrap();
    let errors = checker.check("foobar").unwrap();
    println!("errors: {:?}", errors);
    assert!(errors.is_empty());
}

pub fn check(&mut self, text: &str) -> Result<Vec<IspellError>>

Checks the spelling of a line.

This method only returns the errors that ispell detects. Since the position returned in those errors is the number of characters since the beginning of the line, this method needs to be called line by line and not on a full document.

Examples found in repository

examples/dict.rs (line 10)

fn main() {
    let mut checker = SpellLauncher::new()
        .launch()
        .unwrap();
    
    // "foobar" is not a valid word...
    let errors = checker.check("foobar").unwrap();
    println!("errors: {:?}", errors);
    assert_eq!(errors.len(), 1);
    
    // let's add it
    checker.add_word("foobar").unwrap();
    let errors = checker.check("foobar").unwrap();
    println!("errors: {:?}", errors);
    assert!(errors.is_empty());
}

examples/readme.rs (line 11)

fn main() {
    let mut checker = SpellLauncher::new()
        .aspell()
        .command("aspell")
        .dictionary("en")
        .launch()
        .unwrap();
    let errors = checker.check("A simpel test to to see if it detetcs typing errors").unwrap();
    for e in errors {
        println!("'{}' (pos: {}) is misspelled!", &e.misspelled, e.position);
        if !e.suggestions.is_empty() {
            println!("Maybe you meant '{}'?", &e.suggestions[0]);
        }
    }
}

examples/simple.rs (line 29)

fn main() {
    let checker = SpellLauncher::new()
        .dictionary("en_GB")
        .command("hunspell")
        .launch();
    match checker {
        Ok(mut checker) => {
            let res = checker.check("test of a msitake").unwrap();
            display(&res);
            let res = checker.check("test without mistake (?)").unwrap();
            display(&res);
            let res = checker.check("Another test wiht a mistake").unwrap();
            display(&res);
        },
        Err(err) => println!("Error: {}", err)
    }
}

pub fn check_raw(&mut self, text: &str) -> Result<Vec<IspellResult>>

Checks the spelling of a string

This method returns a vector of all ispell answers, even when there is no errors. Usually, the check method, which only returns errors, will be more useful.

Trait Implementations

impl Drop for SpellChecker

fn drop(&mut self)

Executes the destructor for this type.