oliframe 0.3.9

Add a simple border to one or more images
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
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Relative position of an element in the final frame.
use crate::errors::OliframeError;
use derive_getters::Getters;
use std::str::FromStr;
use strum::IntoEnumIterator;
use strum_macros::{AsRefStr, EnumIter, EnumString};

/// Relative position of an image in the final frame.
///
/// The relative position is defined by two values:
/// - Horizontal position: left, center, right
/// - Vertical position: top, center, bottom
///
#[derive(Debug, Default, Getters, PartialEq)]
pub struct RelativePosition {
    /// Horizontal position of the image.
    horizontal: HorizontalPosition,
    /// Vertical position of the image.
    vertical: VerticalPosition,
}

impl FromStr for RelativePosition {
    type Err = OliframeError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let horizontal = extract_position(s).ok_or(OliframeError::InvalidInput(
            "Please provide only one horizontal position.".to_string(),
        ))?;

        let vertical = extract_position(s).ok_or(OliframeError::InvalidInput(
            "Please provide only one vertical position.".to_string(),
        ))?;

        Ok(Self {
            horizontal,
            vertical,
        })
    }
}

/// Extract the position from the given string.
fn extract_position<P>(s: &str) -> Option<P>
where
    P: FromStr + IntoEnumIterator + AsRef<str> + Default + PartialEq,
    P::Err: std::fmt::Debug,
{
    P::iter()
        .filter(|pos| s.contains(pos.as_ref()))
        .try_fold(P::default(), |acc, pos| match (acc, pos) {
            (acc, pos) if acc == P::default() => Ok(pos),
            (acc, pos) if pos == P::default() => Ok(acc),
            _ => Err(()),
        })
        .ok()
}

/// Horizontal position of an element in the final frame.
#[derive(AsRefStr, Debug, Default, EnumIter, EnumString, PartialEq)]
#[strum(serialize_all = "snake_case")]
pub enum HorizontalPosition {
    /// The element is positioned on the left side of the frame.
    Left,
    /// The element is positioned in the center of the frame.
    #[default]
    Center,
    /// The element is positioned on the right side of the frame.
    Right,
}

/// Vertical position of an element in the final frame.
#[derive(AsRefStr, Debug, Default, EnumIter, EnumString, PartialEq)]
#[strum(serialize_all = "snake_case")]
pub enum VerticalPosition {
    /// The element is positioned at the top of the frame.
    Top,
    #[default]
    /// The element is positioned in the center of the frame.
    Center,
    /// The element is positioned at the bottom of the frame.
    Bottom,
}

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

    #[test]
    fn parse_horizontal_position_from_string() {
        let position = "left".parse::<HorizontalPosition>().unwrap();
        assert_eq!(position, HorizontalPosition::Left);

        let position = "center".parse::<HorizontalPosition>().unwrap();
        assert_eq!(position, HorizontalPosition::Center);

        let position = "right".parse::<HorizontalPosition>().unwrap();
        assert_eq!(position, HorizontalPosition::Right);
    }

    #[test]
    fn parse_vertical_position_from_string() {
        let position = "top".parse::<VerticalPosition>().unwrap();
        assert_eq!(position, VerticalPosition::Top);

        let position = "center".parse::<VerticalPosition>().unwrap();
        assert_eq!(position, VerticalPosition::Center);

        let position = "bottom".parse::<VerticalPosition>().unwrap();
        assert_eq!(position, VerticalPosition::Bottom);
    }

    #[test]
    fn parse_relative_position_from_string() {
        let position = "left,top".parse::<RelativePosition>().unwrap();
        assert_eq!(position.horizontal, HorizontalPosition::Left);
        assert_eq!(position.vertical, VerticalPosition::Top);

        let position = "center,bottom".parse::<RelativePosition>().unwrap();
        assert_eq!(position.horizontal, HorizontalPosition::Center);
        assert_eq!(position.vertical, VerticalPosition::Bottom);

        let position = "right,center".parse::<RelativePosition>().unwrap();
        assert_eq!(position.horizontal, HorizontalPosition::Right);
        assert_eq!(position.vertical, VerticalPosition::Center);

        let position = "center,center".parse::<RelativePosition>().unwrap();
        assert_eq!(position.horizontal, HorizontalPosition::Center);
        assert_eq!(position.vertical, VerticalPosition::Center);

        let position = "center".parse::<RelativePosition>().unwrap();
        assert_eq!(position.horizontal, HorizontalPosition::Center);
        assert_eq!(position.vertical, VerticalPosition::Center);
    }

    #[test]
    fn parse_invalid_relative_position_from_string() {
        let position = "left,right,bottom".parse::<RelativePosition>();
        assert!(position.is_err());
        assert_eq!(
            position.unwrap_err().to_string(),
            "Invalid input: Please provide only one horizontal position."
        );

        let position = "center,bottom,top".parse::<RelativePosition>();
        assert!(position.is_err());
        assert_eq!(
            position.unwrap_err().to_string(),
            "Invalid input: Please provide only one vertical position."
        );
    }
}