topdown-rs 0.3.3

use super::{CharSeq, ParserHook, ParserResult, Parser, Succ};

pub struct Skip<'a> {
    skip_char: &'a str
}

pub fn skip<'a>(chars: &'a str) -> Skip<'a> {
    return Skip{skip_char: chars};
}

impl<'a> ParserHook for Skip<'a> {
    fn hook(&self, cs: &mut CharSeq) {
        while self.skip_char.contains(cs.current()) {
            cs.next();
        }
    }
}

impl<'a> Parser<String> for Skip<'a> {
    fn _parse(&self, cs: &mut CharSeq) -> ParserResult<String> {
        let mut r = String::new();
        while self.skip_char.contains(cs.current()) {
            r.push(cs.current());
            cs.next();
        }
        return Succ(r);
    }
}

#[cfg(test)]
#[allow(unused_variables)]
#[allow(unused_imports)]
mod tests {
    use super::skip;
    use super::super::{CharSeq, ParserResult, Parser, Succ, Fail, Error};
    #[test]
    fn test_skip_ws1() {
        let skip_ws = skip(" \t\r\n");
        let mut cs = CharSeq::new("ab\tc\n   d ", "<mem>");
        cs.add_hook(&skip_ws);
        let a = "a";
        let b = "b";
        let c = "c";
        let d = "d";
        match cs.accept(&a) {
            Succ(r) => assert_eq!(r.as_slice(), "a"),
            Fail(m, l) => assert!(false),
            Error(m, l) => assert!(false)
        }
        match cs.accept(&b) {
            Succ(r) => assert_eq!(r.as_slice(), "b"),
            Fail(m, l) => assert!(false),
            Error(m, l) => assert!(false)
        }
        match cs.accept(&c) {
            Succ(r) => assert_eq!(r.as_slice(), "c"),
            Fail(m, l) => assert!(false),
            Error(m, l) => assert!(false)
        }
        match cs.accept(&d) {
            Succ(r) => assert_eq!(r.as_slice(), "d"),
            Fail(m, l) => assert!(false),
            Error(m, l) => assert!(false)
        }
    }
}