polka/parser/

symbols.rs

use crate::dot::{AttributeType, GraphType};
use crate::parser::ident::ident;

use pom::parser::{end, one_of, sym, tag, Parser};
// use pom::Parser;

pub fn strict_symbol<'a>() -> Parser<'a, char, String> {
  (tag("strict") | tag("STRICT")).map(|_| "strict".to_string())
}

pub fn graph_symbol<'a>() -> Parser<'a, char, AttributeType> {
  (tag("graph") | tag("GRAPH")).map(|_| AttributeType::Graph)
}

pub fn digraph_symbol<'a>() -> Parser<'a, char, bool> {
  (tag("digraph") | tag("DIGRAPH")).map(|_| true)
}

pub fn graph_type<'a>() -> Parser<'a, char, GraphType> {
  graph_symbol().map(|_| GraphType::Graph) | digraph_symbol().map(|_| GraphType::Digraph)
}

pub fn subgraph_symbol<'a>() -> Parser<'a, char, bool> {
  (tag("subgraph") | tag("SUBGRAPH")).map(|_| true)
}

pub fn node_symbol<'a>() -> Parser<'a, char, AttributeType> {
  (tag("node") | tag("NODE")).map(|_| AttributeType::Node)
}

pub fn edge_symbol<'a>() -> Parser<'a, char, AttributeType> {
  (tag("edge") | tag("EDGE")).map(|_| AttributeType::Edge)
}

pub fn space<'a>() -> Parser<'a, char, ()> {
  one_of(" \t\r\n").repeat(0..).discard()
}

pub fn id<'a>() -> Parser<'a, char, String> {
  ident()
}

pub fn comment<'a>() -> Parser<'a, char, ()> {
  let eol = (sym('\n').discard() | end()).name("eol");
  let not_eol = !(sym('\n').discard() | end()).name("not_eol");
  (tag("//") - (not_eol).repeat(1..) - eol).discard()
}


#[cfg(test)]
mod test {
  #[cfg(test)]
  mod comment {
    use super::super::comment;

    #[test]
    fn mixed_tokens() {
      let input1: Vec<char> = "// some stuff here.".chars().collect();
      match comment().parse(&input1) {
        Ok(r) => assert_eq!(r, ()),
        Err(e) => panic!(format!(
          "failed with input: {:?} with error: {:?}",
          input1, e
        )),
      };
    }

  }

  #[cfg(test)]
  mod strict {
    use super::super::strict_symbol;

    #[test]
    fn mixed_tokens() {
      let input1: Vec<char> = "strict".chars().collect();
      match strict_symbol().parse(&input1) {
        Ok(r) => assert_eq!(r, "strict".to_string()),
        _ => panic!(format!("failed with input: {:?}", input1)),
      };

      let input2: Vec<char> = "STRICT".chars().collect();
      match strict_symbol().parse(&input2) {
        Ok(r) => assert_eq!(r, "strict".to_string()),
        _ => panic!(format!("failed with input: {:?}", input2)),
      };

      let input3: Vec<char> = "strect".chars().collect();
      if strict_symbol().parse(&input3).is_ok() {
        panic!("Should have failed")
      }
    }

  }

  #[cfg(test)]
  mod graph {
    use super::super::*;

    #[test]
    fn mixed_tokens() {
      let input1: Vec<char> = "graph".chars().collect();
      match graph_symbol().parse(&input1) {
        Ok(r) => assert_eq!(r, AttributeType::Graph),
        _ => panic!(format!("failed with input: {:?}", input1)),
      };

      let input2: Vec<char> = "GRAPH".chars().collect();
      match graph_symbol().parse(&input2) {
        Ok(r) => assert_eq!(r, AttributeType::Graph),
        _ => panic!(format!("failed with input: {:?}", input2)),
      };

      let input3: Vec<char> = "greph".chars().collect();
      if strict_symbol().parse(&input3).is_ok() {
        panic!("Should have failed")
      }
    }

  }

  #[cfg(test)]
  mod digraph {
    use super::super::*;

    #[test]
    fn mixed_tokens() {
      let input1: Vec<char> = "digraph".chars().collect();
      match digraph_symbol().parse(&input1) {
        Ok(r) => assert_eq!(r, true),
        _ => panic!(format!("failed with input: {:?}", input1)),
      };

      let input2: Vec<char> = "DIGRAPH".chars().collect();
      match digraph_symbol().parse(&input2) {
        Ok(r) => assert_eq!(r, true),
        _ => panic!(format!("failed with input: {:?}", input2)),
      };

      let input3: Vec<char> = "diegreph".chars().collect();
      if strict_symbol().parse(&input3).is_ok() {
        panic!("Should have failed")
      }
    }

  }

  #[cfg(test)]
  mod subgraph {
    use super::super::*;

    #[test]
    fn mixed_tokens() {
      let input1: Vec<char> = "subgraph".chars().collect();
      match subgraph_symbol().parse(&input1) {
        Ok(r) => assert_eq!(r, true),
        _ => panic!(format!("failed with input: {:?}", input1)),
      };

      let input2: Vec<char> = "SUBGRAPH".chars().collect();
      match subgraph_symbol().parse(&input2) {
        Ok(r) => assert_eq!(r, true),
        _ => panic!(format!("failed with input: {:?}", input2)),
      };

      let input3: Vec<char> = "subgreph".chars().collect();
      if strict_symbol().parse(&input3).is_ok() {
        panic!("Should have failed")
      }
    }
  }

  #[cfg(test)]
  mod node {
    use super::super::*;

    #[test]
    fn mixed_tokens() {
      let input1: Vec<char> = "node".chars().collect();
      match node_symbol().parse(&input1) {
        Ok(r) => assert_eq!(r, AttributeType::Node),
        _ => panic!(format!("failed with input: {:?}", input1)),
      };

      let input2: Vec<char> = "NODE".chars().collect();
      match node_symbol().parse(&input2) {
        Ok(r) => assert_eq!(r, AttributeType::Node),
        _ => panic!(format!("failed with input: {:?}", input2)),
      };

      let input3: Vec<char> = "nodd".chars().collect();
      if strict_symbol().parse(&input3).is_ok() {
        panic!("Should have failed")
      }
    }

  }

  #[cfg(test)]
  mod edge {
    use super::super::*;

    #[test]
    fn mixed_tokens() {
      let input1: Vec<char> = "edge".chars().collect();
      match edge_symbol().parse(&input1) {
        Ok(r) => assert_eq!(r, AttributeType::Edge),
        _ => panic!(format!("failed with input: {:?}", input1)),
      };

      let input2: Vec<char> = "EDGE".chars().collect();
      match edge_symbol().parse(&input2) {
        Ok(r) => assert_eq!(r, AttributeType::Edge),
        _ => panic!(format!("failed with input: {:?}", input2)),
      };

      let input3: Vec<char> = "egde".chars().collect();
      if strict_symbol().parse(&input3).is_ok() {
        panic!("Should have failed")
      }
    }

  }
}