helix - Unnamed repository; edit this file 'description' to name the repository.


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
133

use std::{
    fmt,
    path::{Path, PathBuf},
    str::FromStr,
    sync::Arc,
};

/// A generic pointer to a file location.
///
/// Currently this type only supports paths to local files.
///
/// Cloning this type is cheap: the internal representation uses an Arc.
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
#[non_exhaustive]
pub enum Uri {
    File(Arc<Path>),
}

impl Uri {
    pub fn as_path(&self) -> Option<&Path> {
        match self {
            Self::File(path) => Some(path),
        }
    }
}

impl From<PathBuf> for Uri {
    fn from(path: PathBuf) -> Self {
        Self::File(path.into())
    }
}

impl fmt::Display for Uri {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            Self::File(path) => write!(f, "{}", path.display()),
        }
    }
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub struct UriParseError {
    source: String,
    kind: UriParseErrorKind,
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum UriParseErrorKind {
    UnsupportedScheme(String),
    MalformedUri,
}

impl fmt::Display for UriParseError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match &self.kind {
            UriParseErrorKind::UnsupportedScheme(scheme) => {
                write!(f, "unsupported scheme '{scheme}' in URI {}", self.source)
            }
            UriParseErrorKind::MalformedUri => {
                write!(
                    f,
                    "unable to convert malformed URI to file path: {}",
                    self.source
                )
            }
        }
    }
}

impl std::error::Error for UriParseError {}

impl FromStr for Uri {
    type Err = UriParseError;

    fn from_str(s: &str) -> Result<Self, Self::Err> {
        use std::ffi::OsStr;
        #[cfg(any(unix, target_os = "redox"))]
        use std::os::unix::prelude::OsStrExt;
        #[cfg(target_os = "wasi")]
        use std::os::wasi::prelude::OsStrExt;

        let Some((scheme, rest)) = s.split_once("://") else {
            return Err(Self::Err {
                source: s.to_string(),
                kind: UriParseErrorKind::MalformedUri,
            });
        };

        if scheme != "file" {
            return Err(Self::Err {
                source: s.to_string(),
                kind: UriParseErrorKind::UnsupportedScheme(scheme.to_string()),
            });
        }

        // Assert there is no query or fragment in the URI.
        if s.find(['?', '#']).is_some() {
            return Err(Self::Err {
                source: s.to_string(),
                kind: UriParseErrorKind::MalformedUri,
            });
        }

        let mut bytes = Vec::new();
        bytes.extend(percent_encoding::percent_decode(rest.as_bytes()));
        Ok(PathBuf::from(OsStr::from_bytes(&bytes)).into())
    }
}

impl TryFrom<&str> for Uri {
    type Error = UriParseError;

    fn try_from(s: &str) -> Result<Self, Self::Error> {
        s.parse()
    }
}

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

    #[test]
    fn unknown_scheme() {
        let uri = "csharp://metadata/foo/barBaz.cs";
        assert_eq!(
            uri.parse::<Uri>(),
            Err(UriParseError {
                source: uri.to_string(),
                kind: UriParseErrorKind::UnsupportedScheme("csharp".to_string()),
            })
        );
    }
}