Skip to main content

slack_messaging/blocks/rich_text/
preformatted.rs

1use crate::blocks::rich_text::types::RichTextElementType;
2use crate::validators::*;
3
4use serde::Serialize;
5use slack_messaging_derive::Builder;
6
7/// [Rich text preformatted element](https://docs.slack.dev/reference/block-kit/blocks/rich-text-block#rich_text_preformatted)
8/// representation.
9///
10/// # Fields and Validations
11///
12/// For more details, see the [official
13/// documentation](https://docs.slack.dev/reference/block-kit/blocks/rich-text-block#rich_text_preformatted).
14///
15/// | Field | Type | Required | Validation |
16/// |-------|------|----------|------------|
17/// | elements | Vec<[RichTextElementType]> | Yes | N/A |
18/// | border | i64 | No | N/A |
19/// | language | String | No | N/A |
20///
21/// # Example
22///
23/// ```
24/// use slack_messaging::blocks::rich_text::prelude::*;
25/// # use std::error::Error;
26///
27/// # fn try_main() -> Result<(), Box<dyn Error>> {
28/// let preformatted = RichTextPreformatted::builder()
29///     .element(
30///         RichTextElementText::builder()
31///             .text("{\n  \"object\": {\n    \"description\": \"this is an example of a json object\"\n  }\n}")
32///             .build()?
33///     )
34///     .border(0)
35///     .build()?;
36///
37/// let expected = serde_json::json!({
38///     "type": "rich_text_preformatted",
39///     "elements": [
40///         {
41///             "type": "text",
42///             "text": "{\n  \"object\": {\n    \"description\": \"this is an example of a json object\"\n  }\n}"
43///         }
44///     ],
45///     "border": 0
46/// });
47///
48/// let json = serde_json::to_value(preformatted).unwrap();
49///
50/// assert_eq!(json, expected);
51///
52/// // If your object has any validation errors, the build method returns Result::Err
53/// let preformatted = RichTextPreformatted::builder().build();
54/// assert!(preformatted.is_err());
55/// #     Ok(())
56/// # }
57/// # fn main() {
58/// #     try_main().unwrap()
59/// # }
60/// ```
61#[derive(Debug, Clone, Serialize, PartialEq, Builder)]
62#[serde(tag = "type", rename = "rich_text_preformatted")]
63pub struct RichTextPreformatted {
64    #[builder(push_item = "element", validate("required"))]
65    pub(crate) elements: Option<Vec<RichTextElementType>>,
66
67    #[serde(skip_serializing_if = "Option::is_none")]
68    pub(crate) border: Option<i64>,
69
70    #[serde(skip_serializing_if = "Option::is_none")]
71    pub(crate) language: Option<String>,
72}
73
74#[cfg(test)]
75mod tests {
76    use super::*;
77    use crate::blocks::rich_text::types::test_helpers::*;
78    use crate::errors::*;
79
80    #[test]
81    fn it_implements_builder() {
82        let expected = RichTextPreformatted {
83            elements: Some(vec![el_text("foo"), el_emoji("bar")]),
84            border: Some(3),
85            language: Some("python".into()),
86        };
87
88        let val = RichTextPreformatted::builder()
89            .set_elements(Some(vec![el_text("foo"), el_emoji("bar")]))
90            .set_border(Some(3))
91            .set_language(Some("python"))
92            .build()
93            .unwrap();
94
95        assert_eq!(val, expected);
96
97        let val = RichTextPreformatted::builder()
98            .elements(vec![el_text("foo"), el_emoji("bar")])
99            .border(3)
100            .language("python")
101            .build()
102            .unwrap();
103
104        assert_eq!(val, expected);
105    }
106
107    #[test]
108    fn it_implements_push_item_method() {
109        let expected = RichTextPreformatted {
110            elements: Some(vec![el_text("foo"), el_emoji("bar")]),
111            border: None,
112            language: None,
113        };
114
115        let val = RichTextPreformatted::builder()
116            .element(text("foo"))
117            .element(emoji("bar"))
118            .build()
119            .unwrap();
120
121        assert_eq!(val, expected);
122    }
123
124    #[test]
125    fn it_requres_elements_field() {
126        let err = RichTextPreformatted::builder().build().unwrap_err();
127        assert_eq!(err.object(), "RichTextPreformatted");
128
129        let errors = err.field("elements");
130        assert!(errors.includes(ValidationErrorKind::Required));
131    }
132}