hina 0.1.3

:].
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

pub mod ext;
pub mod macros;
pub mod util;


pub use self::{ext::*, macros::*};


use std::borrow::Cow;
use std::ffi::OsStr;
use std::path::{Component, Path, PathBuf, Prefix};


// returns the volume name for some path, intended for display.
pub fn volume_name(path: &Path) -> Option<String> {
    fn display(string: &OsStr) -> Cow<str> {
        string.to_string_lossy()
    }


    if let Some(component) = path.components().next() {
        let volume = match component {
            Component::Prefix(prefix) => match prefix.kind() {
                Prefix::Verbatim(name) => format!("{}", display(name)),
                Prefix::VerbatimUNC(server, share) => format!("{}\\{}", display(server), display(share)),
                Prefix::VerbatimDisk(disk) => format!("{}:\\", disk as char),
                Prefix::DeviceNS(namespace) => format!("{}", display(namespace)),
                Prefix::UNC(server, share) => format!("{}\\{}\\", display(server), display(share)),
                Prefix::Disk(disk) => format!("{}:\\", disk as char),
            },
            Component::RootDir => "/".to_owned(),
            Component::CurDir => ".".to_owned(),
            Component::ParentDir => "..".to_owned(),
            Component::Normal(x) => x.to_string_lossy().into(),
        };

        Some(volume)
    } else {
        None
    }
}



pub trait PathExt {
    /// appends a `path` to self. if `path` is a unix-like rooted path, then it is transformed into a relative path.
    ///
    /// # examples
    ///
    /// ```
    /// # use std::path::PathBuf;
    /// # use hina::path::PathExt;
    ///
    /// let mut path = PathBuf::from("/home/code");
    /// path.append("/rust/projects/awesome");
    ///
    /// let expected = PathBuf::from("/home/code/rust/projects/awesome");
    /// assert_eq!(path, expected);
    /// ```
    fn append(&mut self, path: impl AsRef<Path>);
}

impl PathExt for PathBuf {
    fn append(&mut self, path: impl AsRef<Path>) {
        crate::path::util::__for_internal_usage_only_append__(self, path);
    }
}



pub struct PathBufEx;

impl PathBufEx {
    /// constructs a `PathBuf` from a slice of path components
    ///
    /// # examples
    ///
    /// ```
    /// use hina::path::PathBufEx;
    /// use std::path::PathBuf;
    ///
    /// let path = PathBufEx::from(&["/home", "code", "/projects"]);
    /// let expected = PathBuf::from("home/code/projects");
    /// assert_eq!(path, expected);
    /// ```
    pub fn from(args: &[impl AsRef<Path>]) -> PathBuf {
        let mut path = PathBuf::new();

        for arg in args {
            path.append(arg);
        }

        path
    }
}



pub struct PathEx;

impl PathEx {
    /// constructs a `Path` from a slice of path components
    ///
    /// # examples
    ///
    /// ```
    /// use hina::path::PathEx;
    /// use std::path::Path;
    ///
    /// let path = PathEx::from(&["/home", "code", "/projects"]);
    /// let expected = Path::new("home/code/projects");
    /// assert_eq!(path, expected);
    /// ```
    pub fn from(args: &[impl AsRef<Path>]) -> PathBuf {
        PathBufEx::from(args)
    }
}