seru 0.1.0

simple image renderer
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

use std::str::FromStr;

use crate::render::{args::Args, styles::Size};

#[derive(Debug, Clone, Copy, Default)]
pub struct BoxStyle {
    pub gap: Option<Size>,
    pub direction: Option<BoxDirection>,
    pub main: Option<MainAlign>,
    pub cross: Option<CrossAlign>,
}

#[derive(Debug, Clone, Copy)]
pub enum MainAlign {
    Center,
    Start,
    End,
    FlexStart,
    FlexEnd,
    Between,
    Around,
    Evenly,
    Stretch,
}

#[derive(Debug, Clone, Copy)]
pub enum CrossAlign {
    Start,
    End,
    FlexStart,
    FlexEnd,
    Center,
    Baseline,
    Stretch,
}

#[derive(Debug, Clone, Copy)]
pub enum BoxDirection {
    Column,
    Row,
}

impl BoxStyle {
    pub fn take_from(name: &str, args: &mut Args) -> anyhow::Result<Self> {
        let mut style = BoxStyle::default();

        if let Some(v) = args.take("gap") {
            style.gap = Some(v.into_size()?);
        }

        if let Some(v) = args.take_string("direction")? {
            style.direction = Some(v.parse()?);
        }

        if let Some(v) = args.take_string("main")? {
            style.main = Some(v.parse()?);
        }

        if let Some(v) = args.take_string("cross")? {
            style.cross = Some(v.parse()?);
        }

        apply_box_preset(name, &mut style);

        Ok(style)
    }
}

fn apply_box_preset(name: &str, style: &mut BoxStyle) {
    match name {
        "Center" => {
            style.direction.get_or_insert(BoxDirection::Column);
            style.main.get_or_insert(MainAlign::Center);
            style.cross.get_or_insert(CrossAlign::Center);
        }
        "Column" => {
            style.direction.get_or_insert(BoxDirection::Column);
        }
        "Row" => {
            style.direction.get_or_insert(BoxDirection::Row);
        }
        "Box" => {
            style.direction.get_or_insert(BoxDirection::Column);
            style.main.get_or_insert(MainAlign::Start);
            style.cross.get_or_insert(CrossAlign::Stretch);
        }
        _ => {}
    }
}

impl FromStr for BoxDirection {
    type Err = anyhow::Error;

    fn from_str(value: &str) -> Result<Self, Self::Err> {
        Ok(match value {
            "column" => BoxDirection::Column,
            "row" => BoxDirection::Row,
            v => anyhow::bail!("invalid box direction: {}", v),
        })
    }
}

impl FromStr for MainAlign {
    type Err = anyhow::Error;

    fn from_str(value: &str) -> Result<Self, Self::Err> {
        Ok(match value {
            "center" => MainAlign::Center,
            "start" => MainAlign::Start,
            "end" => MainAlign::End,
            "flex-start" => MainAlign::FlexStart,
            "flex-end" => MainAlign::FlexEnd,
            "between" => MainAlign::Between,
            "around" => MainAlign::Around,
            "evenly" => MainAlign::Evenly,
            "stretch" => MainAlign::Stretch,
            v => anyhow::bail!("invalid main align: {}", v),
        })
    }
}

impl FromStr for CrossAlign {
    type Err = anyhow::Error;

    fn from_str(value: &str) -> Result<Self, Self::Err> {
        Ok(match value {
            "start" => CrossAlign::Start,
            "end" => CrossAlign::End,
            "flex-start" => CrossAlign::FlexStart,
            "flex-end" => CrossAlign::FlexEnd,
            "center" => CrossAlign::Center,
            "baseline" => CrossAlign::Baseline,
            "stretch" => CrossAlign::Stretch,
            v => anyhow::bail!("invalid cross align: {}", v),
        })
    }
}