tzemanovic/inflorescence - Change ESMM3FELOBYIX7FUNOU37FYKRJHFU2IMX6LY6EGJTVPTBDU3SEEQC

test selection reindexing

Created by Tomáš Zemanovič on June 1, 2025

ESMM3FELOBYIX7FUNOU37FYKRJHFU2IMX6LY6EGJTVPTBDU3SEEQC

Dependencies

In channels

main

Change contents

Replacement in inflorescence/src/test.rs at line 2 [13.2521]

B:BD[15.1320] → [16.34:87]

use crate::{cursor, init, task, update, Msg, State};

[15.1320]

[15.1428]

use crate::{cursor, init, reindex_selection, task, update, Msg, State};

Replacement in inflorescence/src/test.rs at line 5 [13.2521]
∅:D[15.1488] → [13.2552:2578]
B:BD[13.2552] → [13.2552:2578]
```
use libflorescence::repo;
```
[15.1488]
[15.1489]
```
use libflorescence::prelude::pijul;
```
Insertion in inflorescence/src/test.rs at line 9 [13.2521]
[15.1581]
[13.2643]
```
use libflorescence::{file, repo};
```
Replacement in inflorescence/src/test.rs at line 265 [13.2521]
B:BD[17.159] → [17.159:187]
```
/// Test add untracked file
```
[17.159]
[17.187]
```
/// Test add and rm untracked file
```

Replacement in inflorescence/src/test.rs at line 329 [13.2521]

B:BD[17.2098] → [17.2098:2189]

        Msg::FromRepo(repo::MsgOut::AddedUntrackedFile { path }) if path == file_to_record

[17.2098]

[17.2189]

        Msg::FromRepo(repo::MsgOut::AddedUntrackedFile { path })
            if path == file_to_record

Replacement in inflorescence/src/test.rs at line 371 [13.2521]

B:BD[18.630] → [18.630:716]

        Msg::FromRepo(repo::MsgOut::RmedAddedFile { path }) if path == file_to_record

[18.630]

[18.716]

        Msg::FromRepo(repo::MsgOut::RmedAddedFile { path })
            if path == file_to_record

Insertion in inflorescence/src/test.rs at line 384 [13.2521]

[17.2710]


