Struct WordFilterGenerator

Source

pub struct WordFilterGenerator { /* private fields */ }

Expand description

Code generator for WordFilters, following the builder pattern.

Generates code that can be compiled to a WordFilter. Filtered words, ignored exceptions, allowed separators, and character aliases may all be provided through the associated methods.

§Example

use word_filter_codegen::{Visibility, WordFilterGenerator};

let generated_code = WordFilterGenerator::new()
    .visibility(Visibility::Pub)
    .word("foo")
    .exception("foobar")
    .separator(' ')
    .alias('f', 'F')
    .generate("FILTER");

The generated code can then be written to a file in the OUT_DIR. See crate-level documentation for more details.

Implementations§

Source §

impl WordFilterGenerator

Source

pub fn new() -> Self

Creates a new WordFilterGenerator.

This is equivalent to WordFilterGenerator::default().

§Example

use word_filter_codegen::WordFilterGenerator;

let generator = WordFilterGenerator::new();

Source

pub fn word<S>(&mut self, word: S) -> &mut Self
where S: ToString,

Add a single word.

§Example

use word_filter_codegen::WordFilterGenerator;

let mut generator = WordFilterGenerator::new();
generator.word("foo");

Source

pub fn words<I, S>(&mut self, words: I) -> &mut Self
where I: IntoIterator<Item = S>, S: ToString,

Add words.

§Example

use word_filter_codegen::WordFilterGenerator;

let mut generator = WordFilterGenerator::new();
generator.words(&["foo", "bar"]);

Source

pub fn exception<S>(&mut self, exception: S) -> &mut Self
where S: ToString,

Add a single exception.

§Example

use word_filter_codegen::WordFilterGenerator;

let mut generator = WordFilterGenerator::new();
generator.exception("foo");

Source

pub fn exceptions<I, S>(&mut self, exceptions: I) -> &mut Self
where I: IntoIterator<Item = S>, S: ToString,

Add exceptions.

§Example

use word_filter_codegen::WordFilterGenerator;

let mut generator = WordFilterGenerator::new();
generator.exceptions(&["foo", "bar"]);

Source

pub fn separator<S>(&mut self, separator: S) -> &mut Self
where S: ToString,

Add a single separator.

§Example

use word_filter_codegen::WordFilterGenerator;

let mut generator = WordFilterGenerator::new();
generator.separator("foo");

Source

pub fn separators<I, S>(&mut self, separators: I) -> &mut Self
where I: IntoIterator<Item = S>, S: ToString,

Add separators.

§Example

use word_filter_codegen::WordFilterGenerator;

let mut generator = WordFilterGenerator::new();
generator.separators(&["foo", "bar"]);

Source

pub fn alias<S, T>(&mut self, source: S, alias: T) -> &mut Self
where S: ToString, T: ToString,

Add a single alias.

§Example

use word_filter_codegen::WordFilterGenerator;

let mut generator = WordFilterGenerator::new();
generator.alias("foo", "bar");

Source

pub fn aliases<'a, I, S, T>(&mut self, aliases: I) -> &mut Self
where I: IntoIterator<Item = &'a (S, T)>, S: ToString + 'a, T: ToString + 'a,

Add aliases.

§Example

use word_filter_codegen::WordFilterGenerator;

let mut generator = WordFilterGenerator::new();
generator.aliases(&[("foo", "bar"), ("baz", "qux")]);

Source

pub fn visibility(&mut self, visibility: Visibility) -> &mut Self

Set visibility of the generated code.

§Example

use word_filter_codegen::{Visibility, WordFilterGenerator};

let mut generator = WordFilterGenerator::new();
generator.visibility(Visibility::Pub);

Source

pub fn separator_flags(&mut self, separator_flags: SeparatorFlags) -> &mut Self

Source

pub fn doc<S>(&mut self, doc: S) -> &mut Self
where S: ToString,

Set the doc string of the generated code.

The generated code will be generated with doc as the item-level doc-string.

§Example

use word_filter_codegen::WordFilterGenerator;

let mut generator = WordFilterGenerator::new();
generator.doc("foo");

§Multiple Lines

For doc strings that contain multiple lines, users are advised to use the indoc crate.

use word_filter_codegen::WordFilterGenerator;
use indoc::indoc;

let mut generator = WordFilterGenerator::new();
generator.doc(indoc!(
   "foo

    bar baz quux"
));

Source

pub fn generate(&self, identifier: &str) -> String

Generate code defining a WordFilter with the given words, exceptions, separators, aliases, and visibility.

The generated code is most often written to a file at compile time within a build.rs script. An example build.rs is as follows:

use std::{
    env,
    fs::File,
    io::{BufWriter, Write},
    path::Path,
};
use word_filter_codegen::{Visibility, WordFilterGenerator};

fn main() {
    let path = Path::new(&env::var("OUT_DIR").unwrap()).join("codegen.rs");
    let mut file = BufWriter::new(File::create(&path).unwrap());

    writeln!(
        &mut file,
        "{}",
        WordFilterGenerator::new()
            .visibility(Visibility::Pub)
            .word("foo")
            .generate("FILTER")
        );
}