chara_card 0.4.1

A library to deal with character card formats and `.charx` in Rust.
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

use std::path::PathBuf;
use url::Url;

#[derive(Debug, Clone)]
pub enum Source {
    CCDefault,
    Embedded(PathBuf),
    File(PathBuf),
    Misc(Url),
}

impl From<&Url> for Source {
    fn from(url: &Url) -> Self {
        match url.scheme() {
            "ccdefault" => return Self::CCDefault,

            "embeded" | "embedded" => {
                let host = url.host_str().unwrap_or("");
                let path = url.path();

                let path = format!(
                    "{}{}",
                    urlencoding::decode(host).unwrap(),
                    urlencoding::decode(path).unwrap()
                );

                return Self::Embedded(path.to_string().into());
            }

            "file" => {
                if let Ok(path) = url.to_file_path() {
                    return Self::File(path);
                }
            }

            _ => {}
        }

        Self::Misc(url.to_owned())
    }
}

impl Into<Url> for Source {
    fn into(self) -> Url {
        match self {
            Source::CCDefault => "ccdefault:".parse().unwrap(),
            Source::Embedded(path) => format!("embeded://{}", path.to_str().unwrap())
                .parse()
                .unwrap(),
            Source::File(path) => Url::from_file_path(path).unwrap(),
            Source::Misc(url) => url,
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use rstest::rstest;

    #[rstest]
    #[case("ccdefault:")]
    #[case("embeded://")]
    #[case("embeded://path")]
    #[case("embeded:///path")]
    #[case("embeded://path/where")]
    #[case("embeded:///path/where")]
    #[case("file:")]
    #[case("file://")]
    #[case("file://path")]
    #[case("file:///path")]
    #[case("file://path/where")]
    #[case("file:///path/where")]
    #[case("http://domain")]
    #[case("http:///path")]
    #[case("http://domain/where")]
    #[case("http:///path/where")]
    fn isomorphic_test(#[case] url: &str) {
        let url: Url = url.parse().unwrap();

        let source: Source = (&url).into();
        let source_url: Url = source.into();

        assert_eq!(url, source_url);
    }
}