queue-ast-hop 0.4.0

Static queue dependency graph for BullMQ and glide-mq
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

pub(crate) use no_mistakes_core::cli::Format;
use no_mistakes_core::cli::{edge_view, root_scoped_edge_depth};
use no_mistakes_core::queue::{Edge, ProjectReport};
use serde::Serialize;

pub(crate) fn print_edges(
    report: &ProjectReport,
    roots: &[String],
    depth: Option<usize>,
    format: Format,
) -> anyhow::Result<()> {
    let depth = root_scoped_edge_depth(roots, depth);
    let edges = edge_view(&report.edges, roots, depth);
    match format {
        Format::Json => {
            println!("{}", serde_json::to_string_pretty(&edges)?);
            Ok(())
        }
        Format::Yml => {
            println!("{}", serde_yaml::to_string(&edges)?);
            Ok(())
        }
        Format::Paths => {
            for edge in &edges {
                println!("{}", edge.to);
            }
            Ok(())
        }
        Format::Md => {
            println!("# Queue edges");
            for edge in &edges {
                println!("- `{}` -> `{}` ({})", edge.from, edge.to, edge.kind);
            }
            Ok(())
        }
        Format::Human => {
            if roots.is_empty() {
                println!("queue edges");
            } else {
                println!("{}", roots.join(", "));
            }
            for edge in &edges {
                println!("  {} -> {}", edge.from, edge.to);
            }
            Ok(())
        }
    }
}

pub(crate) fn print_related(
    roots: &[String],
    edges: &[Edge],
    format: Format,
) -> anyhow::Result<()> {
    #[derive(Serialize)]
    struct Related<'a> {
        roots: &'a [String],
        edges: &'a [Edge],
    }
    match format {
        Format::Json => {
            println!(
                "{}",
                serde_json::to_string_pretty(&Related { roots, edges })?
            );
        }
        Format::Yml => {
            println!("{}", serde_yaml::to_string(&Related { roots, edges })?);
        }
        Format::Paths => {
            for edge in edges {
                println!("{}", edge.to);
            }
        }
        Format::Md => {
            println!("# Related queue files");
            for edge in edges {
                println!("- `{}` -> `{}`", edge.from, edge.to);
            }
        }
        Format::Human => {
            println!("{}", roots.join(", "));
            for edge in edges {
                println!("  {} -> {}", edge.from, edge.to);
            }
        }
    }
    Ok(())
}

pub(crate) fn print_check(report: &ProjectReport, format: Format) -> anyhow::Result<()> {
    match format {
        Format::Json => println!("{}", serde_json::to_string_pretty(&report.check)?),
        Format::Yml => println!("{}", serde_yaml::to_string(&report.check)?),
        Format::Paths => {
            for finding in &report.check {
                println!("{}", finding.file);
            }
        }
        Format::Md => {
            println!("# Queue check");
            for finding in &report.check {
                println!("- `{}`:{} {}", finding.file, finding.line, finding.message);
            }
        }
        Format::Human => {
            for finding in &report.check {
                println!(
                    "{}[{}] {}:{} {}",
                    finding.kind,
                    finding.job.as_deref().unwrap_or("*"),
                    finding.file,
                    finding.line,
                    finding.message
                );
            }
        }
    }
    Ok(())
}