cargo-compiler-interrupts 4.0.1

Cargo subcommands that integrate the Compiler Interrupts to the package
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
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

//! Paths utilities

use std::path::{Path, PathBuf};

use anyhow::Context;

use crate::CIResult;

/// Extension trait for `AsRef<Path>`.
pub trait PathExt {
    /// Gets the file name of a path as a string.
    fn file_name(&self) -> CIResult<String>;

    /// Gets the file stem of a path as a string.
    fn file_stem(&self) -> CIResult<String>;

    /// Gets the file extension of a path as string.
    fn extension(&self) -> CIResult<String>;

    /// Gets the parent directory of a path.
    fn parent(&self) -> CIResult<PathBuf>;

    /// Converts a path to string.
    fn to_string(&self) -> CIResult<String>;

    /// Returns true if a path is executable.
    fn executable(&self) -> bool;

    /// Appends the suffix to the file stem of a path.
    fn append_suffix(&self, suffix: &str) -> CIResult<PathBuf>;

    /// Reads the directory for files matching the predicate.
    fn read_dir<P>(&self, predicate: P) -> CIResult<Vec<PathBuf>>
    where
        P: FnMut(&PathBuf) -> bool;
}

impl<T> PathExt for T
where
    T: AsRef<Path>,
{
    fn file_name(&self) -> CIResult<String> {
        let path = self.as_ref();
        path.file_name()
            .and_then(|s| s.to_str())
            .map(|s| s.to_string())
            .with_context(|| format!("failed to get file name `{}`", path.display()))
    }

    fn file_stem(&self) -> CIResult<String> {
        let path = self.as_ref();
        path.file_stem()
            .and_then(|s| s.to_str())
            .map(|s| s.to_string())
            .with_context(|| format!("failed to get file stem `{}`", path.display()))
    }

    fn extension(&self) -> CIResult<String> {
        let path = self.as_ref();
        path.extension()
            .and_then(|s| s.to_str())
            .map(|s| s.to_string())
            .with_context(|| format!("failed to get extension `{}`", path.display()))
    }

    fn parent(&self) -> CIResult<PathBuf> {
        let path = self.as_ref();
        Ok(path
            .parent()
            .with_context(|| format!("failed to get parent dir `{}`", path.display()))?
            .to_path_buf())
    }

    fn to_string(&self) -> CIResult<String> {
        let path = self.as_ref();
        path.to_str()
            .map(|s| s.to_string())
            .with_context(|| format!("failed to convert to string `{}`", path.display()))
    }

    fn executable(&self) -> bool {
        use std::os::unix::prelude::*;
        std::fs::metadata(self.as_ref())
            .map(|metadata| metadata.is_file() && metadata.permissions().mode() & 0o111 != 0)
            .unwrap_or(false)
    }

    fn append_suffix(&self, suffix: &str) -> CIResult<PathBuf> {
        let file_stem = self.file_stem()?;
        let extension = self.extension();
        let file_name = if let Ok(extension) = extension {
            format!("{}-{}.{}", file_stem, suffix, extension)
        } else {
            format!("{}-{}", file_stem, suffix)
        };
        Ok(self.as_ref().with_file_name(file_name))
    }

    fn read_dir<P>(&self, predicate: P) -> CIResult<Vec<PathBuf>>
    where
        P: FnMut(&PathBuf) -> bool,
    {
        let path = self.as_ref();
        Ok(path
            .read_dir()
            .with_context(|| format!("failed to read directory `{}`", path.display()))?
            .filter_map(|e| e.ok())
            .map(|e| e.path())
            .filter(predicate)
            .collect::<Vec<_>>())
    }
}