sim-table-fs 0.1.3

SIM workspace package for sim table fs.
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
129

use super::support::*;

#[test]
fn grep_reports_path_and_line() {
    let mut cx = cx();
    grant(
        &mut cx,
        &[table_fs_read_capability(), table_fs_find_capability()],
    );
    let root = test_root("find-grep-line");
    let dir = FsDir::open(root.clone()).unwrap();
    write_value_with_codec(
        &mut cx,
        &root.join("note.siml"),
        Symbol::qualified("codec", "lisp"),
        "alpha\nneedle here\nomega\n",
    );

    let result = dir.find_grep(&mut cx, "needle", None, 10).unwrap();

    assert!(!result.truncated);
    assert_eq!(result.matches.len(), 1);
    assert_eq!(result.matches[0].path, "note.siml");
    assert_eq!(result.matches[0].line, 2);
    assert_eq!(result.matches[0].text, "needle here");
}

#[test]
fn glob_filters_paths() {
    let mut cx = cx();
    grant(
        &mut cx,
        &[table_fs_read_capability(), table_fs_find_capability()],
    );
    let root = test_root("find-glob");
    let dir = FsDir::open(root.clone()).unwrap();
    std::fs::create_dir_all(root.join("notes")).unwrap();
    write_value_with_codec(
        &mut cx,
        &root.join("notes/a.siml"),
        Symbol::qualified("codec", "lisp"),
        "a",
    );
    write_value_with_codec(
        &mut cx,
        &root.join("notes/b.siml"),
        Symbol::qualified("codec", "lisp"),
        "b",
    );
    write_value_with_codec(
        &mut cx,
        &root.join("other.siml"),
        Symbol::qualified("codec", "lisp"),
        "other",
    );

    let result = dir.find_glob(&mut cx, "notes/*.siml", 10).unwrap();

    assert!(!result.truncated);
    assert_eq!(
        result.paths,
        vec!["notes/a.siml".to_owned(), "notes/b.siml".to_owned()]
    );
}

#[cfg(unix)]
#[test]
fn symlink_escape_refused() {
    let mut cx = cx();
    grant(
        &mut cx,
        &[table_fs_read_capability(), table_fs_find_capability()],
    );
    let root = test_root("find-symlink-escape");
    let outside = test_root("find-symlink-outside").with_extension("siml");
    std::fs::write(&outside, "\"outside\"").unwrap();
    let dir = FsDir::open(root.clone()).unwrap();
    std::os::unix::fs::symlink(&outside, root.join("escape.siml")).unwrap();

    let err = dir.find_glob(&mut cx, "*.siml", 10).unwrap_err();

    assert!(err.to_string().contains("escapes root"));
}

#[test]
fn max_truncation_reported() {
    let mut cx = cx();
    grant(
        &mut cx,
        &[table_fs_read_capability(), table_fs_find_capability()],
    );
    let root = test_root("find-truncated");
    let dir = FsDir::open(root.clone()).unwrap();
    for name in ["a", "b"] {
        write_value_with_codec(
            &mut cx,
            &root.join(format!("{name}.siml")),
            Symbol::qualified("codec", "lisp"),
            "needle\n",
        );
    }

    let result = dir.find_grep(&mut cx, "needle", None, 1).unwrap();

    assert_eq!(result.matches.len(), 1);
    assert!(result.truncated);
}

#[test]
fn find_requires_find_capability() {
    let mut cx = cx();
    grant(&mut cx, &[table_fs_read_capability()]);
    let root = test_root("find-capability");
    let dir = FsDir::open(root.clone()).unwrap();
    write_value_with_codec(
        &mut cx,
        &root.join("note.siml"),
        Symbol::qualified("codec", "lisp"),
        "needle",
    );

    let err = dir.find_grep(&mut cx, "needle", None, 10).unwrap_err();

    assert!(matches!(
        err,
        sim_kernel::Error::CapabilityDenied { capability }
            if capability == table_fs_find_capability()
    ));
}