/// When the repo is refreshed we try to re-index the selection if it's still
/// present.
///
/// If the selection is still present we must perform different actions
/// depending on the selection type:
///
/// - untracked file: We should start loading the file
/// - changed file: Load the file if the diff has any contents
/// - log change: Request the diffs
///
/// If the selection is not present any more, no action must be taken.
#[test(tokio::test)]
async fn test_reindex_selection() {
    let TestState {
        mut state,
        tasks: _tasks,
        fs_watch_task: _,
        id: _,
        repo: _,
    } = setup_state().await;
    let repo::State {
        dir_name: _,
        channel: _,
        untracked_files,
        changed_files,
        log,
    } = &state.repo.as_ref().unwrap();
    // _________________________________________________________________________
    // Case: no current selection
    assert!(state.cursor.selection.is_none());
    let task = reindex_selection(
        &mut state.cursor,
        &mut state.files,
        untracked_files,
        changed_files,
        log,
    );
    assert!(state.cursor.selection.is_none());
    assert!(state.files.diffs_cache.inner.is_empty());
    assert!(task.is_none());
    // _________________________________________________________________________
    // Case: untracked file selection present after refresh, index is increased

Insertion in inflorescence/src/test.rs at line 435 [13.2521]

[17.2711]

[15.4747]

    let untracked_files = BTreeSet::from_iter([
        "untracked_0.rs".to_string(),
        "untracked_1.rs".to_string(),
        "untracked_2.rs".to_string(),
    ]);
    state.cursor.selection = Some(cursor::Selection::UntrackedFile {
        ix: 0,
        path: "untracked_1.rs".to_string(),
    });
    let task = reindex_selection(
        &mut state.cursor,
        &mut state.files,
        &untracked_files,
        changed_files,
        log,
    );
    assert!(state.cursor.selection.is_some());
    assert_matches!(
        state.cursor.selection.as_ref().unwrap(),
        libflorescence::cursor::Selection::UntrackedFile { ix, path }
            if *ix == 1 && path == "untracked_1.rs"
    );
    assert!(task.is_none());
    assert_eq!(state.files.diffs_cache.inner.len(), 1);
    assert_matches!(
        state.files.diffs_cache.inner.peek(&file::Id {
            path: "untracked_1.rs".to_string(),
            file_kind: file::Kind::Untracked
        }),
        Some(file::Diff::Loading)
    );
    // Clear the cache for next test case
    state.files.diffs_cache.inner.clear();
    // _________________________________________________________________________
    // Case: untracked file selection not present after refresh
    state.cursor.selection = Some(cursor::Selection::UntrackedFile {
        ix: 0,
        path: "untracked_gone.rs".to_string(),
    });
    let task = reindex_selection(
        &mut state.cursor,
        &mut state.files,
        &untracked_files,
        changed_files,
        log,
    );
    assert!(state.cursor.selection.is_none());
    assert!(task.is_none());
    assert!(state.files.diffs_cache.inner.is_empty());
    // _________________________________________________________________________
    // Case: changed file selection present after refresh, index is decreased,
    // file has diffs with contents
    let changed_files = repo::ChangedFiles::from_iter([
        (
            "changed_0.rs".to_string(),
            BTreeSet::from_iter([repo::ChangedFileDiff::Add]),
        ),
        ("changed_1.rs".to_string(), BTreeSet::new()),
        ("changed_2.rs".to_string(), BTreeSet::new()),
    ]);
    state.cursor.selection = Some(cursor::Selection::ChangedFile {
        ix: 1,
        path: "changed_0.rs".to_string(),
    });
    let task = reindex_selection(
        &mut state.cursor,
        &mut state.files,
        &untracked_files,
        &changed_files,
        log,
    );
    assert!(state.cursor.selection.is_some());
    assert_matches!(
        state.cursor.selection.as_ref().unwrap(),
        libflorescence::cursor::Selection::ChangedFile { ix, path }
            if *ix == 0 && path == "changed_0.rs"
    );
    assert!(task.is_none());
    assert_eq!(state.files.diffs_cache.inner.len(), 1);
    assert_matches!(
        state.files.diffs_cache.inner.peek(&file::Id {
            path: "changed_0.rs".to_string(),
            file_kind: file::Kind::Changed
        }),
        Some(file::Diff::Loading)
    );
    // Clear the cache for next test case
    state.files.diffs_cache.inner.clear();
    // _________________________________________________________________________
    // Case: changed file selection present after refresh, index is the same,
    // but file has no diffs with contents
    state.cursor.selection = Some(cursor::Selection::ChangedFile {
        ix: 1,
        path: "changed_1.rs".to_string(),
    });
    let task = reindex_selection(
        &mut state.cursor,
        &mut state.files,
        &untracked_files,
        &changed_files,
        log,
    );
    assert!(state.cursor.selection.is_some());
    assert_matches!(
        state.cursor.selection.as_ref().unwrap(),
        libflorescence::cursor::Selection::ChangedFile { ix, path }
            if *ix == 1 && path == "changed_1.rs"
    );
    assert!(task.is_none());
    assert!(state.files.diffs_cache.inner.is_empty());
    // _________________________________________________________________________
    // Case: changed file selection not present after refresh
    state.cursor.selection = Some(cursor::Selection::ChangedFile {
        ix: 0,
        path: "changed_gone.rs".to_string(),
    });
    let task = reindex_selection(
        &mut state.cursor,
        &mut state.files,
        &untracked_files,
        &changed_files,
        log,
    );
    assert!(state.cursor.selection.is_none());
    assert!(task.is_none());
    assert!(state.files.diffs_cache.inner.is_empty());
    // _________________________________________________________________________
    // Case: log selection present after refresh
    let change_hash = |bytes: &[u8]| {
        let mut hasher = pijul::pristine::Hasher::default();
        hasher.update(bytes);
        hasher.finish()
    };
    let change_hash_0 = change_hash(&[0]);
    let change_hash_1 = change_hash(&[1]);
    let change_hash_2 = change_hash(&[2]);
    let log = vec![
        repo::LogEntry {
            hash: change_hash_0,
            message: "".to_string(),
            file_paths: vec![],
        },
        repo::LogEntry {
            hash: change_hash_1,
            message: "".to_string(),
            file_paths: vec![],
        },
        repo::LogEntry {
            hash: change_hash_2,
            message: "".to_string(),
            file_paths: vec![],
        },
    ];
    state.cursor.selection = Some(cursor::Selection::LogChange {
        ix: 0,
        hash: change_hash_2,
        message: "".to_string(),
        diffs: None,
        file: None,
    });
    let task = reindex_selection(
        &mut state.cursor,
        &mut state.files,
        &untracked_files,
        &changed_files,
        &log,
    );
    assert!(state.cursor.selection.is_some());
    assert_matches!(
        state.cursor.selection.as_ref().unwrap(),
        libflorescence::cursor::Selection::LogChange { ix, hash, .. }
            if *ix == 2 && *hash == change_hash_2
    );
    assert!(task.is_some());
    assert!(state.files.diffs_cache.inner.is_empty());
    // _________________________________________________________________________
    // Case: log selection not present after refresh
    state.cursor.selection = Some(cursor::Selection::UntrackedFile {
        ix: 0,
        path: "log_gone.rs".to_string(),
    });
    let task = reindex_selection(
        &mut state.cursor,
        &mut state.files,
        &untracked_files,
        &changed_files,
        &log,
    );
    assert!(state.cursor.selection.is_none());
    assert!(task.is_none());
    assert!(state.files.diffs_cache.inner.is_empty());
}

Insertion in inflorescence/src/task.rs at line 29 [12.33]

