tzemanovic/inflorescence - Change KWTBNTO3QUUE2YADF6SYW6G6ZOKYEWRJQKIWDGZXR33S3YNDVIZQC

diffs selection and scrolling

Created by Tomáš Zemanovič on July 10, 2025

KWTBNTO3QUUE2YADF6SYW6G6ZOKYEWRJQKIWDGZXR33S3YNDVIZQC

Dependencies

In channels

main

Change contents

Insertion in libflorescence/src/repo.rs at line 4 [4.7]
[46.908]
[12.7]
```
#[doc(inline)]
pub use pijul::Hash as ChangeHash;
```

Replacement in libflorescence/src/repo.rs at line 17 [4.7]

B:BD[22.194] → [22.194:306]

    working_copy, ChannelMutTxnT, ChannelTxnT, Encoding, Hash, HashSet,
    MutTxnT, MutTxnTExt, TxnT, TxnTExt,

[22.194]

[22.306]

    working_copy, ChannelMutTxnT, ChannelTxnT, Encoding, HashSet, MutTxnT,
    MutTxnTExt, TxnT, TxnTExt,

Replacement in libflorescence/src/repo.rs at line 143 [4.7]
B:BD[26.28] → [26.28:55]
```
        hash: pijul::Hash,
```
[26.28]
[12.546]
```
        hash: ChangeHash,
```
Replacement in libflorescence/src/repo.rs at line 160 [4.7]
B:BD[26.77] → [26.77:104]
```
        hash: pijul::Hash,
```
[26.77]
[26.104]
```
        hash: ChangeHash,
```

Replacement in libflorescence/src/repo.rs at line 165 [4.7]

B:BD[11.726] → [11.726:790]

pub type Diff = LocalChange<Hunk<Option<Hash>, Local>, Author>;

[11.726]

[21.119]

pub type Diff = LocalChange<Hunk<Option<ChangeHash>, Local>, Author>;

Replacement in libflorescence/src/repo.rs at line 171 [4.7]
B:BD[21.197] → [21.197:224]
```
    pub hash: pijul::Hash,
```
[21.197]
[21.224]
```
    pub hash: ChangeHash,
```
Deletion in libflorescence/src/repo.rs at line 176 [4.7]
B:BD[21.252] → [24.136:204]
B:BD[24.204] → [55.6:64]
∅:D[55.64] → [24.238:263]
B:BD[24.238] → [24.238:263]
```
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub struct LogFileId {
    /// Hash of the log change
    pub hash: pijul::Hash,
    pub path: String,
}
```

Insertion in libflorescence/src/repo.rs at line 286 [4.7]

[25.1569]

pub fn hash_bytes(bytes: &[u8]) -> ChangeHash {
    let mut hasher = pijul::pristine::Hasher::default();
    hasher.update(bytes);
    hasher.finish()
}

Replacement in libflorescence/src/repo.rs at line 605 [4.7]

B:BD[16.428] → [16.428:457]

        match dbg!(change) {

[16.428]

[7.1758]

        // match dbg!(change) {
        match change {

Replacement in libflorescence/src/repo.rs at line 838 [4.7]

B:BD[22.484] → [24.1030:1103]

                let entry = mk_log_entry(repo, pijul::Hash::from(hash));

[22.484]

[21.2025]

                let entry = mk_log_entry(repo, ChangeHash::from(hash));

Replacement in libflorescence/src/repo.rs at line 852 [4.7]

B:BD[21.2241] → [24.1104:1179]

fn mk_log_entry(repo: &pijul::Repository, hash: pijul::Hash) -> LogEntry {

[21.2241]

[24.1179]

fn mk_log_entry(repo: &pijul::Repository, hash: ChangeHash) -> LogEntry {

Insertion in libflorescence/src/lib.rs at line 10 [2.1776]

[39.2186]


#[doc(inline)]
pub use std::hash::DefaultHasher;
pub type AHash = u64;
pub fn hasher() -> DefaultHasher {
    DefaultHasher::new()
}
pub fn hash_one<T>(x: T) -> u64
where
    T: std::hash::Hash,
{
    let mut hasher = hasher();
    x.hash(&mut hasher);
    std::hash::Hasher::finish(&hasher)
}
pub type NoHashMap<K, V> = std::collections::HashMap<K, V, BuildNoHashHasher>;
pub type BuildNoHashHasher = std::hash::BuildHasherDefault<NoHashHasher>;
#[derive(Debug, Default)]
pub struct NoHashHasher(u64);
impl std::hash::Hasher for NoHashHasher {
    fn write(&mut self, _: &[u8]) {
        unimplemented!("Invalid use of NoHashHasher")
    }
    fn write_u8(&mut self, n: u8) {
        self.0 = u64::from(n)
    }
    fn write_u16(&mut self, n: u16) {
        self.0 = u64::from(n)
    }
    fn write_u32(&mut self, n: u32) {
        self.0 = u64::from(n)
    }
    fn write_u64(&mut self, n: u64) {
        self.0 = n
    }
    fn write_usize(&mut self, n: usize) {
        self.0 = n as u64
    }
    fn write_i8(&mut self, n: i8) {
        self.0 = n as u64
    }
    fn write_i16(&mut self, n: i16) {
        self.0 = n as u64
    }
    fn write_i32(&mut self, n: i32) {
        self.0 = n as u64
    }
    fn write_i64(&mut self, n: i64) {
        self.0 = n as u64
    }
    fn write_isize(&mut self, n: isize) {
        self.0 = n as u64
    }
    fn finish(&self) -> u64 {
        self.0
    }
}

Replacement in libflorescence/src/file.rs at line 1 [35.58]
B:BD[35.58] → [35.59:76]
```
use crate::diff;
```
[35.58]
[35.76]
```
use crate::{diff, hash_one, repo, AHash, NoHashMap};
```

Insertion in libflorescence/src/file.rs at line 6 [35.58]

[35.160]

    pub file_kind: Kind,
}
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub struct IdRef<'a> {
    pub path: &'a str,

Insertion in libflorescence/src/file.rs at line 13 [35.58]

[35.185]

}
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
pub struct IdHash(pub AHash);
pub type IdMap<V> = NoHashMap<IdHash, V>;
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub struct LogId {
    /// Hash of the log change
    pub hash: repo::ChangeHash,
    pub path: String,
}
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub struct LogIdRef<'a> {
    pub hash: repo::ChangeHash,
    pub path: &'a str,

Insertion in libflorescence/src/file.rs at line 32 [35.58]

[35.187]


#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
pub struct LogIdHash(pub AHash);
pub type LogIdMap<V> = NoHashMap<LogIdHash, V>;

Insertion in libflorescence/src/file.rs at line 48 [35.58]

[35.356]

}
pub fn id_hash(id: &Id) -> IdHash {
    IdHash(hash_one(id))
}
pub fn id_ref_hash(id: &IdRef<'_>) -> IdHash {
    IdHash(hash_one(id))
}
pub fn id_parts_hash(path: &str, file_kind: Kind) -> IdHash {
    id_ref_hash(&IdRef { path, file_kind })
}
pub fn log_id_hash(id: &LogId) -> LogIdHash {
    LogIdHash(hash_one(id))
}
pub fn log_id_ref_hash(id: &LogIdRef<'_>) -> LogIdHash {
    LogIdHash(hash_one(id))
}
pub fn log_id_parts_hash(hash: repo::ChangeHash, path: &str) -> LogIdHash {
    log_id_ref_hash(&LogIdRef { path, hash })
}
#[cfg(test)]
mod test {
    use super::*;
    #[test]
    fn id_hash_eq_id_ref_hash() {
        let path = "some random path";
        let file_kind = Kind::Untracked;
        assert_eq!(
            id_ref_hash(&IdRef { path, file_kind }),
            id_hash(&Id {
                path: path.to_string(),
                file_kind
            })
        );
        assert_eq!(
            id_ref_hash(&IdRef { path, file_kind }),
            id_parts_hash(path, file_kind),
        );
        assert_ne!(
            id_ref_hash(&IdRef { path, file_kind }),
            id_hash(&Id {
                path: path.to_string(),
                file_kind: Kind::Changed
            })
        );
    }
    #[test]
    fn log_id_hash_eq_log_id_ref_hash() {
        let path = "some change file path";
        let hash = repo::hash_bytes(&[0, 1, 2]);
        assert_eq!(
            log_id_ref_hash(&LogIdRef { path, hash }),
            log_id_hash(&LogId {
                path: path.to_string(),
                hash
            })
        );
        assert_eq!(
            log_id_ref_hash(&LogIdRef { path, hash }),
            log_id_parts_hash(hash, path),
        );
        assert_ne!(
            log_id_ref_hash(&LogIdRef { path, hash }),
            log_id_hash(&LogId {
                path: path.to_string(),
                hash: repo::hash_bytes(&[255])
            })
        );
    }

Insertion in inflorescence_view/src/theme.rs at line 91 [33.167]
[36.87]
[34.1363]
```
    Selected,
```

Replacement in inflorescence_view/src/theme.rs at line 218 [33.167]

B:BD[33.3596] → [33.3596:3693]

        let background =
            palette::Background::new(PALETTE.background, PALETTE.text);

[33.3596]

[33.3693]

        let background = palette::Background::new(
            match class {
                Scrollable::Normal => PALETTE.background,
                Scrollable::Selected => MAGENTA_DARKEST,
            },
            PALETTE.text,
        );

Replacement in inflorescence_view/src/theme.rs at line 230 [33.167]

B:BD[33.3905] → [33.3905:3953]

                color: background.strong.color,

[33.3905]

[33.3953]

                color: match class {
                    Scrollable::Normal => background.strong.color,
                    Scrollable::Selected => MAGENTA_LIGHTEST,
                },

Replacement in inflorescence_view/src/diff.rs at line 28 [32.417]

B:BD[32.2803] → [55.85:164]

pub fn view<'a>(state: &'a State, file: &'a File) -> Element<'a, Msg, Theme> {

[32.2803]

[32.3549]

pub fn view<'a>(
    state: &'a State,
    file: &'a File,
    diff_selected: bool,
) -> Element<'a, Msg, Theme> {

Replacement in inflorescence_view/src/diff.rs at line 34 [32.417]

B:BD[32.3566] → [32.3566:3640]

        File::Decoded(decoded_file) => view_decoded(state, decoded_file),

[32.3566]

[32.3640]

        File::Decoded(decoded_file) => {
            view_decoded(state, decoded_file, diff_selected)
        }

Replacement in inflorescence_view/src/diff.rs at line 38 [32.417]

B:BD[32.3689] → [32.3689:3743]

            view_undecodable(state, undecodable_file)

[32.3689]

[32.3743]

            view_undecodable(state, undecodable_file, diff_selected)

Insertion in inflorescence_view/src/diff.rs at line 46 [32.417]
[32.3951]
[33.6447]
```
    diff_selected: bool,
```

Replacement in inflorescence_view/src/diff.rs at line 104 [32.417]

B:BD[54.166] → [54.166:177]

))

[54.166]

[53.898]

        )
        .class(if diff_selected {
            theme::Scrollable::Selected
        } else {
            theme::Scrollable::Normal
        }))

Insertion in inflorescence_view/src/diff.rs at line 129 [32.417]
[32.5962]
[33.6479]
```
    diff_selected: bool,
```

Replacement in inflorescence_view/src/diff.rs at line 147 [32.417]

∅:D[55.315] → [54.178:318]

B:BD[53.1403] → [54.178:318]

        el(iced_nav_scrollable::view(
            nav,
            diffs,
            diffs_len,
            Msg::NavScrollable,
        ))

[55.315]

[53.1614]

        el(
            iced_nav_scrollable::view(
                nav,
                diffs,
                diffs_len,
                Msg::NavScrollable,
            )
            .class(if diff_selected {
                theme::Scrollable::Selected
            } else {
                theme::Scrollable::Normal
            }),
        )

Insertion in inflorescence_view/src/cursor.rs at line 22 [35.3124]
[35.3488]
[35.3488]
```
        diff_selected: bool,
```
Insertion in inflorescence_view/src/cursor.rs at line 27 [35.3124]
[35.3554]
[35.3554]
```
        diff_selected: bool,
```
Insertion in inflorescence_view/src/cursor.rs at line 41 [35.3124]
[35.4101]
[35.4101]
```
    pub diff_selected: bool,
```
Replacement in inflorescence_view/src/app.rs at line 44 [32.12409]
B:BD[32.13210] → [32.13210:13232]
```
        id: file::Id,
```
[32.13210]
[32.13232]
```
        id_hash: file::IdHash,
```

Replacement in inflorescence_view/src/app.rs at line 169 [32.12409]

