path: root/src/wikitext.rs

use crate::directive::Directive;
use crate::error::SiteError;
use crate::page::PageMeta;
use crate::site::Site;
use log::trace;
use regex::Regex;
use std::collections::HashMap;
use std::convert::TryFrom;
use std::path::Path;

#[derive(Debug)]
pub struct WikitextParser {
    // Text without open bracket: can't be a link or a directive.
    no_bracket: Regex,

    // An open bracket.
    bracket: Regex,

    // A wikilink that is just a bare page name.
    wikilink_bare: Regex,

    // A wikilink that has link text separately from target.
    wikilink_complex: Regex,

    // A directive without arguments.
    directive_no_args: Regex,

    // A directive with arguments.
    directive_args: Regex,

    // A plain argument without a value.
    plain: Regex,
    // An argument with an unquoted value.
    simple: Regex,
    // An argument with a quoted value.
    quoted: Regex,
    // An argument with a triple-quoted value.
    multiline: Regex,
}

impl WikitextParser {
    pub fn parse<'a>(&self, text: &'a str) -> Result<(Snippet, &'a str), SiteError> {
        let patterns = vec![
            &self.directive_args,
            &self.directive_no_args,
            &self.wikilink_bare,
            &self.wikilink_complex,
            &self.no_bracket,
            &self.bracket,
        ];
        for pat in patterns {
            if let Some(m) = pat.find(text) {
                if m.start() > 0 {
                    continue;
                }
                trace!("WikitextParser: m={:?}", m);
                let t = m.as_str();
                let c = pat.captures(t).unwrap();
                let token = if pat.as_str() == self.directive_args.as_str() {
                    let name = c.name("name").unwrap().as_str();
                    let args = c.name("args").unwrap().as_str();
                    let args = self.parse_args(args);
                    let d = ParsedDirective::new(name, args)?;
                    trace!("WikitextParser: directive={:?}", d);
                    let d = Directive::try_from(d)?;
                    Snippet::Directive(d)
                } else if pat.as_str() == self.directive_no_args.as_str() {
                    let name = c.name("name").unwrap().as_str();
                    let args = self.parse_args("");
                    let d = ParsedDirective::new(name, args)?;
                    trace!("WikitextParser: directive={:?}", d);
                    let d = Directive::try_from(d)?;
                    Snippet::Directive(d)
                } else if pat.as_str() == self.wikilink_bare.as_str() {
                    let s = c.name("linktext").unwrap().as_str();
                    let link = WikiLink::new(s, s);
                    Snippet::WikiLink(link)
                } else if pat.as_str() == self.wikilink_complex.as_str() {
                    let link_text = c.name("linktext").unwrap().as_str();
                    let target = c.name("target").unwrap().as_str();
                    let link = WikiLink::new(link_text, target);
                    Snippet::WikiLink(link)
                } else if pat.as_str() == self.no_bracket.as_str()
                    || pat.as_str() == self.bracket.as_str()
                {
                    Snippet::Markdown(m.as_str().into())
                } else {
                    unreachable!("need to handle pattern: {}", pat.as_str());
                };
                let rest = text.get(m.end()..).unwrap();
                trace!("WikitextParser: token={:?}", token);
                return Ok((token, rest));
            }
        }
        Ok((Snippet::Markdown(text.into()), ""))
    }

    fn parse_args(&self, mut args: &str) -> HashMap<String, String> {
        let mut map = HashMap::new();
        let patterns = vec![&self.multiline, &self.quoted, &self.simple, &self.plain];
        loop {
            args = args.trim_start();
            if args.is_empty() {
                break;
            }
            let mut matched = false;
            for pat in patterns.iter() {
                if let Some(m) = pat.find(args) {
                    if m.start() > 0 {
                        continue;
                    }
                    matched = true;
                    let t = m.as_str();
                    let c = pat.captures(t).unwrap();
                    if pat.as_str() == self.plain.as_str() {
                        let key = c.name("key").unwrap().as_str();
                        map.insert(key.into(), "".into());
                    } else {
                        let key = c.name("key").unwrap().as_str();
                        let value = c.name("value").unwrap().as_str();
                        map.insert(key.into(), value.into());
                    }
                    args = args.get(m.end()..).unwrap();
                }
            }
            if !matched {
                break;
            }
        }
        map
    }
}

