1use dot_structures::*;
7use pest::{
8 error::Error,
9 iterators::{Pair, Pairs},
10};
11
12use crate::pest::Parser;
13
14#[derive(Parser)]
15#[grammar = "grammar/dot.pest"]
16struct DotParser;
17
18pub(crate) fn parse(dot: &str) -> Result<Graph, String> {
19 do_parse(dot, Rule::file)
20 .map(|r| r.into_iter().next().unwrap())
21 .map(|r| process_graph(down(r)))
22 .map_err(|v| v.to_string())
23}
24
25fn down(rule: Pair<Rule>) -> Pair<Rule> {
26 rule.into_inner().next().unwrap()
27}
28
29fn do_parse(input: &str, ty: Rule) -> Result<Pairs<Rule>, Error<Rule>> {
30 DotParser::parse(ty, input)
31}
32
33fn process_attr_list(rule: Pair<Rule>) -> Vec<Attribute> {
34 let mut attrs = vec![];
35 let mut attr_list = rule.into_inner();
36 while attr_list.peek().is_some() {
37 attrs.push(process_attr(attr_list.next().unwrap()))
38 }
39 attrs
40}
41
42fn process_bare_attr(rule: Pair<Rule>) -> Attribute {
43 let mut attr = rule.into_inner();
44 let key = attr.next().map(process_id).unwrap();
45 let val = attr.next().map(process_id).unwrap();
46 Attribute(key, val)
47}
48
49fn process_attr(rule: Pair<Rule>) -> Attribute {
50 process_bare_attr(down(rule))
51}
52
53fn process_id(rule: Pair<Rule>) -> Id {
54 let val = rule.as_str().to_string();
55 match down(rule).as_rule() {
56 Rule::plain => Id::Plain(val),
57 Rule::html => Id::Html(val),
58 Rule::string_qt => Id::Escaped(val),
59 p => panic!("unreachable, got {:?}", p),
60 }
61}
62
63fn parse_compass_manually(id: Id) -> Option<String> {
64 match id {
65 Id::Plain(ref s) => match s.as_str() {
66 "n" | "ne" | "e" | "se" | "s" | "sw" | "w" | "nw" | "c" | "_" => Some(id.to_string()),
67 _ => None
68 }
69 _ => None
70 }
71}
72
73fn process_port(port: Pair<Rule>) -> Port {
74 let mut port_r = port.into_inner();
75 if let Some(r) = port_r.next() {
76 match r.as_rule() {
77 Rule::compass => Port(None, Some(r.as_str().to_string())),
78 Rule::id => {
79 let mb_id_mb_compass = process_id(r);
80 if let Some(r) = port_r.next() {
81 Port(Some(mb_id_mb_compass), Some(r.as_str().to_string()))
82 } else {
83 parse_compass_manually(mb_id_mb_compass.clone())
84 .map(|s| Port(None, Some(s)))
85 .unwrap_or_else(|| Port(Some(mb_id_mb_compass), None))
86 }
87 }
88 _ => panic!("unreachable!"),
89 }
90 } else {
91 panic!("port can not be empty")
92 }
93}
94
95fn process_node_id(rule: Pair<Rule>) -> NodeId {
96 let mut node_id = rule.into_inner();
97 let id = node_id.next().map(process_id).unwrap();
98 if let Some(r) = node_id.next() {
99 NodeId(id, Some(process_port(r)))
100 } else {
101 NodeId(id, None)
102 }
103}
104
105fn process_subgraph(rule: Pair<Rule>) -> Subgraph {
106 let mut sub_r = rule.into_inner();
107 let id = match sub_r.peek().map(|r| r.as_rule()) {
108 Some(Rule::id) => process_id(sub_r.next().unwrap()),
109 _ => Id::Anonymous(rand::random::<usize>().to_string()),
110 };
111 let stmts = process_body(sub_r.next().unwrap());
112 Subgraph { id, stmts }
113}
114
115fn process_body(rule: Pair<Rule>) -> Vec<Stmt> {
116 let mut stmts = vec![];
117 let mut body_r = rule.into_inner();
118 while body_r.peek().is_some() {
119 stmts.push(process_stmt(body_r.next().unwrap()));
120 }
121 stmts
122}
123
124fn process_node(rule: Pair<Rule>) -> Node {
125 let mut node_r = rule.into_inner();
126 let id = process_node_id(node_r.next().unwrap());
127 if let Some(r) = node_r.next() {
128 Node {
129 id,
130 attributes: process_attr_list(r),
131 }
132 } else {
133 Node {
134 id,
135 attributes: vec![],
136 }
137 }
138}
139
140fn process_vertex(rule: Pair<Rule>) -> Vertex {
141 let vertex_r = down(rule);
142 match vertex_r.as_rule() {
143 Rule::node_id => Vertex::N(process_node_id(vertex_r)),
144 Rule::subgraph => Vertex::S(process_subgraph(vertex_r)),
145 _ => unreachable!(""),
146 }
147}
148
149fn process_edge(rule: Pair<Rule>) -> Vec<Vertex> {
150 let mut edge_r = rule.into_inner();
151 let h = process_vertex(edge_r.next().unwrap());
152 let mut chain = vec![h];
153
154 while edge_r.peek().is_some() {
155 chain.push(process_vertex(down(edge_r.next().unwrap())))
156 }
157 chain
158}
159
160fn process_edge_stmt(rule: Pair<Rule>) -> Edge {
161 let mut edge_r = rule.into_inner();
162 let edges = process_edge(edge_r.next().unwrap());
163
164 let ty = if edges.len() > 2 {
165 EdgeTy::Chain(edges)
166 } else {
167 let mut edge_iter = edges.into_iter();
168 EdgeTy::Pair(edge_iter.next().unwrap(), edge_iter.next().unwrap())
169 };
170
171 if let Some(attr_r) = edge_r.next() {
172 Edge {
173 ty,
174 attributes: process_attr_list(attr_r),
175 }
176 } else {
177 Edge {
178 ty,
179 attributes: vec![],
180 }
181 }
182}
183
184fn process_attr_stmt(rule: Pair<Rule>) -> GraphAttributes {
185 let mut stmts_r = rule.into_inner();
186 let mark = stmts_r.next().unwrap().as_str();
187 let attrs = process_attr_list(stmts_r.next().unwrap());
188 GraphAttributes::new(mark, attrs)
189}
190
191fn process_stmt(rule: Pair<Rule>) -> Stmt {
192 let stmt_r = down(rule);
193 match stmt_r.as_rule() {
194 Rule::attr_stmt => Stmt::GAttribute(process_attr_stmt(stmt_r)),
195 Rule::subgraph => Stmt::Subgraph(process_subgraph(stmt_r)),
196 Rule::node => Stmt::Node(process_node(stmt_r)),
197 Rule::bare_attr => Stmt::Attribute(process_bare_attr(stmt_r)),
198 Rule::edge_stmt => Stmt::Edge(process_edge_stmt(stmt_r)),
199 _ => unreachable!(),
200 }
201}
202
203fn process_graph(rule: Pair<Rule>) -> Graph {
204 let mut graph_r = rule.into_inner();
205 let strict = match graph_r.peek().map(|r| r.as_rule()) {
206 Some(Rule::strict) => {
207 graph_r.next();
208 true
209 }
210 _ => false,
211 };
212
213 let is_di = matches!(graph_r.next().map(|r| r.as_str()), Some("digraph"));
214
215 let id = match graph_r.peek().map(|r| r.as_rule()) {
216 Some(Rule::id) => process_id(graph_r.next().unwrap()),
217 _ => Id::Anonymous(rand::random::<usize>().to_string()),
218 };
219
220 let stmts = process_body(graph_r.next().unwrap());
221 if is_di {
222 Graph::DiGraph { id, strict, stmts }
223 } else {
224 Graph::Graph { id, strict, stmts }
225 }
226}
227
228#[cfg(test)]
229mod test {
230 use dot_generator::{attr, edge, graph, id, node, node_id, port, stmt, subgraph};
231 use dot_structures::*;
232 use pest::iterators::Pair;
233
234 use crate::parser::{
235 do_parse, parse, process_attr, process_attr_list, process_attr_stmt, process_edge,
236 process_edge_stmt, process_id, process_node, process_node_id, process_stmt, process_vertex,
237 Rule, Stmt, Vertex,
238 };
239
240 fn _parse(input: &str, ty: Rule) -> Pair<Rule> {
241 match do_parse(input, ty) {
242 Ok(mut r) => r.next().unwrap(),
243 Err(e) => panic!("parsing err: {}", e),
244 }
245 }
246
247 #[test]
248 fn id_test() {
249 let result = process_id(_parse("abc_a", Rule::id));
250 assert_eq!(result, id!("abc_a"));
251
252 let result = process_id(_parse(r#""a\b\c.'\"""#, Rule::id));
254 assert_eq!(result, id!(esc r#"a\b\c.'\""#));
255
256 let result = process_id(_parse(r#""a\b"\c.'\"""#, Rule::id));
258 assert_eq!(result, id!(esc r#"a\b"#));
259
260 let result = process_id(_parse("\"ab\\\"c\"", Rule::id));
261 assert_eq!(result, id!(esc "ab\\\"c"));
262
263 let result = process_id(_parse(
264 r#"<<IMG SCALE="FAL" SRC="value" /></B>abc </B>>"#,
265 Rule::id,
266 ));
267 assert_eq!(
268 result,
269 id!(html r#"<<IMG SCALE="FAL" SRC="value" /></B>abc </B>>"#)
270 );
271
272 let result = process_id(_parse(
273 r#"<<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0">
274 <TR><TD>left</TD><TD PORT="f1">mid dle</TD><TD PORT="f2">right</TD></TR>
275 </TABLE>>"#,
276 Rule::id,
277 ));
278 assert_eq!(
279 result,
280 id!(html r#"<<TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0">
281 <TR><TD>left</TD><TD PORT="f1">mid dle</TD><TD PORT="f2">right</TD></TR>
282 </TABLE>>"#)
283 );
284
285 let result = process_id(_parse(
286 r#"<
287 <TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0">
288 <TR><TD>left</TD><TD PORT="f1">mid dle</TD><TD PORT="f2">right</TD></TR>
289 </TABLE>
290 >"#,
291 Rule::id,
292 ));
293 assert_eq!(
294 result,
295 id!(html r#"<
296 <TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0">
297 <TR><TD>left</TD><TD PORT="f1">mid dle</TD><TD PORT="f2">right</TD></TR>
298 </TABLE>
299 >"#)
300 );
301 let result = process_id(_parse(
302 r#"<<tr><td>address_id:!@#$%^&*()_+/.,"\| int</td></tr>>"#,
303 Rule::id,
304 ));
305 assert_eq!(
306 result,
307 id!(html r#"<<tr><td>address_id:!@#$%^&*()_+/.,"\| int</td></tr>>"#)
308 );
309 }
310
311 #[test]
312 fn attr_test() {
313 let result = process_attr(_parse("a=1", Rule::attr));
314 assert_eq!(result, attr!("a", "1"));
315 let result = process_attr(_parse("a = 1 , ;", Rule::attr));
316 assert_eq!(result, attr!("a", "1"));
317 }
318
319 #[test]
320 fn attr_list_test() {
321 let result = process_attr_list(_parse("[a=1 , b=c ; d=<<abc>> e=e]", Rule::attr_list));
322 let expect = vec![
323 attr!("a", "1"),
324 attr!("b", "c"),
325 attr!("d", html "<<abc>>"),
326 attr!("e", "e"),
327 ];
328 assert_eq!(result, expect);
329 let result = process_attr_list(_parse("[a=1 , b=c] [ d=<<abc>> e=e]", Rule::attr_list));
330 assert_eq!(result, expect);
331 }
332
333 #[test]
334 fn node_id_test() {
335 let result = process_node_id(_parse("abc:n", Rule::node_id));
336 let expect = node_id!(id!("abc"), port!(, "n"));
337 assert_eq!(result, expect);
338
339 let result = process_node_id(_parse("abc:abc", Rule::node_id));
340 let expect = node_id!(id!("abc"), port!(id!("abc")));
341 assert_eq!(result, expect);
342
343 let result = process_node_id(_parse("abc:abc:n", Rule::node_id));
344 let expect = node_id!(id!("abc"), port!(id!("abc"), "n"));
345 assert_eq!(result, expect);
346 }
347
348 #[test]
349 fn node_test() {
350 let result = process_node(_parse("abc:n[a=1 , b=c ; d=<<abc>> e=e]", Rule::node));
351 let p = port!(, "n" );
352 let attributes = vec![
353 attr!("a", "1"),
354 attr!("b", "c"),
355 attr!("d", html "<<abc>>"),
356 attr!("e", "e"),
357 ];
358 assert_eq!(result, node!("abc" => p, attributes));
359 }
360
361 #[test]
362 fn attr_stmts_test() {
363 let result = process_attr_stmt(_parse("node [a=1 , b=c ; d=<<abc>> e=e]", Rule::attr_stmt));
364 let attributes = vec![
365 attr!("a", "1"),
366 attr!("b", "c"),
367 attr!("d", html "<<abc>>"),
368 attr!("e", "e"),
369 ];
370 assert_eq!(result, GraphAttributes::Node(attributes));
371
372 let result =
373 process_attr_stmt(_parse("graph [a=1 , b=c ; d=<<abc>> e=e]", Rule::attr_stmt));
374 let attributes = vec![
375 attr!("a", "1"),
376 attr!("b", "c"),
377 attr!("d", html "<<abc>>"),
378 attr!("e", "e"),
379 ];
380 assert_eq!(result, GraphAttributes::Graph(attributes));
381 }
382
383 #[test]
384 fn vertex_test() {
385 let result = process_vertex(_parse("node", Rule::vertex));
386 assert_eq!(result, Vertex::N(node_id!("node")));
387 }
388
389 #[test]
390 fn edge_test() {
391 let result = process_edge(_parse("node -> node1 -> node2", Rule::edge));
392 let expected = vec![
393 Vertex::N(node_id!("node")),
394 Vertex::N(node_id!("node1")),
395 Vertex::N(node_id!("node2")),
396 ];
397 assert_eq!(result, expected);
398 }
399
400 #[test]
401 fn edge_stmt_test() {
402 let result = process_edge_stmt(_parse("node -> node1 -> node2[a=2]", Rule::edge_stmt));
403 assert_eq!(
404 result,
405 edge!(node_id!("node")=> node_id!("node1")=>node_id!("node2"); attr!("a","2"))
406 );
407
408 let result = process_edge_stmt(_parse("node -> subgraph sg{a -> b}[a=2]", Rule::edge_stmt));
409
410 assert_eq!(
411 result,
412 edge!(
413 node_id!("node") => subgraph!("sg";stmt!(edge!(node_id!("a") => node_id!("b"))));
414 attr!("a","2")
415 )
416 );
417 }
418
419 #[test]
420 fn stmt_test() {
421 let result = process_stmt(_parse("a=b", Rule::stmt));
422 assert_eq!(result, stmt!(attr!("a", "b")));
423
424 let result = process_stmt(_parse("node [a=1 , b=c ; d=<<abc>> e=e]", Rule::stmt));
425 let attributes = vec![
426 attr!("a", "1"),
427 attr!("b", "c"),
428 attr!("d", html "<<abc>>"),
429 attr!("e", "e"),
430 ];
431 assert_eq!(result, stmt!(GraphAttributes::Node(attributes)));
432
433 let result = process_stmt(_parse("node -> node1 -> node2[a=2]", Rule::stmt));
434
435 assert_eq!(
436 result,
437 stmt!(edge!(node_id!("node")=> node_id!("node1")=>node_id!("node2"); attr!("a","2")))
438 );
439 }
440
441 #[test]
442 fn graph_html_test() {
443 let g: Graph = parse(
444 r#"
445 digraph G {
446 a [ label=< <TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0">
447 <TR><TD ROWSPAN="3" BGCOLOR="yellow">class</TD></TR>
448 <TR><TD PORT="here" BGCOLOR="lightblue">qualifier</TD></TR>
449 </TABLE>>
450 ]
451 b [shape=ellipse style=filled
452 label=<
453 <TABLE BGCOLOR="bisque">
454 <TR>
455 <TD COLSPAN="3">elephant</TD>
456 <TD ROWSPAN="2" BGCOLOR="chartreuse"
457 VALIGN="bottom" ALIGN="right">two</TD>
458 </TR>
459 <TR>
460 <TD COLSPAN="2" ROWSPAN="2">
461 <TABLE BGCOLOR="grey">
462 <TR><TD>corn</TD></TR>
463 <TR><TD BGCOLOR="yellow">c</TD></TR>
464 <TR><TD>f</TD></TR>
465 </TABLE>
466 </TD>
467 <TD BGCOLOR="white">penguin</TD>
468 </TR>
469 <TR>
470 <TD COLSPAN="2" BORDER="4" ALIGN="right" PORT="there">4</TD>
471 </TR>
472 </TABLE>>
473 ]
474 c [ label=<long line 1<BR/>line 2<BR ALIGN="LEFT"/>line 3<BR ALIGN="RIGHT"/>> ]
475 d [ label=<<tr><td>address_id: int</td></tr>> ]
476 }
477 "#,
478 )
479 .unwrap();
480
481 assert_eq!(
482 g,
483 graph!(di id!("G");
484 node!("a"; attr!("label",html r#"< <TABLE BORDER="0" CELLBORDER="1" CELLSPACING="0">
485 <TR><TD ROWSPAN="3" BGCOLOR="yellow">class</TD></TR>
486 <TR><TD PORT="here" BGCOLOR="lightblue">qualifier</TD></TR>
487 </TABLE>>"#)),
488 node!("b";
489 attr!("shape","ellipse"),
490 attr!("style","filled"),
491 attr!("label",html r#"<
492 <TABLE BGCOLOR="bisque">
493 <TR>
494 <TD COLSPAN="3">elephant</TD>
495 <TD ROWSPAN="2" BGCOLOR="chartreuse"
496 VALIGN="bottom" ALIGN="right">two</TD>
497 </TR>
498 <TR>
499 <TD COLSPAN="2" ROWSPAN="2">
500 <TABLE BGCOLOR="grey">
501 <TR><TD>corn</TD></TR>
502 <TR><TD BGCOLOR="yellow">c</TD></TR>
503 <TR><TD>f</TD></TR>
504 </TABLE>
505 </TD>
506 <TD BGCOLOR="white">penguin</TD>
507 </TR>
508 <TR>
509 <TD COLSPAN="2" BORDER="4" ALIGN="right" PORT="there">4</TD>
510 </TR>
511 </TABLE>>"#)
512 ),
513 node!("c"; attr!("label", html r#"<long line 1<BR/>line 2<BR ALIGN="LEFT"/>line 3<BR ALIGN="RIGHT"/>>"#)),
514 node!("d"; attr!("label", html r#"<<tr><td>address_id: int</td></tr>>"#))
515
516 )
517 )
518 }
519
520 #[test]
521 fn graph_test() {
522 let g: Graph = parse(
523 r#"
524 strict digraph t {
525 aa[color=green,label="shouln't er\ror"]
526 subgraph v {
527 aa[shape=square]
528 subgraph vv{a2 -> b2}
529 aaa[color=red]
530 aaa -> bbb
531 }
532 aa -> be -> subgraph v { d -> aaa}
533 aa -> aaa -> v
534 }
535 "#,
536 )
537 .unwrap();
538
539 assert_eq!(
540 g,
541 graph!(strict di id!("t");
542 node!("aa";attr!("color","green"),attr!("label", esc "shouln't er\\ror")),
543 subgraph!("v";
544 node!("aa"; attr!("shape","square")),
545 subgraph!("vv"; edge!(node_id!("a2") => node_id!("b2"))),
546 node!("aaa";attr!("color","red")),
547 edge!(node_id!("aaa") => node_id!("bbb"))
548 ),
549 edge!(node_id!("aa") => node_id!("be") => subgraph!("v"; edge!(node_id!("d") => node_id!("aaa")))),
550 edge!(node_id!("aa") => node_id!("aaa") => node_id!("v"))
551 )
552 )
553 }
554
555 #[test]
556 fn global_attr_test() {
557 let g: Graph = parse(
558 r#"
559 graph t {
560 graph [_draw_="c 9 "];
561 node [label="\N"];
562 a -- b;
563 }
564 "#,
565 )
566 .unwrap();
567
568 assert_eq!(
569 g,
570 graph!(id!("t");
571 stmt!(GraphAttributes::Graph(vec![attr!("_draw_", esc "c 9 ")])),
572 stmt!(GraphAttributes::Node(vec![attr!("label", esc "\\N")])),
573 edge!(node_id!("a") => node_id!("b"))
574 )
575 )
576 }
577
578 #[test]
579 fn comments_test() {
580 let g: Graph = parse("// abc \n # abc \n strict digraph t { \n /* \n abc */ \n}").unwrap();
581
582 assert_eq!(g, graph!(strict di id!("t")))
583 }
584
585 #[test]
586 fn comments_after_graph_test() {
587 let g: Graph = parse("// b \n strict digraph t { \n /* \n abc */ \n} \n // a ").unwrap();
588
589 assert_eq!(g, graph!(strict di id!("t")))
590 }
591
592 #[test]
593 fn port_test() {
594 let g = parse(r#"
595 digraph test { A:s0 -> B;}"#).unwrap();
596 assert_eq!(g, graph!(di id!("test"); edge!(node_id!("A", port!(id!("s0"))) => node_id!("B"))))
597 }
598
599 #[test]
600 fn port_w_test() {
601 let g = parse(r#"
602 digraph test { A:s0:s -> B;}"#).unwrap();
603 assert_eq!(g, graph!(di id!("test"); edge!(node_id!("A", port!(id!("s0"),"s")) => node_id!("B"))))
604 }
605
606 #[test]
607 fn port_compass_test() {
608 let g = parse(r#"
609 digraph test { A:s -> B;}"#).unwrap();
610 assert_eq!(g, graph!(di id!("test"); edge!(node_id!("A", port!(,"s")) => node_id!("B"))))
611 }
612}