dot_generator/
lib.rs

Help
1//! # The set of macroses helping to generate the elements of graphviz
2//! The set helps to generate the major components of the graphviz dot notation
3//! endevouring to follow comparatively close to the language [`notation`]
4//!
5//! [`notation`]: https://graphviz.org/doc/info/lang.html
6//! # Description:
7//! In overall, the format of macros is the following one:
8//!  - name or id or any other markers
9//!  - list of vec with a prefix , or seq of elems with a prefix ;
10//!
11//! #Note:
12//!  - for the list of items the way to pass vec is the following one: element(.. , vec of items)
13//!  - for the seq of items the way to pass several items is the following one: element(.. ; items+)
14//!
15//! # Examples:
16//! ```rust
17//!        fn graph_test() {
18//!        use dot_generator::*;
19//!        use dot_structures::*;
20//!
21//!        let g = r#"
22//!        strict digraph t {
23//!            aa[color=green]
24//!            subgraph v {
25//!                aa[shape=square]
26//!                subgraph vv{a2 -> b2}
27//!                aaa[color=red]
28//!                aaa -> bbb
29//!            }
30//!            aa -> be -> subgraph v { d -> aaa}
31//!            aa -> aaa -> v
32//!        }
33//!        "#;
34//!
35//!            graph!(strict di id!("t");
36//!              node!("aa";attr!("color","green")),
37//!              subgraph!("v";
38//!                node!("aa"; attr!("shape","square")),
39//!                subgraph!("vv"; edge!(node_id!("a2") => node_id!("b2"))),
40//!                node!("aaa";attr!("color","red")),
41//!                edge!(node_id!("aaa") => node_id!("bbb"))
42//!                ),
43//!              edge!(node_id!("aa") => node_id!("be") => subgraph!("v"; edge!(node_id!("d") => node_id!("aaa")))),
44//!              edge!(node_id!("aa") => node_id!("aaa") => node_id!("v"))
45//!            );
46//!    }
47//! ```
48use dot_structures::*;
49
50/// represents a port in dot lang
51#[macro_export]
52macro_rules! port {
53    () => {Port(None,None)};
54    ( , $str:expr) => { Port(None,Some($str.to_string()))};
55    ( $id:expr , $str:expr) => {Port(Some($id),Some($str.to_string()))};
56    ( $id:expr) => {Port(Some($id),None)};
57}
58/// represents a node id in dot lang
59/// Essentially it is a combination of id and port
60#[macro_export]
61macro_rules! node_id {
62    () => {  NodeId(id!(),None) };
63    ($e:expr) => { NodeId(id!($e),None) };
64    ($e:expr, $p:expr) => { NodeId(id!($e),Some($p)) };
65    ($i:ident $e:expr) => { NodeId(id!($i$e),None) };
66    ($i:ident $e:expr, $p:expr) => { NodeId(id!($i$e),Some($p)) };
67}
68
69/// represents an id for node or subgraph in dot lang.
70/// #Arguments:
71///  - html - html format.
72///  - esc - escaped string. It allows the escaped quotes inside and also wraps the string to the quotas
73/// #Example:
74/// ```rust
75///     fn id_test() {
76///         use dot_generator::*;
77///         use dot_structures::*;
78///
79///         assert_eq!(id!(), Id::Anonymous("".to_string()));
80///         assert_eq!(id!(html "<<abc>>"), Id::Html("<<abc>>".to_string()));
81///         assert_eq!(id!("abc"), Id::Plain("abc".to_string()));
82///         assert_eq!(id!(esc r#"ab\"c"#"), Id::Escaped(r#"\"ab\"c\""#.to_string()));
83///     }
84/// ```
85#[macro_export]
86macro_rules! id {
87    () => { Id::Anonymous("".to_string()) };
88    (html$e:expr) => { Id::Html(format!("{}",$e))};
89    (esc$e:expr) => { Id::Escaped(format!("\"{}\"",$e))};
90    ($e:expr) => { Id::Plain(format!("{}",$e))};
91}
92
93/// represents an attribute in dot lang.
94/// # Example:
95/// ```rust
96///     fn attr_test() {
97///         use dot_generator::*;
98///         use dot_structures::*;
99///
100///         assert_eq!(attr!("a","1"), Attribute(id!("a"), id!("1")));
101///         assert_eq!(attr!(html "a","1"), Attribute(id!(html "a"), id!("1")))
102///     }
103/// ```
104#[macro_export]
105macro_rules! attr {
106    ($ik:ident $k:expr,$iv:ident $v:expr) => {Attribute(id!($k),id!($iv $v))};
107    ($ik:ident $k:expr,$v:expr) => {Attribute(id!($ik $k),id!($v))};
108    ($k:expr, $iv:ident $v:expr) => {Attribute(id!($k),id!($iv $v))};
109    ($k:expr,$v:expr) => {Attribute(id!($k),id!($v))}
110}
111
112/// represents an element of graph or subgraph which is, in turn, just a wrapper
113/// for the underlying structure as node,edge, subgraph etc.
114/// #Example:
115/// ```rust
116///     fn stmt_test() {
117///         use dot_generator::*;
118///         use dot_structures::*;
119///
120///         assert_eq!(stmt!(node!()), Stmt::Node(Node::new(NodeId(id!(), None), vec![])));
121///     }
122/// ```
123#[macro_export]
124macro_rules! stmt {
125    ($k:expr) => {Stmt::from($k)};
126}
127
128/// represents a subgraph in dot lang.
129/// #Example:
130/// ```rust
131///     fn subgraph_test() {
132///         use dot_generator::*;
133///         use dot_structures::*;
134///
135///         assert_eq!(subgraph!(), Subgraph { id: Id::Anonymous("".to_string()), stmts: vec![] });
136///         assert_eq!(subgraph!("abc";node!()),
137///                    Subgraph {
138///                        id: Id::Plain("abc".to_string()),
139///                        stmts: vec![stmt!(node!())],
140///                    });
141///     }
142/// ```
143#[macro_export]
144macro_rules! subgraph {
145    () => {Subgraph{id:id!(),stmts:vec![]}};
146    ($id:expr) => {Subgraph{id:id!($id),stmts:vec![]}};
147    ($i:ident $id:expr) => {Subgraph{id:id!($i$id),stmts:vec![]}};
148    ($id:expr, $stmts:expr) => {Subgraph{id:id!($id),stmts:$stmts}};
149    ($i:ident $id:expr, $stmts:expr) => {Subgraph{id:id!($i$id),stmts:$stmts}};
150    ($i:ident $id:expr; $($stmts:expr),+ ) => {{
151        let mut stmts_vec = Vec::new();
152        $( stmts_vec.push(stmt!($stmts)) ; )+
153        Subgraph{id:id!($i$id),stmts:stmts_vec}
154    }};
155    ($id:expr; $($stmts:expr),+ ) => {{
156        let mut stmts_vec = Vec::new();
157        $( stmts_vec.push(stmt!($stmts)) ; )+
158        Subgraph{id:id!($id),stmts:stmts_vec}
159    }};
160    (; $($stmts:expr),+ ) => {{
161        let mut stmts_vec = Vec::new();
162        $( stmts_vec.push(stmt!($stmts)) ; )+
163        Subgraph{id:id!(),stmts:stmts_vec}
164    }};
165
166}
167
168/// represents a node in dot lang.
169/// #Example:
170/// ```rust
171///     fn node_test() {
172///         use dot_generator::*;
173///         use dot_structures::*;
174///
175///         assert_eq!(node!(), Node::new(NodeId(id!(), None), vec![]));
176///         assert_eq!(node!(html "abc"; attr!("a","a")),
177///                    Node::new(NodeId(id!(html "abc"), None),
178///                              vec![attr!("a","a")]));
179///         assert_eq!(node!(html "abc" ; attr!("a","a")),
180///                    Node::new(NodeId(id!(html "abc"), None),
181///                              vec![attr!("a","a")]));
182///         assert_eq!(node!("abc" ; attr!("a","a"),attr!("a","a")),
183///                    Node::new(NodeId(id!( "abc"), None),
184///                              vec![attr!("a","a"), attr!("a","a")]))
185///     }
186/// ```
187#[macro_export]
188macro_rules! node {
189    () => {Node::new(NodeId(id!(), None), vec![])};
190    ($i:ident $id:expr) => {Node::new(NodeId(id!($i$id), None), vec![])};
191    ($id:expr) => {Node::new(NodeId(id!($id), None), vec![])};
192    ($i:ident $id:expr; $($attr:expr),+ ) => {{
193        let mut attrs = Vec::new();
194        $( attrs.push($attr) ; )+
195        Node::new(NodeId(id!($i$id), None), attrs)
196    }};
197     ($i:ident $id:expr, $attrs:expr  ) => {
198        Node::new(NodeId(id!($i$id), None), $attrs)
199    };
200    ($id:expr, $attrs:expr  ) => {
201        Node::new(NodeId(id!($id), None), $attrs)
202    };
203    ( $id:expr; $($attr:expr),+ ) => {{
204        let mut attrs = Vec::new();
205        $( attrs.push($attr) ; )+
206        Node::new(NodeId(id!( $id), None), attrs)
207    }};
208    ($i:ident $id:expr => $p:expr, $attrs:expr  ) => {
209        Node::new(NodeId(id!($i$id), Some($p)), $attrs)
210    };
211    ($i:ident $id:expr => $p:expr; $($attr:expr),+ ) => {{
212        let mut attrs = Vec::new();
213         $( attrs.push($attr) ; )+
214        Node::new(NodeId(id!($i$id), Some($p)), attrs)
215    }};
216    ( $id:expr => $p:expr, $attrs:expr  ) => {
217        Node::new(NodeId(id!($id), Some($p)), $attrs)
218    };
219    ( $id:expr => $p:expr; $($attr:expr),+ ) => {{
220        let mut attrs = Vec::new();
221        $( attrs.push($attr) ; )+
222        Node::new(NodeId(id!($id), Some($p)), attrs)
223    }};
224}
225
226/// represents an edge in dot lang.
227/// #Example:
228/// ```rust
229///     fn edge_test() {
230///         use dot_generator::*;
231///         use dot_structures::*;
232///
233///          assert_eq!(
234///             edge!(node_id!("1") => node_id!("2")),
235///             Edge { ty: EdgeTy::Pair(Vertex::N(node_id!("1")), Vertex::N(node_id!("2"))), attributes: vec![] }
236///         );
237///         assert_eq!(
238///             edge!(node_id!("1") => node_id!("2") => subgraph!("a")),
239///             Edge { ty: EdgeTy::Chain(vec![Vertex::N(node_id!("1")), Vertex::N(node_id!("2")), Vertex::S(subgraph!("a"))]), attributes: vec![] }
240///         );
241///         assert_eq!(
242///             edge!(node_id!("1") => node_id!("2"), vec![attr!("a","b")]),
243///             Edge { ty: EdgeTy::Pair(Vertex::N(node_id!("1")), Vertex::N(node_id!("2"))), attributes: vec![attr!("a","b")] }
244///         );
245///         assert_eq!(
246///             edge!(node_id!("1") => node_id!("2"); attr!("a","b")),
247///             Edge { ty: EdgeTy::Pair(Vertex::N(node_id!("1")), Vertex::N(node_id!("2"))), attributes: vec![attr!("a","b")] }
248///         );
249///     }
250/// ```
251#[macro_export]
252macro_rules! edge {
253    ($l:expr => $r:expr) => {
254        Edge{ ty: EdgeTy::Pair(Vertex::from($l),Vertex::from($r)), attributes: vec![] }
255    };
256    ($l:expr => $r:expr $(=> $nexts:expr)+) => {{
257         let mut edges_vec = vec![Vertex::from($l),Vertex::from($r)];
258         $( edges_vec.push(Vertex::from($nexts)) ; )+
259
260        Edge{ ty: EdgeTy::Chain(edges_vec), attributes: vec![] }
261    }};
262
263    ($l:expr => $r:expr, $attrs:expr) => {
264        Edge{ ty: EdgeTy::Pair(Vertex::from($l),Vertex::from($r)), attributes: $attrs };
265    };
266    ($l:expr => $r:expr; $($attrs:expr),+) => {{
267         let mut attrs_vec = Vec::new();
268        $( attrs_vec.push($attrs) ; )+
269        Edge{ ty: EdgeTy::Pair(Vertex::from($l),Vertex::from($r)), attributes: attrs_vec }
270    }};
271    ($l:expr => $r:expr $(=> $nexts:expr)+; $($attrs:expr),+) => {{
272         let mut attrs_vec = Vec::new();
273         $( attrs_vec.push($attrs) ; )+
274
275         let mut edges_vec = vec![Vertex::from($l),Vertex::from($r)];
276         $( edges_vec.push(Vertex::from($nexts)) ; )+
277
278        Edge{ ty: EdgeTy::Chain(edges_vec), attributes: attrs_vec }
279    }};
280    ($l:expr => $r:expr $(=> $nexts:expr)+ , $attrs:expr) => {{
281
282         let mut edges_vec = vec![Vertex::from($l),Vertex::from($r)]
283         $( edges_vec.push(Vertex::from($nexts)) ; )+
284
285        Edge{ ty: EdgeTy::Chain(edges_vec), attributes: $attrs }
286    }};
287}
288
289/// represents a graph in dot lang.
290///  - strict word stands for strict in graph
291///  - di word stands for digraph
292/// #Example:
293/// ```rust
294///     fn graph_test() {
295///         use dot_generator::*;
296///         use dot_structures::*;
297///
298///          assert_eq!(
299///             graph!(strict di id!("abc")),
300///             Graph::DiGraph { id: id!("abc"), strict: true, stmts: vec![] }
301///         );
302///         assert_eq!(
303///             graph!(strict di id!("abc");node!("abc")),
304///             Graph::DiGraph { id: id!("abc"), strict: true, stmts: vec![stmt!(node!("abc"))] }
305///         );
306///     }
307/// ```
308#[macro_export]
309macro_rules! graph {
310    (strict $id:expr) => {
311        Graph::Graph { id: $id, strict: true, stmts: vec![] }
312    };
313    ($id:expr) => {
314        Graph::Graph { id: $id, strict: false, stmts: vec![] }
315    };
316    (strict di $id:expr) => {
317        Graph::DiGraph { id: id!($id), strict: true, stmts: vec![] }
318    };
319    (di $id:expr) => {
320        Graph::DiGraph { id: id!($id), strict: false, stmts: vec![] }
321    };
322    (strict $id:expr, $stmts:expr) => {
323        Graph::Graph { id: $id, strict: true, stmts: $stmts }
324    };
325    ($id:expr, $stmts:expr) => {
326        Graph::Graph { id: $id, strict: false, stmts: $stmts }
327    };
328    (strict di $id:expr, $stmts:expr) => {
329        Graph::DiGraph { id: $id, strict: true, stmts: $stmts }
330    };
331    (di $id:expr, $stmts:expr) => {
332        Graph::DiGraph { id: $id, strict: false, stmts: $stmts }
333    };
334
335    (strict $id:expr; $($stmts:expr),+) => {{
336         let mut stmts = vec![];
337         $( stmts.push(stmt!($stmts)) ; )+
338        Graph::Graph { id: $id, strict: true, stmts: stmts }
339    }};
340    ($id:expr; $($stmts:expr),+) => {{
341         let mut stmts = vec![];
342         $( stmts.push(stmt!($stmts)) ; )+
343        Graph::Graph { id: $id, strict: false, stmts: stmts }
344    }};
345    (strict di $id:expr; $($stmts:expr),+) => {{
346         let mut stmts = vec![];
347         $( stmts.push(stmt!($stmts)) ; )+
348         Graph::DiGraph { id: $id, strict: true, stmts: stmts }
349    }};
350    (di $id:expr; $($stmts:expr),+) => {{
351         let mut stmts = vec![];
352         $( stmts.push(stmt!($stmts)) ; )+
353         Graph::DiGraph { id: $id, strict: false, stmts: stmts }
354    }};
355
356}
357
358#[cfg(test)]
359mod tests {
360    use dot_structures::*;
361
362    #[test]
363    fn graph_test() {
364        assert_eq!(
365            graph!(strict di id!("abc")),
366            Graph::DiGraph { id: id!("abc"), strict: true, stmts: vec![] }
367        );
368        assert_eq!(
369            graph!(strict di id!("abc");stmt!(node!("abc"))),
370            Graph::DiGraph { id: id!("abc"), strict: true, stmts: vec![stmt!(node!("abc"))] }
371        );
372    }
373
374    #[test]
375    fn edge_test() {
376        assert_eq!(
377            edge!(node_id!("1") => node_id!("2")),
378            Edge { ty: EdgeTy::Pair(Vertex::N(node_id!("1")), Vertex::N(node_id!("2"))), attributes: vec![] }
379        );
380        assert_eq!(
381            edge!(node_id!("1") => node_id!("2") => subgraph!("a")),
382            Edge { ty: EdgeTy::Chain(vec![Vertex::N(node_id!("1")), Vertex::N(node_id!("2")), Vertex::S(subgraph!("a"))]), attributes: vec![] }
383        );
384        assert_eq!(
385            edge!(node_id!("1") => node_id!("2"), vec![attr!("a","b")]),
386            Edge { ty: EdgeTy::Pair(Vertex::N(node_id!("1")), Vertex::N(node_id!("2"))), attributes: vec![attr!("a","b")] }
387        );
388        assert_eq!(
389            edge!(node_id!("1") => node_id!("2"); attr!("a","b")),
390            Edge { ty: EdgeTy::Pair(Vertex::N(node_id!("1")), Vertex::N(node_id!("2"))), attributes: vec![attr!("a","b")] }
391        );
392    }
393
394    #[test]
395    fn stmt_test() {
396        assert_eq!(stmt!(node!()), Stmt::Node(Node::new(NodeId(id!(), None), vec![])));
397    }
398
399    #[test]
400    fn subgraph_test() {
401        assert_eq!(subgraph!(), Subgraph { id: Id::Anonymous("".to_string()), stmts: vec![] });
402        assert_eq!(subgraph!("abc";node!()),
403                   Subgraph {
404                       id: Id::Plain("abc".to_string()),
405                       stmts: vec![stmt!(node!())],
406                   });
407    }
408
409    #[test]
410    fn node_test() {
411        assert_eq!(node!(), Node::new(NodeId(id!(), None), vec![]));
412        assert_eq!(node!(html "abc"; attr!("a","a")),
413                   Node::new(NodeId(id!(html "abc"), None),
414                             vec![attr!("a","a")]));
415        assert_eq!(node!(html "abc" ; attr!("a","a")),
416                   Node::new(NodeId(id!(html "abc"), None),
417                             vec![attr!("a","a")]));
418        assert_eq!(node!("abc" ; attr!("a","a"),attr!("a","a")),
419                   Node::new(NodeId(id!( "abc"), None),
420                             vec![attr!("a","a"), attr!("a","a")]))
421    }
422
423    #[test]
424    fn attr_test() {
425        assert_eq!(attr!("a","1"), Attribute(id!("a"), id!("1")));
426        assert_eq!(attr!(html "a","1"), Attribute(id!(html "a"), id!("1")))
427    }
428
429    #[test]
430    fn id_test() {
431        assert_eq!(id!(), Id::Anonymous("".to_string()));
432        assert_eq!(id!(html "<<abc>>"), Id::Html("<<abc>>".to_string()));
433        assert_eq!(id!("abc"), Id::Plain("abc".to_string()));
434        assert_eq!(id!(esc "ab\\\"c"), Id::Escaped("\"ab\\\"c\"".to_string()));
435    }
436}
dot_generator/lib.rs

dot_generator/
lib.rs
