web-url 0.10.0

This library aids in processing web-based URLs.
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

use crate::{Fragment, WebUrl};

impl WebUrl {
    //! Fragment

    /// Gets the optional fragment.
    pub fn fragment(&self) -> Option<Fragment<'_>> {
        let fragment: &str = self.fragment_str();
        if fragment.is_empty() {
            None
        } else {
            Some(unsafe { Fragment::new(fragment) })
        }
    }

    /// Gets the fragment string.
    ///
    /// This will be a valid fragment starting with a '#' or empty.
    fn fragment_str(&self) -> &str {
        let start: usize = self.query_end as usize;
        &self.url[start..]
    }
}

impl WebUrl {
    //! Fragment Mutation

    /// Sets the `fragment`.
    pub fn set_fragment<'a, F>(&mut self, fragment: F)
    where
        F: Into<Option<Fragment<'a>>>,
    {
        self.url
            .truncate(self.url.len() - self.fragment_str().len());
        if let Some(fragment) = fragment.into() {
            self.url.push_str(fragment.as_str())
        }
    }

    /// Sets the `fragment`.
    pub fn with_fragment<'a, F>(mut self, fragment: F) -> Self
    where
        F: Into<Option<Fragment<'a>>>,
    {
        self.set_fragment(fragment);
        self
    }
}

#[cfg(test)]
mod tests {
    use crate::{Fragment, WebUrl};
    use std::error::Error;
    use std::str::FromStr;

    #[test]
    fn fragment_accessor() -> Result<(), Box<dyn Error>> {
        let url = WebUrl::from_str("https://example.com/path#section")?;
        let fragment = url.fragment().unwrap();
        assert_eq!(fragment.as_str(), "#section");
        assert_eq!(fragment.value(), "section");

        let url = WebUrl::from_str("https://example.com/path")?;
        assert!(url.fragment().is_none());

        Ok(())
    }

    #[test]
    fn set_fragment() -> Result<(), Box<dyn Error>> {
        let mut url: WebUrl = WebUrl::from_str("https://example.com")?;

        url.set_fragment(Fragment::try_from("#fragment")?);
        assert_eq!(url.as_str(), "https://example.com/#fragment");

        Ok(())
    }

    #[test]
    fn set_fragment_none() -> Result<(), Box<dyn Error>> {
        let mut url = WebUrl::from_str("https://example.com/path#fragment")?;
        assert!(url.fragment().is_some());

        url.set_fragment(None);
        assert!(url.fragment().is_none());
        assert_eq!(url.as_str(), "https://example.com/path");

        Ok(())
    }

    #[test]
    fn with_fragment() -> Result<(), Box<dyn Error>> {
        let url =
            WebUrl::from_str("https://example.com")?.with_fragment(Fragment::try_from("#frag")?);
        assert_eq!(url.as_str(), "https://example.com/#frag");

        let url = WebUrl::from_str("https://example.com/path#old")?.with_fragment(None);
        assert_eq!(url.as_str(), "https://example.com/path");

        Ok(())
    }
}