Crate graphviz_rust

source ·
Expand description

The library allows to interact with graphviz format.

Description:

Essentially, it starts from 3 base methods:

  • parse: a source of a dot file in the dot notation. The output format is a Graph.
  • print: Graph and DotPrinter provides an ability to transform a graph into string following the notation
  • exec: an ability to execute a cmd graphviz engine into different formats and etc.
  • exec_dot: an ability to execute a cmd graphviz engine into different formats from a prepared string containing a dot graph.

Examples:

use dot_generator::*;
use dot_structures::*;
use graphviz_rust::{
    attributes::*,
    cmd::{CommandArg, Format},
    exec, exec_dot, parse,
    printer::{DotPrinter, PrinterContext},
};

fn parse_test() {
    let g: Graph = parse(
        r#"
        strict digraph t {
            aa[color=green]
            subgraph v {
                aa[shape=square]
                subgraph vv{a2 -> b2}
                aaa[color=red]
                aaa -> bbb
            }
            aa -> be -> subgraph v { d -> aaa}
            aa -> aaa -> v
        }
        "#,
    )
    .unwrap();

    assert_eq!(
        g,
        graph!(strict di id!("t");
          node!("aa";attr!("color","green")),
          subgraph!("v";
            node!("aa"; attr!("shape","square")),
            subgraph!("vv"; edge!(node_id!("a2") => node_id!("b2"))),
            node!("aaa";attr!("color","red")),
            edge!(node_id!("aaa") => node_id!("bbb"))
            ),
          edge!(node_id!("aa") => node_id!("be") => subgraph!("v"; edge!(node_id!("d") => node_id!("aaa")))),
          edge!(node_id!("aa") => node_id!("aaa") => node_id!("v"))
        )
    )
}

fn print_test() {
    let mut g = graph!(strict di id!("id"));
    assert_eq!(
        "strict digraph id {}".to_string(),
        g.print(&mut PrinterContext::default())
    );
}

fn output_test() {
    let mut g = graph!(id!("id");
         node!("nod"),
         subgraph!("sb";
             edge!(node_id!("a") => subgraph!(;
                node!("n";
                NodeAttributes::color(color_name::black), NodeAttributes::shape(shape::egg))
            ))
        ),
        edge!(node_id!("a1") => node_id!(esc "a2"))
    );
    let graph_svg = exec(
        g,
        &mut PrinterContext::default(),
        vec![Format::Svg.into()],
    )
    .unwrap();
}
fn output_exec_from_test() {
    let mut g = graph!(id!("id");
         node!("nod"),
         subgraph!("sb";
             edge!(node_id!("a") => subgraph!(;
                node!("n";
                NodeAttributes::color(color_name::black), NodeAttributes::shape(shape::egg))
            ))
        ),
        edge!(node_id!("a1") => node_id!(esc "a2"))
    );
    let dot = g.print(&mut PrinterContext::default());
    println!("{}", dot);
    let format = Format::Svg;

    let graph_svg = exec_dot(dot.clone(), vec![format.into()]).unwrap();

    let graph_svg = exec_dot(dot, vec![format.clone().into()]).unwrap();
}

Re-exports

Modules

  • attributes
    graphviz attributes
  • cmd
    It allows to execute cmd engine passing extra parameters
  • printer
    It allows to transform a graph into a string carrying dot info according to the notation.

Macros

Functions

  • exec
    Executes a given graph using a dot cmd client
  • exec_dot
    Executes a given string representation of the graph using a dot cmd client
  • parse
    Parses a given string into a graph format that can be used afterwards or returning an string with an error description
  • print
    Prints a given graph according to a given PrinterContext