uf 0.1.5

Minimalistic file opener
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

use {
    anyhow::{Context, anyhow, bail},
    std::{
        fmt::{self, Display, Formatter},
        fs, io,
        path::Path,
        process::Command,
        str,
    },
};

#[derive(Debug)]
pub struct MimeType {
    supertype: String,
    subtype: String,
}

impl MimeType {
    /// Get the MIME type of a file.
    ///
    /// # Errors
    ///
    /// Fails if the MIME type cannot be determined.
    pub fn detect<P: AsRef<Path>>(file_path: P) -> anyhow::Result<Self> {
        if !fs::exists(&file_path).context("Could not determine if file exists")? {
            bail!("No such file");
        }

        let output = Command::new("file")
            .arg("--brief")
            .arg("--dereference")
            .arg("--mime-type")
            .arg(file_path.as_ref())
            .output()
            .map_err(|err| match err.kind() {
                io::ErrorKind::NotFound => {
                    anyhow!("'file' command not found. Ensure that the 'file' program is installed on your system.")
                }
                _ => anyhow::Error::from(err).context("'file' command failed"),
            })?;

        if output.status.success() {
            let mime_type =
                str::from_utf8(&output.stdout).context("'file' output is invalid UTF-8")?;
            let (supertype, subtype) = mime_type
                .trim()
                .split_once('/')
                .with_context(|| format!("'file' output is not a valid MIME type: {mime_type}"))?;
            Ok(Self {
                supertype: supertype.to_string(),
                subtype: subtype.to_string(),
            })
        } else {
            let error = String::from_utf8_lossy(&output.stderr);
            Err(anyhow!("{}", error).context("'file' command failed"))
        }
    }

    pub fn supertype(&self) -> &str {
        &self.supertype
    }

    pub fn subtype(&self) -> &str {
        &self.subtype
    }
}

impl Display for MimeType {
    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
        write!(f, "{}/{}", self.supertype, self.subtype)
    }
}