path: root/src/lib.rs

//! Simple graphviz dot file format output.

use AttributeText::*;
use std;
use std::borrow::Cow;
use std::collections::HashMap;
use std::io;
use std::io::prelude::*;
use std::marker::PhantomData;

static INDENT: &str = "    ";

/// Most of this comes from core rust. Where to provide attribution?
/// The text for a graphviz label on a node or edge.
#[derive(Clone, PartialEq, Eq, Debug)]
pub enum AttributeText<'a> {

    /// Preserves the text directly as is but wrapped in quotes.
    AttrStr(Cow<'a, str>),

    /// This kind of label uses the graphviz label escString type:
    /// <http://www.graphviz.org/doc/info/attrs.html#k:escString>
    ///
    /// Occurrences of backslashes (`\`) are not escaped; instead they
    /// are interpreted as initiating an escString escape sequence.
    ///
    /// Escape sequences of particular interest: in addition to `\n`
    /// to break a line (centering the line preceding the `\n`), there
    /// are also the escape sequences `\l` which left-justifies the
    /// preceding line and `\r` which right-justifies it.
    EscStr(Cow<'a, str>),

    /// This uses a graphviz [HTML string label][html]. 
    /// The string is printed exactly as given, but between `<` and `>`. 
    /// **No escaping is performed.**
    ///
    /// [html]: https://graphviz.org/doc/info/shapes.html#html
    HtmlStr(Cow<'a, str>),

    /// Preserves the text directly as is but wrapped in quotes.
    ///
    /// Occurrences of backslashes (`\`) are escaped, and thus appear
    /// as backslashes in the rendered label.
    QuottedStr(Cow<'a, str>),
}

impl<'a> AttributeText<'a> {
    pub fn attr<S: Into<Cow<'a, str>>>(s: S) -> AttributeText<'a> {
        AttrStr(s.into())
    }

    pub fn escaped<S: Into<Cow<'a, str>>>(s: S) -> AttributeText<'a> {
        EscStr(s.into())
    }

    pub fn html<S: Into<Cow<'a, str>>>(s: S) -> AttributeText<'a> {
        HtmlStr(s.into())
    }

    pub fn quotted<S: Into<Cow<'a, str>>>(s: S) -> AttributeText<'a> {
        QuottedStr(s.into())
    }

    fn escape_char<F>(c: char, mut f: F)
    where
        F: FnMut(char),
    {
        match c {
            // not escaping \\, since Graphviz escString needs to
            // interpret backslashes; see EscStr above.
            '\\' => f(c),
            _ => {
                for c in c.escape_default() {
                    f(c)
                }
            }
        }
    }

    fn escape_str(s: &str) -> String {
        let mut out = String::with_capacity(s.len());
        for c in s.chars() {
            AttributeText::escape_char(c, |c| out.push(c));
        }
        out
    }

    /// Renders text as string suitable for a attribute in a .dot file.
    /// This includes quotes or suitable delimiters.
    pub fn to_dot_string(&self) -> String {
        match *self {
            AttrStr(ref s) => format!("{}", s),
            EscStr(ref s) => format!("\"{}\"", AttributeText::escape_str(&s)),
            HtmlStr(ref s) => format!("<{}>", s),
            QuottedStr(ref s) => format!("\"{}\"", s.escape_default()),
        }
    }

    /// Decomposes content into string suitable for making EscStr that
    /// yields same content as self. The result obeys the law
    /// render(`lt`) == render(`EscStr(lt.pre_escaped_content())`) for
    /// all `lt: LabelText`.
    fn pre_escaped_content(self) -> Cow<'a, str> {
        match self {
            AttrStr(s) => s,
            EscStr(s) => s,
            HtmlStr(s) => s,
            QuottedStr(s) => {
                if s.contains('\\') {
                    (&*s).escape_default().to_string().into()
                } else {
                    s
                }
            }
            
        }
    }

    /// Puts `prefix` on a line above this label, with a blank line separator.
    pub fn prefix_line(self, prefix: AttributeText<'_>) -> AttributeText<'static> {
        prefix.suffix_line(self)
    }

    /// Puts `suffix` on a line below this label, with a blank line separator.
    pub fn suffix_line(self, suffix: AttributeText<'_>) -> AttributeText<'static> {
        let mut prefix = self.pre_escaped_content().into_owned();
        let suffix = suffix.pre_escaped_content();
        prefix.push_str(r"\n\n");
        prefix.push_str(&suffix);
        EscStr(prefix.into())
    }
}

// TODO: need a way to print out values
// TODO: not sure we need this enum but should support setting nodeport either via
// headport / tailport attributes e.g. a -> b [tailport=se]
// or via edge declaration using the syntax node name:port_name e.g. a -> b:se
// aka compass
pub enum Compass {
    N,
    NE,
    E,
    SE,
    S,
    SW,
    W,
    NW,
    None
}

impl Compass {
    pub fn as_slice(self) -> &'static str {
        match self {
            Compass::N => "n",
            Compass::NE => "ne",
            Compass::E => "e",
            Compass::SE => "se",
            Compass::S => "s",
            Compass::SW => "sw",
            Compass::W => "w",
            Compass::NW => "nw",
            Compass::None => "",
        }
    }
}

/// A graph's edge type determines whether it has directed edges or not.
pub trait GraphType {
    fn is_directed() -> bool;

    // TODO: maybe this doesnt below here
    // dont love the name
    fn as_slice() -> &'static str;

    fn edge_slice() -> &'static str;
}

impl GraphType for Directed {
    fn is_directed() -> bool {
        true
    }

    fn as_slice() -> &'static str {
        "digraph"
    }

    fn edge_slice() -> &'static str {
        "->"
    }
}

impl GraphType for Undirected {
    fn is_directed() -> bool {
        false
    }

    fn as_slice() -> &'static str {
        "graph"
    }

    fn edge_slice() -> &'static str {
        "--"
    }
}

