simple_dot 0.1.1

Simple API for creating GraphViz DOT files.
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

/*!
One-line description.

More detailed description, with

# Example

# Features

 */

#![warn(
    unknown_lints,
    // ---------- Stylistic
    absolute_paths_not_starting_with_crate,
    elided_lifetimes_in_paths,
    explicit_outlives_requirements,
    macro_use_extern_crate,
    nonstandard_style, /* group */
    noop_method_call,
    rust_2018_idioms,
    single_use_lifetimes,
    trivial_casts,
    trivial_numeric_casts,
    // ---------- Future
    future_incompatible, /* group */
    rust_2021_compatibility, /* group */
    // ---------- Public
    missing_debug_implementations,
    // missing_docs,
    unreachable_pub,
    // ---------- Unsafe
    unsafe_code,
    unsafe_op_in_unsafe_fn,
    // ---------- Unused
    unused, /* group */
)]
#![deny(
    // ---------- Public
    exported_private_dependencies,
    private_in_public,
    // ---------- Deprecated
    anonymous_parameters,
    bare_trait_objects,
    ellipsis_inclusive_range_patterns,
    // ---------- Unsafe
    deref_nullptr,
    drop_bounds,
    dyn_drop,
)]

use unique_id::sequence::SequenceGenerator;
use unique_id::Generator;

#[macro_use]
mod macros;

// ------------------------------------------------------------------------------------------------
// Public Types
// ------------------------------------------------------------------------------------------------

pub trait Identified {
    fn id(&self) -> &Identifier;
}

#[derive(Clone, Debug, PartialEq)]
pub struct Identifier(String);

// ------------------------------------------------------------------------------------------------
// Public Functions
// ------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------
// Implementations
// ------------------------------------------------------------------------------------------------

string_newtype!(Identifier, "Identifier", is_valid_id_string);

impl From<i64> for Identifier {
    fn from(v: i64) -> Self {
        Self::new_unchecked(&v.to_string())
    }
}

impl From<usize> for Identifier {
    fn from(v: usize) -> Self {
        Self::new_unchecked(&v.to_string())
    }
}

impl From<f64> for Identifier {
    fn from(v: f64) -> Self {
        Self::new_unchecked(&v.to_string())
    }
}

impl Identifier {
    pub fn new_unchecked(s: &str) -> Self {
        Self(s.to_string())
    }

    pub fn new_node() -> Self {
        Self(format!("n{}", SequenceGenerator::default().next_id()))
    }

    pub fn new_edge() -> Self {
        Self(format!("e{}", SequenceGenerator::default().next_id()))
    }

    pub fn new_graph() -> Self {
        Self(format!("G{}", SequenceGenerator::default().next_id()))
    }

    pub fn new_cluster_graph() -> Self {
        Self(format!("C{}", SequenceGenerator::default().next_id()))
    }

    pub fn prefix(self, prefix: Identifier) -> Self {
        Self(format!("{}{}", prefix, self))
    }
}

// ------------------------------------------------------------------------------------------------
// Private Functions
// ------------------------------------------------------------------------------------------------

#[inline]
fn is_valid_id_string(s: &str) -> bool {
    let mut chars = s.chars();
    if let Some(first) = chars.next() {
        if first.is_ascii_alphabetic() || first == '_' {
            chars.all(|c| c.is_ascii_alphanumeric() || c == '_')
        } else if first.is_ascii_digit() || first == '-' || first == '.' {
            chars.all(|c| c.is_ascii_digit() || c == '.')
        } else if first == '"' && s.ends_with('"') {
            true
        } else if first == '<' && s.ends_with('>') {
            true
        } else {
            false
        }
    } else {
        false
    }
}

// ------------------------------------------------------------------------------------------------
// Modules
// ------------------------------------------------------------------------------------------------

pub mod error;

pub mod graph;
pub use graph::RootGraph;

pub mod node;
pub use node::Node;

pub mod edge;
pub use edge::Edge;

pub mod attributes;

pub mod visitor;

pub mod writer;