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

#[cfg(unix)]
use std::os::unix::fs::PermissionsExt;
use std::path::{Component, Path, PathBuf};

use nu_path::{canonicalize_with, expand_path_with};
use nu_protocol::{ShellError, Span, Spanned};

/// This function is like `nu_glob::glob` from the `glob` crate, except it is relative to a given cwd.
///
/// It returns a tuple of two values: the first is an optional prefix that the expanded filenames share.
/// This prefix can be removed from the front of each value to give an approximation of the relative path
/// to the user
///
/// The second of the two values is an iterator over the matching filepaths.
#[allow(clippy::type_complexity)]
pub fn glob_from(
    pattern: &Spanned<String>,
    cwd: &Path,
    span: Span,
) -> Result<
    (
        Option<PathBuf>,
        Box<dyn Iterator<Item = Result<PathBuf, ShellError>> + Send>,
    ),
    ShellError,
> {
    let path = PathBuf::from(&pattern.item);
    let path = expand_path_with(path, cwd);

    let (prefix, pattern) = if path.to_string_lossy().contains('*') {
        // Path is a glob pattern => do not check for existence
        // Select the longest prefix until the first '*'
        let mut p = PathBuf::new();
        for c in path.components() {
            if let Component::Normal(os) = c {
                if os.to_string_lossy().contains('*') {
                    break;
                }
            }
            p.push(c);
        }
        (Some(p), path)
    } else {
        let path = if let Ok(p) = canonicalize_with(path, &cwd) {
            p
        } else {
            return Err(ShellError::DirectoryNotFound(pattern.span));
        };

        if path.is_dir() {
            if permission_denied(&path) {
                #[cfg(unix)]
                let error_msg = format!(
                    "The permissions of {:o} do not allow access for this user",
                    path.metadata()
                        .expect("this shouldn't be called since we already know there is a dir")
                        .permissions()
                        .mode()
                        & 0o0777
                );

                #[cfg(not(unix))]
                let error_msg = String::from("Permission denied");

                return Err(ShellError::SpannedLabeledError(
                    "Permission denied".into(),
                    error_msg,
                    pattern.span,
                ));
            }

            if is_empty_dir(&path) {
                return Ok((Some(path), Box::new(vec![].into_iter())));
            }

            (Some(path.clone()), path.join("*"))
        } else {
            (path.parent().map(|parent| parent.to_path_buf()), path)
        }
    };

    let pattern = pattern.to_string_lossy().to_string();

    let glob = nu_glob::glob(&pattern).map_err(|err| {
        nu_protocol::ShellError::SpannedLabeledError(
            "Error extracting glob pattern".into(),
            err.to_string(),
            span,
        )
    })?;

    Ok((
        prefix,
        Box::new(glob.map(move |x| match x {
            Ok(v) => Ok(v),
            Err(err) => Err(nu_protocol::ShellError::SpannedLabeledError(
                "Error extracting glob pattern".into(),
                err.to_string(),
                span,
            )),
        })),
    ))
}

fn permission_denied(dir: impl AsRef<Path>) -> bool {
    match dir.as_ref().read_dir() {
        Err(e) => matches!(e.kind(), std::io::ErrorKind::PermissionDenied),
        Ok(_) => false,
    }
}

fn is_empty_dir(dir: impl AsRef<Path>) -> bool {
    match dir.as_ref().read_dir() {
        Err(_) => true,
        Ok(mut s) => s.next().is_none(),
    }
}