// TODO: probably dont need this struct and can move impl methods into lib module
pub struct Dot<'a, Ty> {
    graph: Graph<'a, Ty>,
    //config: Config,
}

impl<'a, Ty> Dot<'a, Ty> 
where Ty: GraphType
{

    /// Renders directed graph `g` into the writer `w` in DOT syntax.
    /// (Simple wrapper around `render_opts` that passes a default set of options.)
    //pub fn render<W>(self, g: Graph, w: &mut W) -> io::Result<()>
    pub fn render<W>(self, w: &mut W) -> io::Result<()>
    where
        W: Write,
    {
        // TODO: use default_options?
        self.render_opts(w, &[])
    }

    // io::Result<()> vs Result<(), Box<dyn Error>>
    // https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html#the--operator-can-be-used-in-functions-that-return-result
    /// Renders directed graph `g` into the writer `w` in DOT syntax.
    /// (Main entry point for the library.)
    // pub fn render_opts<W>(self, graph: Graph, w: &mut W, options: &[RenderOption]) -> io::Result<()>
    pub fn render_opts<W>(self, w: &mut W, options: &[RenderOption]) -> io::Result<()>
    where
        W: Write,
    {
        if self.graph.comment.is_some() {
            writeln!(w, "{}", self.graph.comment.as_deref().unwrap_or_default())?;
        }
        
        let strict = if self.graph.strict { "strict " } else { "" }; 
        let id = self.graph.id.as_deref().unwrap_or_default();

        writeln!(w, "{}{} {} {{", strict, self.graph.as_slice(), id)?;

        // TODO: add global graph attributes

        for n in self.graph.nodes {
            // TODO: handle render options
            // Are render options something we need?
            // we could clone the node or and remove the attributes based on render options
            // or maybe we keep a set of attributes to ignore based on the options
            writeln!(w, "{}", n.to_dot_string());
        }

        for e in self.graph.edges {

        }

        writeln!(w, "}}")
    }
}

/// `Dot` configuration.
///
/// This enum does not have an exhaustive definition (will be expanded)
#[derive(Debug, PartialEq, Eq)]
pub enum Config {
    /// Use indices for node labels.
    NodeIndexLabel,
    /// Use indices for edge labels.
    EdgeIndexLabel,
    /// Use no edge labels.
    EdgeNoLabel,
    /// Use no node labels.
    NodeNoLabel,
    /// Do not print the graph/digraph string.
    GraphContentOnly,
    #[doc(hidden)]
    _Incomplete(()),
}

