imagecli 0.2.1

A command line image processing tool.
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

//! Support for rendering markdown diagrams showing the evolution of the
//! image stack as a pipeline is evaluated.

use std::fmt::Write;

/// A diagram showing the evolution of the image stack
/// as a pipeline is evaluated.
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct StackDiagram {
    /// The stages to render, in order.
    pub stages: Vec<StackDiagramStage>,
}

/// A stage in a stack diagram.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum StackDiagramStage {
    /// A desription of what occurs between one stack state and the next.
    Transition(String),
    /// A list of the current stack contents.
    Stack(Vec<String>),
}

impl StackDiagram {
    /// Render the stack in a form suitable for inclusion in a markdown document.
    pub fn render_for_markdown(&self) -> String {
        let mut rendered = String::new();
        writeln!(rendered, "```").unwrap();
        for stage in &self.stages {
            match stage {
                StackDiagramStage::Transition(t) => {
                    writeln!(rendered, "    |").unwrap();
                    writeln!(rendered, "    | {}", t).unwrap();
                    writeln!(rendered, "    v").unwrap();
                }
                StackDiagramStage::Stack(s) => {
                    writeln!(rendered, " --------------------").unwrap();
                    let mut top = true;
                    for entry in s.iter() {
                        if top {
                            writeln!(rendered, " * {}", entry).unwrap();
                        } else {
                            writeln!(rendered, "   {}", entry).unwrap();
                        }
                        top = false;
                    }
                    writeln!(rendered, " --------------------").unwrap();
                }
            }
        }
        writeln!(rendered, "```").unwrap();
        rendered
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use pretty_assertions::assert_eq;

    #[test]
    fn test_render_stack_diagram() {
        let diagram = StackDiagram {
            stages: vec![
                StackDiagramStage::Transition("get inputs".into()),
                StackDiagramStage::Stack(vec!["A".into(), "B".into()]),
                StackDiagramStage::Transition("some operation".into()),
                StackDiagramStage::Stack(vec!["C".into(), "B".into()]),
                StackDiagramStage::Transition("save results".into()),
            ],
        };
        let expected = "```
    |
    | get inputs
    v
 --------------------
 * A
   B
 --------------------
    |
    | some operation
    v
 --------------------
 * C
   B
 --------------------
    |
    | save results
    v
```
";
        assert_eq!(diagram.render_for_markdown(), expected);
    }
}