murl 0.2.0

Non-stringly-typed 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

 [<img alt="crates.io" src="https://img.shields.io/crates/v/murl">](https://crates.io/crates/murl)

 # Murl
 Non-stringly-typed URLs.

 Urls are often used as strings, but what they really are is a serialized
 structure with fields such as `scheme`, `host`, `path` and `query_params`.
 In fact, `murl` URLs do _not_ contain their string representation inside them.

 This crate provides the `Url` struct, which should be the preferred
 way to create and modify URLs instead of fallibly parsing and/or concatenating
 strings, without ever exposing the user to things like percent-encoding issues.
 <br>
 ## Examples

 ### Infallibly creating a URL
 ```rust
use std::str::FromStr;
use murl::{Url, Scheme, Host, Label};
use camino::Utf8PathBuf;
// non-fallibly creating the url
 let mut url = Url{
     scheme: Scheme::Https,
     host: Host { // the hostname is "example.com"
         name: Label::from_str("example").unwrap(),
         domains:  vec![
             Label::from_str("com").unwrap(),
         ]
     },
     port: Some(443),
     path: Utf8PathBuf::from("/some/path"),
     query: ordermap::OrderMap::from([ // query params are just strings. Escaping is done automatically
         ("key with spaces".into(), "val&with&ampersands".into()),
         ("key=with=equals".into(), "val#with#hashtag".into()),
     ]),
     fragment: None,
 };
 assert_eq!(
     url.to_string(),
     "https://example.com:443/some/path?key%20with%20spaces=val%26with%26ampersands&key%3Dwith%3Dequals=val%23with%23hashtag"
 );
```

 ### Parsing a URL from a string
 If you get a string from a user or an external process, you can fallibly parse it via `FromStr`:

 ```rust
 use std::str::FromStr;
 use murl::{Url, Scheme, Host, Label};
 use camino::Utf8PathBuf;

 let parsed_url = Url::from_str("http://example.com/some/path?a=123").unwrap();
 let expected = Url{
     scheme: Scheme::Http,
     host: Host{
         name: Label::from_str("example").unwrap(),
         domains: vec![
             Label::from_str("com").unwrap()
         ],
     },
     port: None,
     path: Utf8PathBuf::from("/some/path"),
     query: ordermap::OrderMap::from([
         ("a".to_owned(), "123".to_owned())
     ]),
     fragment: None,
 };
 assert_eq!(parsed_url, expected);
 ```