prov 0.7.0

A self-describing plaintext workspace: structure lives in documents' own embedded metadata.
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

//! What `prov` supplies to the skiplist, witnessed through a real workspace
//! and a real historica store.

use std::path::Path;

use prov_history::{SkipHost, Standing, apply, historica};

use super::support::*;

#[test]
fn the_skiplist_scopes_recording_to_the_graph() {
    let dir = seed("scopes");
    historica::store::Store::init(dir.join("history")).unwrap();

    let ws = ws(&dir);
    let standing = Standing::read(&dir).unwrap();
    let plan = block_on(ws.skiplist(Path::new("index.md"), &standing)).unwrap();
    apply(&dir, &plan).unwrap();

    // The rule is drawn from the real reachable walk, and lands in a file
    // historica itself reads back.
    let store = historica::store::Store::open(dir.join("history")).unwrap();
    assert!(
        store.skipped().skips("notes/loose.md"),
        "the loose note is not skipped"
    );
    assert!(!store.skipped().skips("notes/a.md"));
    assert!(!store.skipped().skips("index.md"));
}

#[test]
fn the_bin_and_the_derived_page_are_bookkeeping() {
    let dir = tempdir("bookkeeping");
    write(
        &dir,
        "index.md",
        "---\ntitle: Home\nrecycle_bin: recyclebin/index.md\nabout: about.md\n---\nroot\n",
    );
    write(&dir, "recyclebin/index.md", "deleted: []\n");
    write(&dir, "about.md", "---\ntitle: About\n---\nderived\n");

    let ws = ws(&dir);
    let prefixes = block_on(SkipHost::bookkeeping(&ws, Path::new("index.md"))).unwrap();

    assert_eq!(
        prefixes,
        [
            Path::new("recyclebin/items").to_path_buf(),
            Path::new("about.md").to_path_buf()
        ]
    );
}

#[test]
fn a_manifest_claim_answers_for_its_directory() {
    let dir = tempdir("claimed");
    write(&dir, "index.md", "---\ntitle: Home\n---\nroot\n");
    write(&dir, "photos/a.jpg", "JPEGBYTES");

    let mut workspace = ws(&dir);
    block_on(workspace.attach_manifest(Path::new("photos"), Path::new("index.md"))).unwrap();

    assert!(block_on(SkipHost::claimed(&workspace, Path::new("photos"))).unwrap());
    assert!(!block_on(SkipHost::claimed(&workspace, Path::new("notes"))).unwrap());
}

#[test]
fn a_historica_store_is_parked_out_of_every_walk() {
    let dir = seed("parked");
    historica::store::Store::init(dir.join("history")).unwrap();

    let workspace = ws(&dir);
    let parked = block_on(workspace.parked_dirs(Path::new("index.md"))).unwrap();
    assert!(parked.contains(&Path::new("history").to_path_buf()));

    // Parked means unreached: the store's own documents never enter the
    // reachable set, so nothing indexes, orphan-sweeps, or records them.
    let reachable = block_on(workspace.reachable_files("index.md")).unwrap();
    assert!(reachable.iter().all(|p| !p.starts_with("history")));

    // And a folder merely called `history` is content like any other.
    let plain = seed("parked-plain");
    write(
        &plain,
        "history/essay.md",
        "---\ntitle: Essay\n---\nprose\n",
    );
    let workspace = ws(&plain);
    let parked = block_on(workspace.parked_dirs(Path::new("index.md"))).unwrap();
    assert!(!parked.contains(&Path::new("history").to_path_buf()));
}

#[test]
fn a_workspace_with_a_store_checks_clean() {
    let dir = seed("check-clean");
    historica::store::Store::init(dir.join("history")).unwrap();

    let ws = ws(&dir);
    let standing = Standing::read(&dir).unwrap();
    let plan = block_on(ws.skiplist(Path::new("index.md"), &standing)).unwrap();
    apply(&dir, &plan).unwrap();

    // The store's interior — marker file, skipped.txt, empty shards — raises
    // nothing: not an orphan, not an unreadable document, not a loose file.
    let findings = block_on(ws.check("index.md")).unwrap();
    let about_store: Vec<_> = findings
        .iter()
        .filter(|f| f.subject().starts_with("history"))
        .collect();
    assert!(about_store.is_empty(), "{about_store:?}");
}