willdo 0.0.1

Task manager with DAG
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

use super::{Edge, Graph, Relation};
use petgraph::{dot::Dot, visit::EdgeRef as _};
use core::fmt::{Debug, Display, Formatter};

impl Display for Graph {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        let config = [
            petgraph::dot::Config::EdgeNoLabel,
            petgraph::dot::Config::NodeNoLabel,
        ];
        Dot::with_attr_getters(
            self.dag.graph(),
            &config,
            &|_g, i| {
                let passed = self.passed(i.id());
                let trigger = self.is_trigger(i.id());

                format!(
                    "tooltip={:?},comment={source:?},{arrows},color={color}",
                    i.weight().to_string(),
                    source = i.weight().source,
                    color = match passed {
                        Some(true) => "green",
                        Some(false) => "red",
                        None => "black",
                    },
                    arrows = match trigger {
                        true => "dir=back,arrowtail=inv",
                        false => "arrowhead=odot",
                    }
                )
            },
            &|_g, (_i, job)| {
                let status = job.get_status();
                format!(
                    "label={:?},comment={source:?},shape=record,style=rounded,color={color}",
                    format!(
                        "{{ {} | {} }}",
                        job.job.id.to_string(),
                        match status {
                            Some(code) => format!("{code}"),
                            None => "-".to_string(),
                        }
                    ),
                    source = job.job.source,
                    color = match status {
                        None if job.is_running() => "cyan",
                        None => "gray",
                        Some(_) => "black",
                    }
                )
            },
        )
        .fmt(f)
    }
}

impl core::fmt::Display for Relation {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        match self {
            Relation::Trigger => f.write_str("=>"),
            Relation::Dependency => f.write_str("K="),
        }
    }
}
impl Display for Edge {
    fn fmt(&self, f: &mut Formatter<'_>) -> core::fmt::Result {
        write!(f, "{} {} {}", self.origin, self.relation, self.reference)?;
        for code in &self.codes {
            write!(f, "\n{}", code)?;
        }
        Ok(())
    }
}