enum AttributeType {
    Graph,
    Node,
    Edge,
    None
}


// TODO: better name for this trait?
pub trait GraphTraits {

    /// Add a general or graph/node/edge attribute statement.
    /// ``None`` or ``'graph'``, ``'node'``, ``'edge'`
    fn add_attribute();

    fn add_node(label: &str);

    // fn add_edge(a: NodeIndex, b: NodeIndex, label: &str);

    // <(), i32>
    /// deps.extend_with_edges(&[
    ///     (pg, fb), (pg, qc),
    ///     (qc, rand), (rand, libc), (qc, libc),
    /// ]);
    /// pub fn from_edges<I>(iterable: I) -> Self
    fn add_edges();

    fn add_subgraph();
}


/// Marker type for a directed graph.
#[derive(Clone, Copy, Debug)]
pub enum Directed {}

/// Marker type for an undirected graph.
#[derive(Clone, Copy, Debug)]
pub enum Undirected {}


pub type DiGraph<'a> = Graph<'a, Directed>;

pub type UnGraph<'a> = Graph<'a, Undirected>;

pub struct Graph<'a, Ty = Directed> {

    pub id: Option<String>,
    
    pub strict: bool,

    // Comment added to the first line of the source.
    // TODO: support multiple comments
    pub comment: Option<String>,

    pub graph_attributes: Option<Vec<String>>,

    // pub nodes: Vec<&'a Node<'a>>,

    pub nodes: Vec<Node<'a>>,

    pub edges: Vec<String>,

    ty: PhantomData<Ty>,

    // TODO: should this have
    // pub graph_type: Ty,
    // then have Directed and Undirected enums implement fn to print graph type string?
    // pub graph_type: Ty,
}

// TODO: i feel like default should be undirect. 
// imo, feel more natural to say new_directed vs new_undirected. check to see if 
impl<'a> Graph<'a, Directed> {
    pub fn new(id: Option<String>) -> Self {
        Graph {
            id: id,
            strict: false,
            comment: None,
            graph_attributes: None,
            nodes: Vec::new(),
            edges: Vec::new(),
            ty: PhantomData,
        }
    }
}

impl<'a> Graph<'a, Undirected> {
    /// Create a new `Graph` with undirected edges.
    ///
    /// This is a convenience method. Use `Graph::with_capacity` or `Graph::default` for
    /// a constructor that is generic in all the type parameters of `Graph`.
    pub fn new_undirected(id: Option<String>) -> Self {
        Graph {
            id: id,
            strict: false,
            comment: None,
            graph_attributes: None,
            nodes: Vec::new(),
            edges: Vec::new(),
            ty: PhantomData,
        }
    }
}

impl<'a, Ty> Graph<'a, Ty> 
where Ty: GraphType
{
    /// Whether the graph has directed edges or not.
    #[inline]
    pub fn is_directed(&self) -> bool {
        Ty::is_directed()
    }

    pub fn as_slice(&self) -> &'static str {
        Ty::as_slice()
    }

    // graphviz calls this edgeop
    pub fn edge_type(&self) -> &'static str {
        Ty::edge_slice()
    }

    // fn add_node(&mut self, node: &'a Node<'a>) {
    //     self.nodes.push(node);
    // }

    fn add_node(&mut self, node: Node<'a>) {
        self.nodes.push(node);
    }

    // fn add_node_mut(&mut self, node: &mut Node<'a>) {
    //     self.nodes.push(node);
    // }

    // fn create_node(&mut self, id: &str) -> Node {
    //     let node = Node::new(id.to_string());
    //     self.nodes.push(node);
    //     node
    // }
}

// TODO: add node builder using "with" convention
pub struct Node<'a> {

    pub id: String,

    pub port: Option<String>,

    // pub compass: Option<Compass>,

    // // TODO: enum?
    // shape: Option<String>,

    // label: Option<String>,
    
    pub attributes: HashMap<String, AttributeText<'a>>,

    // style

}

