slack-messaging 0.7.7

Support building Slack Block Kit message
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162

use crate::blocks::RichText;
use crate::blocks::table::RawText;
use serde::Serialize;
use serde_json::Number;

/// A table cell for DataTable block.
#[derive(Debug, Clone, Serialize, PartialEq)]
#[serde(untagged)]
pub enum DataTableCell {
    /// A plain text table cell
    RawText(RawText),

    /// A raw number table cell
    RawNumber(RawNumber),

    /// A rich text table cell
    RichText(RichText),
}

impl DataTableCell {
    pub fn is_raw_text(&self) -> bool {
        matches!(self, Self::RawText(_))
    }

    pub fn is_raw_number(&self) -> bool {
        matches!(self, Self::RawNumber(_))
    }

    pub fn is_rich_text(&self) -> bool {
        matches!(self, Self::RichText(_))
    }
}

impl<T: Into<String>> From<T> for DataTableCell {
    fn from(value: T) -> Self {
        Self::RawText(RawText::from(value))
    }
}

impl From<RawText> for DataTableCell {
    fn from(value: RawText) -> Self {
        Self::RawText(value)
    }
}

impl From<RawNumber> for DataTableCell {
    fn from(value: RawNumber) -> Self {
        Self::RawNumber(value)
    }
}

impl From<RichText> for DataTableCell {
    fn from(value: RichText) -> Self {
        Self::RichText(value)
    }
}

/// A raw number table cell value which can be used in [DataTable](crate::blocks::DataTable) block.
#[derive(Debug, Clone, PartialEq)]
pub struct RawNumber(Number, String);

impl RawNumber {
    pub fn new<N: Into<Number>, S: Into<String>>(value: N, text: S) -> Self {
        Self(value.into(), text.into())
    }
}

impl<N: Into<Number>, S: Into<String>> From<(N, S)> for RawNumber {
    fn from((value, text): (N, S)) -> Self {
        Self::new(value, text)
    }
}

impl Serialize for RawNumber {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer
    {
        use serde::ser::SerializeStruct;

        let mut state = serializer.serialize_struct("RawNumber", 3)?;
        state.serialize_field("type", "raw_number")?;
        state.serialize_field("value", &self.0)?;
        state.serialize_field("text", &self.1)?;
        state.end()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::blocks::rich_text::{RichTextSection, types::RichTextElementLink};

    #[test]
    fn it_serializes_into_raw_text_cell() {
        let cell = DataTableCell::RawText("Data 1A".into());

        let expected = serde_json::json!({
            "type": "raw_text",
            "text": "Data 1A",
        });

        let json = serde_json::to_value(cell).unwrap();
        assert_eq!(json, expected);
    }

    #[test]
    fn it_serializes_into_raw_number_cell() {
        let cell = DataTableCell::RawNumber((10usize, "Data 1A").into());

        let expected = serde_json::json!({
            "type": "raw_number",
            "value": 10,
            "text": "Data 1A"
        });

        let json = serde_json::to_value(cell).unwrap();
        assert_eq!(json, expected);
    }

    #[test]
    fn it_serializes_into_rich_text_cell() {
        let cell = DataTableCell::RichText(rich_text());

        let expected = serde_json::json!({
            "type": "rich_text",
            "elements": [
                {
                    "type": "rich_text_section",
                    "elements": [
                        {
                            "text": "Data 1B",
                            "type": "link",
                            "url": "https://slack.com"
                        }
                    ]
                }
            ]
        });

        let json = serde_json::to_value(cell).unwrap();
        assert_eq!(json, expected);
    }

    fn rich_text() -> RichText {
        RichText::builder()
            .element(
                RichTextSection::builder()
                    .element(
                        RichTextElementLink::builder()
                            .text("Data 1B")
                            .url("https://slack.com")
                            .build()
                            .unwrap(),
                    )
                    .build()
                    .unwrap(),
            )
            .build()
            .unwrap()
    }
}