[12.705]

    }
    pub fn is_none(&self) -> bool {
        self.stream.is_none()
    }
    pub fn is_some(&self) -> bool {
        self.stream.is_some()

Replacement in inflorescence/src/main.rs at line 29 [19.2763]
B:BD[12.5338] → [12.5338:5369]
```
use std::collections::HashMap;
```
[12.5338]
[12.5369]
```
use std::collections::{BTreeSet, HashMap};
```

Replacement in inflorescence/src/main.rs at line 482 [19.2763]

B:BD[14.9475] → [14.9475:9641]

    let task = if let Some(selection) = state.cursor.selection.take() {
        // Try to find the file with the same name. If not found, remove
        // selection

[14.9475]

[14.9641]

    let task = reindex_selection(
        &mut state.cursor,
        &mut state.files,
        untracked_files,
        changed_files,
        log,
    );
    state.repo = Some(repo);
    task
}
/// Try to find the file with the same name. If not found, remove selection
fn reindex_selection(
    cursor: &mut cursor::State,
    files: &mut file::State,
    untracked_files: &BTreeSet<String>,
    changed_files: &repo::ChangedFiles,
    log: &repo::Log,
) -> Task<Msg> {
    if let Some(selection) = cursor.selection.take() {

Deletion in inflorescence/src/main.rs at line 506 [19.2763]

B:BD[14.9757] → [14.9757:10021]

∅:D[11.784] → [2.15249:15250]

∅:D[4.5309] → [2.15249:15250]

∅:D[14.10021] → [2.15249:15250]

∅:D[7.14023] → [2.15249:15250]

B:BD[2.15249] → [2.15249:15250]

                file::load_src_file_if_not_cached(
                    &mut state.files,
                    file::Id {
                        path: path.clone(),
                        file_kind: file::Kind::Untracked,
                    },
                );

Replacement in inflorescence/src/main.rs at line 512 [19.2763]

B:BD[14.10299] → [14.10299:10329]

                        path,

[14.10299]

[14.10329]

                        path: path.clone(),

Insertion in inflorescence/src/main.rs at line 514 [19.2763]

[14.10353]


                if selection.is_some() {
                    file::load_src_file_if_not_cached(
                        files,
                        file::Id {
                            path,
                            file_kind: file::Kind::Untracked,
                        },
                    );
                }

Deletion in inflorescence/src/main.rs at line 528 [19.2763]

B:BD[14.10473] → [14.10473:10597]

∅:D[14.10597] → [11.785:929]

B:BD[10.1629] → [11.785:929]

∅:D[11.929] → [7.14292:14344]

B:BD[7.14292] → [7.14292:14344]

B:BD[7.14344] → [14.10598:10662]

∅:D[11.996] → [7.14408:14439]

∅:D[14.10662] → [7.14408:14439]

B:BD[7.14408] → [7.14408:14439]

∅:D[6.2576] → [4.5507:5534]

∅:D[7.14439] → [4.5507:5534]

B:BD[4.5507] → [4.5507:5534]

∅:D[8.13481] → [3.8120:8142]

B:BD[3.8120] → [3.8120:8142]

B:BD[3.8142] → [14.10663:10682]

                if let Some(diffs) = changed_files.get(&path) {
                    if diff::any_diff_has_contents(diffs) {
                        file::load_src_file_if_not_cached(
                            &mut state.files,
                            file::Id {
                                path: path.clone(),
                                file_kind: file::Kind::Changed,
                            },
                        );
                    }
                }

Insertion in inflorescence/src/main.rs at line 538 [19.2763]

[14.11112]


                if selection.is_some() {
                    if let Some(diffs) = changed_files.get(&path) {
                        if diff::any_diff_has_contents(diffs) {
                            file::load_src_file_if_not_cached(
                                files,
                                file::Id {
                                    path: path.clone(),
                                    file_kind: file::Kind::Changed,
                                },
                            );
                        }
                    }
                }

Deletion in inflorescence/src/main.rs at line 562 [19.2763]

B:BD[14.11348] → [14.11348:11538]

                // Request to get the diffs
                let task = Task::done(Msg::View(app::Msg::ToRepo(
                    repo::MsgIn::GetChangeDiffs { hash },
                )));

Insertion in inflorescence/src/main.rs at line 588 [19.2763]

[14.12568]

[5.3992]


                let task = if selection.is_some() {
                    // Request to get the diffs
                    Task::done(Msg::View(app::Msg::ToRepo(
                        repo::MsgIn::GetChangeDiffs { hash },
                    )))
                } else {
                    Task::none()
                };

Insertion in inflorescence/src/main.rs at line 601 [19.2763]
[14.12628]
[9.9662]
```
        cursor.selection = selection;
```
Deletion in inflorescence/src/main.rs at line 604 [19.2763]
B:BD[9.9663] → [14.12629:12673]
```
        state.cursor.selection = selection;
```
Replacement in inflorescence/src/main.rs at line 607 [19.2763]
B:BD[14.12720] → [14.12720:12727]
∅:D[14.12727] → [8.15737:15738]
B:BD[8.15737] → [8.15737:15738]
B:BD[8.15738] → [14.12728:12757]
∅:D[14.12757] → [8.15803:15804]
B:BD[2.16426] → [8.15803:15804]
B:BD[8.15804] → [14.12758:12767]
```
    };
    state.repo = Some(repo);
    task
```
[14.12720]
[14.12767]
```
    }
```