impl<'a> Node<'a> {

    pub fn new(id: String) -> Node<'a> {
        Node {
            id: id,
            port: None,
            // compass: None,
            // shape: None,
            // label: None,
            attributes: HashMap::new(),
        }
    }

    /// Set the port for the node.
    pub fn port(mut self, port: String) -> Self {
        self.port = Some(port);
        self
    }

    // pub fn compass<'a>(&'a mut self, compass: Compass) -> &'a mut Node {
    //     self.compass = Some(compass);
    //     self
    // }

    pub fn label(mut self, text: String) -> Self {
        // self.label = Some(text);
        self.attributes.insert("label".to_string(), QuottedStr(text.into()));
        self
    }

    // TODO: create enum for shape at some point
    // pub fn shape<'a>(&'a mut self, shape: String) -> &'a mut Node {
    //     self.attributes.insert("shape".to_string(), shape);
    //     self
    // }

    /// Add an attribute to the node.
    pub fn attribute(mut self, key: String, value: AttributeText<'a>) -> Self {
        self.attributes.insert(key, value);
        self
    }

    /// Add multiple attribures to the node.
    pub fn attributes(mut self, attributes: HashMap<String, AttributeText<'a>>) -> Self {
        self.attributes.extend(attributes);
        self
    }

    pub fn to_dot_string(&self) -> String {
        let mut dot_string = format!("{}{}", INDENT, &self.id);
        // TODO: I dont love this logic. I would like to find away to not have a special case.
        // I think we introduce a AttributeText enum which encodes how to write out the attribute value
        if !self.attributes.is_empty() {
            dot_string.push_str(" [");
            for (key, value) in &self.attributes {
                dot_string.push_str(format!("{}={}", key, value.to_dot_string()).as_str());
            }
            dot_string.push_str("]");
        }
        dot_string.push_str(";");
        return dot_string.to_string();
    }
}


pub struct NodeBuilder<'a> {
    id: String,

    port: Option<String>,
    
    attributes: HashMap<String, AttributeText<'a>>,
}

impl<'a> NodeBuilder<'a> {
    pub fn new(id: String) -> NodeBuilder<'a> {
        NodeBuilder {
            id: id,
            port: None,
            // compass: None,
            // shape: None,
            // label: None,
            attributes: HashMap::new(),
        }
    }

    /// Set the port for the node.
    pub fn port<S: Into<String>>(&mut self, port: S) -> &mut Self {
        self.port = Some(port.into());
        self
    }

    // pub fn compass<'a>(&'a mut self, compass: Compass) -> &'a mut Node {
    //     self.compass = Some(compass);
    //     self
    // }

    pub fn label<S: Into<Cow<'a, str>>>(&mut self, text: S) -> &mut Self {
        // self.label = Some(text);
        self.attributes.insert("label".to_string(), QuottedStr(text.into()));
        self
    }

    // TODO: create enum for shape at some point
    // pub fn shape<'a>(&'a mut self, shape: String) -> &'a mut Node {
    //     self.attributes.insert("shape".to_string(), shape);
    //     self
    // }

    /// Add an attribute to the node.
    pub fn attribute<S: Into<String>>(&mut self, key: S, value: AttributeText<'a>) -> &mut Self {
        self.attributes.insert(key.into(), value);
        self
    }

    /// Add multiple attribures to the node.
    pub fn attributes(&'a mut self, attributes: HashMap<String, AttributeText<'a>>) -> &mut Self {
        self.attributes.extend(attributes);
        self
    }

    pub fn build(&self) -> Node<'a> {
        Node {
            // TODO: are these to_owned and clones necessary?
            id: self.id.to_owned(),
            port: self.port.to_owned(),
            attributes: self.attributes.clone()
        }
    }
}

#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum RenderOption {
    NoEdgeLabels,
    NoNodeLabels,
    NoEdgeStyles,
    NoNodeStyles,

    // TODO: replace with Fontname(String),
    Monospace,
}

/// Returns vec holding all the default render options.
pub fn default_options() -> Vec<RenderOption> {
    vec![]
}


