yog 0.0.2

yog: a balls-oriented session manager for lernie loops (egui frontend)
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! **S11-T4 headless work-diff**: the query answers off the same derivation
//! the Work tab renders, and its wire shape keeps every state distinguishable
//! — an unreadable project, an absent ref and a real diff are three different
//! answers on the wire exactly as they are three different sentences on screen.

use std::path::PathBuf;
use std::sync::Arc;

use super::super::encode;
use crate::boundary::answer::answer;
use crate::boundary::dispatch::Deps;
use crate::boundary::reply::Reply;
use crate::boundary::{Query, tests::snapshot};
use crate::cli_outbound::Cli;
use crate::files_view::Preview;
use crate::ui_state::UiState;
use crate::workdiff::{Attempt, Change, Churn, FileChurn, WorkFile};

/// A `Deps` wrapping `snap` — this query never touches the rest of it.
fn deps(snap: crate::app::Snapshot) -> Deps {
    Deps {
        lernie: Cli::new("/no/such/lernie"),
        bl: Cli::new("/no/such/bl"),
        state_root: PathBuf::from("/nonexistent/state"),
        yog_binary: PathBuf::from("/no/such/yog"),
        world: crate::test_support::no_world(),
        home: PathBuf::from("/home/x"),
        yog_data_root: PathBuf::from("/data"),
        balls_state_root: PathBuf::from("/balls"),
        snapshot: Arc::new(snap),
        mint_seed: 0,
    }
}

fn attempt(change: Change) -> Attempt {
    Attempt {
        project: PathBuf::from("/proj"),
        ball_id: "bl-1".to_owned(),
        change,
    }
}

fn diff() -> Change {
    Change::Diff {
        target: "main".to_owned(),
        source: "work/bl-1".to_owned(),
        target_oid: "aaaa".to_owned(),
        source_oid: "bbbb".to_owned(),
        files: vec![
            FileChurn {
                path: "src/a.rs".to_owned(),
                churn: Churn::Text {
                    added: 2,
                    removed: 1,
                },
            },
            FileChurn {
                path: "logo.png".to_owned(),
                churn: Churn::Binary,
            },
        ],
        truncated: false,
    }
}

/// The diff row carries both refs, both commits, and one entry per changed
/// file — binary said as itself, never as zero lines.
#[test]
fn a_diff_row_carries_the_range_the_commits_and_the_files() {
    let v = encode(&Reply::WorkDiff {
        attempts: vec![attempt(diff())],
        patch: None,
    });
    assert_eq!(v["ok"], true);
    assert_eq!(v["kind"], "work-diff");
    let row = &v["rows"][0];
    assert_eq!(row["project"], "/proj");
    assert_eq!(row["ball_id"], "bl-1");
    assert_eq!(row["state"], "diff");
    assert_eq!(row["target"], "main");
    assert_eq!(row["source"], "work/bl-1");
    assert_eq!(row["target_oid"], "aaaa");
    assert_eq!(row["source_oid"], "bbbb");
    assert_eq!(row["truncated"], false);
    assert_eq!(row["files"][0]["added"], 2);
    assert_eq!(row["files"][0]["removed"], 1);
    assert_eq!(row["files"][1]["binary"], true);
    assert!(v.get("patch").is_none(), "no file was asked for");
}

/// The two declines keep their own tokens: an answer that flattened them into
/// "no rows" would be the silent empty listing the ruling forbids.
#[test]
fn every_decline_keeps_its_own_token() {
    let v = encode(&Reply::WorkDiff {
        attempts: vec![
            attempt(Change::Unreadable),
            attempt(Change::Absent {
                target: "main".to_owned(),
                source: "work/bl-1".to_owned(),
                missing: vec!["work/bl-1".to_owned()],
            }),
        ],
        patch: None,
    });
    assert_eq!(v["rows"][0]["state"], "unreadable");
    assert!(v["rows"][0].get("target").is_none(), "nothing to name");
    assert_eq!(v["rows"][1]["state"], "absent");
    assert_eq!(v["rows"][1]["missing"][0], "work/bl-1");
}

/// The patch rides the same three classes the seat paints.
#[test]
fn the_patch_rides_the_previews_own_classes() {
    let with = |patch| {
        encode(&Reply::WorkDiff {
            attempts: vec![attempt(diff())],
            patch: Some(patch),
        })["patch"]
            .clone()
    };
    assert_eq!(with(Preview::Text("@@".to_owned()))["kind"], "text");
    let truncated = with(Preview::Truncated {
        text: "@@".to_owned(),
        size: 99,
    });
    assert_eq!(truncated["kind"], "truncated");
    assert_eq!(truncated["size"], 99);
    assert_eq!(with(Preview::Binary { size: 7 })["kind"], "binary");
}

/// The query is answered by the same read the tab builds — a workspace with no
/// claim answers with no rows, and a named file with no attempt behind it adds
/// no patch. One derivation, two serializations.
#[test]
fn the_query_answers_off_the_tabs_own_derivation() {
    let ws = PathBuf::from("/names/alba");
    let snap = snapshot(&ws, "alba", vec![], vec![]);
    let ui = UiState::open(PathBuf::from("/nonexistent/ui.json"));
    let d = deps(snap);
    let Ok(Reply::WorkDiff { attempts, patch }) = answer(
        &Query::WorkDiff {
            workspace: ws,
            file: Some(WorkFile {
                ball: "bl-1".to_owned(),
                path: "src/a.rs".to_owned(),
            }),
        },
        &d,
        &ui,
        200,
    ) else {
        panic!("the work-diff query answers a work-diff");
    };
    assert!(attempts.is_empty(), "this workspace claims nothing");
    assert!(patch.is_none(), "no attempt, no patch");
}