path-utils 0.1.0

std::path utilities
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

//! Utility library for [`std::path::Path`] and [`std::path::PathBuf`].
//!
//! ```
//! use std::path::Path;
//! use path_utils::PathExt;
//!
//! let path = Path::new("file.tar.gz");
//! let extensions = path.extensions_lossy().collect::<Vec<String>>();
//! assert_eq!(extensions, ["gz", "tar"]);
//! ```

#![deny(clippy::all, missing_docs)]
#![warn(clippy::pedantic, clippy::nursery, clippy::cargo)]

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

/// [`Path`] and [`PathBuf`] extensions.
pub trait PathExt {
    /// Returns an iterator over the extensions of a path, lossily converted.
    ///
    /// ```
    /// use std::path::Path;
    /// use path_utils::PathExt;
    ///
    /// let path = Path::new("file.tar.gz");
    /// let extensions = path.extensions_lossy().collect::<Vec<String>>();
    /// assert_eq!(extensions, ["gz", "tar"]);
    fn extensions_lossy(&self) -> ExtensionsLossy;
}

impl<T> PathExt for T
where
    T: AsRef<Path>,
{
    fn extensions_lossy(&self) -> ExtensionsLossy {
        ExtensionsLossy {
            path: self.as_ref().to_path_buf(),
        }
    }
}

/// An iterator over the [`Path::extension`]s of a path, lossily converted.
#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
#[must_use = "iterators are lazy and do nothing unless consumed"]
pub struct ExtensionsLossy {
    path: PathBuf,
}

impl Iterator for ExtensionsLossy {
    type Item = String;
    fn next(&mut self) -> Option<Self::Item> {
        let s = self
            .path
            .extension()
            .map(|s| String::from(s.to_string_lossy()));
        self.path.set_extension("");
        s
    }
}

// ----------------------------------------------------------------------------
// tests
// ----------------------------------------------------------------------------

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

    fn exts_lossy(p: impl AsRef<Path>) -> Vec<String> {
        p.as_ref().extensions_lossy().collect()
    }

    #[test]
    fn extensions_lossy() {
        assert!(Path::new("/path/to/file")
            .extensions_lossy()
            .next()
            .is_none());

        assert!(PathBuf::from("/path/to/.file")
            .extensions_lossy()
            .next()
            .is_none());

        assert_eq!(exts_lossy("/path/to/file.tar"), ["tar"]);
        assert_eq!(exts_lossy("/path/to/.file.tar"), ["tar"]);
        assert_eq!(exts_lossy("/path/to/file.tar.gz"), ["gz", "tar"]);
    }
}