Struct SpellLauncher

pub struct SpellLauncher { /* private fields */ }

Spell Launcher wizard (ah, ah). A builder for SpellChecker.

Runs ispell or one of its variant.

Examples

• Launches ispell with british dictionary:

use ispell::SpellLauncher;
let checker = SpellLauncher::new()
              .dictionary("british")
              .launch()
              .unwrap();

• Launches aspell with french (France) language:

use ispell::SpellLauncher;
let checker = SpellLauncher::new()
              .aspell()
              .dictionary("fr_FR")
              .launch()
              .unwrap();

Implementations

impl SpellLauncher

pub fn new() -> SpellLauncher

Creates a new spell checker with default options

Examples found in repository

examples/timeout.rs (line 5)

fn main() {
    let checker = SpellLauncher::new()
        .command("examples/sleep.sh")
        .timeout(5)
        .launch();
    assert!(checker.is_err());
    if let Err(err) = checker {
        println!("{}", err);
    }
}

examples/dict.rs (line 5)

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 5)

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 23)

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 aspell(&mut self) -> &mut SpellLauncher

Sets mode to aspell instead of ispell.

Will run aspell as the command if it is not set

Examples found in repository

examples/readme.rs (line 6)

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]);
        }
    }
}

pub fn hunspell(&mut self) -> &mut SpellLauncher

Sets compatibility mode to hunspell instead of ispell.

Will run hunspell as the command if it is not set

pub fn ispell(&mut self) -> &mut SpellLauncher

Sets compatibility mode to ispell

Will run ispell as the command if it is not set (default setting)

pub fn timeout(&mut self, timeout: u64) -> &mut SpellLauncher

Sets the timeout when checking ispell

If the spawned process takes longer than this timeout to answer to a query, it will be killed and an error will be returned, preventing your program from freezing indefinitely.

The timeout is set in milliseconds, and is 1000 (a second) by default.

Examples found in repository

examples/timeout.rs (line 7)

fn main() {
    let checker = SpellLauncher::new()
        .command("examples/sleep.sh")
        .timeout(5)
        .launch();
    assert!(checker.is_err());
    if let Err(err) = checker {
        println!("{}", err);
    }
}

pub fn command<S: Into<String>>(&mut self, command: S) -> &mut SpellLauncher

Set the name of the command to run

By default, it inferred from the mode (which is ispell by default).

Unless you want to run a specific (ispell-compatible) command, you shouldn’t use this method directly, but rather use the aspell or hunspell methods, since this also allow the the library to know which actual program is runned and to set encoding options accordingly.

Examples found in repository

examples/timeout.rs (line 6)

fn main() {
    let checker = SpellLauncher::new()
        .command("examples/sleep.sh")
        .timeout(5)
        .launch();
    assert!(checker.is_err());
    if let Err(err) = checker {
        println!("{}", err);
    }
}

examples/readme.rs (line 7)

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 25)

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 dictionary<S: Into<String>>(&mut self, lang: S) -> &mut SpellLauncher

Determine the dictionary that should be used.

Note that ispell, hunspell and aspell have different naming schemes:

• ispell accepts full names, e.g. “american”, “british”, “french”, …
• hunspell accepts unicode language codes, e.g. “fr_FR”, “en_GB”, …
• aspell accepts both.

Example

use ispell::SpellLauncher;
let checker = SpellLauncher::new()
              .aspell()
              .dictionary("en_GB")
              .launch()
              .unwrap();

Examples found in repository

examples/readme.rs (line 8)

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 24)

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 launch(&self) -> Result<SpellChecker>

Launch ispell (or aspell or hunspell) and return a SpellChecker

Examples found in repository

examples/timeout.rs (line 8)

fn main() {
    let checker = SpellLauncher::new()
        .command("examples/sleep.sh")
        .timeout(5)
        .launch();
    assert!(checker.is_err());
    if let Err(err) = checker {
        println!("{}", err);
    }
}

examples/dict.rs (line 6)

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 9)

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 26)

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)
    }
}

Trait Implementations

impl Debug for SpellLauncher

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.