B:BD[47.1601] → [47.1601:1802]

        Some(cursor::Selection::UntrackedFile { ix: _, path }) => {
            let id = file::Id {
                path: path.clone(),
                file_kind: file::Kind::Untracked,
            };

[47.1601]

[55.616]

        Some(cursor::Selection::UntrackedFile {
            ix: _,
            path,
            diff_selected,
        }) => {
            let id_hash = file::id_parts_hash(path, file::Kind::Untracked);

Replacement in inflorescence_view/src/app.rs at line 176 [32.12409]

B:BD[55.668] → [55.668:770]

∅:D[54.629] → [47.2046:2253]

∅:D[55.770] → [47.2046:2253]

B:BD[47.2046] → [47.2046:2253]

                Some((file, state)) => {
                    diff::view(state, file).map(move |msg| {
                        Msg::FileDiffsContentsAction {
                            id: id.clone(),
                            action: msg,
                        }
                    })
                }

[55.668]

[55.771]

                Some((file, state)) => diff::view(state, file, *diff_selected)
                    .map(move |msg| Msg::FileDiffsContentsAction {
                        id_hash,
                        action: msg,
                    }),

Replacement in inflorescence_view/src/app.rs at line 190 [32.12409]

B:BD[47.2546] → [47.2546:2743]

        Some(cursor::Selection::ChangedFile { path, ix: _ }) => {
            let id = file::Id {
                path: path.clone(),
                file_kind: file::Kind::Changed,
            };

[47.2546]

[55.825]

        Some(cursor::Selection::ChangedFile {
            path,
            ix: _,
            diff_selected,
        }) => {
            let id_hash = file::id_parts_hash(path, file::Kind::Changed);

Replacement in inflorescence_view/src/app.rs at line 197 [32.12409]

B:BD[55.877] → [55.877:979]

∅:D[54.705] → [47.2987:3194]

∅:D[55.979] → [47.2987:3194]

B:BD[47.2987] → [47.2987:3194]

                Some((file, state)) => {
                    diff::view(state, file).map(move |msg| {
                        Msg::FileDiffsContentsAction {
                            id: id.clone(),
                            action: msg,
                        }
                    })
                }

[55.877]

[55.980]

                Some((file, state)) => diff::view(state, file, *diff_selected)
                    .map(move |msg| Msg::FileDiffsContentsAction {
                        id_hash,
                        action: msg,
                    }),

Replacement in inflorescence_view/src/app.rs at line 299 [32.12409]

B:BD[55.1195] → [55.1195:1267]

            file: Some(cursor::LogChangeFileSelection { ix: _, path }),

[55.1195]

[55.1267]

            file:
                Some(cursor::LogChangeFileSelection {
                    ix: _,
                    path,
                    diff_selected,
                }),

Replacement in inflorescence_view/src/app.rs at line 313 [32.12409]

B:BD[55.1563] → [55.1563:1626]

                        diff::view(state, file).map(|action| {

[55.1563]

[55.1626]

                        diff::view(state, file, *diff_selected).map(|action| {

Replacement in inflorescence_view/src/app.rs at line 324 [32.12409]

B:BD[48.314] → [48.314:347]

B:BD[48.347] → [49.3179:3213]

            .width(Length::Fill)
            .height(Length::Fill)

[48.314]

[55.1822]

            // .width(Length::Fill)
            // .height(Length::Fill)

Insertion in inflorescence_view/src/app/test.rs at line 131 [59.4223]
[33.8883]
[33.8883]
```
            diff_selected: false,
```
Deletion in inflorescence/src/test.rs at line 7 [39.2521]
B:BD[41.1488] → [44.107:143]
```
use libflorescence::prelude::pijul;
```
Insertion in inflorescence/src/test.rs at line 184 [39.2521]
[42.1025]
[42.1025]
```
        diff_selected: false,
```
Deletion in inflorescence/src/test.rs at line 380 [39.2521]
B:BD[43.347] → [43.347:402]
```
    let _msg = task::await_next_msg(&mut tasks).await;
```
Insertion in inflorescence/src/test.rs at line 461 [39.2521]
[44.2141]
[44.2141]
```
        diff_selected: false,
```

Replacement in inflorescence/src/test.rs at line 474 [39.2521]

B:BD[44.2424] → [53.2119:2173]

∅:D[53.2173] → [44.2494:2546]

B:BD[44.2494] → [44.2494:2546]

        cursor::Selection::UntrackedFile { ix, path }
            if *ix == 1 && path == "untracked_1.rs"

[44.2424]

[44.2546]

        cursor::Selection::UntrackedFile { ix, path, diff_selected }
            if *ix == 1 && path == "untracked_1.rs" && !diff_selected

Replacement in inflorescence/src/test.rs at line 481 [39.2521]

B:BD[44.2660] → [44.2660:2820]

        state.files.diffs_cache.inner.peek(&file::Id {
            path: "untracked_1.rs".to_string(),
            file_kind: file::Kind::Untracked
        }),

[44.2660]

[44.2820]

        state.files.diffs_cache.inner.peek(&file::id_parts_hash(
            "untracked_1.rs",
            file::Kind::Untracked
        )),

Insertion in inflorescence/src/test.rs at line 496 [39.2521]
[44.3224]
[44.3224]
```
        diff_selected: false,
```
Insertion in inflorescence/src/test.rs at line 527 [39.2521]
[44.4142]
[44.4142]
```
        diff_selected: false,
```

Replacement in inflorescence/src/test.rs at line 540 [39.2521]

B:BD[44.4426] → [53.2174:2226]

∅:D[53.2226] → [44.4494:4544]

B:BD[44.4494] → [44.4494:4544]

        cursor::Selection::ChangedFile { ix, path }
            if *ix == 0 && path == "changed_0.rs"

[44.4426]

[44.4544]

        cursor::Selection::ChangedFile { ix, path, diff_selected }
            if *ix == 0 && path == "changed_0.rs" && !diff_selected

Replacement in inflorescence/src/test.rs at line 547 [39.2521]

B:BD[44.4658] → [44.4658:4814]

        state.files.diffs_cache.inner.peek(&file::Id {
            path: "changed_0.rs".to_string(),
            file_kind: file::Kind::Changed
        }),

[44.4658]

[44.4814]

        state
            .files
            .diffs_cache
            .inner
            .peek(&file::id_parts_hash("changed_0.rs", file::Kind::Changed)),

Insertion in inflorescence/src/test.rs at line 564 [39.2521]
[44.5268]
[44.5268]
```
        diff_selected: false,
```

Replacement in inflorescence/src/test.rs at line 577 [39.2521]

B:BD[44.5552] → [53.2227:2279]

∅:D[53.2279] → [44.5620:5670]

B:BD[44.5620] → [44.5620:5670]

        cursor::Selection::ChangedFile { ix, path }
            if *ix == 1 && path == "changed_1.rs"

[44.5552]

[44.5670]

        cursor::Selection::ChangedFile { ix, path, diff_selected }
            if *ix == 1 && path == "changed_1.rs" && !diff_selected

Insertion in inflorescence/src/test.rs at line 590 [39.2521]
[44.6034]
[44.6034]
```
        diff_selected: false,
```

Replacement in inflorescence/src/test.rs at line 608 [39.2521]

B:BD[44.6625] → [44.6625:6754]

    let change_hash_0 = change_hash(&[0]);
    let change_hash_1 = change_hash(&[1]);
    let change_hash_2 = change_hash(&[2]);

[44.6464]

[44.6754]

    let change_hash_0 = repo::hash_bytes(&[0]);
    let change_hash_1 = repo::hash_bytes(&[1]);
    let change_hash_2 = repo::hash_bytes(&[2]);

Insertion in inflorescence/src/test.rs at line 659 [39.2521]
[44.8137]
[44.8137]
```
        diff_selected: false,
```

Replacement in inflorescence/src/test.rs at line 687 [39.2521]

B:BD[45.498] → [45.498:584]

    let change_hash_0 = change_hash(&[0]);
    let change_hash_1 = change_hash(&[1]);

[45.498]

[45.584]

    let change_hash_0 = repo::hash_bytes(&[0]);
    let change_hash_1 = repo::hash_bytes(&[1]);

Replacement in inflorescence/src/test.rs at line 724 [39.2521]

B:BD[45.1996] → [54.2818:2892]

    // Initializes nav-scrollables for diffs
    assert!(task.is_some());

[45.1996]

[45.2025]

    assert!(task.is_none());

Insertion in inflorescence/src/test.rs at line 771 [39.2521]

[41.7441]

    /// Tasks to open window, set icon, tasks replies from repo, load user id
    /// and files

Deletion in inflorescence/src/test.rs at line 780 [39.2521]

B:BD[45.2216] → [45.2216:2366]

∅:D[45.2366] → [41.7650:7652]

B:BD[41.7650] → [41.7650:7652]


fn change_hash(bytes: &[u8]) -> pijul::Hash {
    let mut hasher = pijul::pristine::Hasher::default();
    hasher.update(bytes);
    hasher.finish()
}

Replacement in inflorescence/src/main.rs at line 14 [2.2763]
B:BD[3.1025] → [58.37:82]
```
use iced::widget::{scrollable, text_editor};
```
[3.1025]
[38.5279]
```
use iced::widget::text_editor;
```
Replacement in inflorescence/src/main.rs at line 26 [2.2763]
B:BD[38.5338] → [44.8591:8634]
```
use std::collections::{BTreeSet, HashMap};
```
[38.5338]
[38.5369]
```
use std::collections::BTreeSet;
```

Replacement in inflorescence/src/main.rs at line 102 [2.2763]

B:BD[29.164] → [54.2894:2974]

            files_diffs: HashMap::new(),
            log_diffs: HashMap::new(),

[29.164]

[6.1520]

            files_diffs: diff::FilesState::default(),
            logs: diff::LogFilesAndState::default(),

Replacement in inflorescence/src/main.rs at line 122 [2.2763]
B:BD[54.3085] → [54.3085:3134]
```
    files_diffs: HashMap<file::Id, diff::State>,
```
[54.3085]
[54.3134]
```
    files_diffs: diff::FilesState,
```
Replacement in inflorescence/src/main.rs at line 124 [2.2763]
B:BD[54.3200] → [55.2908:2962]
```
    log_diffs: HashMap<repo::LogFileId, LogFileDiff>,
```
[54.3200]
[19.1025]
```
    logs: diff::LogFilesAndState,
```
Replacement in inflorescence/src/main.rs at line 139 [2.2763]
B:BD[29.260] → [53.2490:2531]
```
    DiffStateNav {
        id: file::Id,
```
[29.260]
[53.2531]
```
    DiffNav {
        id_hash: file::IdHash,
```

Replacement in inflorescence/src/main.rs at line 143 [2.2763]

B:BD[53.2562] → [53.2562:2631]

    LogChangeDiff {
        hash: pijul::Hash,
        file: String,

[53.2562]

[53.2631]

    LogDiffNav {
        id_hash: file::LogIdHash,

Deletion in inflorescence/src/main.rs at line 149 [2.2763]
B:BD[54.3368] → [54.3368:3460]
∅:D[15.122] → [5.735:737]
∅:D[27.134] → [5.735:737]
∅:D[13.216] → [5.735:737]
∅:D[9.240] → [5.735:737]
∅:D[8.649] → [5.735:737]
∅:D[10.1205] → [5.735:737]
∅:D[17.1921] → [5.735:737]
∅:D[53.2662] → [5.735:737]
∅:D[14.2792] → [5.735:737]
∅:D[54.3460] → [5.735:737]
∅:D[7.4637] → [5.735:737]
B:BD[5.735] → [5.735:737]
∅:D[5.737] → [2.3098:3099]
∅:D[4.5117] → [2.3098:3099]
B:BD[2.3098] → [2.3098:3099]
```
#[derive(Debug)]
struct LogFileDiff {
    pub diff: diff::File,
    pub state: diff::State,
}
```
Replacement in inflorescence/src/main.rs at line 180 [2.2763]
B:BD[56.76] → [56.76:96]
```
                id,
```
[56.76]
[56.96]
```
                id_hash: id,
```

Replacement in inflorescence/src/main.rs at line 192 [2.2763]

B:BD[53.3059] → [53.3059:3208]

                let id_clone = id.clone();
                return tasks.map(move |msg| Msg::DiffStateNav {
                    id: id_clone.clone(),

[53.3059]

[53.3208]

                return tasks.map(move |msg| Msg::DiffNav {
                    id_hash: id,

Replacement in inflorescence/src/main.rs at line 199 [2.2763]
B:BD[53.3333] → [53.3333:3376]
```
        Msg::DiffStateNav { id, msg } => {
```
[53.3333]
[54.3532]
```
        Msg::DiffNav { id_hash: id, msg } => {
```

Replacement in inflorescence/src/main.rs at line 203 [2.2763]

B:BD[53.3548] → [53.3548:3653]

                return task.map(move |msg| Msg::DiffStateNav {
                    id: id_clone.clone(),

[53.3548]

[53.3653]

                return task.map(move |msg| Msg::DiffNav {
                    id_hash: id_clone.clone(),

Replacement in inflorescence/src/main.rs at line 210 [2.2763]

B:BD[53.3747] → [53.3747:3799]

B:BD[53.3799] → [55.2963:3018]

∅:D[55.3018] → [53.3874:3963]

B:BD[53.3874] → [53.3874:3963]

B:BD[53.3963] → [54.3604:3680]

∅:D[54.3680] → [53.4024:4073]

B:BD[53.4024] → [53.4024:4073]

        Msg::LogChangeDiff { hash, file, msg } => {
            if let Some(cursor::Selection::LogChange {
                ix: _,
                hash: selection_hash,
                message: _,
                file: Some(cursor::LogChangeFileSelection { ix: _, path }),
            }) = state.cursor.selection.as_mut()

[53.3747]

[53.4073]

        Msg::LogDiffNav { id_hash: id, msg } => {
            if let Some(diff::FileAndState { file: _, state }) =
                state.logs.diffs.get_mut(&id)

Replacement in inflorescence/src/main.rs at line 214 [2.2763]

B:BD[53.4087] → [53.4087:4132]

B:BD[53.4132] → [55.3019:3066]

∅:D[55.3066] → [54.3722:4021]

B:BD[54.3722] → [54.3722:4021]

∅:D[54.4021] → [53.4276:4531]

B:BD[53.4276] → [53.4276:4531]

                if selection_hash == &hash {
                    let id = repo::LogFileId {
                        hash,
                        path: path.clone(),
                    };
                    if let Some(LogFileDiff { diff: _, state }) =
                        state.log_diffs.get_mut(&id)
                    {
                        let task = diff::update(state, msg);
                        return task.map(move |msg| Msg::LogChangeDiff {
                            hash,
                            file: file.clone(),
                            msg,
                        });
                    }
                }

[53.4087]

[53.4531]

                let task = diff::update(state, msg);
                return task.map(move |msg| Msg::LogDiffNav {
                    id_hash: id.clone(),
                    msg,
                });

Insertion in inflorescence/src/main.rs at line 266 [2.2763]
[58.164]
[58.164]
```
                msg,
```

Replacement in inflorescence/src/main.rs at line 270 [2.2763]

B:BD[58.270] → [58.270:291]

                msg,

[58.270]

[58.291]

                &state.files_diffs,
                &state.logs,

Replacement in inflorescence/src/main.rs at line 275 [2.2763]

B:BD[58.364] → [58.364:2256]

            // If the selected file's diff is already loaded, scroll back to its
            // last offset
            let scroll_task = match state.cursor.selection.as_ref() {
                Some(cursor::Selection::UntrackedFile { ix: _, path }) => {
                    let id = file::Id {
                        path: path.clone(),
                        file_kind: file::Kind::Untracked,
                    };
                    if let Some(nav) = state
                        .files_diffs
                        .get(&id)
                        .and_then(|state| state.nav.as_ref())
                    {
                        task::scroll_to(
                            nav.id.clone(),
                            scrollable::AbsoluteOffset {
                                x: 0.0,
                                y: nav.offset,
                            },
                        )
                    } else {
                        Task::none()
                    }
                }
                Some(cursor::Selection::ChangedFile { ix: _, path }) => {
                    let id = file::Id {
                        path: path.clone(),
                        file_kind: file::Kind::Changed,
                    };
                    if let Some(nav) = state
                        .files_diffs
                        .get(&id)
                        .and_then(|state| state.nav.as_ref())
                    {
                        task::scroll_to(
                            nav.id.clone(),
                            scrollable::AbsoluteOffset {
                                x: 0.0,
                                y: nav.offset,
                            },
                        )
                    } else {
                        Task::none()
                    }
                }
                Some(cursor::Selection::LogChange {

[58.364]

[58.2256]

            let init_log_nav_task =
                if let Some(cursor::Selection::LogChange {

Replacement in inflorescence/src/main.rs at line 280 [2.2763]

B:BD[58.2341] → [58.2341:3150]

                    file: Some(cursor::LogChangeFileSelection { ix: _, path }),
                }) => {
                    let id = repo::LogFileId {
                        hash: *hash,
                        path: path.clone(),
                    };
                    if let Some(nav) = state
                        .log_diffs
                        .get(&id)
                        .and_then(|diff| diff.state.nav.as_ref())
                    {
                        task::scroll_to(
                            nav.id.clone(),
                            scrollable::AbsoluteOffset {
                                x: 0.0,
                                y: nav.offset,
                            },
                        )
                    } else {
                        Task::none()

[58.2341]

[58.3150]

                    file:
                        Some(cursor::LogChangeFileSelection {
                            ix: _,
                            path,
                            diff_selected: false,
                        }),
                }) = state.cursor.selection.as_ref()
                {
                    let id_hash = file::log_id_parts_hash(*hash, path);
                    match state.logs.diffs.get_mut(&id_hash) {
                        Some(log) if log.state.nav.is_none() => {
                            let contents_count =
                                diff::contents_count(&log.file);
                            let unchanged_sections =
                                diff::unchanged_sections(&log.file);
                            let (nav, tasks) = iced_nav_scrollable::init(
                                contents_count,
                                unchanged_sections,
                            );
                            log.state.nav = Some(nav);
                            tasks.map(move |msg| Msg::LogDiffNav {
                                id_hash,
                                msg: diff::Msg::NavScrollable(msg),
                            })
                        }
                        _ => Task::none(),

Insertion in inflorescence/src/main.rs at line 307 [2.2763]

[58.3172]

                } else {
                    Task::none()
                };
            let get_diffs_task = if let Some(cursor::Selection::LogChange {
                ix: _,
                hash,
                message: _,
                file: None,
            }) = state.cursor.selection.as_ref()
            {
                if !state.logs.change_hashes.contains(hash) {
                    Task::done(Msg::View(app::Msg::ToRepo(
                        repo::MsgIn::GetChangeDiffs { hash: *hash },
                    )))
                } else {
                    Task::none()

Replacement in inflorescence/src/main.rs at line 325 [2.2763]

B:BD[58.3190] → [58.3190:3421]

                Some(cursor::Selection::LogChange {
                    ix: _,
                    hash: _,
                    message: _,
                    file: None,
                })
                | None => Task::none(),

[58.3190]

[58.3421]

            } else {
                Task::none()

Replacement in inflorescence/src/main.rs at line 329 [2.2763]

B:BD[58.3437] → [58.3437:3489]

            Task::batch([cursor_task, scroll_task])

[58.3437]

[58.3489]

            Task::batch([cursor_task, get_diffs_task, init_log_nav_task])

Replacement in inflorescence/src/main.rs at line 339 [2.2763]

B:BD[40.582] → [40.582:702]

        app::Msg::FileDiffsContentsAction { id, action } => {
            file_diffs_contents_action(state, id, action)

[40.582]

[9.772]

        app::Msg::FileDiffsContentsAction { id_hash, action } => {
            file_diffs_contents_action(state, id_hash, action)

Replacement in inflorescence/src/main.rs at line 363 [2.2763]

B:BD[40.1311] → [40.1311:1424]

        if let Some(cursor::Selection::UntrackedFile { ix, path }) =
            state.cursor.selection.as_ref()

[40.1311]

[40.1424]

        if let Some(cursor::Selection::UntrackedFile {
            ix,
            path,
            diff_selected: _,
        }) = state.cursor.selection.as_ref()

Replacement in inflorescence/src/main.rs at line 398 [2.2763]

B:BD[40.2419] → [40.2419:2530]

        if let Some(cursor::Selection::ChangedFile { ix, path }) =
            state.cursor.selection.as_ref()

[40.2419]

[40.2530]

        if let Some(cursor::Selection::ChangedFile {
            ix,
            path,
            diff_selected: _,
        }) = state.cursor.selection.as_ref()

Replacement in inflorescence/src/main.rs at line 524 [2.2763]
B:BD[40.6417] → [40.6417:6435]
```
    id: file::Id,
```
[40.6417]
[40.6435]
```
    id_hash: file::IdHash,
```

Replacement in inflorescence/src/main.rs at line 528 [2.2763]

B:BD[40.6538] → [40.6538:6738]

B:BD[40.6738] → [54.4247:4325]

∅:D[54.4325] → [53.6606:6825]

B:BD[53.6606] → [53.6606:6825]

        match (selection, id.file_kind) {
            (
                cursor::Selection::UntrackedFile { ix: _, path },
                file::Kind::Untracked,
            ) if path == &id.path => {
                let diffs = state.files_diffs.entry(id.clone()).or_default();
                return diff::update(diffs, action).map(move |msg| {
                    Msg::DiffStateNav {
                        id: id.clone(),
                        msg,
                    }
                });

[40.6538]

[14.7355]

        match selection {
            cursor::Selection::UntrackedFile {
                ix: _,
                path,
                diff_selected: _,
            } => {
                let selection_hash =
                    file::id_parts_hash(path, file::Kind::Untracked);
                if id_hash == selection_hash {
                    let diffs = state.files_diffs.entry(id_hash).or_default();
                    return diff::update(diffs, action)
                        .map(move |msg| Msg::DiffNav { id_hash, msg });
                }

Replacement in inflorescence/src/main.rs at line 542 [2.2763]

B:BD[14.7369] → [40.6854:7008]

B:BD[40.7008] → [54.4326:4404]

∅:D[54.4404] → [53.6904:7104]

B:BD[53.6904] → [53.6904:7104]

            (
                cursor::Selection::ChangedFile { ix: _, path },
                file::Kind::Changed,
            ) if path == &id.path => {
                let diffs = state.files_diffs.entry(id.clone()).or_default();
                let task = diff::update(diffs, action);
                return task.map(move |msg| Msg::DiffStateNav {
                    id: id.clone(),
                    msg,
                });

[14.7369]

[40.7123]

            cursor::Selection::ChangedFile {
                ix: _,
                path,
                diff_selected: _,
            } => {
                let selection_hash =
                    file::id_parts_hash(path, file::Kind::Changed);
                if id_hash == selection_hash {
                    let diffs = state.files_diffs.entry(id_hash).or_default();
                    let task = diff::update(diffs, action);
                    return task.map(move |msg| Msg::DiffNav { id_hash, msg });
                }

Insertion in inflorescence/src/main.rs at line 577 [2.2763]
[40.7615]
[40.7615]
```
                diff_selected: _,
```

Replacement in inflorescence/src/main.rs at line 582 [2.2763]

B:BD[40.7740] → [55.3067:3106]

∅:D[55.3106] → [54.4438:4614]

B:BD[54.4438] → [54.4438:4614]

            let id = repo::LogFileId {
                hash,
                path: file.clone(),
            };
            if let Some(LogFileDiff { diff: _, state }) =
                state.log_diffs.get_mut(&id)

[40.7740]

[54.4614]

            let id_hash = file::log_id_parts_hash(hash, &file);
            if let Some(diff::FileAndState { file: _, state }) =
                state.logs.diffs.get_mut(&id_hash)

Replacement in inflorescence/src/main.rs at line 586 [2.2763]

B:BD[54.4628] → [54.4628:4882]

                return diff::update(state, action).map(move |msg| {
                    Msg::LogChangeDiff {
                        hash,
                        file: file.clone(),
                        msg,
                    }
                });

[54.4628]

[54.4882]

                return diff::update(state, action)
                    .map(move |msg| Msg::LogDiffNav { id_hash, msg });

Replacement in inflorescence/src/main.rs at line 668 [2.2763]

B:BD[40.9691] → [40.9691:9757]

            cursor::Selection::UntrackedFile { ix: _, path } => {

[40.9691]

[40.10022]

            cursor::Selection::UntrackedFile {
                ix: _,
                path,
                diff_selected,
            } => {

Insertion in inflorescence/src/main.rs at line 680 [2.2763]
[44.9210]
[40.10329]
```
                        diff_selected,
```

Replacement in inflorescence/src/main.rs at line 695 [2.2763]

B:BD[40.10409] → [40.10409:10473]

            cursor::Selection::ChangedFile { ix: _, path } => {

[40.10409]

[40.10682]

            cursor::Selection::ChangedFile {
                ix: _,
                path,
                diff_selected,
            } => {

Insertion in inflorescence/src/main.rs at line 708 [2.2763]
[40.11062]
[40.11062]
```
                            diff_selected,
```

Replacement in inflorescence/src/main.rs at line 739 [2.2763]

B:BD[40.11737] → [40.11737:12196]

∅:D[29.1165] → [20.15057:15117]

∅:D[40.12196] → [20.15057:15117]

B:BD[20.15057] → [20.15057:15117]

B:BD[20.15117] → [40.12197:12298]

                        let file = file.and_then(|file| {
                            entry
                                .file_paths
                                .iter()
                                .enumerate()
                                .find(|(_ix, path)| *path == &file.path)
                                .map(|(ix, path)| {
                                    cursor::LogChangeFileSelection {
                                        ix,
                                        path: path.clone(),
                                    }
                                })
                        });

[40.11737]

[40.12298]

                        let file = file.and_then(
                            |cursor::LogChangeFileSelection {
                                 ix: _,
                                 path: selected_path,
                                 diff_selected,
                             }| {
                                entry
                                    .file_paths
                                    .iter()
                                    .enumerate()
                                    .find(|(_ix, path)| *path == &selected_path)
                                    .map(|(ix, path)| {
                                        cursor::LogChangeFileSelection {
                                            ix,
                                            path: path.clone(),
                                            diff_selected,
                                        }
                                    })
                            },
                        );

Deletion in inflorescence/src/main.rs at line 801 [2.2763]
B:BD[40.13140] → [54.4897:4958]
```
            let mut tasks = Vec::with_capacity(diffs.len());
```

Replacement in inflorescence/src/main.rs at line 804 [2.2763]

B:BD[54.5129] → [54.5129:5173]

                let diff = diff::init_file(

[54.5129]

[54.5173]

                let file = diff::init_file(

Replacement in inflorescence/src/main.rs at line 808 [2.2763]

B:BD[54.5282] → [54.5282:5348]

B:BD[54.5348] → [56.361:596]

∅:D[56.596] → [54.5450:5601]

B:BD[54.5450] → [54.5450:5601]

                let contents_count = diff::contents_count(&diff);
                let unchanged_sections = diff::unchanged_sections(&diff);
                let (nav, nav_tasks) = iced_nav_scrollable::init(
                    contents_count,
                    unchanged_sections,
                );
                let diff_state = diff::State {
                    nav: Some(nav),
                    state: libflorescence::diff::State::default(),

[54.5282]

[54.5601]

                let id_hash = file::log_id_parts_hash(hash, &path);
                let log_file_diff = diff::FileAndState {
                    file,
                    // The nav is initialized only once a file is selected,
                    // because its tasks need it to be visible to complete
                    state: diff::State::default(),

Deletion in inflorescence/src/main.rs at line 815 [2.2763]

B:BD[54.5620] → [54.5620:5667]

B:BD[54.5667] → [55.3107:3164]

∅:D[55.3164] → [54.5718:5852]

B:BD[54.5718] → [54.5718:5852]

                let path_clone = path.clone();
                let id = repo::LogFileId { hash, path };
                let log_file_diff = LogFileDiff {
                    diff,
                    state: diff_state,
                };

Replacement in inflorescence/src/main.rs at line 816 [2.2763]

B:BD[54.5853] → [54.5853:6133]

                state.log_diffs.insert(id, log_file_diff);
                tasks.push(nav_tasks.map(move |msg| Msg::LogChangeDiff {
                    hash,
                    file: path_clone.clone(),
                    msg: diff::Msg::NavScrollable(msg),
                }))

[54.5853]

[54.6133]

                state.logs.change_hashes.insert(hash);
                state.logs.diffs.insert(id_hash, log_file_diff);

Deletion in inflorescence/src/main.rs at line 819 [2.2763]
B:BD[54.6149] → [54.6149:6188]
```
            return Task::batch(tasks);
```
Replacement in inflorescence/src/main.rs at line 824 [2.2763]
B:BD[17.4299] → [32.27331:27378]
```
fn subs(_state: &State) -> Subscription<Msg> {
```
[17.4299]
[18.22]
```
fn subs(state: &State) -> Subscription<Msg> {
```

Replacement in inflorescence/src/main.rs at line 877 [2.2763]

B:BD[49.5720] → [49.5720:5769]

    Subscription::batch([key_subs, window_subs])

[49.5720]

[5.4172]

    let nav_subs = match state.cursor.selection.as_ref() {
        Some(cursor::Selection::UntrackedFile {
            ix: _,
            path,
            diff_selected: true,
        }) => {
            let id_hash = file::id_parts_hash(path, file::Kind::Untracked);
            iced_nav_scrollable::subs()
                .with(id_hash)
                .map(|(id_hash, msg)| Msg::DiffNav {
                    id_hash,
                    msg: diff::Msg::NavScrollable(msg),
                })
        }
        Some(cursor::Selection::ChangedFile {
            ix: _,
            path,
            diff_selected: true,
        }) => {
            let id_hash = file::id_parts_hash(path, file::Kind::Changed);
            iced_nav_scrollable::subs()
                .with(id_hash)
                .map(|(id_hash, msg)| Msg::DiffNav {
                    id_hash,
                    msg: diff::Msg::NavScrollable(msg),
                })
        }
        Some(cursor::Selection::LogChange {
            ix: _,
            hash,
            message: _,
            file:
                Some(cursor::LogChangeFileSelection {
                    ix: _,
                    path,
                    diff_selected: true,
                }),
        }) => {
            let id_hash = file::log_id_parts_hash(*hash, path);
            iced_nav_scrollable::subs()
                .with(id_hash)
                .map(|(id_hash, msg)| Msg::LogDiffNav {
                    id_hash,
                    msg: diff::Msg::NavScrollable(msg),
                })
        }
        Some(cursor::Selection::UntrackedFile { .. })
        | Some(cursor::Selection::ChangedFile { .. })
        | Some(cursor::Selection::LogChange { .. })
        | None => Subscription::none(),
    };
    Subscription::batch([key_subs, window_subs, nav_subs])

Replacement in inflorescence/src/main.rs at line 943 [2.2763]

B:BD[32.28696] → [54.6189:6242]

        files_diffs: diffs_state,
        log_diffs,

[32.28696]

[32.28717]

        files_diffs,
        logs: log_diffs,

Replacement in inflorescence/src/main.rs at line 948 [2.2763]

B:BD[54.6308] → [54.6308:6509]

B:BD[54.6509] → [55.3165:3223]

        Some(cursor::Selection::UntrackedFile { ix: _, path }) => {
            let id = file::Id {
                path: path.clone(),
                file_kind: file::Kind::Untracked,
            };
            let file = files.diffs_cache.inner.peek(&id);

[54.6308]

[55.3223]

        Some(cursor::Selection::UntrackedFile {
            ix: _,
            path,
            diff_selected: _,
        }) => {
            let id_hash = file::id_parts_hash(path, file::Kind::Untracked);
            let file = files.diffs_cache.inner.peek(&id_hash);

Replacement in inflorescence/src/main.rs at line 957 [2.2763]

B:BD[55.3300] → [55.3300:3368]

                    diffs_state.get(&id).map(|state| (file, state))

[55.3300]

[55.3368]

                    files_diffs.get(&id_hash).map(|state| (file, state))

Replacement in inflorescence/src/main.rs at line 962 [2.2763]

B:BD[54.6552] → [54.6552:6749]

B:BD[54.6749] → [55.3459:3517]

        Some(cursor::Selection::ChangedFile { path, ix: _ }) => {
            let id = file::Id {
                path: path.clone(),
                file_kind: file::Kind::Changed,
            };
            let file = files.diffs_cache.inner.peek(&id);

[54.6552]

[55.3517]

        Some(cursor::Selection::ChangedFile {
            path,
            ix: _,
            diff_selected: _,
        }) => {
            let id_hash = file::id_parts_hash(path, file::Kind::Changed);
            let file = files.diffs_cache.inner.peek(&id_hash);

Replacement in inflorescence/src/main.rs at line 971 [2.2763]

B:BD[55.3594] → [55.3594:3662]

                    diffs_state.get(&id).map(|state| (file, state))

[55.3594]

[55.3662]

                    files_diffs.get(&id_hash).map(|state| (file, state))

Replacement in inflorescence/src/main.rs at line 980 [2.2763]

B:BD[54.7039] → [54.7039:7111]

            file: Some(cursor::LogChangeFileSelection { ix: _, path }),

[54.7039]

[54.7111]

            file:
                Some(cursor::LogChangeFileSelection {
                    ix: _,
                    path,
                    diff_selected: _,
                }),

Replacement in inflorescence/src/main.rs at line 987 [2.2763]

B:BD[54.7127] → [55.3753:3792]

∅:D[55.3792] → [54.7160:7240]

B:BD[54.7160] → [54.7160:7240]

            let id = repo::LogFileId {
                hash: *hash,
                path: path.clone(),
            };

[54.7127]

[54.7240]

            let id_hash = file::log_id_parts_hash(*hash, path);

Replacement in inflorescence/src/main.rs at line 989 [2.2763]

B:BD[54.7262] → [54.7262:7288]

B:BD[54.7288] → [55.3793:3865]

                .get(&id)
                .map(|LogFileDiff { diff: file, state }| (file, state))

[54.7262]

[54.7354]

                .diffs
                .get(&id_hash)
                .map(|diff::FileAndState { file, state }| (file, state))

Replacement in inflorescence/src/file.rs at line 4 [29.1806]

∅:D[37.1678] → [35.6102:6150]

B:BD[32.29020] → [35.6102:6150]

pub use libflorescence::file::{Diff, Id, Kind};

[37.1678]

[29.1869]

pub use libflorescence::file::{
    id_hash, id_parts_hash, log_id_parts_hash, Diff, Id, IdHash, IdMap, Kind,
    LogIdHash, LogIdMap,
};

Replacement in inflorescence/src/file.rs at line 53 [29.1806]

B:BD[29.2831] → [29.2831:2898]

    CLruCache<Id, Diff, std::hash::RandomState, DiffsCacheWeight>;

[29.2831]

[29.3180]

    CLruCache<IdHash, Diff, std::hash::RandomState, DiffsCacheWeight>;

Replacement in inflorescence/src/file.rs at line 97 [29.1806]
B:BD[53.7756] → [53.7756:7772]
```
    pub id: Id,
```
[53.7756]
[53.7772]
```
    pub id_hash: IdHash,
```
Insertion in inflorescence/src/file.rs at line 122 [29.1806]
[29.4904]
[29.4904]
```
                let id_hash = id_hash(&id);
```

Replacement in inflorescence/src/file.rs at line 133 [29.1806]

B:BD[29.5192] → [53.7994:8034]

                            id.clone(),

[29.5192]

[29.5224]

                            id_hash,

Replacement in inflorescence/src/file.rs at line 138 [29.1806]

B:BD[56.836] → [56.836:868]

id,

[56.836]

[56.868]

                            id_hash,

Replacement in inflorescence/src/file.rs at line 156 [29.1806]

B:BD[29.5732] → [53.8222:8266]

                                id.clone(),

[29.5732]

[29.5768]

                                id_hash,

Replacement in inflorescence/src/file.rs at line 161 [29.1806]

B:BD[56.1157] → [56.1157:1193]

id,

[56.1157]

[56.1193]

                                id_hash,

Replacement in inflorescence/src/file.rs at line 196 [29.1806]

B:BD[29.6473] → [29.6473:6597]

    if !state.diffs_cache.inner.contains(&id) {
        diffs_cache_put(&mut state.diffs_cache, id.clone(), Diff::Loading);

[29.6473]

[29.6597]

    let id_hash = id_hash(&id);
    if !state.diffs_cache.inner.contains(&id_hash) {
        diffs_cache_put(&mut state.diffs_cache, id_hash, Diff::Loading);

Replacement in inflorescence/src/file.rs at line 211 [29.1806]

B:BD[29.6850] → [29.6850:6917]

fn diffs_cache_put(cache: &mut DiffsCache, key: Id, value: Diff) {

[29.6850]

[29.6917]

fn diffs_cache_put(cache: &mut DiffsCache, key: IdHash, value: Diff) {

Replacement in inflorescence/src/file.rs at line 214 [29.1806]

B:BD[29.7053] → [29.7053:7165]

        info!("Source file cache is too small to hold {}. Resizing cache to to {kv_weight} fit it.", key.path);

[29.7053]

[29.7165]

        info!("Source file cache is too small to fit new key. Resizing cache to {kv_weight} fit it.");

Replacement in inflorescence/src/file.rs at line 221 [29.1806]

B:BD[29.7325] → [29.7325:7472]

impl WeightScale<Id, Diff> for DiffsCacheWeight {
    fn weight(&self, key: &Id, value: &Diff) -> usize {
        let key_weight = key.path.len();

[29.7325]

[29.7472]

impl WeightScale<IdHash, Diff> for DiffsCacheWeight {
    fn weight(&self, _key: &IdHash, value: &Diff) -> usize {
        const KEY_WEIGHT: usize = mem::size_of::<IdHash>();

Replacement in inflorescence/src/file.rs at line 248 [29.1806]
B:BD[29.8419] → [29.8419:8451]
```
        key_weight + val_weight
```
[29.8419]
[29.8451]
```
        KEY_WEIGHT + val_weight
```
Insertion in inflorescence/src/diff.rs at line 12 [60.5018]
[31.732]
[53.8470]
```
use crate::file;
```

Insertion in inflorescence/src/diff.rs at line 19 [60.5018]

[56.1373]

[23.287]


pub type FilesState = file::IdMap<State>;
#[derive(Debug, Default)]
pub struct LogFilesAndState {
    /// All the hashes in this set have `diffs` loaded
    pub change_hashes: HashSet<repo::ChangeHash>,
    /// All the diffs in this map have the change hash present in
    /// `change_hashes`
    pub diffs: file::LogIdMap<FileAndState>,
}

Insertion in inflorescence/src/diff.rs at line 31 [60.5018]

[23.288]

[53.8493]

#[derive(Debug)]
pub struct FileAndState {
    pub file: File,
    pub state: State,
}

Insertion in inflorescence/src/diff.rs at line 203 [60.5018]

[56.1917]

}
pub fn file_diff_needs_scrolling(
    files_diffs: &FilesState,
    id: file::IdHash,
) -> bool {
    matches!(
        files_diffs
            .get(&id)
            .and_then(|diff| diff.nav.as_ref())
            .and_then(|nav| nav.ready),
        Some(iced_nav_scrollable::NeedsScrolling::Yes)
    )
}
pub fn log_diff_needs_scrolling(
    logs: &LogFilesAndState,
    id_hash: file::LogIdHash,
) -> bool {
    matches!(
        logs.diffs
            .get(&id_hash)
            .and_then(|diff| diff.state.nav.as_ref())
            .and_then(|nav| nav.ready),
        Some(iced_nav_scrollable::NeedsScrolling::Yes)
    )

Replacement in inflorescence/src/cursor.rs at line 10 [5.26]
B:BD[28.2281] → [28.2281:2296]
```
pub fn update(
```
[29.8578]
[28.2296]
```
pub fn update<M>(
    msg: Msg,
```

Replacement in inflorescence/src/cursor.rs at line 15 [5.26]

B:BD[28.2440] → [28.2440:2479]

    msg: Msg,
) -> Task<repo::MsgIn> {

[28.2385]

[28.2479]

    files_diffs: &diff::FilesState,
    log_diffs: &diff::LogFilesAndState,
) -> Task<M> {

Replacement in inflorescence/src/cursor.rs at line 19 [5.26]

B:BD[28.2495] → [30.939:962]

∅:D[30.962] → [28.2524:3023]

B:BD[28.2524] → [28.2524:3023]

B:BD[28.3023] → [29.8609:8742]

∅:D[29.8742] → [28.3339:3741]

B:BD[28.3339] → [28.3339:3741]

B:BD[28.3741] → [29.8743:8800]

∅:D[29.8800] → [28.3942:4163]

B:BD[28.3942] → [28.3942:4163]

B:BD[28.4163] → [29.8801:8928]

∅:D[29.8928] → [28.4457:4594]

B:BD[28.4457] → [28.4457:4594]

        Msg::Down => {
            if let Some(repo) = repo.as_ref() {
                let (selection, task) = match state.selection.take() {
                    Some(Selection::UntrackedFile { ix, path: _ }) => {
                        let (selection, task) =
                            if repo.untracked_files.len().saturating_sub(1)
                                == ix
                            {
                                if !repo.changed_files.is_empty() {
                                    let ix = 0;
                                    let selection =
                                        changed_file_selection(repo, ix, files);
                                    (selection, Task::none())
                                } else if !repo.log.is_empty() {
                                    let ix = 0;
                                    log_selection(repo, ix)
                                } else {
                                    let ix = 0;
                                    let selection = untracked_file_selection(
                                        repo, ix, files,
                                    );
                                    (selection, Task::none())
                                }
                            } else {
                                let ix = ix + 1;
                                let selection =
                                    untracked_file_selection(repo, ix, files);
                                (selection, Task::none())
                            };
                        (Some(selection), task)

[28.2495]

[28.4594]

        Msg::Down => select_down(state, files, repo, files_diffs, log_diffs),
        Msg::Up => select_up(state, files, repo, files_diffs, log_diffs),
        Msg::Left => select_left(state, repo),
        Msg::Right => select_right(state, repo, files_diffs, log_diffs),
        Msg::Select(select) => {
            select_exact(select, state, files, repo, files_diffs, log_diffs)
        }
    }
}
pub fn untracked_file_selection(
    repo: &repo::State,
    ix: usize,
    files: &mut file::State,
) -> Selection {
    let path = repo.untracked_files.iter().nth(ix).unwrap().clone();
    let id = file::Id {
        path: path.clone(),
        file_kind: file::Kind::Untracked,
    };
    file::load_src_file_if_not_cached(files, id);
    Selection::UntrackedFile {
        ix,
        path,
        diff_selected: false,
    }
}
pub fn changed_file_selection(
    repo: &repo::State,
    ix: usize,
    files: &mut file::State,
) -> Selection {
    let (path, diffs) = repo.changed_files.iter().nth(ix).unwrap();
    if diff::any_diff_has_contents(diffs) {
        let id = file::Id {
            path: path.clone(),
            file_kind: file::Kind::Changed,
        };
        file::load_src_file_if_not_cached(files, id);
    }
    Selection::ChangedFile {
        ix,
        path: path.clone(),
        diff_selected: false,
    }
}
pub fn log_selection(repo: &repo::State, ix: usize) -> Selection {
    let entry = repo.log.get(ix).unwrap();
    Selection::LogChange {
        ix,
        hash: entry.hash,
        message: entry.message.clone(),
        file: None,
    }
}
pub fn log_file_selection(
    log_entry: &repo::LogEntry,
    file_ix: usize,
) -> LogChangeFileSelection {
    let path = log_entry.file_paths.get(file_ix).unwrap().clone();
    LogChangeFileSelection {
        ix: file_ix,
        path,
        diff_selected: false,
    }
}
fn select_down<M>(
    state: &mut State,
    files: &mut file::State,
    repo: Option<&repo::State>,
    files_diffs: &diff::FilesState,
    logs: &diff::LogFilesAndState,
) -> Task<M> {
    // TODO stair
    if let Some(repo) = repo.as_ref() {
        let (selection, task) = match state.selection.take() {
            Some(Selection::UntrackedFile {
                ix,
                path,
                diff_selected,
            }) => {
                let (selection, task) = if diff_selected {
                    let id_hash =
                        file::id_parts_hash(&path, file::Kind::Untracked);
                    (
                        Selection::UntrackedFile {
                            ix,
                            path,
                            diff_selected,
                        },
                        if let Some(nav) = files_diffs
                            .get(&id_hash)
                            .and_then(|state| state.nav.as_ref())
                        {
                            iced_nav_scrollable::scroll_down(nav)
                        } else {
                            Task::none()
                        },
                    )
                } else if repo.untracked_files.len().saturating_sub(1) == ix {
                    if !repo.changed_files.is_empty() {
                        let ix = 0;
                        let selection = changed_file_selection(repo, ix, files);
                        (selection, Task::none())
                    } else if !repo.log.is_empty() {
                        let ix = 0;
                        (log_selection(repo, ix), Task::none())
                    } else {
                        let ix = 0;
                        let selection =
                            untracked_file_selection(repo, ix, files);
                        (selection, Task::none())

Replacement in inflorescence/src/cursor.rs at line 140 [5.26]

B:BD[28.4616] → [28.4616:5213]

B:BD[28.5213] → [29.8929:8986]

∅:D[29.8986] → [28.5414:5604]

B:BD[28.5414] → [28.5414:5604]

B:BD[28.5604] → [29.8987:9120]

∅:D[29.9120] → [28.5920:6102]

B:BD[28.5920] → [28.5920:6102]

B:BD[28.6102] → [29.9121:9246]

∅:D[29.9246] → [28.6394:6531]

B:BD[28.6394] → [28.6394:6531]

                    Some(Selection::ChangedFile { ix, path: _ }) => {
                        let (selection, task) =
                            if repo.changed_files.len().saturating_sub(1) == ix
                            {
                                if !repo.log.is_empty() {
                                    let ix = 0;
                                    log_selection(repo, ix)
                                } else if !repo.untracked_files.is_empty() {
                                    let ix = 0;
                                    let selection = untracked_file_selection(
                                        repo, ix, files,
                                    );
                                    (selection, Task::none())
                                } else {
                                    let ix = 0;
                                    let selection =
                                        changed_file_selection(repo, ix, files);
                                    (selection, Task::none())
                                }
                            } else {
                                let ix = ix + 1;
                                let selection =
                                    changed_file_selection(repo, ix, files);
                                (selection, Task::none())
                            };
                        (Some(selection), task)

[28.4616]

[28.6531]

                } else {
                    let ix = ix + 1;
                    let selection = untracked_file_selection(repo, ix, files);
                    (selection, Task::none())
                };
                (Some(selection), task)
            }
            Some(Selection::ChangedFile {
                ix,
                path,
                diff_selected,
            }) => {
                let (selection, task) = if diff_selected {
                    let id_hash =
                        file::id_parts_hash(&path, file::Kind::Changed);
                    (
                        Selection::ChangedFile {
                            ix,
                            path,
                            diff_selected,
                        },
                        if let Some(nav) = files_diffs
                            .get(&id_hash)
                            .and_then(|state| state.nav.as_ref())
                        {
                            iced_nav_scrollable::scroll_down(nav)
                        } else {
                            Task::none()
                        },
                    )
                } else if repo.changed_files.len().saturating_sub(1) == ix {
                    if !repo.log.is_empty() {
                        let ix = 0;
                        (log_selection(repo, ix), Task::none())
                    } else if !repo.untracked_files.is_empty() {
                        let ix = 0;
                        let selection =
                            untracked_file_selection(repo, ix, files);
                        (selection, Task::none())
                    } else {
                        let ix = 0;
                        let selection = changed_file_selection(repo, ix, files);
                        (selection, Task::none())

Replacement in inflorescence/src/cursor.rs at line 184 [5.26]

B:BD[28.6553] → [28.6553:6700]

B:BD[28.6731] → [28.6731:6761]

                    Some(Selection::LogChange {
                        ix: log_ix,
                        hash,
                        message,
                        file,

[28.6553]

[28.6761]

                } else {
                    let ix = ix + 1;
                    let selection = changed_file_selection(repo, ix, files);
                    (selection, Task::none())
                };
                (Some(selection), task)
            }
            Some(Selection::LogChange {
                ix: log_ix,
                hash,
                message,
                file,
            }) => {
                let (selection, task) = match file {
                    Some(LogChangeFileSelection {
                        ix: file_ix,
                        path,
                        diff_selected,

Replacement in inflorescence/src/cursor.rs at line 203 [5.26]

B:BD[28.6789] → [28.6789:7109]

                        let (selection, task) = match file {
                            Some(LogChangeFileSelection {
                                ix: file_ix,
                                path: _,
                            }) => {
                                let log_entry = repo.log.get(log_ix).unwrap();

[28.6789]

[28.7109]

                        if diff_selected {
                            let id_hash = file::log_id_parts_hash(hash, &path);
                            (
                                Selection::LogChange {
                                    ix: log_ix,
                                    hash,
                                    message,
                                    file: Some(LogChangeFileSelection {
                                        ix: file_ix,
                                        path,
                                        diff_selected,
                                    }),
                                },
                                if let Some(nav) = logs
                                    .diffs
                                    .get(&id_hash)
                                    .and_then(|diff| diff.state.nav.as_ref())
                                {
                                    iced_nav_scrollable::scroll_down(nav)
                                } else {
                                    Task::none()
                                },
                            )
                        } else {
                            let log_entry = repo.log.get(log_ix).unwrap();

Replacement in inflorescence/src/cursor.rs at line 229 [5.26]

B:BD[28.7110] → [28.7110:7315]

                                let file_ix = if log_entry
                                    .file_paths
                                    .len()
                                    .saturating_sub(1)

[28.7110]

[28.7315]

                            let file_ix =
                                if log_entry.file_paths.len().saturating_sub(1)

Replacement in inflorescence/src/cursor.rs at line 238 [5.26]

B:BD[28.7559] → [28.7559:7678]

                                let file =
                                    log_file_selection(log_entry, file_ix);

[28.7559]

[28.7678]

                            let file = log_file_selection(log_entry, file_ix);

Replacement in inflorescence/src/cursor.rs at line 240 [5.26]

B:BD[28.7679] → [28.7679:7919]

B:BD[28.7966] → [28.7966:8750]

B:BD[28.8750] → [29.9247:9312]

∅:D[29.9312] → [28.8983:9307]

B:BD[28.8983] → [28.8983:9307]

B:BD[28.9307] → [29.9313:9374]

∅:D[29.9374] → [28.9524:9832]

B:BD[28.9524] → [28.9524:9832]

                                (
                                    Selection::LogChange {
                                        ix: log_ix,
                                        hash,
                                        message,
                                        file: Some(file),
                                    },
                                    Task::none(),
                                )
                            }
                            None => {
                                let (selection, task) = if repo
                                    .log
                                    .len()
                                    .saturating_sub(1)
                                    == log_ix
                                {
                                    if !repo.untracked_files.is_empty() {
                                        let ix = 0;
                                        let selection =
                                            untracked_file_selection(
                                                repo, ix, files,
                                            );
                                        (selection, Task::none())
                                    } else if !repo.changed_files.is_empty() {
                                        let ix = 0;
                                        let selection = changed_file_selection(
                                            repo, ix, files,
                                        );
                                        (selection, Task::none())
                                    } else {
                                        let ix = 0;
                                        log_selection(repo, ix)
                                    }

[28.7679]

[28.9832]

                            (
                                Selection::LogChange {
                                    ix: log_ix,
                                    hash,
                                    message,
                                    file: Some(file),
                                },
                                Task::none(),
                            )
                        }
                    }
                    None => {
                        let selection =
                            if repo.log.len().saturating_sub(1) == log_ix {
                                if !repo.untracked_files.is_empty() {
                                    let ix = 0;
                                    untracked_file_selection(repo, ix, files)
                                } else if !repo.changed_files.is_empty() {
                                    let ix = 0;
                                    changed_file_selection(repo, ix, files)

Replacement in inflorescence/src/cursor.rs at line 261 [5.26]

B:BD[28.9873] → [28.9873:9930]

                                    let ix = log_ix + 1;

[28.9873]

[28.9930]

                                    let ix = 0;

Replacement in inflorescence/src/cursor.rs at line 263 [5.26]

B:BD[28.9990] → [28.9990:10180]

                                };
                                (selection, task)
                            }
                        };
                        (Some(selection), task)

[28.9990]

[28.10180]

                                }
                            } else {
                                let ix = log_ix + 1;
                                log_selection(repo, ix)
                            };
                        (selection, Task::none())

Replacement in inflorescence/src/cursor.rs at line 270 [5.26]

B:BD[28.10202] → [28.10202:10232]

B:BD[28.10232] → [29.9375:9517]

                    None => {
                        let (selection, task) = if !repo
                            .untracked_files
                            .is_empty()

[28.10202]

[29.9517]

                };
                (Some(selection), task)
            }
            None => {
                let (selection, task) = if !repo.untracked_files.is_empty() {
                    let ix = 0;
                    let selection =
                        Some(untracked_file_selection(repo, ix, files));
                    (selection, Task::none())
                } else if !repo.changed_files.is_empty() {
                    let ix = 0;
                    let selection =
                        Some(changed_file_selection(repo, ix, files));
                    (selection, Task::none())
                } else if !repo.log.is_empty() {
                    let ix = repo.log.len() - 1;
                    let selection = log_selection(repo, ix);
                    (Some(selection), Task::none())
                } else {
                    (None, Task::none())
                };
                (selection, task)
            }
        };
        state.selection = selection;
        task
    } else {
        Task::none()
    }
}
fn select_up<M>(
    state: &mut State,
    files: &mut file::State,
    repo: Option<&repo::State>,
    files_diffs: &diff::FilesState,
    logs: &diff::LogFilesAndState,
) -> Task<M> {
    // TODO stair
    if let Some(repo) = repo.as_ref() {
        let (selection, task) = match state.selection.take() {
            Some(Selection::UntrackedFile {
                ix,
                path,
                diff_selected,
            }) => {
                let (selection, task) = if diff_selected {
                    let id_hash =
                        file::id_parts_hash(&path, file::Kind::Untracked);
                    (
                        Selection::UntrackedFile {
                            ix,
                            path,
                            diff_selected,
                        },
                        if let Some(nav) = files_diffs
                            .get(&id_hash)
                            .and_then(|state| state.nav.as_ref())

Replacement in inflorescence/src/cursor.rs at line 329 [5.26]

B:BD[29.9543] → [29.9543:10289]

                            let ix = 0;
                            let selection =
                                Some(untracked_file_selection(repo, ix, files));
                            (selection, Task::none())
                        } else if !repo.changed_files.is_empty() {
                            let ix = 0;
                            let selection =
                                Some(changed_file_selection(repo, ix, files));
                            (selection, Task::none())
                        } else if !repo.log.is_empty() {
                            let ix = repo.log.len() - 1;
                            let (selection, task) = log_selection(repo, ix);
                            (Some(selection), task)

[29.9543]

[29.10289]

                            iced_nav_scrollable::scroll_up(nav)

Replacement in inflorescence/src/cursor.rs at line 331 [5.26]

B:BD[29.10322] → [29.10322:10398]

∅:D[29.10398] → [28.11599:11641]

B:BD[28.11599] → [28.11599:11641]

                            (None, Task::none())
                        };
                        (selection, task)

[29.10322]

[28.11641]

                            Task::none()
                        },
                    )
                } else if 0 == ix {
                    if !repo.log.is_empty() {
                        let ix = repo.log.len() - 1;
                        (log_selection(repo, ix), Task::none())
                    } else if !repo.changed_files.is_empty() {
                        let ix = repo.changed_files.len() - 1;
                        let selection = changed_file_selection(repo, ix, files);
                        (selection, Task::none())
                    } else {
                        let ix = repo.untracked_files.len() - 1;
                        let selection =
                            untracked_file_selection(repo, ix, files);
                        (selection, Task::none())

Insertion in inflorescence/src/cursor.rs at line 348 [5.26]

[28.11663]

                } else {
                    let ix = ix - 1;
                    let selection = untracked_file_selection(repo, ix, files);
                    (selection, Task::none())

Replacement in inflorescence/src/cursor.rs at line 353 [5.26]

B:BD[28.11682] → [28.11682:11798]

                state.selection = selection;
                task
            } else {
                Task::none()

[28.11682]

[28.11798]

                (Some(selection), task)
            }
            Some(Selection::ChangedFile {
                ix,
                path,
                diff_selected,
            }) => {
                let (selection, task) = if diff_selected {
                    let id_hash =
                        file::id_parts_hash(&path, file::Kind::Changed);
                    (
                        Selection::ChangedFile {
                            ix,
                            path,
                            diff_selected,
                        },
                        if let Some(nav) = files_diffs
                            .get(&id_hash)
                            .and_then(|state| state.nav.as_ref())
                        {
                            iced_nav_scrollable::scroll_up(nav)
                        } else {
                            Task::none()
                        },
                    )
                } else if 0 == ix {
                    let selection = if !repo.untracked_files.is_empty() {
                        let ix = repo.untracked_files.len() - 1;
                        untracked_file_selection(repo, ix, files)
                    } else if !repo.log.is_empty() {
                        let ix = repo.log.len() - 1;
                        log_selection(repo, ix)
                    } else {
                        let ix = repo.changed_files.len() - 1;
                        changed_file_selection(repo, ix, files)
                    };
                    (selection, Task::none())
                } else {
                    let ix = ix - 1;
                    let selection = changed_file_selection(repo, ix, files);
                    (selection, Task::none())
                };
                (Some(selection), task)

Replacement in inflorescence/src/cursor.rs at line 397 [5.26]

B:BD[28.11812] → [28.11812:11822]

B:BD[28.11822] → [30.963:984]

∅:D[30.984] → [28.11849:12414]

B:BD[28.11849] → [28.11849:12414]

B:BD[28.12414] → [29.10399:10524]

∅:D[29.10524] → [28.12706:12874]

B:BD[28.12706] → [28.12706:12874]

B:BD[28.12874] → [29.10525:10652]

∅:D[29.10652] → [28.13168:13256]

B:BD[28.13168] → [28.13168:13256]

        }
        Msg::Up => {
            if let Some(repo) = repo.as_ref() {
                let (selection, task) = match state.selection.take() {
                    Some(Selection::UntrackedFile { ix, path: _ }) => {
                        let (selection, task) = if 0 == ix {
                            if !repo.log.is_empty() {
                                let ix = repo.log.len() - 1;
                                log_selection(repo, ix)
                            } else if !repo.changed_files.is_empty() {
                                let ix = repo.changed_files.len() - 1;
                                let selection =
                                    changed_file_selection(repo, ix, files);
                                (selection, Task::none())
                            } else {
                                let ix = repo.untracked_files.len() - 1;
                                let selection =
                                    untracked_file_selection(repo, ix, files);
                                (selection, Task::none())
                            }

[28.11812]

[28.13256]

            Some(Selection::LogChange {
                ix: log_ix,
                hash,
                message,
                file,
            }) => {
                let (selection, task) = match file {
                    Some(LogChangeFileSelection {
                        ix: file_ix,
                        path,
                        diff_selected,
                    }) => {
                        if diff_selected {
                            let id_hash = file::log_id_parts_hash(hash, &path);
                            (
                                Selection::LogChange {
                                    ix: log_ix,
                                    hash,
                                    message,
                                    file: Some(LogChangeFileSelection {
                                        ix: file_ix,
                                        path,
                                        diff_selected,
                                    }),
                                },
                                if let Some(nav) = logs
                                    .diffs
                                    .get(&id_hash)
                                    .and_then(|diff| diff.state.nav.as_ref())
                                {
                                    iced_nav_scrollable::scroll_up(nav)
                                } else {
                                    Task::none()
                                },
                            )

Replacement in inflorescence/src/cursor.rs at line 433 [5.26]

B:BD[28.13289] → [28.13289:13334]

B:BD[28.13334] → [29.10653:10772]

∅:D[29.10772] → [28.13604:13733]

B:BD[28.13604] → [28.13604:13733]

                            let ix = ix - 1;
                            let selection =
                                untracked_file_selection(repo, ix, files);
                            (selection, Task::none())
                        };
                        (Some(selection), task)

[28.13289]

[28.13733]

                            let log_entry = repo.log.get(log_ix).unwrap();
                            let file_ix = if 0 == file_ix {
                                log_entry.file_paths.len() - 1
                            } else {
                                file_ix - 1
                            };
                            let file = log_file_selection(log_entry, file_ix);
                            (
                                Selection::LogChange {
                                    ix: log_ix,
                                    hash,
                                    message,
                                    file: Some(file),
                                },
                                Task::none(),
                            )
                        }

Replacement in inflorescence/src/cursor.rs at line 453 [5.26]

B:BD[28.13755] → [28.13755:13952]

                    Some(Selection::ChangedFile { ix, path: _ }) => {
                        let (selection, task) = if 0 == ix {
                            if !repo.untracked_files.is_empty() {

[28.13755]

[28.13952]

                    None => {
                        let selection = if 0 == log_ix {
                            if !repo.changed_files.is_empty() {
                                let ix = repo.changed_files.len() - 1;
                                changed_file_selection(repo, ix, files)
                            } else if !repo.untracked_files.is_empty() {

Replacement in inflorescence/src/cursor.rs at line 460 [5.26]

B:BD[28.14025] → [29.10773:10900]

∅:D[29.10900] → [28.14319:14438]

B:BD[28.14319] → [28.14319:14438]

                                let selection =
                                    untracked_file_selection(repo, ix, files);
                                (selection, Task::none())
                            } else if !repo.log.is_empty() {

[28.14025]

[28.14438]

                                untracked_file_selection(repo, ix, files)
                            } else {

Deletion in inflorescence/src/cursor.rs at line 464 [5.26]

B:BD[28.14555] → [28.14555:14663]

B:BD[28.14663] → [29.10901:11026]

∅:D[29.11026] → [28.14955:15013]

B:BD[28.14955] → [28.14955:15013]

                            } else {
                                let ix = repo.changed_files.len() - 1;
                                let selection =
                                    changed_file_selection(repo, ix, files);
                                (selection, Task::none())

Replacement in inflorescence/src/cursor.rs at line 466 [5.26]

B:BD[28.15076] → [28.15076:15121]

B:BD[28.15121] → [29.11027:11144]

∅:D[29.11144] → [28.15389:15443]

B:BD[28.15389] → [28.15389:15443]

                            let ix = ix - 1;
                            let selection =
                                changed_file_selection(repo, ix, files);
                            (selection, Task::none())

[28.15076]

[28.15443]

                            let ix = log_ix - 1;
                            log_selection(repo, ix)

Replacement in inflorescence/src/cursor.rs at line 469 [5.26]

B:BD[28.15470] → [28.15470:15518]

                        (Some(selection), task)

[28.15470]

[28.15518]

                        (selection, Task::none())

Insertion in inflorescence/src/cursor.rs at line 471 [5.26]

[28.15540]

                };
                (Some(selection), task)
            }
            None => {
                let (selection, task) = if !repo.log.is_empty() {
                    let ix = repo.log.len() - 1;
                    let selection = log_selection(repo, ix);
                    (Some(selection), Task::none())
                } else if !repo.changed_files.is_empty() {
                    let ix = repo.changed_files.len() - 1;
                    let selection = changed_file_selection(repo, ix, files);
                    (Some(selection), Task::none())
                } else if !repo.untracked_files.is_empty() {
                    let ix = repo.untracked_files.len() - 1;
                    let selection = untracked_file_selection(repo, ix, files);
                    (Some(selection), Task::none())
                } else {
                    (None, Task::none())
                };
                (selection, task)
            }
        };
        state.selection = selection;
        task
    } else {
        Task::none()
    }
}
fn select_left<M>(state: &mut State, repo: Option<&repo::State>) -> Task<M> {
    if let Some(_repo) = repo.as_ref() {
        let selection: Option<Selection> = match state.selection.take() {
            Some(Selection::LogChange {
                ix,
                hash,
                message,
                file:
                    Some(LogChangeFileSelection {
                        ix: file_ix,
                        path,
                        diff_selected,
                    }),
            }) => {
                if diff_selected {
                    Some(Selection::LogChange {
                        ix,
                        hash,
                        message,
                        file: Some(LogChangeFileSelection {
                            ix: file_ix,
                            path,
                            diff_selected: false,
                        }),
                    })
                } else {

Replacement in inflorescence/src/cursor.rs at line 528 [5.26]
B:BD[28.15588] → [28.15588:15624]
```
                        ix: log_ix,
```
[28.15588]
[28.15624]
```
                        ix,
```

Replacement in inflorescence/src/cursor.rs at line 531 [5.26]

B:BD[28.15718] → [28.15718:16096]

                        file,
                    }) => {
                        let (selection, task) = match file {
                            Some(LogChangeFileSelection {
                                ix: file_ix,
                                path: _,
                            }) => {
                                let log_entry = repo.log.get(log_ix).unwrap();

[28.15687]

[28.16096]

                        file: None,
                    })
                }
            }
            Some(Selection::UntrackedFile {
                ix,
                path,
                diff_selected: true,
            }) => Some(Selection::UntrackedFile {
                ix,
                path,
                diff_selected: false,
            }),
            Some(Selection::ChangedFile {
                ix,
                path,
                diff_selected: true,
            }) => Some(Selection::ChangedFile {
                ix,
                path,
                diff_selected: false,
            }),
            selection @ (Some(Selection::UntrackedFile { .. })
            | Some(Selection::ChangedFile { .. })
            | Some(Selection::LogChange { file: None, .. })
            | None) => selection,
        };
        state.selection = selection;
    }
    Task::none()
}

Replacement in inflorescence/src/cursor.rs at line 563 [5.26]

B:BD[28.16097] → [28.16097:16712]

B:BD[28.16759] → [28.16759:17312]

B:BD[28.17312] → [29.11145:11206]

∅:D[29.11206] → [28.17529:17926]

B:BD[28.17529] → [28.17529:17926]

B:BD[28.17926] → [29.11207:11272]

∅:D[29.11272] → [28.18159:18836]

B:BD[28.18159] → [28.18159:18836]

                                let file_ix = if 0 == file_ix {
                                    log_entry.file_paths.len() - 1
                                } else {
                                    file_ix - 1
                                };
                                let file =
                                    log_file_selection(log_entry, file_ix);
                                (
                                    Selection::LogChange {
                                        ix: log_ix,
                                        hash,
                                        message,
                                        file: Some(file),
                                    },
                                    Task::none(),
                                )
                            }
                            None => {
                                let (selection, task) = if 0 == log_ix {
                                    if !repo.changed_files.is_empty() {
                                        let ix = repo.changed_files.len() - 1;
                                        let selection = changed_file_selection(
                                            repo, ix, files,
                                        );
                                        (selection, Task::none())
                                    } else if !repo.untracked_files.is_empty() {
                                        let ix = repo.untracked_files.len() - 1;
                                        let selection =
                                            untracked_file_selection(
                                                repo, ix, files,
                                            );
                                        (selection, Task::none())
                                    } else {
                                        let ix = repo.log.len() - 1;
                                        log_selection(repo, ix)
                                    }
                                } else {
                                    let ix = log_ix - 1;
                                    log_selection(repo, ix)
                                };
                                (selection, task)
                            }
                        };
                        (Some(selection), task)

[28.16097]

[28.18836]

fn select_right<M>(
    state: &mut State,
    repo: Option<&repo::State>,
    files_diffs: &diff::FilesState,
    logs: &diff::LogFilesAndState,
) -> Task<M> {
    if let Some(repo) = repo.as_ref() {
        let (selection, task): (Option<Selection>, Task<M>) = match state
            .selection
            .take()
        {
            Some(Selection::UntrackedFile {
                ix,
                path,
                diff_selected: false,
            }) => {
                let id_hash = file::id_parts_hash(&path, file::Kind::Untracked);
                let diff_selected =
                    diff::file_diff_needs_scrolling(files_diffs, id_hash);
                // If the selected file's diff is already loaded (it has an
                // attached state), scroll back to its last offset
                // TODO: simplify in rust 1.88
                let task = if diff_selected {
                    if let Some(nav) = files_diffs
                        .get(&id_hash)
                        .and_then(|state| state.nav.as_ref())
                    {
                        iced_nav_scrollable::scroll_to_stored_offset(nav)
                    } else {
                        Task::none()
                    }
                } else {
                    Task::none()
                };
                (
                    Some(Selection::UntrackedFile {
                        ix,
                        path,
                        diff_selected,
                    }),
                    task,
                )
            }
            Some(Selection::ChangedFile {
                ix,
                path,
                diff_selected: false,
            }) => {
                let id_hash = file::id_parts_hash(&path, file::Kind::Changed);
                let diff_selected =
                    diff::file_diff_needs_scrolling(files_diffs, id_hash);
                // If the selected file's diff is already loaded (it has an
                // attached state), scroll back to its last offset
                // TODO: simplify in rust 1.88
                let task = if diff_selected {
                    if let Some(nav) = files_diffs
                        .get(&id_hash)
                        .and_then(|state| state.nav.as_ref())
                    {
                        iced_nav_scrollable::scroll_to_stored_offset(nav)
                    } else {
                        Task::none()

Replacement in inflorescence/src/cursor.rs at line 626 [5.26]

B:BD[28.18858] → [28.18858:19282]

B:BD[28.19282] → [29.11273:11390]

∅:D[29.11390] → [28.19550:19748]

B:BD[28.19550] → [28.19550:19748]

B:BD[28.19748] → [29.11391:11510]

∅:D[29.11510] → [28.20018:20229]

B:BD[28.20018] → [28.20018:20229]

                    None => {
                        let (selection, task) = if !repo.log.is_empty() {
                            let ix = repo.log.len() - 1;
                            let (selection, task) = log_selection(repo, ix);
                            (Some(selection), task)
                        } else if !repo.changed_files.is_empty() {
                            let ix = repo.changed_files.len() - 1;
                            let selection =
                                changed_file_selection(repo, ix, files);
                            (Some(selection), Task::none())
                        } else if !repo.untracked_files.is_empty() {
                            let ix = repo.untracked_files.len() - 1;
                            let selection =
                                untracked_file_selection(repo, ix, files);
                            (Some(selection), Task::none())
                        } else {
                            (None, Task::none())
                        };
                        (selection, task)

[28.18858]

[28.20229]

                } else {
                    Task::none()
                };
                (
                    Some(Selection::ChangedFile {
                        ix,
                        path,
                        diff_selected,
                    }),
                    task,
                )
            }
            Some(Selection::LogChange {
                ix,
                hash,
                message,
                file:
                    Some(LogChangeFileSelection {
                        ix: file_ix,
                        path,
                        diff_selected: false,
                    }),
            }) => {
                let id_hash = file::log_id_parts_hash(hash, &path);
                let diff_selected =
                    diff::log_diff_needs_scrolling(logs, id_hash);
                // If the selected file's diff is already loaded (it has an
                // attached state), scroll back to its last offset
                // TODO: simplify in rust 1.88
                let task = if diff_selected {
                    if let Some(nav) = logs
                        .diffs
                        .get(&id_hash)
                        .and_then(|diff| diff.state.nav.as_ref())
                    {
                        iced_nav_scrollable::scroll_to_stored_offset(nav)
                    } else {
                        Task::none()

Insertion in inflorescence/src/cursor.rs at line 665 [5.26]

[28.20251]

                } else {
                    Task::none()

Replacement in inflorescence/src/cursor.rs at line 668 [5.26]

B:BD[28.20270] → [28.20270:20387]


                state.selection = selection;
                task
            } else {
                Task::none()

[28.20270]

[28.20387]

                (
                    Some(Selection::LogChange {
                        ix,
                        hash,
                        message,
                        file: Some(LogChangeFileSelection {
                            ix: file_ix,
                            path,
                            diff_selected,
                        }),
                    }),
                    task,
                )

Replacement in inflorescence/src/cursor.rs at line 682 [5.26]

B:BD[28.20401] → [28.20401:20411]

B:BD[28.20411] → [50.43:401]

B:BD[50.436] → [50.436:682]

B:BD[50.721] → [50.721:765]

        }
        Msg::Left => {
            if let Some(_repo) = repo.as_ref() {
                let (selection, task): (Option<Selection>, Task<repo::MsgIn>) =
                    match state.selection.take() {
                        Some(Selection::LogChange {
                            ix,
                            hash,
                            message,
                            file: Some(_),
                        }) => (
                            Some(Selection::LogChange {
                                ix,
                                hash,
                                message,
                                file: None,

[28.20401]

[50.765]

            Some(Selection::LogChange {
                ix,
                hash,
                message,
                file: None,
            }) => {
                let log_entry = repo.log.get(ix).unwrap();
                let (file, task) =
                    if let Some(path) = log_entry.file_paths.first() {
                        (
                            Some(LogChangeFileSelection {
                                ix: 0,
                                path: path.clone(),
                                diff_selected: false,

Replacement in inflorescence/src/cursor.rs at line 698 [5.26]

B:BD[50.839] → [50.839:1321]

                        ),
                        selection @ (Some(Selection::UntrackedFile {
                            ..
                        })
                        | Some(Selection::ChangedFile {
                            ..
                        })
                        | Some(Selection::LogChange {
                            file: None,
                            ..
                        })
                        | None) => (selection, Task::none()),

[50.839]

[50.1321]

                        )
                    } else {
                        (None, Task::none())

Replacement in inflorescence/src/cursor.rs at line 702 [5.26]

B:BD[50.1344] → [50.1344:1410]

                state.selection = selection;
                task

[50.1344]

[50.1410]

                (
                    Some(Selection::LogChange {
                        ix,
                        hash,
                        message,
                        file,
                    }),
                    task,
                )
            }
            selection => (selection, Task::none()),
        };
        state.selection = selection;
        task
    } else {
        Task::none()
    }
}
fn select_exact<M>(
    select: Select,
    state: &mut State,
    files: &mut file::State,
    repo: Option<&repo::State>,
    files_diffs: &diff::FilesState,
    logs: &diff::LogFilesAndState,
) -> Task<M> {
    let (selection, task) = match select {
        Select::UntrackedFile { ix, path } => {
            let id = file::Id {
                path: path.clone(),
                file_kind: file::Kind::Changed,
            };
            let id_hash = file::id_hash(&id);
            file::load_src_file_if_not_cached(files, id);
            // If the selected file's diff is already loaded (it has an attached
            // state), scroll back to its last offset
            // TODO: simplify in rust 1.88
            let is_diff_scrollable =
                diff::file_diff_needs_scrolling(files_diffs, id_hash);
            let task = if is_diff_scrollable {
                if let Some(nav) = files_diffs
                    .get(&id_hash)
                    .and_then(|state| state.nav.as_ref())
                {
                    iced_nav_scrollable::scroll_to_stored_offset(nav)
                } else {
                    Task::none()
                }

Insertion in inflorescence/src/cursor.rs at line 753 [5.26]

[50.1460]

            };
            (
                Some(Selection::UntrackedFile {
                    ix,
                    path,
                    diff_selected: false,
                }),
                task,
            )
        }
        Select::ChangedFile { ix, path } => {
            let id = file::Id {
                path: path.clone(),
                file_kind: file::Kind::Changed,
            };
            let id_hash = file::id_hash(&id);
            if let Some(diffs) =
                repo.as_ref().and_then(|repo| repo.changed_files.get(&path))
            {
                if diff::any_diff_has_contents(diffs) {
                    file::load_src_file_if_not_cached(files, id);
                }

Replacement in inflorescence/src/cursor.rs at line 776 [5.26]

B:BD[50.1474] → [50.1474:1508]

∅:D[30.1021] → [28.20459:20793]

∅:D[50.1508] → [28.20459:20793]

B:BD[28.20459] → [28.20459:20793]

B:BD[28.20828] → [50.1509:1549]

∅:D[50.1549] → [28.20862:20894]

B:BD[28.20862] → [28.20862:20894]

B:BD[28.20894] → [50.1550:1779]

∅:D[50.1779] → [28.21679:21713]

B:BD[28.21679] → [28.21679:21713]

B:BD[28.21713] → [50.1780:1953]

∅:D[50.1953] → [28.22009:22049]

B:BD[28.22009] → [28.22009:22049]

B:BD[28.22049] → [50.1954:2004]

∅:D[50.2004] → [28.22091:22162]

B:BD[28.22091] → [28.22091:22162]

B:BD[28.22162] → [50.2005:2306]

B:BD[50.2349] → [50.2349:2495]

∅:D[50.2495] → [28.22652:22861]

B:BD[28.22652] → [28.22652:22861]

B:BD[28.22861] → [50.2496:2651]

∅:D[50.2651] → [28.22861:23070]

B:BD[28.22861] → [28.22861:23070]

        }
        Msg::Right => {
            if let Some(repo) = repo.as_ref() {
                let (selection, task): (Option<Selection>, Task<repo::MsgIn>) =
                    match state.selection.take() {
                        Some(Selection::LogChange {
                            ix,
                            hash,
                            message,
                            file: None,
                        }) => {
                            let log_entry = repo.log.get(ix).unwrap();
                            let (file, task) = if let Some(path) =
                                log_entry.file_paths.first()
                            {
                                (
                                    Some(LogChangeFileSelection {
                                        ix: 0,
                                        path: path.clone(),
                                    }),
                                    Task::none(),
                                )
                            } else {
                                (None, Task::none())
                            };
                            (
                                Some(Selection::LogChange {
                                    ix,
                                    hash,
                                    message,
                                    file,
                                }),
                                task,
                            )
                        }
                        selection @ (Some(Selection::UntrackedFile {
                            ..
                        })
                        | Some(Selection::ChangedFile {
                            ..
                        })
                        | Some(Selection::LogChange {
                            file: Some(_),
                            ..
                        })
                        | None) => (selection, Task::none()),
                    };
                state.selection = selection;
                task

[50.1474]

[28.23070]

            // If the selected file's diff is already loaded (it has an attached
            // state), scroll back to its last offset
            // TODO: simplify in rust 1.88
            let is_diff_scrollable =
                diff::file_diff_needs_scrolling(files_diffs, id_hash);
            let task = if is_diff_scrollable {
                if let Some(nav) = files_diffs
                    .get(&id_hash)
                    .and_then(|state| state.nav.as_ref())
                {
                    iced_nav_scrollable::scroll_to_stored_offset(nav)
                } else {
                    Task::none()
                }

Replacement in inflorescence/src/cursor.rs at line 792 [5.26]

B:BD[28.23120] → [28.23120:23134]

[28.23120]

[28.23134]

            };
            (
                Some(Selection::ChangedFile {
                    ix,
                    path,
                    diff_selected: false,
                }),
                task,
            )

Replacement in inflorescence/src/cursor.rs at line 802 [5.26]

B:BD[28.23144] → [30.1022:1055]

∅:D[30.1055] → [28.23183:23290]

B:BD[28.23183] → [28.23183:23290]

B:BD[28.23290] → [29.11511:11632]

∅:D[29.11632] → [28.23451:23499]

B:BD[28.23451] → [28.23451:23499]

B:BD[28.23499] → [29.11633:11695]

∅:D[29.11695] → [28.23559:23999]

B:BD[28.23559] → [28.23559:23999]

B:BD[28.23999] → [29.11696:11841]

∅:D[29.11841] → [28.24192:24248]

B:BD[28.24192] → [28.24192:24248]

B:BD[28.24248] → [29.11842:11910]

∅:D[29.11910] → [28.24314:24380]

B:BD[28.24314] → [28.24314:24380]

        Msg::Select(select) => {
            let (selection, task) = match select {
                Select::UntrackedFile { ix, path } => {
                    file::load_src_file_if_not_cached(
                        files,
                        file::Id {
                            path: path.clone(),
                            file_kind: file::Kind::Untracked,
                        },
                    );
                    (Some(Selection::UntrackedFile { ix, path }), Task::none())
                }
                Select::ChangedFile { ix, path } => {
                    if let Some(diffs) = repo
                        .as_ref()
                        .and_then(|repo| repo.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,
                                },
                            );

[28.23144]

[28.24380]

        Select::LogChange { ix, hash, message } => (
            Some(Selection::LogChange {
                ix,
                hash,
                message,
                file: None,
            }),
            Task::none(),
        ),
        Select::LogChangeFile { ix: file_ix, path } => {
            match state.selection.take() {
                Some(Selection::LogChange {
                    ix: change_ix,
                    hash,
                    message,
                    file: _,
                }) => {
                    let id_hash = file::log_id_parts_hash(hash, &path);
                    let diff_selected =
                        diff::log_diff_needs_scrolling(logs, id_hash);
                    // If the selected file's diff is already loaded (it has an
                    // attached state), scroll back to its last offset
                    // TODO: simplify in rust 1.88
                    let task = if diff_selected {
                        if let Some(nav) = logs
                            .diffs
                            .get(&id_hash)
                            .and_then(|diff| diff.state.nav.as_ref())
                        {
                            iced_nav_scrollable::scroll_to_stored_offset(nav)
                        } else {
                            Task::none()

Replacement in inflorescence/src/cursor.rs at line 835 [5.26]

B:BD[28.24406] → [28.24406:24714]

                    }
                    (Some(Selection::ChangedFile { ix, path }), Task::none())
                }
                Select::LogChange { ix, hash, message } => {
                    // Request to get the diffs
                    let task = Task::done(repo::MsgIn::GetChangeDiffs { hash });

[28.24406]

[28.24714]

                    } else {
                        Task::none()
                    };
                    let file = LogChangeFileSelection {
                        ix: file_ix,
                        path,
                        diff_selected: false,
                    };

Replacement in inflorescence/src/cursor.rs at line 845 [5.26]

B:BD[28.24788] → [28.24788:24820]

ix,

[28.24788]

[28.24820]

                            ix: change_ix,

Replacement in inflorescence/src/cursor.rs at line 848 [5.26]

B:BD[28.24932] → [28.24932:24972]

                            file: None,

[28.24891]

[28.24972]

                            file: Some(file),

Deletion in inflorescence/src/cursor.rs at line 852 [5.26]

B:BD[28.25052] → [28.25052:25352]

B:BD[28.25387] → [28.25387:25801]

B:BD[28.25844] → [28.25844:26122]

                }
                Select::LogChangeFile { ix: file_ix, path } => {
                    match state.selection.take() {
                        Some(Selection::LogChange {
                            ix: change_ix,
                            hash,
                            message,
                            file: _,
                        }) => {
                            let file =
                                LogChangeFileSelection { ix: file_ix, path };
                            (
                                Some(Selection::LogChange {
                                    ix: change_ix,
                                    hash,
                                    message,
                                    file: Some(file),
                                }),
                                Task::none(),
                            )
                        }
                        selection => (selection, Task::none()),
                    }

Replacement in inflorescence/src/cursor.rs at line 853 [5.26]

B:BD[28.26140] → [28.26140:26213]

            };
            state.selection = selection;
            task

[28.26140]

[28.26213]

                selection => (selection, Task::none()),
            }

Deletion in inflorescence/src/cursor.rs at line 856 [5.26]
B:BD[28.26223] → [28.26223:26304]
B:BD[28.26304] → [29.11911:11940]
∅:D[29.11940] → [28.26393:26480]
B:BD[28.26393] → [28.26393:26480]
B:BD[28.26480] → [29.11941:11965]
∅:D[29.11965] → [28.26502:26530]
B:BD[28.26502] → [28.26502:26530]
B:BD[28.26530] → [29.11966:12008]
```
    }
}
pub fn untracked_file_selection(
    repo: &repo::State,
    ix: usize,
    files: &mut file::State,
) -> Selection {
    let path = repo.untracked_files.iter().nth(ix).unwrap().clone();
    let id = file::Id {
        path: path.clone(),
        file_kind: file::Kind::Untracked,
```

Replacement in inflorescence/src/cursor.rs at line 857 [5.26]

B:BD[28.26577] → [29.12009:12059]

∅:D[29.12059] → [28.26645:26761]

B:BD[28.26645] → [28.26645:26761]

B:BD[28.26761] → [29.12060:12089]

∅:D[29.12089] → [28.26850:26980]

B:BD[28.26850] → [28.26850:26980]

B:BD[28.26980] → [29.12090:12118]

∅:D[29.12118] → [28.27006:27038]

B:BD[28.27006] → [28.27006:27038]

B:BD[28.27038] → [29.12119:12163]

∅:D[29.12163] → [28.27080:27091]

B:BD[28.27080] → [28.27080:27091]

B:BD[28.27091] → [29.12164:12218]

∅:D[29.12218] → [28.27163:27245]

B:BD[28.27163] → [28.27163:27245]

    file::load_src_file_if_not_cached(files, id);
    Selection::UntrackedFile { ix, path }
}
pub fn changed_file_selection(
    repo: &repo::State,
    ix: usize,
    files: &mut file::State,
) -> Selection {
    let (path, diffs) = repo.changed_files.iter().nth(ix).unwrap();
    if diff::any_diff_has_contents(diffs) {
        let id = file::Id {
            path: path.clone(),
            file_kind: file::Kind::Changed,
        };
        file::load_src_file_if_not_cached(files, id);
    }
    Selection::ChangedFile {
        ix,
        path: path.clone(),
    }

[28.26577]

[28.27245]

    state.selection = selection;
    task

Deletion in inflorescence/src/cursor.rs at line 860 [5.26]

B:BD[28.27247] → [28.27247:27628]

B:BD[28.27653] → [28.27653:27938]


pub fn log_selection(
    repo: &repo::State,
    ix: usize,
) -> (Selection, Task<repo::MsgIn>) {
    let entry = repo.log.get(ix).unwrap();
    // Request to get the diffs
    let task = Task::done(repo::MsgIn::GetChangeDiffs { hash: entry.hash });
    (
        Selection::LogChange {
            ix,
            hash: entry.hash,
            message: entry.message.clone(),
            file: None,
        },
        task,
    )
}
pub fn log_file_selection(
    log_entry: &repo::LogEntry,
    file_ix: usize,
) -> LogChangeFileSelection {
    let path = log_entry.file_paths.get(file_ix).unwrap().clone();
    LogChangeFileSelection { ix: file_ix, path }
}

Replacement in iced_nav_scrollable/src/lib.rs at line 8 [51.95]
B:BD[51.190] → [51.190:239]
```
use iced::widget::{self, container, scrollable};
```
[51.190]
[53.11770]
```
use iced::widget::{self, container, scrollable, Scrollable};
```
Deletion in iced_nav_scrollable/src/lib.rs at line 43 [51.95]
B:BD[51.681] → [51.681:717]
```
    ScrollToPrev,
    ScrollToNext,
```

Deletion in iced_nav_scrollable/src/lib.rs at line 185 [51.95]

∅:D[52.3895] → [51.2369:2435]

B:BD[51.2369] → [51.2369:2435]

B:BD[51.2435] → [52.3896:4101]

∅:D[52.4101] → [51.2614:2632]

B:BD[51.2614] → [51.2614:2632]

B:BD[51.2632] → [53.13381:13425]

∅:D[53.13425] → [51.2682:2847]

B:BD[51.2682] → [51.2682:2847]

            Task::none()
        }
        Msg::ScrollToNext => {
            if nav.pending_tasks.is_none() {
                if let Some(y) = nav
                    .section_offsets
                    .iter()
                    .find(|offset| *offset > &nav.offset)
                {
                    return task::scroll_to(
                        nav.id.clone(),
                        scrollable::AbsoluteOffset { x: 0.0, y: *y },
                    );
                }
            }

Deletion in iced_nav_scrollable/src/lib.rs at line 187 [51.95]

B:BD[51.2882] → [51.2882:2913]

B:BD[51.2913] → [52.4102:4147]

∅:D[52.4147] → [51.2981:3018]

B:BD[51.2981] → [51.2981:3018]

B:BD[51.3018] → [52.4148:4185]

∅:D[52.4185] → [51.3047:3102]

B:BD[51.3047] → [51.3047:3102]

B:BD[51.3102] → [52.4186:4244]

∅:D[52.4244] → [51.3162:3180]

B:BD[51.3162] → [51.3162:3180]

B:BD[51.3180] → [53.13426:13470]

∅:D[53.13470] → [51.3230:3430]

B:BD[51.3230] → [51.3230:3430]

        Msg::ScrollToPrev => {
            if nav.pending_tasks.is_none() {
                if let Some(y) = nav
                    .section_offsets
                    .iter()
                    .rev()
                    .find(|offset| *offset < &nav.offset)
                {
                    return task::scroll_to(
                        nav.id.clone(),
                        scrollable::AbsoluteOffset { x: 0.0, y: *y },
                    );
                }
            }
            Task::none()
        }

Replacement in iced_nav_scrollable/src/lib.rs at line 197 [51.95]
∅:D[52.4316] → [51.3740:3783]
B:BD[51.3740] → [51.3740:3783]
```
) -> Element<'a, Message, Theme, Renderer>
```
[52.4316]
[51.3783]
```
) -> Scrollable<'a, Message, Theme, Renderer>
```

Replacement in iced_nav_scrollable/src/lib.rs at line 210 [51.95]

B:BD[51.4371] → [53.13471:13500]

∅:D[53.13500] → [51.4390:4549]

B:BD[51.4390] → [51.4390:4549]

B:BD[51.4549] → [53.13501:13531]

    let nav = Element::from(
        widget::scrollable(widget::column(children))
            .id(nav.id.clone())
            .on_scroll(move |viewport| map_msg(Msg::Scrolled(viewport))),
    );
    Element::from(nav)

[51.4371]

[51.4555]

    widget::scrollable(widget::column(children))
        .id(nav.id.clone())
        .on_scroll(move |viewport| map_msg(Msg::Scrolled(viewport)))
}
/// A task to scroll to the last stored offset
pub fn scroll_to_stored_offset<M>(nav: &NavScrollable) -> Task<M> {
    task::scroll_to(
        nav.id.clone(),
        scrollable::AbsoluteOffset {
            x: 0.0,
            y: nav.offset,
        },
    )
}
// TODO: time delta
const DELTA: f32 = 10.0;
/// Scroll down, skipping any sections that are marked to skip
pub fn scroll_down<M>(nav: &NavScrollable) -> Task<M> {
    if let Some(y) = nav
        .section_offsets
        .iter()
        .zip(nav.section_heights.values())
        .enumerate()
        .find_map(|(ix, (offset, height))| {
            if !nav.skip_sections.contains(&ix) {
                // dbg!(ix, offset, height, nav.offset);
                let bottom_frame = saturating_sub(
                    nav.offset + nav.height,
                    VISIBLE_CONTEXT_HEIGHT,
                );
                if *offset < bottom_frame && offset + height > bottom_frame {
                    // The top edge of the section is visible, but the bottom
                    // edge of is below the bottom edge of nav, scroll down
                    Some(nav.offset + DELTA)
                } else if *offset > nav.offset + nav.height {
                    // Scroll to the next section
                    Some(saturating_sub(*offset, VISIBLE_CONTEXT_HEIGHT))
                } else {
                    None
                }
            } else {
                None
            }
        })
    {
        return task::scroll_to(
            nav.id.clone(),
            scrollable::AbsoluteOffset { x: 0.0, y },
        );
    }
    Task::none()
}
/// Scroll up, skipping any sections that are marked to skip
pub fn scroll_up<M>(nav: &NavScrollable) -> Task<M> {
    if let Some(y) = nav
        .section_offsets
        .iter()
        .zip(nav.section_heights.values())
        .enumerate()
        .rev()
        .find_map(|(ix, (offset, height))| {
            if !nav.skip_sections.contains(&ix) {
                // dbg!(ix, offset, height, nav.offset);
                let top_frame = nav.offset + VISIBLE_CONTEXT_HEIGHT;
                if offset + height > top_frame && *offset < top_frame {
                    // The bottom edge of the section is visible, but the top
                    // edge of is above the top edge of nav, scroll up
                    Some(saturating_sub(nav.offset, DELTA))
                } else if
                // offset + height < nav.offset &&
                offset + height
                    < saturating_sub(nav.offset, VISIBLE_CONTEXT_HEIGHT)
                {
                    // Scroll to the bottom of the prev section
                    Some(saturating_sub(
                        offset + height + VISIBLE_CONTEXT_HEIGHT,
                        nav.height,
                    ))
                } else {
                    None
                }
            } else {
                None
            }
        })
    {
        return task::scroll_to(
            nav.id.clone(),
            scrollable::AbsoluteOffset { x: 0.0, y },
        );
    }
    Task::none()

Replacement in iced_nav_scrollable/src/lib.rs at line 360 [51.95]

B:BD[57.1157] → [57.1157:1291]

        let y = if *y > -VISIBLE_CONTEXT_HEIGHT {
            *y - VISIBLE_CONTEXT_HEIGHT
        } else {
            0.0
        };

[57.1157]

[57.1291]

        let y = saturating_sub(*y, VISIBLE_CONTEXT_HEIGHT);

Insertion in iced_nav_scrollable/src/lib.rs at line 453 [51.95]

[51.6289]


fn saturating_sub(left: f32, right: f32) -> f32 {
    if left > right {
        left - right
    } else {
        0.0
    }
}

diffs selection and scrolling

Dependencies

In channels

Change contents

Insertion in libflorescence/src/repo.rs at line 4 [4.7]

Replacement in libflorescence/src/repo.rs at line 17 [4.7]

Replacement in libflorescence/src/repo.rs at line 143 [4.7]

Replacement in libflorescence/src/repo.rs at line 160 [4.7]

Replacement in libflorescence/src/repo.rs at line 165 [4.7]

Replacement in libflorescence/src/repo.rs at line 171 [4.7]

Deletion in libflorescence/src/repo.rs at line 176 [4.7]

Insertion in libflorescence/src/repo.rs at line 286 [4.7]

Replacement in libflorescence/src/repo.rs at line 605 [4.7]

Replacement in libflorescence/src/repo.rs at line 838 [4.7]

Replacement in libflorescence/src/repo.rs at line 852 [4.7]

Insertion in libflorescence/src/lib.rs at line 10 [2.1776]

Replacement in libflorescence/src/file.rs at line 1 [35.58]

Insertion in libflorescence/src/file.rs at line 6 [35.58]

Insertion in libflorescence/src/file.rs at line 13 [35.58]

Insertion in libflorescence/src/file.rs at line 32 [35.58]

Insertion in libflorescence/src/file.rs at line 48 [35.58]

Insertion in inflorescence_view/src/theme.rs at line 91 [33.167]

Replacement in inflorescence_view/src/theme.rs at line 218 [33.167]

Replacement in inflorescence_view/src/theme.rs at line 230 [33.167]

Replacement in inflorescence_view/src/diff.rs at line 28 [32.417]

Replacement in inflorescence_view/src/diff.rs at line 34 [32.417]

Replacement in inflorescence_view/src/diff.rs at line 38 [32.417]

Insertion in inflorescence_view/src/diff.rs at line 46 [32.417]

Replacement in inflorescence_view/src/diff.rs at line 104 [32.417]

Insertion in inflorescence_view/src/diff.rs at line 129 [32.417]

Replacement in inflorescence_view/src/diff.rs at line 147 [32.417]

Insertion in inflorescence_view/src/cursor.rs at line 22 [35.3124]

Insertion in inflorescence_view/src/cursor.rs at line 27 [35.3124]

Insertion in inflorescence_view/src/cursor.rs at line 41 [35.3124]

Replacement in inflorescence_view/src/app.rs at line 44 [32.12409]

Replacement in inflorescence_view/src/app.rs at line 169 [32.12409]

Replacement in inflorescence_view/src/app.rs at line 176 [32.12409]

Replacement in inflorescence_view/src/app.rs at line 190 [32.12409]

Replacement in inflorescence_view/src/app.rs at line 197 [32.12409]

Replacement in inflorescence_view/src/app.rs at line 299 [32.12409]

Replacement in inflorescence_view/src/app.rs at line 313 [32.12409]

Replacement in inflorescence_view/src/app.rs at line 324 [32.12409]

Insertion in inflorescence_view/src/app/test.rs at line 131 [59.4223]

Deletion in inflorescence/src/test.rs at line 7 [39.2521]

Insertion in inflorescence/src/test.rs at line 184 [39.2521]

Deletion in inflorescence/src/test.rs at line 380 [39.2521]

Insertion in inflorescence/src/test.rs at line 461 [39.2521]

Replacement in inflorescence/src/test.rs at line 474 [39.2521]

Replacement in inflorescence/src/test.rs at line 481 [39.2521]

Insertion in inflorescence/src/test.rs at line 496 [39.2521]

Insertion in inflorescence/src/test.rs at line 527 [39.2521]

Replacement in inflorescence/src/test.rs at line 540 [39.2521]

Replacement in inflorescence/src/test.rs at line 547 [39.2521]

Insertion in inflorescence/src/test.rs at line 564 [39.2521]

Replacement in inflorescence/src/test.rs at line 577 [39.2521]

Insertion in inflorescence/src/test.rs at line 590 [39.2521]

Replacement in inflorescence/src/test.rs at line 608 [39.2521]

Insertion in inflorescence/src/test.rs at line 659 [39.2521]

Replacement in inflorescence/src/test.rs at line 687 [39.2521]

Replacement in inflorescence/src/test.rs at line 724 [39.2521]

Insertion in inflorescence/src/test.rs at line 771 [39.2521]

Deletion in inflorescence/src/test.rs at line 780 [39.2521]

Replacement in inflorescence/src/main.rs at line 14 [2.2763]

Replacement in inflorescence/src/main.rs at line 26 [2.2763]

Replacement in inflorescence/src/main.rs at line 102 [2.2763]

Replacement in inflorescence/src/main.rs at line 122 [2.2763]

Replacement in inflorescence/src/main.rs at line 124 [2.2763]

Replacement in inflorescence/src/main.rs at line 139 [2.2763]

Replacement in inflorescence/src/main.rs at line 143 [2.2763]

Deletion in inflorescence/src/main.rs at line 149 [2.2763]

Replacement in inflorescence/src/main.rs at line 180 [2.2763]