path-rs 0.1.0

Cross-platform path expansion, normalization, traversal, searching, and caching
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use path_rs::{
    CaseNormalization, CommandLinePathMatchOptions, ExecutableMatchOptions, PathIdentityOptions,
    PathRecord, TextNormalizationOptions, command_line_contains_path, deduplicate_paths,
    directory_exists, executable_paths_match, inspect_directory, is_existing_directory,
    normalize_path_token, path_identity_key, require_directory,
};
use std::fs;
use std::path::PathBuf;
use tempfile::tempdir;

#[test]
fn path_token_normalization() {
    let opts = TextNormalizationOptions {
        trim_whitespace: true,
        trim_trailing_separators: true,
        normalize_separators: true,
        case: CaseNormalization::AsciiLowercase,
    };
    assert_eq!(normalize_path_token(r"  Repo\Name\  ", &opts), "repo/name");
    // Callers strip `.git` themselves — library must not.
    assert_eq!(normalize_path_token("Repo.git", &opts), "repo.git");
}

#[test]
fn identity_key_equivalences() {
    let opts = PathIdentityOptions {
        case: CaseNormalization::AsciiLowercase,
        ..PathIdentityOptions::default()
    };
    let keys = [
        path_identity_key(r"C:\Users\Floris\Repo", opts).unwrap(),
        path_identity_key(r"c:/users/floris/repo", opts).unwrap(),
        path_identity_key(r"C:/Users/Floris/Repo/", opts).unwrap(),
        path_identity_key(r"C:\Users\Floris\Repo\.", opts).unwrap(),
    ];
    assert!(keys.windows(2).all(|w| w[0] == w[1]));
}

#[test]
fn identity_preserves_case_on_unix_policy() {
    let opts = PathIdentityOptions {
        case: CaseNormalization::Preserve,
        ..PathIdentityOptions::default()
    };
    let a = path_identity_key("/tmp/Foo", opts).unwrap();
    let b = path_identity_key("/tmp/foo", opts).unwrap();
    // On all platforms Preserve must keep distinction when separators match.
    assert_ne!(a, b);
}

#[test]
fn deduplicate_and_record() {
    let opts = PathIdentityOptions {
        case: CaseNormalization::AsciiLowercase,
        ..PathIdentityOptions::default()
    };
    let paths = vec![
        PathBuf::from(r"C:\Users\Floris\Repo"),
        PathBuf::from(r"c:/users/floris/repo"),
    ];
    let d = deduplicate_paths(paths, opts).unwrap();
    assert_eq!(d.len(), 1);

    let rec = PathRecord::from_path(r"C:\Users\Floris\Repo", Some(opts)).unwrap();
    assert!(rec.identity_key.is_some());
    assert!(!rec.display.is_empty());
}

#[test]
fn directory_inspection() {
    let dir = tempdir().unwrap();
    assert!(is_existing_directory(dir.path()));
    assert!(directory_exists(dir.path()));
    let insp = inspect_directory(dir.path()).unwrap();
    assert!(insp.exists);
    assert!(insp.is_directory);
    assert!(!insp.is_symlink);
    assert!(require_directory(dir.path()).is_ok());

    let file = dir.path().join("f.txt");
    fs::write(&file, b"x").unwrap();
    assert!(!is_existing_directory(&file));
    assert!(require_directory(&file).is_err());
    assert!(!is_existing_directory(dir.path().join("missing")));
}

#[test]
fn executable_and_command_line() {
    let exec = ExecutableMatchOptions::default();
    assert!(
        executable_paths_match(
            r"C:\Program Files\XBP\xbp.exe",
            r"c:/program files/xbp/xbp.exe",
            exec
        )
        .unwrap()
    );

    let opts = CommandLinePathMatchOptions {
        case_insensitive: true,
        require_component_boundary: true,
        support_quotes: true,
        match_basename: false,
        ..CommandLinePathMatchOptions::default()
    };
    assert!(
        command_line_contains_path(
            r#"run "C:\Users\Floris\repo" --watch"#,
            r"C:\Users\Floris\repo",
            opts
        )
        .unwrap()
    );
    assert!(!command_line_contains_path(r"run C:\repository\x", r"C:\repo", opts).unwrap());
    assert!(
        command_line_contains_path(
            r"run /mnt/c/Users/Floris/repo",
            r"/mnt/c/Users/Floris/repo",
            CommandLinePathMatchOptions {
                support_wsl_translation: true,
                ..opts
            }
        )
        .unwrap()
    );
    assert!(command_line_contains_path("", r"C:\repo", opts).is_ok());
    assert!(command_line_contains_path("x", "", opts).is_err());
}