flou 0.1.0

Parser for Flou, a flowchart description language.
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

use crate::{pos::PixelPos, svg::SVGElement};

pub(crate) enum PathD {
    MoveTo(PixelPos),
    LineTo(PixelPos),
    End,
}

impl ToString for PathD {
    fn to_string(&self) -> String {
        match self {
            PathD::MoveTo(pos) => format!("M {} {}", pos.x, pos.y),
            PathD::LineTo(pos) => format!("L {} {}", pos.x, pos.y),
            PathD::End => "Z".into(),
        }
    }
}

pub(crate) struct SVGPath {
    d: Vec<PathD>,
}

impl SVGPath {
    pub(crate) fn new() -> Self {
        Self { d: Vec::new() }
    }

    pub(crate) fn line_to(mut self, pos: PixelPos) -> Self {
        let cmd = if self.d.is_empty() {
            PathD::MoveTo(pos)
        } else {
            PathD::LineTo(pos)
        };
        self.d.push(cmd);
        self
    }

    pub(crate) fn end(mut self) -> Self {
        self.d.push(PathD::End);
        self
    }

    pub(crate) fn render(self) -> SVGElement<'static> {
        SVGElement::new("path").attr("d", self.get_d())
    }

    fn get_d(&self) -> String {
        self.d
            .iter()
            .map(ToString::to_string)
            .collect::<Vec<_>>()
            .join(" ")
    }
}

#[cfg(test)]
mod tests {
    use crate::{pos::pos, svg::SVGPath};

    use crate::test::assert_eq;

    #[test]
    fn create_path() {
        let mut path = SVGPath::new().line_to(pos(10, 20));
        assert_eq!(path.get_d(), "M 10 20");

        path = path.line_to(pos(30, 40));
        assert_eq!(path.get_d(), "M 10 20 L 30 40");

        path = path.end();
        assert_eq!(path.get_d(), "M 10 20 L 30 40 Z");
    }
}