graphviz-dot-parser 0.0.4

A simple (incomplete) parser for Graphviz DOT format
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use petgraph::EdgeType;
use petgraph::Graph;
use std::collections::HashMap;

pub struct GraphAST {
    pub is_strict: bool,
    pub is_directed: bool,
    pub id: Option<String>,
    pub stmt: Vec<Stmt>,
}

impl GraphAST {
    fn to_graph_internal<Ty: EdgeType, N, E>(
        &self,
        node_parser: &dyn Fn(&String, &Attributes) -> N,
        edge_parser: &dyn Fn(&Attributes) -> E,
        g: &mut Graph<N, E, Ty>,
    ) {
        let mut nodes = HashMap::new();
        for stmt in &self.stmt {
            match stmt {
                Stmt::Node(n, attr) => {
                    let idx = g.add_node(node_parser(n, attr));
                    nodes.insert(n, idx);
                }
                Stmt::Edge(n1, n2, attrs) => {
                    let e = edge_parser(attrs);
                    g.add_edge(*nodes.get(&n1).unwrap(), *nodes.get(&n2).unwrap(), e);
                }
                _ => {}
            }
        }
    }

    pub fn to_directed_graph_using<N, E>(
        &self,
        new_node: &dyn Fn(&String, &Attributes) -> N,
        new_edge: &dyn Fn(&Attributes) -> E,
    ) -> Option<Graph<N, E>> {
        if self.is_directed {
            let mut g = Graph::new();
            self.to_graph_internal(new_node, new_edge, &mut g);
            Some(g)
        } else {
            None
        }
    }

    pub fn to_undirected_graph_using<N, E>(
        &self,
        new_node: &dyn Fn(&String, &Attributes) -> N,
        new_edge: &dyn Fn(&Attributes) -> E,
    ) -> Option<Graph<N, E, petgraph::Undirected>> {
        if !self.is_directed {
            let mut g = Graph::new_undirected();
            self.to_graph_internal(new_node, new_edge, &mut g);
            Some(g)
        } else {
            None
        }
    }

    pub fn to_directed_graph(&self) -> Option<Graph<String, ()>> {
        self.to_directed_graph_using(&|n, _| n.clone(), &|_| ())
    }

    pub fn to_undirected_graph(&self) -> Option<Graph<String, (), petgraph::Undirected>> {
        self.to_undirected_graph_using(&|n, _| n.clone(), &|_| ())
    }
}

#[derive(Eq, PartialEq, Debug)]
pub enum AttributeType {
    Graph,
    Node,
    Edge,
}

pub type Attributes = Vec<(String, String)>;

#[derive(Eq, PartialEq, Debug)]
pub enum Stmt {
    // Many features are currently not supported
    Node(String, Attributes),
    Edge(String, String, Attributes),
    Attr(AttributeType, Attributes),
    Assign(String, String),
    SubGraph(Option<String>, Vec<Stmt>),
}

#[cfg(test)]
mod tests {
    use crate::types::*;
    #[test]
    fn test_petgraph_conversion_directed() {
        let g = GraphAST {
            is_strict: false,
            is_directed: true,
            id: None,
            stmt: vec![
                Stmt::Node(String::from("1"), vec![]),
                Stmt::Node(String::from("2"), vec![]),
                Stmt::Edge(String::from("1"), String::from("2"), vec![]),
            ],
        };
        let graph = g.to_undirected_graph();
        assert_eq!(graph.is_none(), true);
        let graph = g.to_directed_graph();
        assert_eq!(graph.is_some(), true);
        let graph = graph.unwrap();
        assert_eq!(graph.is_directed(), true);
        assert_eq!(graph.node_count(), 2);
        assert_eq!(graph.edge_count(), 1);
    }

    #[test]
    fn test_petgraph_conversion_undirected() {
        let g = GraphAST {
            is_strict: false,
            is_directed: false,
            id: None,
            stmt: vec![
                Stmt::Node(String::from("1"), vec![]),
                Stmt::Node(String::from("2"), vec![]),
                Stmt::Edge(String::from("1"), String::from("2"), vec![]),
            ],
        };
        let graph = g.to_directed_graph();
        assert_eq!(graph.is_none(), true);
        let graph = g.to_undirected_graph();
        assert_eq!(graph.is_some(), true);
        let graph = graph.unwrap();
        assert_eq!(graph.is_directed(), false);
        assert_eq!(graph.node_count(), 2);
        assert_eq!(graph.edge_count(), 1);
    }
}