alpm_types/
source.rs

1use std::{
2    fmt::{Display, Formatter},
3    path::PathBuf,
4    str::FromStr,
5};
6
7use serde::{Deserialize, Serialize};
8
9use crate::{Error, SourceUrl};
10
11/// Represents the location that a source file should be retrieved from
12///
13/// It can be either a local file (next to the PKGBUILD) or a URL.
14#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
15#[serde(tag = "type")]
16pub enum Source {
17    /// A local file source.
18    ///
19    /// The location must be a pure file name, without any path components (`/`).
20    /// Hence, the file must be located directly next to the PKGBUILD.
21    File {
22        /// The optional destination file name.
23        filename: Option<PathBuf>,
24        /// The source file name.
25        location: PathBuf,
26    },
27    /// A URL source.
28    SourceUrl {
29        /// The optional destination file name.
30        filename: Option<PathBuf>,
31        /// The source URL.
32        source_url: SourceUrl,
33    },
34}
35
36impl Source {
37    /// Returns the filename of the source if it is set.
38    pub fn filename(&self) -> Option<&PathBuf> {
39        match self {
40            Self::File { filename, .. } | Self::SourceUrl { filename, .. } => filename.as_ref(),
41        }
42    }
43}
44
45impl FromStr for Source {
46    type Err = Error;
47
48    /// Parses a `Source` from string.
49    ///
50    /// It is either a filename (in the same directory as the PKGBUILD)
51    /// or a url, optionally prefixed by a destination file name (separated by `::`).
52    ///
53    /// # Errors
54    ///
55    /// This function returns an error in the following cases:
56    ///
57    /// - The destination file name or url/source file name are malformed.
58    /// - The source file name is an absolute path.
59    ///
60    /// ## Examples
61    ///
62    /// ```
63    /// use std::{path::Path, str::FromStr};
64    ///
65    /// use alpm_types::Source;
66    /// use url::Url;
67    ///
68    /// # fn main() -> Result<(), alpm_types::Error> {
69    ///
70    /// // Parse from a string that represents a remote file link.
71    /// let source = Source::from_str("foopkg-1.2.3.tar.gz::https://example.com/download")?;
72    /// let Source::SourceUrl {
73    ///     source_url,
74    ///     filename,
75    /// } = source
76    /// else {
77    ///     panic!()
78    /// };
79    ///
80    /// assert_eq!(filename.unwrap(), Path::new("foopkg-1.2.3.tar.gz"));
81    /// assert_eq!(source_url.url.inner().host_str(), Some("example.com"));
82    /// assert_eq!(source_url.to_string(), "https://example.com/download");
83    ///
84    /// // Parse from a string that represents a local file.
85    /// let source = Source::from_str("renamed-source.tar.gz::test.tar.gz")?;
86    /// let Source::File { location, filename } = source else {
87    ///     panic!()
88    /// };
89    /// assert_eq!(location, Path::new("test.tar.gz"));
90    /// assert_eq!(filename.unwrap(), Path::new("renamed-source.tar.gz"));
91    ///
92    /// # Ok(())
93    /// # }
94    /// ```
95    fn from_str(s: &str) -> Result<Self, Self::Err> {
96        // First up, check if there's a filename prefix e.g. `filename::...`.
97        let (filename, location) = if let Some((filename, location)) = s.split_once("::") {
98            (Some(filename.into()), location)
99        } else {
100            (None, s)
101        };
102
103        // The following logic is a bit convoluted:
104        //
105        // - Check if we have a valid URL
106        // - If we don't have an URL, check if we have a valid relative filename.
107        // - If it is a valid URL go ahead and do the next parsing sequence into a SourceUrl.
108        match location.parse::<url::Url>() {
109            Ok(_) => {}
110            Err(url::ParseError::RelativeUrlWithoutBase) => {
111                if location.is_empty() {
112                    return Err(Error::FileNameIsEmpty);
113                } else if location.contains(std::path::MAIN_SEPARATOR) {
114                    return Err(Error::FileNameContainsInvalidChars(
115                        PathBuf::from(location),
116                        std::path::MAIN_SEPARATOR,
117                    ));
118                } else if location.contains('\0') {
119                    return Err(Error::FileNameContainsInvalidChars(
120                        PathBuf::from(location),
121                        '\0',
122                    ));
123                } else {
124                    // We have a valid relative file. Return early
125                    return Ok(Self::File {
126                        filename,
127                        location: location.into(),
128                    });
129                }
130            }
131            Err(e) => return Err(e.into()),
132        }
133
134        // Parse potential extra syntax from the URL.
135        let source_url = SourceUrl::from_str(location)?;
136        Ok(Self::SourceUrl {
137            filename,
138            source_url,
139        })
140    }
141}
142
143impl Display for Source {
144    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
145        match self {
146            Self::File { filename, location } => {
147                if let Some(filename) = filename {
148                    write!(f, "{}::{}", filename.display(), location.display())
149                } else {
150                    write!(f, "{}", location.display())
151                }
152            }
153            Self::SourceUrl {
154                filename,
155                source_url,
156            } => {
157                if let Some(filename) = filename {
158                    write!(f, "{}::{}", filename.display(), source_url)
159                } else {
160                    write!(f, "{}", source_url)
161                }
162            }
163        }
164    }
165}
166
167#[cfg(test)]
168mod tests {
169    use rstest::rstest;
170
171    use super::*;
172
173    #[rstest]
174    #[case("bikeshed_colour.patch::test", Ok(Source::File {
175        filename: Some(PathBuf::from("bikeshed_colour.patch")),
176        location: PathBuf::from("test"),
177    }))]
178    #[case("c:foo::test", Ok(Source::File {
179        filename: Some(PathBuf::from("c:foo")),
180        location: PathBuf::from("test"),
181    }))]
182    #[case(
183        "./bikeshed_colour.patch",
184        Err(Error::FileNameContainsInvalidChars(PathBuf::from("./bikeshed_colour.patch"), '/'))
185    )]
186    #[case("", Err(Error::FileNameIsEmpty))]
187    #[case(
188        "with\0null",
189        Err(Error::FileNameContainsInvalidChars(PathBuf::from("with\0null"), '\0'))
190    )]
191    fn parse_filename(#[case] input: &str, #[case] expected: Result<Source, Error>) {
192        let source = input.parse();
193        assert_eq!(source, expected);
194
195        if let Ok(source) = source {
196            assert_eq!(
197                source.filename(),
198                input.split("::").next().map(PathBuf::from).as_ref()
199            );
200        }
201    }
202
203    #[rstest]
204    #[case("bikeshed_colour.patch", Ok(Source::File {
205        filename: None,
206        location: PathBuf::from("bikeshed_colour.patch"),
207    }))]
208    #[case("renamed::local", Ok(Source::File {
209        filename: Some(PathBuf::from("renamed")),
210        location: PathBuf::from("local"),
211    }))]
212    #[case(
213        "foo-1.2.3.tar.gz::https://example.com/download",
214        Ok(Source::SourceUrl {
215            filename: Some(PathBuf::from("foo-1.2.3.tar.gz")),
216            source_url: SourceUrl::from_str("https://example.com/download").unwrap(),
217        })
218    )]
219    #[case(
220        "my-git-repo::git+https://example.com/project/repo.git?signed#commit=deadbeef",
221        Ok(Source::SourceUrl {
222            filename: Some(PathBuf::from("my-git-repo")),
223            source_url: SourceUrl::from_str("git+https://example.com/project/repo.git?signed#commit=deadbeef").unwrap(),
224        })
225    )]
226    #[case(
227        "file:///somewhere/else",
228        Ok(Source::SourceUrl {
229            filename: None,
230            source_url: SourceUrl::from_str("file:///somewhere/else").unwrap(),
231        })
232    )]
233    #[case(
234        "/absolute/path",
235        Err(Error::FileNameContainsInvalidChars(PathBuf::from("/absolute/path"), '/'))
236    )]
237    #[case(
238        "foo:::/absolute/path",
239        Err(Error::FileNameContainsInvalidChars(PathBuf::from(":/absolute/path"), '/'))
240    )]
241    fn parse_source(#[case] input: &str, #[case] expected: Result<Source, Error>) {
242        let source: Result<Source, Error> = input.parse();
243        assert_eq!(source, expected);
244
245        if let Ok(source) = source {
246            assert_eq!(source.to_string(), input);
247        }
248    }
249}
alpm_types/source.rs

alpm_types/
source.rs