impl Default for WikitextParser {
    fn default() -> Self {
        Self {
            no_bracket: Regex::new(r"^[^\[]+").unwrap(),
            bracket: Regex::new(r"^\[").unwrap(),
            wikilink_bare: Regex::new(r"^\[\[\s*(?P<linktext>(\w|[-/_])+)\s*\]\]").unwrap(),
            wikilink_complex: Regex::new(
                r"\[\[\s*(?P<linktext>.*)\|(?P<target>(\w|[-/_])+)\s*\]\]",
            )
            .unwrap(),
            directive_no_args: Regex::new(r"^\[\[!(?P<name>\w+)\s*\]\]").unwrap(),
            directive_args: Regex::new(r#"\[\[!(?P<name>\w+)\s+(?P<args>[^]]*?)\s*\]\]"#).unwrap(),
            plain: Regex::new(r"(?P<key>[a-z0-9._-]+)").unwrap(),
            simple: Regex::new(r"(?P<key>\w+)=(?P<value>\S+)").unwrap(),
            quoted: Regex::new(r#"(?P<key>\w+)="(?P<value>[^"]*)""#).unwrap(),
            multiline: Regex::new(r#"(?P<key>\w+)=("""(?P<value>(.|\n)*?)""")"#).unwrap(),
        }
    }
}

#[derive(Debug, Eq, PartialEq)]
pub enum Snippet {
    Markdown(String),
    WikiLink(WikiLink),
    Directive(Directive),
}

impl Snippet {
    pub fn process(&self, site: &mut Site, meta: &mut PageMeta) -> Result<String, SiteError> {
        trace!("Snippet::process: self={:?}", self);
        let s = match self {
            Snippet::Markdown(text) => text.into(),
            Snippet::WikiLink(w) => {
                let resolved = site.resolve(meta.path(), Path::new(w.target()))?;
                trace!("resolved {} to {}", w.target(), resolved.display());
                format!("[{}]({})", w.link_text(), resolved.display())
            }
            Snippet::Directive(d) => d.process(site, meta)?,
        };
        Ok(s)
    }
}

#[derive(Debug, Eq, PartialEq)]
pub struct WikiLink {
    link_text: String,
    target: String,
}

impl WikiLink {
    pub fn new(link_text: &str, target: &str) -> Self {
        Self {
            link_text: link_text.into(),
            target: target.into(),
        }
    }

    fn link_text(&self) -> &str {
        &self.link_text
    }

    fn target(&self) -> &str {
        &self.target
    }
}

#[derive(Debug, Eq, PartialEq)]
pub struct ParsedDirective {
    name: String,
    args: HashMap<String, String>,
    unnamed_arg: Option<String>,
}

impl ParsedDirective {
    pub fn new(name: &str, mut args: HashMap<String, String>) -> Result<Self, SiteError> {
        trace!("ParsedDirective::new: name={:?} args={:?}", name, args);
        let unnamed_args: Vec<String> = args
            .iter()
            .filter_map(|(k, v)| {
                if v.is_empty() {
                    Some(k.to_string())
                } else {
                    None
                }
            })
            .collect();
        trace!("ParsedDirective::new: unnamed_args={:?}", unnamed_args);

        let unnamed_arg = match unnamed_args.len() {
            0 => None,
            1 => {
                let key = unnamed_args.get(0).unwrap();
                args.remove(key);
                Some(key.to_string())
            }
            _ => return Err(SiteError::TooManyUnnamedArgs(name.into())),
        };
        trace!("ParsedDirective::new: unnamed_arg={:?}", unnamed_arg);

        Ok(Self {
            name: name.into(),
            args,
            unnamed_arg,
        })
    }

    pub fn name(&self) -> &str {
        &self.name
    }

    pub fn args(&self) -> HashMap<&str, &str> {
        self.args
            .iter()
            .map(|(k, v)| (k.as_str(), v.as_str()))
            .collect()
    }

    pub fn unnamed_arg(&self) -> Option<&str> {
        self.unnamed_arg.as_deref()
    }
}

#[derive(Debug, thiserror::Error)]
pub enum WikiError {}

#[cfg(test)]
mod test {
    use super::{Directive, Snippet, WikiLink, WikitextParser};

    #[test]
    fn plain_markdown() {
        let p = WikitextParser::default();
        let (snippet, rest) = p.parse("hello, world").unwrap();
        assert_eq!(snippet, Snippet::Markdown("hello, world".into()));
        assert_eq!(rest, "");
    }

    #[test]
    fn simple_wikilink() {
        let p = WikitextParser::default();

        let (snippet, rest) = p.parse("hello, [[planet-earth]]").unwrap();
        assert_eq!(snippet, Snippet::Markdown("hello, ".into()));
        assert_eq!(rest, "[[planet-earth]]");

        let (snippet, rest) = p.parse(rest).unwrap();
        assert_eq!(
            snippet,
            Snippet::WikiLink(WikiLink::new("planet-earth", "planet-earth"))
        );
        assert_eq!(rest, "");
    }

    #[test]
    fn simple_wikilink_to_subpage() {
        let p = WikitextParser::default();

        let (snippet, rest) = p.parse("hello, [[planets/earth]]").unwrap();
        assert_eq!(snippet, Snippet::Markdown("hello, ".into()));
        assert_eq!(rest, "[[planets/earth]]");

        let (snippet, rest) = p.parse(rest).unwrap();
        assert_eq!(
            snippet,
            Snippet::WikiLink(WikiLink::new("planets/earth", "planets/earth"))
        );
        assert_eq!(rest, "");
    }

    #[test]
    fn complex_wikilink() {
        let p = WikitextParser::default();

        let (snippet, rest) = p
            .parse("hello, [[whomever we greet|planet-earth]]")
            .unwrap();
        assert_eq!(snippet, Snippet::Markdown("hello, ".into()));
        assert_eq!(rest, "[[whomever we greet|planet-earth]]");

        let (snippet, rest) = p.parse(rest).unwrap();
        assert_eq!(
            snippet,
            Snippet::WikiLink(WikiLink::new("whomever we greet", "planet-earth"))
        );
        assert_eq!(rest, "");
    }

    #[test]
    fn complex_wikilink_to_subpage() {
        let p = WikitextParser::default();

        let (snippet, rest) = p
            .parse("hello, [[whomever we greet|planets/earth]]")
            .unwrap();
        assert_eq!(snippet, Snippet::Markdown("hello, ".into()));
        assert_eq!(rest, "[[whomever we greet|planets/earth]]");

        let (snippet, rest) = p.parse(rest).unwrap();
        assert_eq!(
            snippet,
            Snippet::WikiLink(WikiLink::new("whomever we greet", "planets/earth"))
        );
        assert_eq!(rest, "");
    }

    #[test]
    fn bracket() {
        let p = WikitextParser::default();

        let (snippet, rest) = p.parse("[world").unwrap();
        assert_eq!(snippet, Snippet::Markdown("[".into()));
        assert_eq!(rest, "world");

        let (snippet, rest) = p.parse(rest).unwrap();
        assert_eq!(snippet, Snippet::Markdown("world".into()));
        assert_eq!(rest, "");
    }

    #[test]
    fn simple_directive() {
        let p = WikitextParser::default();
        let (snippet, rest) = p.parse("[[!simple]]").unwrap();
        assert_eq!(snippet, Snippet::Directive(Directive::Simple));
        assert_eq!(rest, "");
    }

    #[test]
    fn directive_unnamed_arg() {
        let p = WikitextParser::default();
        let (snippet, rest) = p.parse("[[!unnamedarg foo.jpg]]").unwrap();
        assert_eq!(snippet, Snippet::Directive(Directive::UnnamedArg));
        assert_eq!(rest, "");
    }

    #[test]
    fn directive_simple_arg() {
        let p = WikitextParser::default();
        let (snippet, rest) = p.parse("[[!simplearg foo=bar]]").unwrap();
        assert_eq!(snippet, Snippet::Directive(Directive::SimpleArg));
        assert_eq!(rest, "");
    }

    #[test]
    fn directive_quoted_arg() {
        let p = WikitextParser::default();
        let (snippet, rest) = p.parse(r#"[[!quotedarg bar="foobar"]]"#).unwrap();
        assert_eq!(snippet, Snippet::Directive(Directive::QuotedArg));
        assert_eq!(rest, "");
    }

    #[test]
    fn directive_multiline_arg() {
        let p = WikitextParser::default();
        let (snippet, rest) = p
            .parse(
                r#"[[!multilinearg yo="""foo
bar"""]]"#,
            )
            .unwrap();
        assert_eq!(snippet, Snippet::Directive(Directive::MultilineArg));
        assert_eq!(rest, "");
    }
}