/// The style for a node or edge.
/// See <http://www.graphviz.org/doc/info/attrs.html#k:style> for descriptions.
/// Note that some of these are not valid for edges.
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum Style {
    None,
    Solid,
    Dashed,
    Dotted,
    Bold,
    Rounded,
    Diagonals,
    Filled,
    Striped,
    Wedged,
}

impl Style {
    pub fn as_slice(self) -> &'static str {
        match self {
            Style::None => "",
            Style::Solid => "solid",
            Style::Dashed => "dashed",
            Style::Dotted => "dotted",
            Style::Bold => "bold",
            Style::Rounded => "rounded",
            Style::Diagonals => "diagonals",
            Style::Filled => "filled",
            Style::Striped => "striped",
            Style::Wedged => "wedged",
        }
    }
}

fn test_input<Ty>(g: Graph<Ty>) -> io::Result<String> 
where Ty: GraphType
{
    let mut writer = Vec::new();
    let dot = Dot {
        graph: g
    };

    dot.render(&mut writer).unwrap();
    let mut s = String::new();
    Read::read_to_string(&mut &*writer, &mut s)?;
    Ok(s)
}

#[test]
fn empty_digraph() {
    // TODO: support both String and &str
    let g = Graph::new(Some("empty_graph".to_string()));
    let r = test_input(g);
    assert_eq!(
        r.unwrap(),
        r#"digraph empty_graph {
}
"#
    );
}

#[test]
fn empty_graph() {
    // TODO: support both String and &str
    let g = Graph::new_undirected(Some("empty_graph".to_string()));
    let r = test_input(g);
    assert_eq!(
        r.unwrap(),
        r#"graph empty_graph {
}
"#
    );
}

#[test]
fn single_node() {
    let mut g = Graph::new(Some("single_node".to_string()));
    g.add_node(Node::new("N0".to_string()));
    let r = test_input(g);
    assert_eq!(
        r.unwrap(),
        r#"digraph single_node {
    N0;
}
"#
    );
}

#[test]
fn single_node_with_style() {
    let mut g = Graph::new(Some("single_node".to_string()));
    let mut nb = NodeBuilder::new("N0".to_string());
    let node = nb.attribute("style", AttributeText::quotted("dashed")).build();

    g.add_node(node);

    let r = test_input(g);
    assert_eq!(
        r.unwrap(),
        r#"digraph single_node {
    N0 [style="dashed"];
}
"#
    );
}

// #[test]
// fn support_non_inline_builder() {
//     let mut g = Graph::new(Some("single_node".to_string()));

//     // TODO: having to split this is stupid. am i doing something wrong?
//     let mut node_builder = NodeBuilder::new("N0".to_string());
//     node_builder.attribute("style", AttributeText::quotted("dashed"));

//     if true {
//         node_builder.attribute("", AttributeText::quotted(""));
//     }

//     let node = node_builder.build();
//     g.add_node(node);

//     let r = test_input(g);
//     assert_eq!(
//         r.unwrap(),
//         r#"digraph single_node {
//     N0 [style="dashed"];
// }
// "#
//     );
// }

// #[test]
// fn single_edge() {
//     let labels: Trivial = UnlabelledNodes(2);
//     let result = test_input(LabelledGraph::new(
//         "single_edge",
//         labels,
//         vec![edge(0, 1, "E", Style::None)],
//         None,
//     ));
//     assert_eq!(
//         result.unwrap(),
//         r#"digraph single_edge {
//     N0[label="N0"];
//     N1[label="N1"];
//     N0 -> N1[label="E"];
// }
// "#
//     );
// }

// #[test]
// fn single_edge_with_style() {
//     let labels: Trivial = UnlabelledNodes(2);
//     let result = test_input(LabelledGraph::new(
//         "single_edge",
//         labels,
//         vec![edge(0, 1, "E", Style::Bold)],
//         None,
//     ));
//     assert_eq!(
//         result.unwrap(),
//         r#"digraph single_edge {
//     N0[label="N0"];
//     N1[label="N1"];
//     N0 -> N1[label="E"][style="bold"];
// }
// "#
//     );
// }