Struct Configuration

pub struct Configuration { /* private fields */ }

Configuration for the parser.

A configuration to correctly parse a real wiki can be created with Configuration::new. A configuration for testing and quick and dirty prototyping can be created with Default::default.

Implementations

impl Configuration

pub fn new(source: &ConfigurationSource<'_>) -> Self

Allocates and returns a new configuration based on the given site specific configuration.

pub fn parse<'a>(&self, wiki_text: &'a str) -> Output<'a>

Parses wiki text into structured data.

Examples found in repository

examples/test/main.rs (line 26)

fn main() {
    let mut args = std::env::args();
    match args.nth(1) {
        None => return test::run_test(&Default::default()),
        Some(command) => match &command as _ {
            "file" => {
                if let Some(path) = args.next() {
                    if args.next().is_none() {
                        match std::fs::read_to_string(path) {
                            Err(error) => {
                                eprintln!("Failed to read file: {}", error);
                                std::process::exit(1);
                            }
                            Ok(file_contents) => {
                                println!(
                                    "{:#?}",
                                    parse_wiki_text::Configuration::default().parse(&file_contents)
                                );
                                return;
                            }
                        }
                    }
                }
            }
            "text" => {
                if let Some(wiki_text) = args.next() {
                    if args.next().is_none() {
                        println!(
                            "{:#?}",
                            parse_wiki_text::Configuration::default()
                                .parse(&wiki_text.replace("\\t", "\t").replace("\\n", "\n"))
                        );
                        return;
                    }
                }
            }
            _ => {}
        },
    }
    eprintln!("invalid use");
    std::process::exit(1);
}

examples/test/test.rs (line 50)

pub fn run_test(configuration: &parse_wiki_text::Configuration) {
    let mut output = concat!(
        "<title>Parse Wiki Text test cases</title>",
        "<style>",
        "a{color:#006064;display:block;padding:8;text-decoration:none}",
        "a:hover{background:#eee}",
        "body{background:#f7f7f7;display:flex;font-family:sans-serif;height:100%;margin:0}",
        "div div{background:#fff;box-shadow: 0 1px 3px rgba(0,0,0,.12),0 1px 2px rgba(0,0,0,.24);margin:16;padding:16}",
        "h1{font-size:20;margin:24 16 16}",
        "hr{border:0;border-top:1px solid #ccc}",
        "pre{margin:0}",
        "span{color:#aaa}",
        "</style>",
        "<div style=\"background:#fff;box-shadow: 0 1px 3px rgba(0,0,0,.12),0 1px 2px rgba(0,0,0,.24);flex:0 1 220px;overflow:auto\">"
    ).to_owned();
    if let Some(window) = TEST_CASES
        .windows(2)
        .find(|window| window[0].0 >= window[1].0)
    {
        panic!("Sort: {:#?}", (window[0].0, window[1].0));
    }
    for (title, test_cases) in TEST_CASES {
        if let Some(window) = test_cases.windows(2).find(|window| window[0] >= window[1]) {
            panic!("Sort: {:#?}", window);
        }
        output += &format!("<a href=#{}>", title.replace(" ", "_"));
        output += title;
        output += &format!(" <span>{}</span></a>", test_cases.len());
    }
    output += "</div><div style=\"flex:1 1 200px;overflow:auto\">";
    for (title, test_cases) in TEST_CASES {
        output += &format!("<h1 id={}>", title.replace(" ", "_"));
        output += title;
        output += "</h1>";
        for wiki_text in *test_cases {
            output += "<div><pre>";
            output += &wiki_text
                .replace("&", "&amp;")
                .replace("<", "&lt;")
                .replace("\t", "<span>⭾</span>")
                .replace("\n", "<span>⏎</span>\n")
                .replace(" ", "<span>·</span>")
                .replace("</span><span>", "");
            match std::panic::catch_unwind(|| configuration.parse(wiki_text)) {
                Err(_) => {
                    eprintln!("Panic with wiki text {:?}", wiki_text);
                    output += "</pre><hr>panic</div>";
                }
                Ok(result) => {
                    output += "</pre><hr><pre>";
                    output += &format!("{:#?}", result)
                        .replace("&", "&amp;")
                        .replace("<", "&lt;");
                    output += "</pre></div>";
                }
            }
        }
    }
    output += "</div>";
    if let Err(error) = std::fs::write("report.html", output) {
        eprintln!("Failed to write report: {}", error);
        std::process::exit(1);
    }
}

Trait Implementations

impl Default for Configuration

fn default() -> Self

Allocates and returns a configuration suitable for testing and quick and dirty prototyping. For correctly parsing an actual wiki, please get the correct site configuration for that particular wiki.