mxp 1.2.1

Rust implementation of the MXP (Mud eXtension Protocol) standard
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

use std::borrow::{Borrow, Cow};

use html_escape::encode_double_quoted_attribute as escape;

use super::tag::TagOpen;
use crate::arguments::Arguments;

/// Utility for servers to build custom opening tags.
///
/// # Examples
///
/// ```
/// let mut builder = mxp::node::TagBuilder::new("monster");
/// builder
///     .push("hostile")
///     .push_all(&["Minotaur", "old veteran"])
///     .insert("hp", "150");
/// let tag = builder.build();
/// assert_eq!(
///     tag.to_string(),
///     r#"<monster hostile Minotaur "old veteran" hp=150>"#
/// );
/// ```
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct TagBuilder<'a> {
    tag: TagOpen<'a, Cow<'a, str>>,
}

/// A server-side utility for building opening tags.
///
///
impl<'a> TagBuilder<'a> {
    /// Creates a builder for an opening tag with the specified element name.
    pub fn new(name: &'a str) -> Self {
        Self {
            tag: TagOpen {
                name,
                arguments: Arguments::default(),
                empty: false,
            },
        }
    }

    /// Converts this builder into a finalized `TagOpen`.
    pub fn build(self) -> TagOpen<'a, Cow<'a, str>> {
        self.tag
    }

    /// Adds a positional argument or keyword without escaping special characters.
    pub fn push(&mut self, value: &'a str) -> &mut Self {
        self.tag.arguments.push(value.into());
        self
    }

    /// Adds a positional argument or keyword after escaping special characters.
    pub fn escape_and_push(&mut self, value: &'a str) -> &mut Self {
        self.tag.arguments.push(escape(value));
        self
    }

    /// Adds multiple positional arguments or keywords without escaping special characters.
    pub fn push_all<I>(&mut self, iter: I) -> &mut Self
    where
        I: IntoIterator,
        I::Item: Borrow<&'a str>,
    {
        self.tag
            .arguments
            .extend(iter.into_iter().map(|s| Cow::Borrowed(*s.borrow())));
        self
    }

    /// Adds multiple positional arguments or keywords after escaping special characters.
    pub fn escape_and_push_all<I>(&mut self, iter: I) -> &mut Self
    where
        I: IntoIterator,
        I::Item: Borrow<&'a str>,
    {
        self.tag
            .arguments
            .extend(iter.into_iter().map(|s| escape(*s.borrow())));
        self
    }

    /// Inserts a named argument without escaping special characters.
    pub fn insert(&mut self, name: &'a str, value: &'a str) -> &mut Self {
        self.tag.arguments.insert(name, value.into());
        self
    }

    /// Inserts a named argument after escaping special characters.
    pub fn escape_and_insert(&mut self, name: &'a str, value: &'a str) -> &mut Self {
        self.tag.arguments.insert(name, escape(value));
        self
    }

    /// Inserts multiple named arguments without escaping special characters.
    pub fn insert_all<I, K, V>(&mut self, iter: I) -> &mut Self
    where
        I: IntoIterator,
        I::Item: Borrow<(K, V)>,
        K: Borrow<&'a str>,
        V: Borrow<&'a str>,
    {
        self.tag.arguments.extend(iter.into_iter().map(|entry| {
            let (k, v) = entry.borrow();
            (*k.borrow(), Cow::Borrowed(*v.borrow()))
        }));
        self
    }

    /// Inserts multiple named arguments after escaping special characters.
    pub fn escape_and_insert_all<I, K, V>(&mut self, iter: I) -> &mut Self
    where
        I: IntoIterator,
        I::Item: Borrow<(K, V)>,
        K: Borrow<&'a str>,
        V: Borrow<&'a str>,
    {
        self.tag.arguments.extend(iter.into_iter().map(|entry| {
            let (k, v) = entry.borrow();
            (*k.borrow(), escape(*v.borrow()))
        }));
        self
    }

    /// Tag will end with a `'/'` character, indicating that is empty.
    pub fn set_empty(&mut self, empty: bool) -> &mut Self {
        self.tag.empty = empty;
        self
    }
}