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

//! Create embed fields.

use twilight_model::channel::message::embed::EmbedField;

/// Create an embed field with a builder.
///
/// This can be passed into [`EmbedBuilder::field`].
///
/// Fields are not inlined by default. Use [`inline`] to inline a field.
///
/// [`EmbedBuilder::field`]: crate::builder::embed::EmbedBuilder::field
/// [`inline`]: Self::inline
#[derive(Clone, Debug, Eq, PartialEq)]
#[must_use = "must be built into an embed field"]
pub struct EmbedFieldBuilder(EmbedField);

impl EmbedFieldBuilder {
    /// Create a new embed field builder.
    ///
    /// Refer to [`FIELD_NAME_LENGTH`] for the maximum number of UTF-16 code
    /// points that can be in a field name.
    ///
    /// Refer to [`FIELD_VALUE_LENGTH`] for the maximum number of UTF-16 code
    /// points that can be in a field value.
    ///
    /// [`FIELD_NAME_LENGTH`]: twilight_validate::embed::FIELD_NAME_LENGTH
    /// [`FIELD_VALUE_LENGTH`]: twilight_validate::embed::FIELD_VALUE_LENGTH
    pub fn new(name: impl Into<String>, value: impl Into<String>) -> Self {
        Self(EmbedField {
            inline: false,
            name: name.into(),
            value: value.into(),
        })
    }

    /// Build into an embed field.
    #[allow(clippy::missing_const_for_fn)]
    #[must_use = "should be used as part of an embed builder"]
    pub fn build(self) -> EmbedField {
        self.0
    }

    /// Inline the field.
    ///
    /// # Examples
    ///
    /// Create an inlined field:
    ///
    /// ```no_run
    /// use twilight_util::builder::embed::EmbedFieldBuilder;
    ///
    /// let field = EmbedFieldBuilder::new("twilight", "is cool")
    ///     .inline()
    ///     .build();
    /// ```
    pub const fn inline(mut self) -> Self {
        self.0.inline = true;

        self
    }
}

impl From<EmbedFieldBuilder> for EmbedField {
    /// Convert an embed field builder into an embed field.
    ///
    /// This is equivalent to calling [`EmbedFieldBuilder::build`].
    fn from(builder: EmbedFieldBuilder) -> Self {
        builder.build()
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use static_assertions::assert_impl_all;
    use std::fmt::Debug;

    assert_impl_all!(EmbedFieldBuilder: Clone, Debug, Eq, PartialEq, Send, Sync);
    assert_impl_all!(EmbedField: From<EmbedFieldBuilder>);

    #[test]
    fn builder_inline() {
        let expected = EmbedField {
            inline: true,
            name: "name".to_owned(),
            value: "value".to_owned(),
        };
        let actual = EmbedFieldBuilder::new("name", "value").inline().build();

        assert_eq!(actual, expected);
    }

    #[test]
    fn builder_no_inline() {
        let expected = EmbedField {
            inline: false,
            name: "name".to_owned(),
            value: "value".to_owned(),
        };
        let actual = EmbedFieldBuilder::new("name", "value").build();

        assert_eq!(actual, expected);
    }
}