slack-messaging 0.7.5

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

use crate::blocks::RichText;
use serde::Serialize;

/// A table cell value in table rows
#[derive(Debug, Clone, Serialize, PartialEq)]
#[serde(untagged)]
pub enum TableCell {
    /// A plain text table cell
    RawText(RawText),

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

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

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

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

/// A plain text table cell value which can be used both in [DataTable](crate::blocks::DataTable) and
/// [Table](crate::blocks::Table) blocks.
#[derive(Debug, Clone, PartialEq)]
pub struct RawText(String);

impl RawText {
    pub fn new<T: Into<String>>(text: T) -> Self {
        Self(text.into())
    }
}

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

impl Serialize for RawText {
    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("RawText", 2)?;
        state.serialize_field("type", "raw_text")?;
        state.serialize_field("text", &self.0)?;
        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 = TableCell::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_rich_text_cell() {
        let cell = TableCell::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()
    }
}