http/uri/
builder.rs

Help
1use std::convert::TryInto;
2
3use super::{Authority, Parts, PathAndQuery, Scheme};
4use crate::Uri;
5
6/// A builder for `Uri`s.
7///
8/// This type can be used to construct an instance of `Uri`
9/// through a builder pattern.
10#[derive(Debug)]
11pub struct Builder {
12    parts: Result<Parts, crate::Error>,
13}
14
15impl Builder {
16    /// Creates a new default instance of `Builder` to construct a `Uri`.
17    ///
18    /// # Examples
19    ///
20    /// ```
21    /// # use http::*;
22    ///
23    /// let uri = uri::Builder::new()
24    ///     .scheme("https")
25    ///     .authority("hyper.rs")
26    ///     .path_and_query("/")
27    ///     .build()
28    ///     .unwrap();
29    /// ```
30    #[inline]
31    pub fn new() -> Builder {
32        Builder::default()
33    }
34
35    /// Set the `Scheme` for this URI.
36    ///
37    /// # Examples
38    ///
39    /// ```
40    /// # use http::*;
41    ///
42    /// let mut builder = uri::Builder::new();
43    /// builder.scheme("https");
44    /// ```
45    pub fn scheme<T>(self, scheme: T) -> Self
46    where
47        T: TryInto<Scheme>,
48        <T as TryInto<Scheme>>::Error: Into<crate::Error>,
49    {
50        self.map(move |mut parts| {
51            let scheme = scheme.try_into().map_err(Into::into)?;
52            parts.scheme = Some(scheme);
53            Ok(parts)
54        })
55    }
56
57    /// Set the `Authority` for this URI.
58    ///
59    /// # Examples
60    ///
61    /// ```
62    /// # use http::*;
63    ///
64    /// let uri = uri::Builder::new()
65    ///     .authority("tokio.rs")
66    ///     .build()
67    ///     .unwrap();
68    /// ```
69    pub fn authority<T>(self, auth: T) -> Self
70    where
71        T: TryInto<Authority>,
72        <T as TryInto<Authority>>::Error: Into<crate::Error>,
73    {
74        self.map(move |mut parts| {
75            let auth = auth.try_into().map_err(Into::into)?;
76            parts.authority = Some(auth);
77            Ok(parts)
78        })
79    }
80
81    /// Set the `PathAndQuery` for this URI.
82    ///
83    /// # Examples
84    ///
85    /// ```
86    /// # use http::*;
87    ///
88    /// let uri = uri::Builder::new()
89    ///     .path_and_query("/hello?foo=bar")
90    ///     .build()
91    ///     .unwrap();
92    /// ```
93    pub fn path_and_query<T>(self, p_and_q: T) -> Self
94    where
95        T: TryInto<PathAndQuery>,
96        <T as TryInto<PathAndQuery>>::Error: Into<crate::Error>,
97    {
98        self.map(move |mut parts| {
99            let p_and_q = p_and_q.try_into().map_err(Into::into)?;
100            parts.path_and_query = Some(p_and_q);
101            Ok(parts)
102        })
103    }
104
105    /// Consumes this builder, and tries to construct a valid `Uri` from
106    /// the configured pieces.
107    ///
108    /// # Errors
109    ///
110    /// This function may return an error if any previously configured argument
111    /// failed to parse or get converted to the internal representation. For
112    /// example if an invalid `scheme` was specified via `scheme("!@#%/^")`
113    /// the error will be returned when this function is called rather than
114    /// when `scheme` was called.
115    ///
116    /// Additionally, the various forms of URI require certain combinations of
117    /// parts to be set to be valid. If the parts don't fit into any of the
118    /// valid forms of URI, a new error is returned.
119    ///
120    /// # Examples
121    ///
122    /// ```
123    /// # use http::*;
124    ///
125    /// let uri = Uri::builder()
126    ///     .build()
127    ///     .unwrap();
128    /// ```
129    pub fn build(self) -> Result<Uri, crate::Error> {
130        let parts = self.parts?;
131        Uri::from_parts(parts).map_err(Into::into)
132    }
133
134    // private
135
136    fn map<F>(self, func: F) -> Self
137    where
138        F: FnOnce(Parts) -> Result<Parts, crate::Error>,
139    {
140        Builder {
141            parts: self.parts.and_then(func),
142        }
143    }
144}
145
146impl Default for Builder {
147    #[inline]
148    fn default() -> Builder {
149        Builder {
150            parts: Ok(Parts::default()),
151        }
152    }
153}
154
155impl From<Uri> for Builder {
156    fn from(uri: Uri) -> Self {
157        Self {
158            parts: Ok(uri.into_parts()),
159        }
160    }
161}
162
163#[cfg(test)]
164mod tests {
165    use super::*;
166
167    #[test]
168    fn build_from_str() {
169        let uri = Builder::new()
170            .scheme(Scheme::HTTP)
171            .authority("hyper.rs")
172            .path_and_query("/foo?a=1")
173            .build()
174            .unwrap();
175        assert_eq!(uri.scheme_str(), Some("http"));
176        assert_eq!(uri.authority().unwrap().host(), "hyper.rs");
177        assert_eq!(uri.path(), "/foo");
178        assert_eq!(uri.query(), Some("a=1"));
179    }
180
181    #[test]
182    fn build_from_string() {
183        for i in 1..10 {
184            let uri = Builder::new()
185                .path_and_query(format!("/foo?a={}", i))
186                .build()
187                .unwrap();
188            let expected_query = format!("a={}", i);
189            assert_eq!(uri.path(), "/foo");
190            assert_eq!(uri.query(), Some(expected_query.as_str()));
191        }
192    }
193
194    #[test]
195    fn build_from_string_ref() {
196        for i in 1..10 {
197            let p_a_q = format!("/foo?a={}", i);
198            let uri = Builder::new().path_and_query(&p_a_q).build().unwrap();
199            let expected_query = format!("a={}", i);
200            assert_eq!(uri.path(), "/foo");
201            assert_eq!(uri.query(), Some(expected_query.as_str()));
202        }
203    }
204
205    #[test]
206    fn build_from_uri() {
207        let original_uri = Uri::default();
208        let uri = Builder::from(original_uri.clone()).build().unwrap();
209        assert_eq!(original_uri, uri);
210    }
211}
http/uri/builder.rs

http/uri/
builder.rs
