tzemanovic/inflorescence - Change UR4J677RWA3OFG6HQTD46BUUE5YFPSBEFCJAEM5OMT4V5A7SBNNQC

nav for log changes and refactors

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

UR4J677RWA3OFG6HQTD46BUUE5YFPSBEFCJAEM5OMT4V5A7SBNNQC

Dependencies

In channels

main

Change contents

Replacement in inflorescence_view/src/diff.rs at line 5 [13.417]

B:BD[19.832] → [28.166:234]

    DiffWithoutContents, File, Lines, Section, UndecodableContents,

[19.832]

[19.907]

    DiffWithoutContents, File, Lines, Section, State, UndecodableContents,

Deletion in inflorescence_view/src/diff.rs at line 16 [13.417]
B:BD[28.236] → [28.236:281]
B:BD[28.364] → [28.364:509]
∅:D[28.509] → [13.912:913]
∅:D[23.578] → [13.912:913]
B:BD[13.912] → [13.912:913]
```
#[derive(Debug, Default)]
pub struct State {
    /// Initialized once the file is loaded and opened in view
    pub nav: Option<NavScrollable>,
    pub state: libflorescence::diff::State,
}
```
Insertion in inflorescence_view/src/diff.rs at line 23 [13.417]
[35.5257]
[35.5257]
```
    nav: &'a NavScrollable,
```

Replacement in inflorescence_view/src/diff.rs at line 29 [13.417]

B:BD[35.5375] → [35.5375:5436]

            view_decoded(state, decoded_file, diff_selected)

[35.5375]

[35.5436]

            view_decoded(state, nav, decoded_file, diff_selected)

Replacement in inflorescence_view/src/diff.rs at line 32 [13.417]

B:BD[13.3689] → [35.5447:5516]

            view_undecodable(state, undecodable_file, diff_selected)

[13.3689]

[13.3743]

            view_undecodable(state, nav, undecodable_file, diff_selected)

Replacement in inflorescence_view/src/diff.rs at line 38 [13.417]
B:BD[13.3893] → [31.165:187]
```
    state: &'a State,
```
[13.3893]
[13.3924]
```
    _state: &'a State,
    nav: &'a NavScrollable,
```

Replacement in inflorescence_view/src/diff.rs at line 92 [13.417]

B:BD[13.5499] → [31.188:247]

∅:D[31.247] → [29.26:74]

B:BD[28.691] → [29.26:74]

B:BD[29.74] → [30.26:134]

B:BD[30.134] → [45.66:92]

∅:D[45.92] → [35.5543:5694]

B:BD[30.166] → [35.5543:5694]

    let sections = if let Some(nav) = state.nav.as_ref() {
        let children_len = sections_view.len();
        el(iced_nav_scrollable::view(
            nav,
            sections_view,
            children_len,
            Msg::DiffNav,
        )
        .class(if diff_selected {
            theme::Scrollable::Selected
        } else {
            theme::Scrollable::Normal
        }))

[13.5499]

[28.898]

    let children_len = sections_view.len();
    let sections = el(iced_nav_scrollable::view(
        nav,
        sections_view,
        children_len,
        Msg::DiffNav,
    )
    .class(if diff_selected {
        theme::Scrollable::Selected

Replacement in inflorescence_view/src/diff.rs at line 102 [13.417]
∅:D[28.911] → [13.5542:5576]
B:BD[13.5542] → [13.5542:5576]
B:BD[13.5576] → [28.912:919]
```
        el(column(sections_view))
    };
```
[28.911]
[28.919]
```
        theme::Scrollable::Normal
    }));
```
Replacement in inflorescence_view/src/diff.rs at line 118 [13.417]
B:BD[13.5900] → [31.248:270]
```
    state: &'a State,
```
[13.5900]
[13.5931]
```
    _state: &'a State,
    nav: &'a NavScrollable,
```

Replacement in inflorescence_view/src/diff.rs at line 138 [13.417]

B:BD[13.6315] → [31.271:315]

B:BD[31.315] → [35.5721:5733]

B:BD[35.5733] → [45.93:349]

∅:D[45.349] → [35.6054:6064]

B:BD[35.6054] → [35.6054:6064]

∅:D[30.318] → [28.1614:1671]

∅:D[35.6064] → [28.1614:1671]

B:BD[28.1614] → [28.1614:1671]

    if let Some(nav) = state.nav.as_ref() {
        el(
            iced_nav_scrollable::view(nav, diffs, diffs_len, Msg::DiffNav)
                .class(if diff_selected {
                    theme::Scrollable::Selected
                } else {
                    theme::Scrollable::Normal
                }),
        )
    } else {
        el(column(diffs).spacing(10))
    }

[13.6315]

[13.6349]

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

Replacement in inflorescence_view/src/cursor.rs at line 1 [18.3124]
B:BD[18.3142] → [28.1707:1743]
```
use libflorescence::prelude::pijul;
```
[18.3124]
[36.27]
```
use libflorescence::repo;
```
Replacement in inflorescence_view/src/cursor.rs at line 52 [18.3124]
B:BD[18.3596] → [18.3596:3623]
```
        hash: pijul::Hash,
```
[18.3596]
[18.3623]
```
        hash: repo::ChangeHash,
```
Replacement in inflorescence_view/src/cursor.rs at line 77 [18.3124]
B:BD[18.4315] → [18.4315:4342]
```
        hash: pijul::Hash,
```
[18.4315]
[18.4342]
```
        hash: repo::ChangeHash,
```

Replacement in inflorescence_view/src/app.rs at line 11 [13.12409]

B:BD[13.12642] → [18.5659:5749]

use iced::widget::{
    button, column, container, row, scrollable, text, text_editor,
};

[13.12642]

[18.5749]

use iced::widget::{button, column, container, row, text, text_editor};

Replacement in inflorescence_view/src/app.rs at line 31 [13.12409]

B:BD[31.415] → [31.415:481]

    pub selected_diff: Option<(&'a diff::File, &'a diff::State)>,

[31.415]

[13.12996]

    pub selection: Option<Selection<'a>>,

Insertion in inflorescence_view/src/app.rs at line 40 [13.12409]

[43.1252]

}
#[derive(Debug)]
pub enum Selection<'a> {
    UntrackedFile {
        ix: usize,
        path: &'a str,
        diff: Option<Diff<'a>>,
    },
    ChangedFile {
        ix: usize,
        path: &'a str,
        diff: Option<Diff<'a>>,
    },
    Log {
        ix: usize,
        hash: repo::ChangeHash,
        message: &'a str,
        file: Option<LogChangeFileSelection<'a>>,
        nav: Option<&'a NavScrollable>,
    },

Insertion in inflorescence_view/src/app.rs at line 63 [13.12409]

[43.1255]

[13.12999]

#[derive(Debug)]
pub struct LogChangeFileSelection<'a> {
    pub ix: usize,
    pub path: &'a str,
    pub diff: Option<Diff<'a>>,
}
#[derive(Debug)]
pub struct Diff<'a> {
    pub is_selected: bool,
    pub file: &'a diff::File,
    pub state: &'a diff::State,
    pub nav: &'a NavScrollable,
}

Insertion in inflorescence_view/src/app.rs at line 83 [13.12409]

[43.1297]

[13.13088]

    LogNav {
        hash: repo::ChangeHash,
        msg: iced_nav_scrollable::Msg,
    },

Replacement in inflorescence_view/src/app.rs at line 91 [13.12409]
B:BD[13.13180] → [13.13180:13210]
```
    FileDiffsContentsAction {
```
[13.13180]
[35.6157]
```
    /// Message for an untracked or changed file diff
    FileDiff {
```
Replacement in inflorescence_view/src/app.rs at line 94 [13.12409]
∅:D[35.6188] → [13.13232:13259]
B:BD[13.13232] → [13.13232:13259]
```
        action: diff::Msg,
```
[35.6188]
[13.13259]
```
        msg: diff::Msg,
```

Replacement in inflorescence_view/src/app.rs at line 96 [13.12409]

B:BD[13.13266] → [13.13266:13372]

    LogChangeFileDiffAction {
        hash: pijul::Hash,
        file: String,
        action: diff::Msg,

[13.13266]

[13.13372]

    /// Message for a log change file diff
    LogChangeFileDiff {
        id_hash: file::LogIdHash,
        msg: diff::Msg,

Replacement in inflorescence_view/src/app.rs at line 113 [13.12409]

B:BD[31.531] → [43.1298:1347]

∅:D[43.1347] → [31.532:564]

B:BD[17.2747] → [31.532:564]

    let inner = if let Some(repo) = state.repo {
        view_repo(&state, repo)

[31.531]

[22.75]

    let State {
        window_size,
        repo_path,
        repo,
        cursor,
        record_msg,
        selection,
    } = state;
    let inner = if let Some(repo) = repo {
        view_repo(window_size, repo_path, repo, cursor, record_msg, selection)

Replacement in inflorescence_view/src/app.rs at line 132 [13.12409]

B:BD[13.15950] → [43.1348:1429]

fn view_repo<'a>(state: &State<'a>, repo: &'a Repo) -> Element<'a, Msg, Theme> {

[13.15950]

[43.1429]

fn view_repo<'a>(
    window_size: iced::Size,
    // TODO show path
    _repo_path: &'a Path,
    repo: &'a Repo,
    cursor: &'a cursor::State,
    record_msg: Option<&'a RecordMsg>,
    selection: Option<Selection<'a>>,
) -> Element<'a, Msg, Theme> {

Replacement in inflorescence_view/src/app.rs at line 142 [13.12409]

B:BD[43.1444] → [43.1444:1465]

        state: repo,

[43.1444]

[43.1465]

        state:
            repo::State {
                dir_name,
                channel,
                untracked_files,
                changed_files,
                log,
            },

Replacement in inflorescence_view/src/app.rs at line 153 [13.12409]
∅:D[31.615] → [22.436:499]
∅:D[43.1500] → [22.436:499]
B:BD[22.436] → [22.436:499]
```
    let repo_info = el(row([
        el(text(&repo.dir_name)),
```
[43.1500]
[22.499]
```
    let view_repo_info = el(row([
        el(text(dir_name)),
```

Replacement in inflorescence_view/src/app.rs at line 157 [13.12409]

B:BD[22.535] → [22.535:650]

            button(text(&repo.channel)), /* TODO
                                          * .on_press(Message) */

[22.535]

[22.650]

            button(text(channel)), /* TODO
                                    * .on_press(Message) */

Replacement in inflorescence_view/src/app.rs at line 162 [13.12409]

B:BD[22.671] → [22.671:702]

B:BD[22.702] → [43.1501:1554]

    let untracked_files = || {
        repo.untracked_files.iter().enumerate().map(

[22.671]

[13.16052]

    let view_untracked_files = || {
        untracked_files.iter().enumerate().map(

Replacement in inflorescence_view/src/app.rs at line 165 [13.12409]

B:BD[13.16079] → [13.16079:16156]

                let is_selected = matches!(state.cursor.selection.as_ref() ,

[13.16079]

[13.16156]

                let is_selected = matches!(cursor.selection.as_ref() ,

Replacement in inflorescence_view/src/app.rs at line 181 [13.12409]

B:BD[13.16643] → [22.774:803]

B:BD[22.803] → [43.1566:1617]

    let changed_files = || {
        repo.changed_files.iter().enumerate().map(

[13.16643]

[13.16741]

    let view_changed_files = || {
        changed_files.iter().enumerate().map(

Replacement in inflorescence_view/src/app.rs at line 184 [13.12409]

B:BD[13.16783] → [13.16783:16859]

                let is_selected = matches!(state.cursor.selection.as_ref(),

[13.16783]

[13.16859]

                let is_selected = matches!(cursor.selection.as_ref(),

Replacement in inflorescence_view/src/app.rs at line 201 [13.12409]
B:BD[13.17369] → [22.873:892]
B:BD[22.892] → [43.1629:1670]
```
    let log = || {
        repo.log.iter().enumerate().map(
```
[13.17369]
[13.17447]
```
    let view_log = || {
        log.iter().enumerate().map(
```

Replacement in inflorescence_view/src/app.rs at line 209 [13.12409]

B:BD[13.17641] → [13.17641:17717]

                let is_selected = matches!(state.cursor.selection.as_ref(),

[13.17641]

[13.17717]

                let is_selected = matches!(cursor.selection.as_ref(),

Replacement in inflorescence_view/src/app.rs at line 225 [13.12409]

B:BD[22.952] → [22.952:1532]

    let record_msg_editor = if let Some(RecordMsg::Typing(msg_content)) =
        state.record_msg.as_ref()
    {
        el(column([
            el(text_editor(msg_content)
                .placeholder("Type something here...")
                .on_action(Msg::EditRecordMsg)),
            el(row([
                el(button(text("Save")).on_press(Msg::SaveRecord)),
                el(button(text("Defer")).on_press(Msg::DeferRecord)),
                el(button(text("Abandon")).on_press(Msg::AbandonRecord)),
            ])),
        ]))
    } else {
        el(row([]))
    };

[22.952]

[13.18330]

    let record_msg_editor =
        if let Some(RecordMsg::Typing(msg_content)) = record_msg.as_ref() {
            el(column([
                el(text_editor(msg_content)
                    .placeholder("Type something here...")
                    .on_action(Msg::EditRecordMsg)),
                el(row([
                    el(button(text("Save")).on_press(Msg::SaveRecord)),
                    el(button(text("Defer")).on_press(Msg::DeferRecord)),
                    el(button(text("Abandon")).on_press(Msg::AbandonRecord)),
                ])),
            ]))
        } else {
            el(row([]))
        };

Replacement in inflorescence_view/src/app.rs at line 241 [13.12409]

B:BD[13.18331] → [22.1533:1601]

B:BD[22.1601] → [35.6189:6317]

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

[13.18331]

[35.6317]

    let selection_details = match selection.as_ref() {
        Some(Selection::UntrackedFile { ix: _, path, diff }) => {

Replacement in inflorescence_view/src/app.rs at line 244 [13.12409]

∅:D[35.6393] → [31.616:668]

B:BD[22.1802] → [31.616:668]

B:BD[31.668] → [35.6394:6634]

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

[35.6393]

[31.771]

            let diffs = match diff {
                Some(Diff {
                    is_selected,
                    file,
                    state,
                    nav,
                }) => diff::view(state, nav, file, *is_selected)
                    .map(move |msg| Msg::FileDiff { id_hash, msg }),

Replacement in inflorescence_view/src/app.rs at line 261 [13.12409]

B:BD[22.2546] → [35.6635:6761]

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

[22.2546]

[35.6761]

        Some(Selection::ChangedFile { path, ix: _, diff }) => {

Replacement in inflorescence_view/src/app.rs at line 263 [13.12409]

∅:D[35.6835] → [31.825:877]

B:BD[22.2743] → [31.825:877]

B:BD[31.877] → [35.6836:7076]

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

[35.6835]

[31.980]

            let diffs = match diff {
                Some(Diff {
                    is_selected,
                    file,
                    state,
                    nav,
                }) => diff::view(state, nav, file, *is_selected)
                    .map(move |msg| Msg::FileDiff { id_hash, msg }),

Replacement in inflorescence_view/src/app.rs at line 279 [13.12409]
B:BD[22.3458] → [22.3458:3502]
```
        Some(cursor::Selection::LogChange {
```
[22.3458]
[22.3502]
```
        Some(Selection::Log {
```
Insertion in inflorescence_view/src/app.rs at line 283 [13.12409]
[22.3557]
[22.3579]
```
            nav,
```

Replacement in inflorescence_view/src/app.rs at line 286 [13.12409]

B:BD[22.3613] → [43.1682:1734]

            let entry = repo.log.get(*ix).unwrap();

[22.3613]

[13.18975]

            let entry = log.get(*ix).unwrap();

Replacement in inflorescence_view/src/app.rs at line 290 [13.12409]

B:BD[13.21516] → [22.3746:3825]

∅:D[22.3825] → [13.21659:21803]

B:BD[13.21659] → [13.21659:21803]

            let files = entry.file_paths.iter().enumerate().map(|(ix, path)| {
                    let is_selected = matches!(file, Some(cursor::LogChangeFileSelection{ path: selected_path, .. }) if selected_path == path);

[13.21516]

[13.21803]

            let view = match nav {
                Some(nav) => {
                    let files_len = entry.file_paths.len();
                    let files = entry.file_paths.iter().enumerate().map(|(ix, path)| {
                    let is_selected = matches!(file, Some(LogChangeFileSelection{ path: selected_path, .. }) if selected_path == path);

Insertion in inflorescence_view/src/app.rs at line 299 [13.12409]

[13.22072]

[22.3826]

                    let hash = *hash;
                    el(iced_nav_scrollable::view(
                        nav,
                        files,
                        files_len,
                        move |msg| Msg::LogNav { hash, msg },
                    )
                    .width(Length::Fill)
                    .height(Length::Fill))
                }
                None => el(text("Loading...")),
            };

Replacement in inflorescence_view/src/app.rs at line 314 [13.12409]

B:BD[22.3918] → [42.210:278]

                el(text(message).shaping(text::Shaping::Advanced)),

[22.3918]

[22.3953]

                el(text(*message).shaping(text::Shaping::Advanced)),

Replacement in inflorescence_view/src/app.rs at line 316 [13.12409]

B:BD[22.4017] → [24.530:597]

                el(scrollable(column(files).width(Length::Fill))),

[22.4017]

[13.23465]

                view,

Replacement in inflorescence_view/src/app.rs at line 329 [13.12409]

B:BD[24.834] → [24.834:908]

        state.window_size.width.floor() as usize / DEFAULT_MIN_COL_WIDTH,

[24.834]

[24.908]

        window_size.width.floor() as usize / DEFAULT_MIN_COL_WIDTH,

Replacement in inflorescence_view/src/app.rs at line 332 [13.12409]

B:BD[24.916] → [24.916:996]

    let depth = if let Some(RecordMsg::Typing(_)) = state.record_msg.as_ref() {

[24.916]

[24.996]

    let depth = if let Some(RecordMsg::Typing(_)) = record_msg.as_ref() {

Replacement in inflorescence_view/src/app.rs at line 334 [13.12409]

B:BD[24.1006] → [24.1006:1076]

    } else if let Some(selection) = state.cursor.selection.as_ref() {

[24.1006]

[24.1076]

    } else if let Some(selection) = cursor.selection.as_ref() {

Replacement in inflorescence_view/src/app.rs at line 347 [13.12409]
B:BD[24.1471] → [24.1471:1507]
```
    //     state.window_size.width,
```
[24.1471]
[24.1507]
```
    //     window_size.width,
```
Replacement in inflorescence_view/src/app.rs at line 355 [13.12409]
B:BD[43.1817] → [43.1817:1851]
```
        .chain(untracked_files())
```
[43.1817]
[43.1851]
```
        .chain(view_untracked_files())
```
Replacement in inflorescence_view/src/app.rs at line 357 [13.12409]
B:BD[43.1896] → [43.1896:1928]
```
        .chain(changed_files())
```
[43.1896]
[43.1928]
```
        .chain(view_changed_files())
```
Replacement in inflorescence_view/src/app.rs at line 359 [13.12409]
B:BD[43.1974] → [43.1974:1997]
```
        .chain(log());
```
[43.1974]
[43.1997]
```
        .chain(view_log());
```

Replacement in inflorescence_view/src/app.rs at line 361 [13.12409]

B:BD[43.1998] → [43.1998:2064]

    let status_nav_children_len = repo::nav_contents_count(repo);

[43.1998]

[43.2064]

    let status_nav_children_len = repo::nav_contents_count(&repo.state);

Insertion in inflorescence_view/src/app.rs at line 363 [13.12409]

[43.2065]

[24.1588]

    let status_selected = match selection.as_ref() {
        Some(Selection::UntrackedFile { diff, .. }) => !diff
            .as_ref()
            .map(|diff| diff.is_selected)
            .unwrap_or_default(),
        Some(Selection::ChangedFile { diff, .. }) => !diff
            .as_ref()
            .map(|diff| diff.is_selected)
            .unwrap_or_default(),
        Some(Selection::Log { file, .. }) => file.is_none(),
        None => true,
    };

Replacement in inflorescence_view/src/app.rs at line 376 [13.12409]
B:BD[24.1616] → [24.1616:1635]
```
        repo_info,
```
[24.1616]
[43.2066]
```
        view_repo_info,
```

Replacement in inflorescence_view/src/app.rs at line 382 [13.12409]

B:BD[43.2226] → [43.2226:2238]

)),

[43.2226]

[24.1831]

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

Replacement in inflorescence_view/src/app.rs at line 410 [13.12409]

B:BD[24.2381] → [31.1034:1134]

    let col_2 = match state.cursor.selection.as_ref() {
        Some(cursor::Selection::LogChange {

[24.2381]

[31.1134]

    let col_2 = match selection.as_ref() {
        Some(Selection::Log {

Replacement in inflorescence_view/src/app.rs at line 415 [13.12409]

B:BD[31.1195] → [35.7077:7257]

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

[31.1195]

[31.1267]

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

Replacement in inflorescence_view/src/app.rs at line 423 [13.12409]

B:BD[31.1474] → [31.1474:1563]

B:BD[31.1563] → [35.7258:7337]

∅:D[35.7337] → [31.1626:1685]

B:BD[31.1626] → [31.1626:1685]

∅:D[30.1400] → [24.2887:3024]

∅:D[31.1685] → [24.2887:3024]

B:BD[24.2887] → [24.2887:3024]

B:BD[24.3024] → [31.1686:1743]

                match state.selected_diff {
                    Some((file, state)) => {
                        diff::view(state, file, *diff_selected).map(|action| {
                            Msg::LogChangeFileDiffAction {
                                hash: *hash,
                                file: path.clone(),
                                action,
                            }
                        })

[31.1474]

[31.1743]

                match diff {
                    Some(Diff {
                        is_selected,
                        file,
                        state,
                        nav,
                    }) => {
                        let id_hash = file::log_id_parts_hash(*hash, path);
                        diff::view(state, nav, file, *is_selected).map(
                            move |action| Msg::LogChangeFileDiff {
                                id_hash,
                                msg: action,
                            },
                        )

Replacement in inflorescence_view/src/app.rs at line 462 [13.12409]

B:BD[13.24110] → [31.2355:2515]

        Some(cursor::Selection::UntrackedFile { .. })
        | Some(cursor::Selection::ChangedFile { .. })
        | Some(cursor::Selection::LogChange { .. })

[13.24110]

[31.2515]

        Some(Selection::UntrackedFile { .. })
        | Some(Selection::ChangedFile { .. })
        | Some(Selection::Log { .. })

Replacement in inflorescence_view/src/app.rs at line 492 [13.12409]
B:BD[13.25114] → [13.25114:25168]
```
fn display_short_hash(hash: &pijul::Hash) -> String {
```
[13.25114]
[13.25168]
```
fn display_short_hash(hash: &repo::ChangeHash) -> String {
```
Deletion in inflorescence_view/src/app/test.rs at line 6 [14.4223]
B:BD[14.4320] → [30.2321:2357]
```
use libflorescence::prelude::pijul;
```
Replacement in inflorescence_view/src/app/test.rs at line 40 [14.4223]
B:BD[14.5104] → [30.2358:2387]
```
        selected_diff: None,
```
[14.5104]
[14.5139]
```
        selection: None,
```
Replacement in inflorescence_view/src/app/test.rs at line 68 [14.4223]
B:BD[15.254] → [30.2421:2450]
```
        selected_diff: None,
```
[15.254]
[15.289]
```
        selection: None,
```
Replacement in inflorescence_view/src/app/test.rs at line 91 [14.4223]
B:BD[15.1422] → [15.1422:1459]
```
            hash: pijul::Hash::None,
```
[15.1422]
[15.1459]
```
            hash: repo::ChangeHash::None,
```
Replacement in inflorescence_view/src/app/test.rs at line 109 [14.4223]
B:BD[16.8425] → [30.2484:2513]
```
        selected_diff: None,
```
[16.8425]
[16.8460]
```
        selection: None,
```
Replacement in inflorescence_view/src/app/test.rs at line 123 [14.4223]
B:BD[19.1433] → [30.2547:2576]
```
        selected_diff: None,
```
[19.1433]
[19.1468]
```
        selection: None,
```
Replacement in inflorescence_view/src/app/test.rs at line 154 [14.4223]
B:BD[14.5787] → [30.2610:2639]
```
        selected_diff: None,
```
[14.5787]
[14.5822]
```
        selection: None,
```
Replacement in inflorescence/src/test.rs at line 721 [46.2521]
B:BD[21.1996] → [35.8624:8653]
```
    assert!(task.is_none());
```
[21.1996]
[21.2025]
```
    assert!(task.is_some());
```
Deletion in inflorescence/src/main.rs at line 139 [47.2763]
B:BD[12.260] → [35.8996:9041]
∅:D[35.9041] → [28.2531:2562]
B:BD[28.2531] → [28.2531:2562]
```
    DiffNav {
        id_hash: file::IdHash,
        msg: diff::Msg,
    },
```
Replacement in inflorescence/src/main.rs at line 179 [47.2763]
B:BD[32.76] → [35.9094:9123]
```
                id_hash: id,
```
[32.76]
[32.96]
```
                id_hash,
```

Deletion in inflorescence/src/main.rs at line 184 [47.2763]

B:BD[32.202] → [38.37:112]

                let diff_state = state.files_diffs.entry(id).or_default();

Replacement in inflorescence/src/main.rs at line 188 [47.2763]

∅:D[32.360] → [28.3015:3059]

B:BD[28.3015] → [28.3015:3059]

B:BD[28.3059] → [35.9124:9216]

B:BD[35.9216] → [45.361:411]

∅:D[45.411] → [28.3264:3333]

B:BD[28.3264] → [28.3264:3333]

B:BD[28.3333] → [35.9217:9264]

∅:D[35.9264] → [30.3532:3603]

B:BD[28.3376] → [30.3532:3603]

∅:D[30.3603] → [28.3447:3505]

B:BD[28.3447] → [28.3447:3505]

B:BD[28.3505] → [38.113:148]

∅:D[38.148] → [35.9265:9323]

B:BD[28.3548] → [35.9265:9323]

B:BD[35.9323] → [38.149:188]

∅:D[38.188] → [28.3653:3678]

∅:D[35.9370] → [28.3653:3678]

B:BD[28.3653] → [28.3653:3678]

                diff_state.nav = Some(nav);
                return tasks.map(move |msg| Msg::DiffNav {
                    id_hash: id,
                    msg: diff::Msg::DiffNav(msg),
                });
            }
            Task::none()
        }
        Msg::DiffNav { id_hash: id, msg } => {
            if let Some(diff_state) = state.files_diffs.get_mut(&id) {
                let task = diff::update(diff_state, msg);
                let id_clone = id;
                return task.map(move |msg| Msg::DiffNav {
                    id_hash: id_clone,
                    msg,

[32.360]

[28.3678]

                state.files_diffs.diffs_nav = Some((id_hash, nav));
                return tasks.map(move |msg| {
                    Msg::View(app::Msg::FileDiff {
                        id_hash,
                        msg: diff::Msg::DiffNav(msg),
                    })

Replacement in inflorescence/src/main.rs at line 198 [47.2763]

B:BD[28.3747] → [35.9371:9532]

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

[28.3747]

[28.4073]

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

Replacement in inflorescence/src/main.rs at line 204 [47.2763]

B:BD[28.4087] → [35.9533:9586]

B:BD[35.9586] → [38.189:292]

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

[28.4087]

[28.4531]

                let nav = state.logs.diffs_nav.as_mut().and_then(
                    |(nav_id_hash, nav)| {
                        (*nav_id_hash == id_hash).then_some(nav)
                    },
                );
                let task = diff::update(diff_state, nav, msg);
                return task.map(move |msg| Msg::LogDiffNav { id_hash, msg });

Replacement in inflorescence/src/main.rs at line 256 [47.2763]

B:BD[13.26390] → [34.83:164]

B:BD[34.164] → [35.9734:9755]

∅:D[35.9755] → [34.164:233]

B:BD[34.164] → [34.164:233]

B:BD[34.233] → [36.727:800]

B:BD[36.800] → [44.37:74]

∅:D[44.74] → [34.291:364]

∅:D[43.4633] → [34.291:364]

∅:D[35.9821] → [34.291:364]

B:BD[34.291] → [34.291:364]

B:BD[34.364] → [35.9822:9917]

∅:D[35.9917] → [34.2256:2341]

B:BD[34.2256] → [34.2256:2341]

B:BD[34.2341] → [35.9918:11029]

B:BD[35.11029] → [45.412:474]

∅:D[45.474] → [35.11097:11197]

B:BD[35.11097] → [35.11097:11197]

∅:D[35.11197] → [34.3150:3172]

B:BD[34.3150] → [34.3150:3172]

B:BD[34.3172] → [35.11198:11788]

∅:D[35.11788] → [34.3172:3190]

B:BD[34.3172] → [34.3172:3190]

B:BD[34.3190] → [35.11789:11839]

∅:D[35.11839] → [34.3421:3437]

B:BD[34.3421] → [34.3421:3437]

B:BD[34.3437] → [35.11840:11914]

∅:D[35.11914] → [34.3489:3499]

B:BD[34.3489] → [34.3489:3499]

        app::Msg::Cursor(msg) => {
            let cursor_task = cursor::update(
                msg,
                &mut state.cursor,
                &mut state.files,
                &mut state.files_diffs,
                &mut state.logs,
                state.repo.as_mut(),
            )
            .map(|msg| Msg::View(app::Msg::ToRepo(msg)));
            let init_log_nav_task =
                if let Some(cursor::Selection::LogChange {
                    ix: _,
                    hash,
                    message: _,
                    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::DiffNav(msg),
                            })
                        }
                        _ => Task::none(),
                    }
                } 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()
                }
            } else {
                Task::none()
            };
            Task::batch([cursor_task, get_diffs_task, init_log_nav_task])
        }

[13.26390]

[13.26614]

        app::Msg::Cursor(msg) => cursor::update(
            msg,
            &mut state.cursor,
            &mut state.files,
            &mut state.files_diffs,
            &mut state.logs,
            state.repo.as_mut(),
        ),

Insertion in inflorescence/src/main.rs at line 274 [47.2763]

[43.4908]

            } else {
                Task::none()
            }
        }
        app::Msg::LogNav { hash, msg } => {
            if let Some((selected_hash, nav)) = state.logs.changes_nav.as_mut()
                && hash == *selected_hash
            {
                iced_nav_scrollable::update(nav, msg)
                    .map(move |msg| Msg::View(app::Msg::LogNav { hash, msg }))

Replacement in inflorescence/src/main.rs at line 292 [47.2763]

B:BD[20.582] → [35.11915:12045]

∅:D[20.702] → [3.772:782]

∅:D[4.1679] → [3.772:782]

∅:D[35.12045] → [3.772:782]

B:BD[3.772] → [3.772:782]

B:BD[3.782] → [20.703:850]

        app::Msg::FileDiffsContentsAction { id_hash, action } => {
            file_diffs_contents_action(state, id_hash, action)
        }
        app::Msg::LogChangeFileDiffAction { hash, file, action } => {
            log_change_file_diff_action(state, hash, file, action)
        }

[20.582]

[20.850]

        app::Msg::FileDiff {
            id_hash,
            msg: action,
        } => file_diffs_contents_action(state, id_hash, action),
        app::Msg::LogChangeFileDiff {
            id_hash,
            msg: action,
        } => log_change_file_diff_action(state, id_hash, action),

Insertion in inflorescence/src/main.rs at line 349 [47.2763]

[43.5584]


        let status_nav_task =
            status_nav_task.map(|msg| Msg::View(app::Msg::StatusNav(msg)));

Replacement in inflorescence/src/main.rs at line 354 [47.2763]

B:BD[41.659] → [43.5586:5662]

∅:D[43.5662] → [41.729:746]

B:BD[41.729] → [41.729:746]

        state.cursor.selection = if repo_state.untracked_files.is_empty() {
            None

[41.659]

[41.746]

        if repo_state.untracked_files.is_empty() {
            state.cursor.selection = None

Replacement in inflorescence/src/main.rs at line 358 [47.2763]

B:BD[43.5737] → [43.5737:5788]

            Some(cursor::untracked_file_selection(

[43.5737]

[43.5788]

            let (selection, selection_task) = cursor::untracked_file_selection(

Insertion in inflorescence/src/main.rs at line 360 [47.2763]
[43.5816]
[43.5816]
```
                status_nav,
```

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

B:BD[43.5870] → [43.5870:5885]

))

[43.5870]

[41.910]

                &mut state.files_diffs,
                cursor::VertDir::Down,
            );
            state.cursor.selection = Some(selection);
            return Task::batch([status_nav_task, selection_task]);

Replacement in inflorescence/src/main.rs at line 371 [47.2763]

B:BD[43.5887] → [43.5887:5966]

        return status_nav_task.map(|msg| Msg::View(app::Msg::StatusNav(msg)));

[43.5887]

[20.2296]

        return status_nav_task;

Insertion in inflorescence/src/main.rs at line 413 [47.2763]

[43.6585]


            let status_nav_task =
                status_nav_task.map(|msg| Msg::View(app::Msg::StatusNav(msg)));

Replacement in inflorescence/src/main.rs at line 418 [47.2763]

B:BD[41.1757] → [43.6587:6665]

∅:D[43.6665] → [41.1829:1850]

B:BD[41.1829] → [41.1829:1850]

            state.cursor.selection = if repo_state.changed_files.is_empty() {
                None

[41.1757]

[41.1850]

            if repo_state.changed_files.is_empty() {
                state.cursor.selection = None

Replacement in inflorescence/src/main.rs at line 422 [47.2763]

B:BD[43.6742] → [43.6742:6908]

                Some(cursor::changed_file_selection(
                    repo_state,
                    ix,
                    &mut state.files,
                ))

[43.6742]

[41.2022]

                let (selection, selection_task) =
                    cursor::changed_file_selection(
                        repo_state,
                        status_nav,
                        ix,
                        &mut state.files,
                        &mut state.files_diffs,
                        cursor::VertDir::Down,
                    );
                state.cursor.selection = Some(selection);
                return Task::batch([status_nav_task, selection_task]);

Replacement in inflorescence/src/main.rs at line 436 [47.2763]

B:BD[43.6910] → [43.6910:7010]

            return status_nav_task
                .map(|msg| Msg::View(app::Msg::StatusNav(msg)));

[43.6910]

[5.1813]

            return status_nav_task;

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

B:BD[20.6475] → [20.6475:6538]

B:BD[20.6538] → [35.12402:12951]

∅:D[7.1089] → [6.7355:7369]

∅:D[28.6825] → [6.7355:7369]

∅:D[20.6853] → [6.7355:7369]

∅:D[35.12951] → [6.7355:7369]

B:BD[6.7355] → [6.7355:7369]

B:BD[6.7369] → [35.12952:13483]

∅:D[28.7104] → [20.7123:7211]

∅:D[35.13483] → [20.7123:7211]

B:BD[20.7123] → [20.7123:7211]

∅:D[20.7211] → [6.7394:7404]

B:BD[6.7394] → [6.7394:7404]

B:BD[6.7404] → [20.7212:7235]

    if let Some(selection) = state.cursor.selection.as_mut() {
        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 });
                }
            }
            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 });
                }
            }
            _ => {
                // Selection has changed
            }
        }
    }
    Task::none()

[20.6475]

[20.7235]

    let diffs = state.files_diffs.diffs.entry(id_hash).or_default();
    let nav =
        state
            .files_diffs
            .diffs_nav
            .as_mut()
            .and_then(|(nav_id_hash, nav)| {
                (*nav_id_hash == id_hash).then_some(nav)
            });
    diff::update(diffs, nav, action)
        .map(move |msg| Msg::View(app::Msg::FileDiff { id_hash, msg }))

Replacement in inflorescence/src/main.rs at line 543 [47.2763]
B:BD[20.7293] → [20.7293:7334]
```
    hash: pijul::Hash,
    file: String,
```
[20.7293]
[20.7334]
```
    id_hash: file::LogIdHash,
```
Deletion in inflorescence/src/main.rs at line 557 [47.2763]
B:BD[20.7672] → [41.2038:2106]
```
        && *selected_hash == hash
        && *selected_path == file
```

Replacement in inflorescence/src/main.rs at line 558 [47.2763]

B:BD[20.7678] → [41.2107:2275]

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

[20.7678]

[41.2275]

        let selected_id_hash =
            file::log_id_parts_hash(*selected_hash, selected_path);
        if selected_id_hash == id_hash
            && let Some(diff::FileAndState {
                file: _,
                state: diff_state,
            }) = state.logs.diffs.get_mut(&id_hash)

Replacement in inflorescence/src/main.rs at line 566 [47.2763]

B:BD[41.2285] → [41.2285:2332]

            return diff::update(state, action)

[41.2285]

[41.2332]

            let nav =
                state
                    .logs
                    .diffs_nav
                    .as_mut()
                    .and_then(|(nav_id_hash, nav)| {
                        (*nav_id_hash == id_hash).then_some(nav)
                    });
            return diff::update(diff_state, nav, action)

Replacement in inflorescence/src/main.rs at line 798 [47.2763]
B:BD[20.12819] → [20.12819:12842]
```
    hash: pijul::Hash,
```
[20.12819]
[20.12842]
```
    hash: repo::ChangeHash,
```

Replacement in inflorescence/src/main.rs at line 801 [47.2763]

B:BD[20.12890] → [20.12890:12937]

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

[20.12890]

[20.12937]

    let changed_files_count = diffs.len();
    let task = if let Some(cursor::Selection::LogChange {

Replacement in inflorescence/src/main.rs at line 807 [47.2763]
B:BD[20.13040] → [20.13040:13057]
```
        file: _,
```
[20.13001]
[20.13057]
```
        file,
```

Replacement in inflorescence/src/main.rs at line 811 [47.2763]

B:BD[20.13104] → [41.2896:3536]

        diffs.into_iter().for_each(|(path, diffs)| {
            // NOTE: using unknown encoding as we don't yet have the file
            // for past changes
            let file = diff::init_file(
                diff::FileContent::UnknownEncoding,
                Some(&diffs),
            );
            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(),
            };

[20.13104]

[30.5852]

        if let Some(file) = file.as_ref() {
            // If a file is selected, init the nav for its diff
            let diff = diffs.get(&file.path).unwrap();
            let diff_contents_count = diff.len();
            let (diffs_nav, nav_task) =
                iced_nav_scrollable::init(diff_contents_count, HashSet::new());
            let id_hash = file::log_id_parts_hash(hash, &file.path);
            state.logs.diffs_nav = Some((id_hash, diffs_nav));
            nav_task.map(move |msg| {
                Msg::View(app::Msg::LogChangeFileDiff {
                    id_hash,
                    msg: diff::Msg::DiffNav(msg),
                })
            })
        } else {
            // Init scrollable nav for log changes
            let (changes_nav, nav_task) =
                iced_nav_scrollable::init(changed_files_count, HashSet::new());
            state.logs.changes_nav = Some((hash, changes_nav));
            nav_task.map(move |msg| Msg::View(app::Msg::LogNav { hash, msg }))
        }
    } else {
        Task::none()
    };
    // Store the changes
    state
        .logs
        .change_file_counts
        .insert(hash, changed_files_count);
    diffs.into_iter().for_each(|(path, diffs)| {
        // NOTE: using unknown encoding as we don't yet have the file
        // for past changes
        let file =
            diff::init_file(diff::FileContent::UnknownEncoding, Some(&diffs));
        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(),
        };
        state.logs.diffs.insert(id_hash, log_file_diff);
    });

Replacement in inflorescence/src/main.rs at line 861 [47.2763]
B:BD[30.5853] → [41.3537:3661]
∅:D[41.3661] → [8.2921:2927]
B:BD[8.2921] → [8.2921:2927]
B:BD[8.2927] → [20.13703:13720]
```
            state.logs.change_hashes.insert(hash);
            state.logs.diffs.insert(id_hash, log_file_diff);
        });
    }
    Task::none()
```
[30.5853]
[8.4296]
```
    task
```

Insertion in inflorescence/src/main.rs at line 1018 [47.2763]

[43.8110]


    let log_nav_sub =
        if let Some((hash, _nav)) = state.logs.changes_nav.as_ref() {
            let hash = *hash;
            iced_nav_scrollable::subs()
                .with(hash)
                .map(|(hash, msg)| Msg::View(app::Msg::LogNav { hash, msg }))
        } else {
            Subscription::none()
        };

Replacement in inflorescence/src/main.rs at line 1038 [47.2763]

B:BD[35.16086] → [35.16086:16168]

B:BD[35.16168] → [45.475:525]

                .map(|(id_hash, msg)| Msg::DiffNav {
                    id_hash,
                    msg: diff::Msg::DiffNav(msg),

[35.16086]

[35.16224]

                .map(|(id_hash, msg)| {
                    Msg::View(app::Msg::FileDiff {
                        id_hash,
                        msg: diff::Msg::DiffNav(msg),
                    })

Replacement in inflorescence/src/main.rs at line 1053 [47.2763]

B:BD[35.16530] → [35.16530:16612]

B:BD[35.16612] → [45.526:576]

                .map(|(id_hash, msg)| Msg::DiffNav {
                    id_hash,
                    msg: diff::Msg::DiffNav(msg),

[35.16530]

[35.16668]

                .map(|(id_hash, msg)| {
                    Msg::View(app::Msg::FileDiff {
                        id_hash,
                        msg: diff::Msg::DiffNav(msg),
                    })

Insertion in inflorescence/src/main.rs at line 1090 [47.2763]
[43.8200]
[43.8200]
```
        log_nav_sub,
```
Replacement in inflorescence/src/main.rs at line 1107 [47.2763]
B:BD[35.17598] → [35.17598:17623]
```
        logs: log_diffs,
```
[35.17598]
[13.28717]
```
        logs,
```

Replacement in inflorescence/src/main.rs at line 1110 [47.2763]

B:BD[30.6244] → [30.6244:6308]

    let selected_diff = match state.cursor.selection.as_ref() {

[30.6244]

[35.17624]

    let selection = match state.cursor.selection.as_ref() {

Replacement in inflorescence/src/main.rs at line 1112 [47.2763]
B:BD[35.17672] → [35.17672:17691]
```
            ix: _,
```
[35.17672]
[35.17691]
```
            ix,
```
Replacement in inflorescence/src/main.rs at line 1114 [47.2763]
B:BD[35.17709] → [35.17709:17739]
```
            diff_selected: _,
```
[35.17709]
[35.17739]
```
            diff_selected,
```

Replacement in inflorescence/src/main.rs at line 1117 [47.2763]

B:BD[35.17831] → [35.17831:17894]

∅:D[35.17894] → [31.3223:3248]

B:BD[31.3223] → [31.3223:3248]

            let file = files.diffs_cache.inner.peek(&id_hash);
            match file {

[35.17831]

[31.3248]

            let diff = files.diffs_cache.inner.peek(&id_hash);
            let diff = match diff {

Replacement in inflorescence/src/main.rs at line 1120 [47.2763]

B:BD[31.3300] → [35.17895:17968]

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

[31.3300]

[31.3368]

                    let nav = files_diffs
                        .diffs_nav
                        .as_ref()
                        .and_then(|(nav_id_hash, nav)| {
                            (*nav_id_hash == id_hash).then_some(nav)
                        })
                        .unwrap();
                    files_diffs.diffs.get(&id_hash).map(|state| app::Diff {
                        is_selected: *diff_selected,
                        file,
                        state,
                        nav,
                    })

Replacement in inflorescence/src/main.rs at line 1135 [47.2763]

B:BD[31.3444] → [31.3444:3458]

[31.3444]

[30.6542]

            };
            Some(app::Selection::UntrackedFile {
                ix: *ix,
                path,
                diff,
            })

Replacement in inflorescence/src/main.rs at line 1144 [47.2763]

B:BD[35.18033] → [35.18033:18082]

            ix: _,
            diff_selected: _,

[35.18033]

[35.18082]

            ix,
            diff_selected,

Replacement in inflorescence/src/main.rs at line 1148 [47.2763]

B:BD[35.18172] → [35.18172:18235]

∅:D[35.18235] → [31.3517:3542]

B:BD[31.3517] → [31.3517:3542]

            let file = files.diffs_cache.inner.peek(&id_hash);
            match file {

[35.18172]

[31.3542]

            let diff = files.diffs_cache.inner.peek(&id_hash);
            let diff = match diff {

Replacement in inflorescence/src/main.rs at line 1151 [47.2763]

B:BD[31.3594] → [35.18236:18309]

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

[31.3594]

[31.3662]

                    let nav = files_diffs
                        .diffs_nav
                        .as_ref()
                        .and_then(|(nav_id_hash, nav)| {
                            (*nav_id_hash == id_hash).then_some(nav)
                        })
                        .unwrap();
                    files_diffs.diffs.get(&id_hash).map(|state| app::Diff {
                        is_selected: *diff_selected,
                        file,
                        state,
                        nav,
                    })

Replacement in inflorescence/src/main.rs at line 1166 [47.2763]

B:BD[31.3738] → [31.3738:3752]

[31.3738]

[30.6782]

            };
            Some(app::Selection::ChangedFile {
                ix: *ix,
                path,
                diff,
            })

Replacement in inflorescence/src/main.rs at line 1174 [47.2763]
B:BD[30.6978] → [30.6978:6997]
```
            ix: _,
```
[30.6978]
[30.6997]
```
            ix: log_ix,
```

Replacement in inflorescence/src/main.rs at line 1176 [47.2763]

B:BD[30.7015] → [30.7015:7039]

B:BD[30.7039] → [35.18310:18493]

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

[30.7015]

[30.7111]

            message,
            file,

Replacement in inflorescence/src/main.rs at line 1179 [47.2763]

B:BD[30.7127] → [35.18494:18558]

∅:D[35.18558] → [30.7240:7262]

B:BD[30.7240] → [30.7240:7262]

B:BD[30.7262] → [35.18559:18686]

            let id_hash = file::log_id_parts_hash(*hash, path);
            log_diffs
                .diffs
                .get(&id_hash)
                .map(|diff::FileAndState { file, state }| (file, state))

[30.7127]

[30.7354]

            let file = file.as_ref().map(
                |cursor::LogChangeFileSelection {
                     ix: change_ix,
                     path,
                     diff_selected,
                 }| {
                    let id_hash = file::log_id_parts_hash(*hash, path);
                    let diff = logs.diffs.get(&id_hash).map(
                        |diff::FileAndState { file, state }| {
                            let nav = logs
                                .diffs_nav
                                .as_ref()
                                .and_then(|(nav_id_hash, nav)| {
                                    (*nav_id_hash == id_hash).then_some(nav)
                                })
                                .unwrap();
                            app::Diff {
                                is_selected: *diff_selected,
                                file,
                                state,
                                nav,
                            }
                        },
                    );
                    app::LogChangeFileSelection {
                        ix: *change_ix,
                        path,
                        diff,
                    }
                },
            );
            let nav = logs
                .changes_nav
                .as_ref()
                .and_then(|(nav_hash, nav)| (nav_hash == hash).then_some(nav));
            Some(app::Selection::Log {
                ix: *log_ix,
                hash: *hash,
                message,
                file,
                nav,
            })

Replacement in inflorescence/src/main.rs at line 1222 [47.2763]

B:BD[30.7364] → [31.3866:3944]

        Some(cursor::Selection::LogChange { file: None, .. }) | None => None,

[30.7364]

[30.7383]

        None => None,

Replacement in inflorescence/src/main.rs at line 1225 [47.2763]

∅:D[30.7391] → [13.28732:28768]

B:BD[13.28732] → [13.28732:28768]

B:BD[13.28768] → [24.5792:5831]

∅:D[24.5831] → [13.28768:28889]

B:BD[13.28768] → [13.28768:28889]

B:BD[13.28889] → [30.7392:7419]

∅:D[30.7450] → [13.28914:28944]

B:BD[13.28914] → [13.28914:28944]

B:BD[13.28991] → [13.28991:29017]

    app::view(
        app::State {
            window_size: *window_size,
            repo_path,
            repo: repo.as_ref(),
            cursor,
            record_msg: record_msg.as_ref(),
            selected_diff,
        },
        window_id,
    )
    .map(Msg::View)

[30.7391]

[10.20154]

    let state = app::State {
        window_size: *window_size,
        repo_path,
        repo: repo.as_ref(),
        cursor,
        record_msg: record_msg.as_ref(),
        selection,
    };
    app::view(state, window_id).map(Msg::View)

Insertion in inflorescence/src/file.rs at line 195 [12.1806]

[12.6409]

pub fn try_get_src_file(state: &State, id_hash: IdHash) -> Option<&diff::File> {
    state
        .diffs_cache
        .inner
        .peek(&id_hash)
        .and_then(|diff| match diff {
            Diff::Loading => None,
            Diff::Loaded(file) => Some(file),
        })
}

Insertion in inflorescence/src/diff.rs at line 13 [48.5018]
[35.19692]
[28.8470]
```
use iced_nav_scrollable::NavScrollable;
```
Replacement in inflorescence/src/diff.rs at line 19 [48.5018]
B:BD[13.29153] → [32.1342:1373]
```
use std::collections::HashSet;
```
[13.29153]
[35.19693]
```
use std::collections::{HashMap, HashSet};
```

Replacement in inflorescence/src/diff.rs at line 21 [48.5018]

B:BD[35.19694] → [35.19694:19736]

pub type FilesState = file::IdMap<State>;

[35.19694]

[35.19736]

#[derive(Debug, Default)]
pub struct FilesState {
    pub diffs: file::IdMap<State>,
    /// Diffs scrollable nav.
    ///
    /// Only the current nav is kept because the sizes of contents have to be
    /// queried everytime the selection changes due to possible container size
    /// changes.
    pub diffs_nav: Option<(file::IdHash, NavScrollable)>,
}

Replacement in inflorescence/src/diff.rs at line 34 [48.5018]

B:BD[35.19793] → [35.19793:19898]

    /// All the hashes in this set have `diffs` loaded
    pub change_hashes: HashSet<repo::ChangeHash>,

[35.19793]

[35.19898]

    /// All the hashes in this map have `diffs` loaded. The value is the number
    /// of the changed files in the change (contents count used for
    /// scrollable-nav).
    pub change_file_counts: HashMap<repo::ChangeHash, usize>,

Insertion in inflorescence/src/diff.rs at line 41 [48.5018]

[35.20033]

    /// Log changes scrollable nav.
    ///
    /// Only the current nav is kept because the sizes of contents have to be
    /// queried everytime the selection changes due to possible container size
    /// changes.
    pub changes_nav: Option<(repo::ChangeHash, NavScrollable)>,
    /// Log diffs scrollable nav.
    ///
    /// Only the current nav is kept because the sizes of contents have to be
    /// queried everytime the selection changes due to possible container size
    /// changes.
    pub diffs_nav: Option<(file::LogIdHash, NavScrollable)>,

Replacement in inflorescence/src/diff.rs at line 61 [48.5018]

∅:D[35.20124] → [28.8493:8551]

B:BD[9.288] → [28.8493:8551]

pub fn update(state: &mut State, msg: Msg) -> Task<Msg> {

[35.20124]

[28.8551]

pub fn update(
    _state: &mut State,
    nav: Option<&mut NavScrollable>,
    msg: Msg,
) -> Task<Msg> {

Replacement in inflorescence/src/diff.rs at line 68 [48.5018]
∅:D[45.661] → [28.8604:8656]
B:BD[28.8604] → [28.8604:8656]
```
            if let Some(nav) = state.nav.as_mut() {
```
[45.661]
[45.662]
```
            if let Some(nav) = nav {
```
Replacement in inflorescence/src/diff.rs at line 235 [48.5018]
B:BD[35.20192] → [35.20192:20214]
```
    id: file::IdHash,
```
[35.20192]
[35.20214]
```
    id_hash: file::IdHash,
```

Replacement in inflorescence/src/diff.rs at line 239 [48.5018]

B:BD[35.20260] → [35.20260:20330]

            .get(&id)
            .and_then(|diff| diff.nav.as_ref())

[35.20260]

[35.20330]

            .diffs_nav
            .as_ref()
            .and_then(
                |(nav_id_hash, nav)| (*nav_id_hash == id_hash).then_some(nav)
            )

Replacement in inflorescence/src/diff.rs at line 254 [48.5018]

B:BD[35.20552] → [35.20552:20652]

        logs.diffs
            .get(&id_hash)
            .and_then(|diff| diff.state.nav.as_ref())

[35.20552]

[35.20652]

        logs.diffs_nav
            .as_ref()
            .and_then(
                |(nav_id_hash, nav)| (*nav_id_hash == id_hash).then_some(nav)
            )

Insertion in inflorescence/src/cursor.rs at line 1 [2.26]
[2.26]
[44.78]
```
use iced_nav_scrollable::NavScrollable;
```
Insertion in inflorescence/src/cursor.rs at line 15 [2.26]
[36.4268]
[12.8577]
```
use std::collections::HashSet;
```
Replacement in inflorescence/src/cursor.rs at line 17 [2.26]
B:BD[12.8578] → [35.20755:20773]
```
pub fn update<M>(
```
[12.8578]
[35.20773]
```
pub fn update(
```
Replacement in inflorescence/src/cursor.rs at line 22 [2.26]
B:BD[36.4309] → [36.4309:4353]
```
    log_diffs: &mut diff::LogFilesAndState,
```
[36.4309]
[44.108]
```
    logs: &mut diff::LogFilesAndState,
```
Replacement in inflorescence/src/cursor.rs at line 24 [2.26]
∅:D[44.142] → [35.20864:20879]
B:BD[35.20864] → [35.20864:20879]
```
) -> Task<M> {
```
[44.142]
[11.2479]
```
) -> Task<crate::Msg> {
```

Replacement in inflorescence/src/cursor.rs at line 51 [2.26]

B:BD[36.5148] → [36.5148:5380]

                Dir::Down => select_down(
                    state,
                    files,
                    repo,
                    files_diffs,
                    log_diffs,
                    delta,
                ),

[36.5148]

[36.5380]

                Dir::Down => {
                    select_down(state, files, files_diffs, logs, repo, delta)
                }

Replacement in inflorescence/src/cursor.rs at line 55 [2.26]

B:BD[36.5409] → [36.5409:5490]

                    select_up(state, files, repo, files_diffs, log_diffs, delta)

[36.5409]

[36.5490]

                    select_up(state, files, files_diffs, logs, repo, delta)

Replacement in inflorescence/src/cursor.rs at line 59 [2.26]

B:BD[44.241] → [44.241:322]

                    select_right(state, repo.as_deref(), files_diffs, log_diffs)

[44.241]

[44.322]

                    select_right(state, files_diffs, logs, repo.as_deref())

Replacement in inflorescence/src/cursor.rs at line 63 [2.26]

B:BD[36.5668] → [36.5668:5745]

        Msg::ReleaseDir(dir) => release(dir, state, files_diffs, log_diffs),

[36.5668]

[37.2886]

        Msg::ReleaseDir(dir) => release(dir, state, files_diffs, logs),

Replacement in inflorescence/src/cursor.rs at line 89 [2.26]

B:BD[37.3802] → [37.3802:4005]

                Dir::Down => {
                    alt_select_down(state, files_diffs, log_diffs, delta)
                }
                Dir::Up => alt_select_up(state, files_diffs, log_diffs, delta),

[37.3802]

[37.4005]

                Dir::Down => alt_select_down(state, files_diffs, logs, delta),
                Dir::Up => alt_select_up(state, files_diffs, logs, delta),

Replacement in inflorescence/src/cursor.rs at line 103 [2.26]
B:BD[44.498] → [44.498:521]
```
            log_diffs,
```
[44.498]
[44.521]
```
            logs,
```

Deletion in inflorescence/src/cursor.rs at line 105 [2.26]

∅:D[44.532] → [35.21272:21708]

B:BD[35.21272] → [35.21272:21708]

    }
}
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,

Deletion in inflorescence/src/cursor.rs at line 107 [2.26]

B:BD[35.21716] → [35.21716:22121]


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);
    }

Replacement in inflorescence/src/cursor.rs at line 108 [2.26]

B:BD[35.22122] → [35.22122:22772]

    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>(

[35.22122]

[35.22772]

fn select_down(

Deletion in inflorescence/src/cursor.rs at line 111 [2.26]
B:BD[35.22824] → [44.533:567]
```
    repo: Option<&mut app::Repo>,
```
Insertion in inflorescence/src/cursor.rs at line 113 [2.26]
[36.5825]
[36.5825]
```
    repo: Option<&mut app::Repo>,
```
Replacement in inflorescence/src/cursor.rs at line 115 [2.26]
∅:D[36.5854] → [35.22927:22942]
B:BD[35.22927] → [35.22927:22942]
```
) -> Task<M> {
```
[36.5854]
[44.568]
```
) -> Task<crate::Msg> {
```

Replacement in inflorescence/src/cursor.rs at line 137 [2.26]

B:BD[40.615] → [40.615:793]

                    if let Some(nav) = files_diffs
                        .get_mut(&id_hash)
                        .and_then(|state| state.nav.as_mut())
                    {

[40.615]

[40.793]

                    if let Some(nav) = files_diffs.diffs_nav.as_mut().and_then(
                        |(nav_id_hash, nav)| {
                            (*nav_id_hash == id_hash).then_some(nav)
                        },
                    ) {

Replacement in inflorescence/src/cursor.rs at line 151 [2.26]

B:BD[40.1100] → [44.854:1235]

                    let selection =
                        changed_file_selection(repo_state, ix, files);
                    let task = iced_nav_scrollable::scroll_down_to_section(
                        status_section_ix(
                            repo_state,
                            ix,
                            StatusSectionKind::Changed,
                        ),

[40.1100]

[44.1235]

                    changed_file_selection(
                        repo_state,

Replacement in inflorescence/src/cursor.rs at line 154 [2.26]

B:BD[44.1271] → [44.1271:1332]

                    );
                    (selection, task)

[44.1271]

[44.1332]

                        ix,
                        files,
                        files_diffs,
                        VertDir::Down,
                    )

Replacement in inflorescence/src/cursor.rs at line 161 [2.26]

B:BD[40.1304] → [44.1388:1658]

                    let task = iced_nav_scrollable::scroll_down_to_section(
                        status_section_ix(
                            repo_state,
                            ix,
                            StatusSectionKind::Log,
                        ),

[40.1304]

[44.1658]

                    log_selection(

Replacement in inflorescence/src/cursor.rs at line 163 [2.26]

B:BD[44.1694] → [44.1694:1775]

                    );
                    (log_selection(repo_state, ix), task)

[44.1694]

[35.24638]

                        logs,
                        repo_state,
                        ix,
                        VertDir::Down,
                    )

Replacement in inflorescence/src/cursor.rs at line 170 [2.26]

B:BD[40.1397] → [44.1776:2159]

                    let selection =
                        untracked_file_selection(repo_state, ix, files);
                    let task = iced_nav_scrollable::scroll_up_to_section(
                        status_section_ix(
                            repo_state,
                            ix,
                            StatusSectionKind::Untracked,
                        ),

[40.1397]

[44.2159]

                    untracked_file_selection(
                        repo_state,

Replacement in inflorescence/src/cursor.rs at line 173 [2.26]

B:BD[44.2195] → [44.2195:2256]

                    );
                    (selection, task)

[44.2195]

[40.1398]

                        ix,
                        files,
                        files_diffs,
                        VertDir::Up,
                    )

Replacement in inflorescence/src/cursor.rs at line 181 [2.26]

B:BD[40.1470] → [44.2257:2590]

                let selection = untracked_file_selection(repo_state, ix, files);
                let task = iced_nav_scrollable::scroll_down_to_section(
                    status_section_ix(
                        repo_state,
                        ix,
                        StatusSectionKind::Untracked,
                    ),

[40.1470]

[44.2590]

                untracked_file_selection(
                    repo_state,

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

B:BD[44.2622] → [44.2622:2675]

                );
                (selection, task)

[44.2622]

[40.1587]

                    ix,
                    files,
                    files_diffs,
                    VertDir::Down,
                )

Replacement in inflorescence/src/cursor.rs at line 205 [2.26]

B:BD[40.2080] → [40.2080:2258]

                    if let Some(nav) = files_diffs
                        .get_mut(&id_hash)
                        .and_then(|state| state.nav.as_mut())
                    {

[40.2080]

[40.2258]

                    if let Some(nav) = files_diffs.diffs_nav.as_mut().and_then(
                        |(nav_id_hash, nav)| {
                            (*nav_id_hash == id_hash).then_some(nav)
                        },
                    ) {

Replacement in inflorescence/src/cursor.rs at line 219 [2.26]

B:BD[40.2553] → [44.2850:3120]

                    let task = iced_nav_scrollable::scroll_down_to_section(
                        status_section_ix(
                            repo_state,
                            ix,
                            StatusSectionKind::Log,
                        ),

[40.2553]

[44.3120]

                    log_selection(

Replacement in inflorescence/src/cursor.rs at line 221 [2.26]

B:BD[44.3156] → [44.3156:3237]

                    );
                    (log_selection(repo_state, ix), task)

[44.3156]

[44.3237]

                        logs,
                        repo_state,
                        ix,
                        VertDir::Down,
                    )

Replacement in inflorescence/src/cursor.rs at line 228 [2.26]

B:BD[40.2706] → [44.3305:3688]

                    let selection =
                        untracked_file_selection(repo_state, ix, files);
                    let task = iced_nav_scrollable::scroll_up_to_section(
                        status_section_ix(
                            repo_state,
                            ix,
                            StatusSectionKind::Untracked,
                        ),

[40.2706]

[44.3688]

                    untracked_file_selection(
                        repo_state,

Replacement in inflorescence/src/cursor.rs at line 231 [2.26]

B:BD[44.3724] → [44.3724:3785]

                    );
                    (selection, task)

[44.3724]

[35.26467]

                        ix,
                        files,
                        files_diffs,
                        VertDir::Up,
                    )

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

B:BD[40.2864] → [44.3786:4165]

                    let selection =
                        changed_file_selection(repo_state, ix, files);
                    let task = iced_nav_scrollable::scroll_up_to_section(
                        status_section_ix(
                            repo_state,
                            ix,
                            StatusSectionKind::Changed,
                        ),

[40.2864]

[44.4165]

                    changed_file_selection(
                        repo_state,

Replacement in inflorescence/src/cursor.rs at line 241 [2.26]

B:BD[44.4201] → [44.4201:4262]

                    );
                    (selection, task)

[44.4201]

[40.2865]

                        ix,
                        files,
                        files_diffs,
                        VertDir::Up,
                    )

Replacement in inflorescence/src/cursor.rs at line 249 [2.26]

B:BD[40.2937] → [44.4263:4592]

                let selection = changed_file_selection(repo_state, ix, files);
                let task = iced_nav_scrollable::scroll_down_to_section(
                    status_section_ix(
                        repo_state,
                        ix,
                        StatusSectionKind::Changed,
                    ),

[40.2937]

[44.4592]

                changed_file_selection(
                    repo_state,

Replacement in inflorescence/src/cursor.rs at line 252 [2.26]

B:BD[44.4624] → [44.4624:4677]

                );
                (selection, task)

[44.4624]

[40.3052]

                    ix,
                    files,
                    files_diffs,
                    VertDir::Down,
                )

Replacement in inflorescence/src/cursor.rs at line 274 [2.26]

B:BD[40.3574] → [40.3574:4513]

                        (
                            Selection::LogChange {
                                ix: log_ix,
                                hash,
                                message,
                                file: Some(LogChangeFileSelection {
                                    ix: file_ix,
                                    path,
                                    diff_selected,
                                }),
                            },
                            if let Some(nav) = logs
                                .diffs
                                .get_mut(&id_hash)
                                .and_then(|diff| diff.state.nav.as_mut())
                            {
                                iced_nav_scrollable::scroll_down(nav, delta)
                            } else {
                                Task::none()
                            },
                        )

[40.3574]

[40.4513]

                        let selection = Selection::LogChange {
                            ix: log_ix,
                            hash,
                            message,
                            file: Some(LogChangeFileSelection {
                                ix: file_ix,
                                path,
                                diff_selected,
                            }),
                        };
                        let task = if let Some(nav) = logs
                            .diffs_nav
                            .as_mut()
                            .and_then(|(nav_id_hash, nav)| {
                                (*nav_id_hash == id_hash).then_some(nav)
                            }) {
                            iced_nav_scrollable::scroll_down(nav, delta)
                        } else {
                            Task::none()
                        };
                        (selection, task)

Insertion in inflorescence/src/cursor.rs at line 306 [2.26]

[40.4947]

[11.7558]


                        let (file, selection_task) =
                            log_file_selection(logs, log_entry, hash, file_ix);

Replacement in inflorescence/src/cursor.rs at line 310 [2.26]

B:BD[11.7559] → [40.4948:5023]

                        let file = log_file_selection(log_entry, file_ix);

[11.7559]

[11.7678]

                        let scroll_task = if let Some((nav_changes_hash, nav)) =
                            logs.changes_nav.as_ref()
                            && *nav_changes_hash == hash
                        {
                            iced_nav_scrollable::scroll_down_to_section(
                                file_ix, nav,
                            )
                        } else {
                            Task::none()
                        };

Replacement in inflorescence/src/cursor.rs at line 321 [2.26]

B:BD[11.7679] → [40.5024:5373]

                        (
                            Selection::LogChange {
                                ix: log_ix,
                                hash,
                                message,
                                file: Some(file),
                            },
                            Task::none(),
                        )

[11.7679]

[35.28950]

                        let selection = Selection::LogChange {
                            ix: log_ix,
                            hash,
                            message,
                            file: Some(file),
                        };
                        (selection, Task::batch([selection_task, scroll_task]))

Replacement in inflorescence/src/cursor.rs at line 335 [2.26]

B:BD[44.4983] → [44.4983:5589]

                            let task =
                                iced_nav_scrollable::scroll_up_to_section(
                                    status_section_ix(
                                        repo_state,
                                        ix,
                                        StatusSectionKind::Untracked,
                                    ),
                                    status_nav,
                                );
                            (
                                untracked_file_selection(repo_state, ix, files),
                                task,

[44.4983]

[44.5589]

                            untracked_file_selection(
                                repo_state,
                                status_nav,
                                ix,
                                files,
                                files_diffs,
                                VertDir::Up,

Replacement in inflorescence/src/cursor.rs at line 345 [2.26]

B:BD[44.5732] → [44.5732:6334]

                            let task =
                                iced_nav_scrollable::scroll_up_to_section(
                                    status_section_ix(
                                        repo_state,
                                        ix,
                                        StatusSectionKind::Changed,
                                    ),
                                    status_nav,
                                );
                            (
                                changed_file_selection(repo_state, ix, files),
                                task,

[44.5732]

[44.6334]

                            changed_file_selection(
                                repo_state,
                                status_nav,
                                ix,
                                files,
                                files_diffs,
                                VertDir::Up,

Replacement in inflorescence/src/cursor.rs at line 355 [2.26]

B:BD[44.6405] → [44.6405:6922]

                            let task =
                                iced_nav_scrollable::scroll_up_to_section(
                                    status_section_ix(
                                        repo_state,
                                        ix,
                                        StatusSectionKind::Log,
                                    ),
                                    status_nav,
                                );
                            (log_selection(repo_state, ix), task)

[44.6405]

[44.6922]

                            log_selection(
                                status_nav,
                                logs,
                                repo_state,
                                ix,
                                VertDir::Up,
                            )

Replacement in inflorescence/src/cursor.rs at line 365 [2.26]

B:BD[44.7022] → [44.7022:7316]

                        let task = iced_nav_scrollable::scroll_down_to_section(
                            status_section_ix(
                                repo_state,
                                ix,
                                StatusSectionKind::Log,
                            ),

[44.7022]

[44.7316]

                        log_selection(

Replacement in inflorescence/src/cursor.rs at line 367 [2.26]

B:BD[44.7356] → [44.7356:7445]

                        );
                        (log_selection(repo_state, ix), task)

[44.7356]

[44.7445]

                            logs,
                            repo_state,
                            ix,
                            VertDir::Down,
                        )

Replacement in inflorescence/src/cursor.rs at line 380 [2.26]

B:BD[40.6334] → [44.7525:7884]

                let selection =
                    Some(untracked_file_selection(repo_state, ix, files));
                let task = iced_nav_scrollable::scroll_down_to_section(
                    status_section_ix(
                        repo_state,
                        ix,
                        StatusSectionKind::Untracked,
                    ),

[40.6334]

[44.7884]

                let (selection, task) = untracked_file_selection(
                    repo_state,

Insertion in inflorescence/src/cursor.rs at line 383 [2.26]

[44.7916]

                    ix,
                    files,
                    files_diffs,
                    VertDir::Down,

Replacement in inflorescence/src/cursor.rs at line 388 [2.26]
B:BD[44.7935] → [44.7935:7969]
```
                (selection, task)
```
[44.7935]
[44.7969]
```
                (Some(selection), task)
```

Replacement in inflorescence/src/cursor.rs at line 391 [2.26]

B:BD[40.6540] → [44.8031:8386]

                let selection =
                    Some(changed_file_selection(repo_state, ix, files));
                let task = iced_nav_scrollable::scroll_down_to_section(
                    status_section_ix(
                        repo_state,
                        ix,
                        StatusSectionKind::Changed,
                    ),

[40.6540]

[44.8386]

                let (selection, task) = changed_file_selection(
                    repo_state,

Insertion in inflorescence/src/cursor.rs at line 394 [2.26]

[44.8418]

                    ix,
                    files,
                    files_diffs,
                    VertDir::Down,

Replacement in inflorescence/src/cursor.rs at line 399 [2.26]
B:BD[44.8437] → [44.8437:8471]
```
                (selection, task)
```
[44.8437]
[44.8471]
```
                (Some(selection), task)
```

Replacement in inflorescence/src/cursor.rs at line 402 [2.26]

B:BD[44.8573] → [44.8573:8787]

                let selection = log_selection(repo_state, ix);
                let task = iced_nav_scrollable::scroll_down_to_section(
                    status_section_ix(repo_state, ix, StatusSectionKind::Log),

[44.8573]

[44.8787]

                let (selection, task) = log_selection(

Insertion in inflorescence/src/cursor.rs at line 404 [2.26]

[44.8819]

                    logs,
                    repo_state,
                    ix,
                    VertDir::Down,

Replacement in inflorescence/src/cursor.rs at line 419 [2.26]
B:BD[35.30877] → [35.30877:30894]
```
fn select_up<M>(
```
[35.30877]
[35.30894]
```
fn select_up(
```
Deletion in inflorescence/src/cursor.rs at line 422 [2.26]
B:BD[35.30946] → [44.8894:8928]
```
    repo: Option<&mut app::Repo>,
```
Insertion in inflorescence/src/cursor.rs at line 424 [2.26]
[36.6526]
[36.6526]
```
    repo: Option<&mut app::Repo>,
```
Replacement in inflorescence/src/cursor.rs at line 426 [2.26]
∅:D[36.6555] → [35.31049:31064]
B:BD[35.31049] → [35.31049:31064]
```
) -> Task<M> {
```
[36.6555]
[44.8929]
```
) -> Task<crate::Msg> {
```

Replacement in inflorescence/src/cursor.rs at line 448 [2.26]

B:BD[40.7594] → [40.7594:7772]

                    if let Some(nav) = files_diffs
                        .get_mut(&id_hash)
                        .and_then(|state| state.nav.as_mut())
                    {

[40.7594]

[40.7772]

                    if let Some(nav) = files_diffs.diffs_nav.as_mut().and_then(
                        |(nav_id_hash, nav)| {
                            (*nav_id_hash == id_hash).then_some(nav)
                        },
                    ) {

Replacement in inflorescence/src/cursor.rs at line 462 [2.26]

B:BD[44.9179] → [44.9179:9449]

                    let task = iced_nav_scrollable::scroll_down_to_section(
                        status_section_ix(
                            repo_state,
                            ix,
                            StatusSectionKind::Log,
                        ),

[44.9179]

[44.9449]

                    log_selection(

Replacement in inflorescence/src/cursor.rs at line 464 [2.26]

B:BD[44.9485] → [44.9485:9566]

                    );
                    (log_selection(repo_state, ix), task)

[44.9485]

[44.9566]

                        logs,
                        repo_state,
                        ix,
                        VertDir::Down,
                    )

Replacement in inflorescence/src/cursor.rs at line 471 [2.26]

B:BD[44.9696] → [44.9696:10077]

                    let selection =
                        changed_file_selection(repo_state, ix, files);
                    let task = iced_nav_scrollable::scroll_down_to_section(
                        status_section_ix(
                            repo_state,
                            ix,
                            StatusSectionKind::Changed,
                        ),

[44.9696]

[44.10077]

                    changed_file_selection(
                        repo_state,

Replacement in inflorescence/src/cursor.rs at line 474 [2.26]

B:BD[44.10113] → [44.10113:10174]

                    );
                    (selection, task)

[44.10113]

[35.32731]

                        ix,
                        files,
                        files_diffs,
                        VertDir::Down,
                    )

Replacement in inflorescence/src/cursor.rs at line 481 [2.26]

B:BD[44.10242] → [44.10242:10627]

                    let selection =
                        untracked_file_selection(repo_state, ix, files);
                    let task = iced_nav_scrollable::scroll_down_to_section(
                        status_section_ix(
                            repo_state,
                            ix,
                            StatusSectionKind::Untracked,
                        ),

[44.10242]

[44.10627]

                    untracked_file_selection(
                        repo_state,

Replacement in inflorescence/src/cursor.rs at line 484 [2.26]

B:BD[44.10663] → [44.10663:10724]

                    );
                    (selection, task)

[44.10663]

[40.8405]

                        ix,
                        files,
                        files_diffs,
                        VertDir::Down,
                    )

Replacement in inflorescence/src/cursor.rs at line 492 [2.26]

B:BD[40.8477] → [44.10725:11056]

                let selection = untracked_file_selection(repo_state, ix, files);
                let task = iced_nav_scrollable::scroll_up_to_section(
                    status_section_ix(
                        repo_state,
                        ix,
                        StatusSectionKind::Untracked,
                    ),

[40.8477]

[44.11056]

                untracked_file_selection(
                    repo_state,

Replacement in inflorescence/src/cursor.rs at line 495 [2.26]

B:BD[44.11088] → [44.11088:11141]

                );
                (selection, task)

[44.11088]

[40.8594]

                    ix,
                    files,
                    files_diffs,
                    VertDir::Up,
                )

Replacement in inflorescence/src/cursor.rs at line 516 [2.26]

B:BD[40.9087] → [40.9087:9265]

                    if let Some(nav) = files_diffs
                        .get_mut(&id_hash)
                        .and_then(|state| state.nav.as_mut())
                    {

[40.9087]

[40.9265]

                    if let Some(nav) = files_diffs.diffs_nav.as_mut().and_then(
                        |(nav_id_hash, nav)| {
                            (*nav_id_hash == id_hash).then_some(nav)
                        },
                    ) {

Replacement in inflorescence/src/cursor.rs at line 530 [2.26]

B:BD[44.11316] → [44.11316:11699]

                    let selection =
                        untracked_file_selection(repo_state, ix, files);
                    let task = iced_nav_scrollable::scroll_up_to_section(
                        status_section_ix(
                            repo_state,
                            ix,
                            StatusSectionKind::Untracked,
                        ),

[44.11316]

[44.11699]

                    untracked_file_selection(
                        repo_state,

Replacement in inflorescence/src/cursor.rs at line 533 [2.26]

B:BD[44.11735] → [44.11735:11796]

                    );
                    (selection, task)

[44.11735]

[44.11796]

                        ix,
                        files,
                        files_diffs,
                        VertDir::Up,
                    )

Replacement in inflorescence/src/cursor.rs at line 540 [2.26]

B:BD[44.11906] → [44.11906:12243]

                    let selection = log_selection(repo_state, ix);
                    let task = iced_nav_scrollable::scroll_down_to_section(
                        status_section_ix(
                            repo_state,
                            ix,
                            StatusSectionKind::Log,
                        ),

[44.11906]

[44.12243]

                    log_selection(

Replacement in inflorescence/src/cursor.rs at line 542 [2.26]

B:BD[44.12279] → [44.12279:12340]

                    );
                    (selection, task)

[44.12279]

[35.34478]

                        logs,
                        repo_state,
                        ix,
                        VertDir::Down,
                    )

Replacement in inflorescence/src/cursor.rs at line 549 [2.26]

B:BD[44.12406] → [44.12406:12787]

                    let selection =
                        changed_file_selection(repo_state, ix, files);
                    let task = iced_nav_scrollable::scroll_down_to_section(
                        status_section_ix(
                            repo_state,
                            ix,
                            StatusSectionKind::Changed,
                        ),

[44.12406]

[44.12787]

                    changed_file_selection(
                        repo_state,

Replacement in inflorescence/src/cursor.rs at line 552 [2.26]

B:BD[44.12823] → [44.12823:12884]

                    );
                    (selection, task)

[44.12823]

[44.12884]

                        ix,
                        files,
                        files_diffs,
                        VertDir::Down,
                    )

Replacement in inflorescence/src/cursor.rs at line 560 [2.26]

B:BD[40.9995] → [44.12903:13230]

                let selection = changed_file_selection(repo_state, ix, files);
                let task = iced_nav_scrollable::scroll_up_to_section(
                    status_section_ix(
                        repo_state,
                        ix,
                        StatusSectionKind::Changed,
                    ),

[40.9995]

[44.13230]

                changed_file_selection(
                    repo_state,

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

B:BD[44.13262] → [44.13262:13315]

                );
                (selection, task)

[44.13262]

[40.10110]

                    ix,
                    files,
                    files_diffs,
                    VertDir::Up,
                )

Replacement in inflorescence/src/cursor.rs at line 585 [2.26]

B:BD[40.10632] → [40.10632:11430]

∅:D[40.11430] → [35.36450:36487]

B:BD[35.36450] → [35.36450:36487]

B:BD[35.36487] → [40.11431:11533]

                        (
                            Selection::LogChange {
                                ix: log_ix,
                                hash,
                                message,
                                file: Some(LogChangeFileSelection {
                                    ix: file_ix,
                                    path,
                                    diff_selected,
                                }),
                            },
                            if let Some(nav) = logs
                                .diffs
                                .get_mut(&id_hash)
                                .and_then(|diff| diff.state.nav.as_mut())
                            {
                                iced_nav_scrollable::scroll_up(nav, delta)
                            } else {
                                Task::none()
                            },
                        )

[40.10632]

[40.11533]

                        let selection = Selection::LogChange {
                            ix: log_ix,
                            hash,
                            message,
                            file: Some(LogChangeFileSelection {
                                ix: file_ix,
                                path,
                                diff_selected,
                            }),
                        };
                        let task = if let Some(nav) = logs
                            .diffs_nav
                            .as_mut()
                            .and_then(|(nav_id_hash, nav)| {
                                (*nav_id_hash == id_hash).then_some(nav)
                            }) {
                            iced_nav_scrollable::scroll_up(nav, delta)
                        } else {
                            Task::none()
                        };
                        (selection, task)

Replacement in inflorescence/src/cursor.rs at line 615 [2.26]

B:BD[40.11792] → [40.11792:12216]

                        let file = log_file_selection(log_entry, file_ix);
                        (
                            Selection::LogChange {
                                ix: log_ix,
                                hash,
                                message,
                                file: Some(file),
                            },
                            Task::none(),
                        )

[40.11792]

[11.15518]

                        let (file, selection_task) =
                            log_file_selection(logs, log_entry, hash, file_ix);
                        let scroll_task = if let Some((nav_changes_hash, nav)) =
                            logs.changes_nav.as_ref()
                            && *nav_changes_hash == hash
                        {
                            iced_nav_scrollable::scroll_up_to_section(
                                file_ix, nav,
                            )
                        } else {
                            Task::none()
                        };
                        let selection = Selection::LogChange {
                            ix: log_ix,
                            hash,
                            message,
                            file: Some(file),
                        };
                        (selection, Task::batch([selection_task, scroll_task]))

Replacement in inflorescence/src/cursor.rs at line 643 [2.26]

B:BD[44.13616] → [44.13616:14240]

                            let selection =
                                changed_file_selection(repo_state, ix, files);
                            let task =
                                iced_nav_scrollable::scroll_up_to_section(
                                    status_section_ix(
                                        repo_state,
                                        ix,
                                        StatusSectionKind::Changed,
                                    ),
                                    status_nav,
                                );
                            (selection, task)

[44.13616]

[44.14240]

                            changed_file_selection(
                                repo_state,
                                status_nav,
                                ix,
                                files,
                                files_diffs,
                                VertDir::Up,
                            )

Replacement in inflorescence/src/cursor.rs at line 653 [2.26]

B:BD[44.14390] → [44.14390:15018]

                            let selection =
                                untracked_file_selection(repo_state, ix, files);
                            let task =
                                iced_nav_scrollable::scroll_up_to_section(
                                    status_section_ix(
                                        repo_state,
                                        ix,
                                        StatusSectionKind::Untracked,
                                    ),
                                    status_nav,
                                );
                            (selection, task)

[44.14390]

[40.12717]

                            untracked_file_selection(
                                repo_state,
                                status_nav,
                                ix,
                                files,
                                files_diffs,
                                VertDir::Up,
                            )

Replacement in inflorescence/src/cursor.rs at line 663 [2.26]

B:BD[44.15082] → [44.15082:15656]

                            let selection = log_selection(repo_state, ix);
                            let task =
                                iced_nav_scrollable::scroll_down_to_section(
                                    status_section_ix(
                                        repo_state,
                                        ix,
                                        StatusSectionKind::Log,
                                    ),
                                    status_nav,
                                );
                            (selection, task)

[44.15082]

[40.12859]

                            log_selection(
                                status_nav,
                                logs,
                                repo_state,
                                ix,
                                VertDir::Down,
                            )

Replacement in inflorescence/src/cursor.rs at line 673 [2.26]

B:BD[40.12959] → [44.15657:16020]

                        let selection = log_selection(repo_state, ix);
                        let task = iced_nav_scrollable::scroll_up_to_section(
                            status_section_ix(
                                repo_state,
                                ix,
                                StatusSectionKind::Log,
                            ),

[40.12959]

[44.16020]

                        log_selection(

Replacement in inflorescence/src/cursor.rs at line 675 [2.26]

B:BD[44.16060] → [44.16060:16129]

                        );
                        (selection, task)

[44.16060]

[44.16129]

                            logs,
                            repo_state,
                            ix,
                            VertDir::Up,
                        )

Replacement in inflorescence/src/cursor.rs at line 688 [2.26]

B:BD[44.16247] → [44.16247:16459]

                let selection = log_selection(repo_state, ix);
                let task = iced_nav_scrollable::scroll_up_to_section(
                    status_section_ix(repo_state, ix, StatusSectionKind::Log),

[44.16247]

[44.16459]

                let (selection, task) = log_selection(

Insertion in inflorescence/src/cursor.rs at line 690 [2.26]

[44.16491]

                    logs,
                    repo_state,
                    ix,
                    VertDir::Up,

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

B:BD[44.16672] → [44.16672:17001]

                let selection = changed_file_selection(repo_state, ix, files);
                let task = iced_nav_scrollable::scroll_up_to_section(
                    status_section_ix(
                        repo_state,
                        ix,
                        StatusSectionKind::Untracked,
                    ),

[44.16672]

[44.17001]

                let (selection, task) = changed_file_selection(
                    repo_state,

Insertion in inflorescence/src/cursor.rs at line 701 [2.26]

[44.17033]

                    ix,
                    files,
                    files_diffs,
                    VertDir::Up,

Replacement in inflorescence/src/cursor.rs at line 709 [2.26]

B:BD[44.17218] → [44.17218:17549]

                let selection = untracked_file_selection(repo_state, ix, files);
                let task = iced_nav_scrollable::scroll_up_to_section(
                    status_section_ix(
                        repo_state,
                        ix,
                        StatusSectionKind::Untracked,
                    ),

[44.17218]

[44.17549]

                let (selection, task) = untracked_file_selection(
                    repo_state,

Insertion in inflorescence/src/cursor.rs at line 712 [2.26]

[44.17581]

                    ix,
                    files,
                    files_diffs,
                    VertDir::Up,

Replacement in inflorescence/src/cursor.rs at line 741 [2.26]

∅:D[38.372] → [37.4583:4715]

B:BD[37.4583] → [37.4583:4715]

            if let Some(nav) = files_diffs
                .get_mut(&id_hash)
                .and_then(|state| state.nav.as_mut())

[38.372]

[37.4715]

            if let Some(nav) =
                files_diffs
                    .diffs_nav
                    .as_ref()
                    .and_then(|(nav_id_hash, nav)| {
                        (*nav_id_hash == id_hash).then_some(nav)
                    })

Replacement in inflorescence/src/cursor.rs at line 760 [2.26]

∅:D[38.447] → [37.5067:5199]

B:BD[37.5067] → [37.5067:5199]

            if let Some(nav) = files_diffs
                .get_mut(&id_hash)
                .and_then(|state| state.nav.as_mut())

[38.447]

[37.5199]

            if let Some(nav) =
                files_diffs
                    .diffs_nav
                    .as_ref()
                    .and_then(|(nav_id_hash, nav)| {
                        (*nav_id_hash == id_hash).then_some(nav)
                    })

Replacement in inflorescence/src/cursor.rs at line 785 [2.26]

∅:D[38.512] → [37.5708:5860]

B:BD[37.5708] → [37.5708:5860]

            if let Some(nav) = logs
                .diffs
                .get_mut(&id_hash)
                .and_then(|diff| diff.state.nav.as_mut())

[38.512]

[37.5860]

            if let Some(nav) =
                logs.diffs_nav.as_ref().and_then(|(nav_id_hash, nav)| {
                    (*nav_id_hash == id_hash).then_some(nav)
                })

Replacement in inflorescence/src/cursor.rs at line 815 [2.26]

∅:D[38.589] → [37.6597:6729]

B:BD[37.6597] → [37.6597:6729]

            if let Some(nav) = files_diffs
                .get_mut(&id_hash)
                .and_then(|state| state.nav.as_mut())

[38.589]

[37.6729]

            if let Some(nav) =
                files_diffs
                    .diffs_nav
                    .as_ref()
                    .and_then(|(nav_id_hash, nav)| {
                        (*nav_id_hash == id_hash).then_some(nav)
                    })

Replacement in inflorescence/src/cursor.rs at line 834 [2.26]

∅:D[38.664] → [37.7079:7211]

B:BD[37.7079] → [37.7079:7211]

            if let Some(nav) = files_diffs
                .get_mut(&id_hash)
                .and_then(|state| state.nav.as_mut())

[38.664]

[37.7211]

            if let Some(nav) =
                files_diffs
                    .diffs_nav
                    .as_ref()
                    .and_then(|(nav_id_hash, nav)| {
                        (*nav_id_hash == id_hash).then_some(nav)
                    })

Replacement in inflorescence/src/cursor.rs at line 859 [2.26]

∅:D[38.729] → [37.7718:7870]

B:BD[37.7718] → [37.7718:7870]

            if let Some(nav) = logs
                .diffs
                .get_mut(&id_hash)
                .and_then(|diff| diff.state.nav.as_mut())

[38.729]

[37.7870]

            if let Some(nav) =
                logs.diffs_nav.as_ref().and_then(|(nav_id_hash, nav)| {
                    (*nav_id_hash == id_hash).then_some(nav)
                })

Replacement in inflorescence/src/cursor.rs at line 876 [2.26]

B:BD[35.38748] → [44.17656:17732]

∅:D[44.17732] → [40.14017:14060]

B:BD[35.38826] → [40.14017:14060]

fn select_left<M>(state: &mut State, repo: Option<&app::Repo>) -> Task<M> {
    let Some(_repo) = repo.as_ref() else {

[35.38748]

[40.14060]

fn select_left(
    state: &mut State,
    repo: Option<&app::Repo>,
) -> Task<crate::Msg> {
    let Some(app::Repo {
        state: _repo_state,
        status_nav,
    }) = repo.as_ref()
    else {

Replacement in inflorescence/src/cursor.rs at line 887 [2.26]

B:BD[40.14096] → [40.14096:14661]

    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 {

[40.14096]

[35.39120]

    let (selection, task): (Option<Selection>, Task<crate::Msg>) =
        match state.selection.take() {
            Some(Selection::LogChange {
                ix,
                hash,
                message,
                file:
                    Some(LogChangeFileSelection {

Replacement in inflorescence/src/cursor.rs at line 897 [2.26]

B:BD[35.39187] → [40.14662:14708]

                        diff_selected: false,

[35.39187]

[35.39226]

                        diff_selected,

Replacement in inflorescence/src/cursor.rs at line 899 [2.26]

B:BD[35.39250] → [40.14709:14793]

                })
            } else {
                Some(Selection::LogChange {

[35.39250]

[40.14793]

            }) => {
                if diff_selected {
                    (
                        Some(Selection::LogChange {
                            ix,
                            hash,
                            message,
                            file: Some(LogChangeFileSelection {
                                ix: file_ix,
                                path,
                                diff_selected: false,
                            }),
                        }),
                        Task::none(),
                    )
                } else {
                    let selection = Selection::LogChange {
                        ix,
                        hash,
                        message,
                        file: None,
                    };
                    let task = iced_nav_scrollable::scroll_to_stored_offset(
                        status_nav,
                    );
                    (Some(selection), task)
                }
            }
            Some(Selection::UntrackedFile {
                ix,
                path,
                diff_selected: true,
            }) => (
                Some(Selection::UntrackedFile {

Replacement in inflorescence/src/cursor.rs at line 934 [2.26]

B:BD[40.14817] → [40.14817:14923]

∅:D[40.14923] → [35.39812:39826]

B:BD[35.39812] → [35.39812:39826]

B:BD[35.39826] → [40.14924:15594]

                    hash,
                    message,
                    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,
    };

[40.14817]

[40.15594]

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

Replacement in inflorescence/src/cursor.rs at line 957 [2.26]
∅:D[40.15627] → [35.40621:40638]
B:BD[35.40621] → [35.40621:40638]
```
    Task::none()
```
[40.15627]
[35.40638]
```
    task
```
Replacement in inflorescence/src/cursor.rs at line 960 [2.26]
B:BD[11.16097] → [35.40641:40661]
```
fn select_right<M>(
```
[11.16097]
[35.40661]
```
fn select_right(
```
Deletion in inflorescence/src/cursor.rs at line 962 [2.26]
B:BD[35.40684] → [44.17733:17763]
```
    repo: Option<&app::Repo>,
```

Replacement in inflorescence/src/cursor.rs at line 963 [2.26]

B:BD[35.40752] → [35.40752:40802]

    logs: &diff::LogFilesAndState,
) -> Task<M> {

[35.40752]

[44.17764]

    logs: &mut diff::LogFilesAndState,
    repo: Option<&app::Repo>,
) -> Task<crate::Msg> {

Replacement in inflorescence/src/cursor.rs at line 973 [2.26]

B:BD[40.15706] → [40.15706:15803]

∅:D[40.15803] → [35.40969:41448]

B:BD[35.40969] → [35.40969:41448]

B:BD[35.41448] → [39.60:155]

∅:D[39.155] → [35.41592:41693]

B:BD[35.41592] → [35.41592:41693]

B:BD[35.41693] → [39.156:244]

    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
                let task = if diff_selected
                    && let Some(nav) = files_diffs
                        .get(&id_hash)
                        .and_then(|state| state.nav.as_ref())
                {
                    iced_nav_scrollable::scroll_to_stored_offset(nav)

[40.15706]

[35.41877]

    let (selection, task): (Option<Selection>, Task<crate::Msg>) = 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
            let task = if diff_selected
                && let Some(nav) = files_diffs.diffs_nav.as_ref().and_then(
                    |(nav_id_hash, nav)| {
                        (*nav_id_hash == id_hash).then_some(nav)
                    },
                ) {
                iced_nav_scrollable::scroll_to_stored_offset(nav)
            } 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
            let task = if diff_selected
                && let Some(nav) = files_diffs.diffs_nav.as_ref().and_then(
                    |(nav_id_hash, nav)| {
                        (*nav_id_hash == id_hash).then_some(nav)
                    },
                ) {
                iced_nav_scrollable::scroll_to_stored_offset(nav)
            } else {
                Task::none()
            };
            (
                Some(Selection::ChangedFile {
                    ix,
                    path,
                    diff_selected,
                }),
                task,
            )
        }
        Some(Selection::LogChange {
            ix,
            hash,
            message,
            file: None,
        }) => {
            let log_entry = repo_state.log.get(ix).unwrap();
            let (file, task) = if let Some(path) = log_entry.file_paths.first()
            {
                let id_hash = file::log_id_parts_hash(log_entry.hash, path);
                let task = if let Some(log) = logs.diffs.get(&id_hash) {
                    // Init log diffs nav
                    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,
                    );
                    logs.diffs_nav = Some((id_hash, nav));
                    tasks.map(move |msg| crate::Msg::LogDiffNav {
                        id_hash,
                        msg: diff::Msg::DiffNav(msg),
                    })

Insertion in inflorescence/src/cursor.rs at line 1060 [2.26]

[35.41902]

                    // If the log is not loaded yet, the nav will be initialized
                    // once it's loaded (`repo::MsgOut::GotChangeDifs`)

Insertion in inflorescence/src/cursor.rs at line 1064 [2.26]
[35.41954]
[35.41954]

Replacement in inflorescence/src/cursor.rs at line 1066 [2.26]

B:BD[35.41972] → [35.41972:42121]

                    Some(Selection::UntrackedFile {
                        ix,
                        path,
                        diff_selected,

[35.41972]

[35.42121]

                    Some(LogChangeFileSelection {
                        ix: 0,
                        path: path.clone(),
                        diff_selected: false,

Replacement in inflorescence/src/cursor.rs at line 1073 [2.26]

B:BD[35.42189] → [35.42189:42678]

B:BD[35.42678] → [39.245:340]

∅:D[39.340] → [35.42822:42923]

B:BD[35.42822] → [35.42822:42923]

B:BD[35.42923] → [39.341:429]

∅:D[39.429] → [35.43086:43259]

B:BD[11.18858] → [35.43086:43259]

            }
            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
                let task = if diff_selected
                    && 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()
                };
                (
                    Some(Selection::ChangedFile {
                        ix,

[35.42189]

[35.43259]

            } else {
                (None, Task::none())
            };
            (
                Some(Selection::LogChange {
                    ix,
                    hash,
                    message,
                    file,
                }),
                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
            let task = if diff_selected
                && let Some(nav) =
                    logs.diffs_nav.as_ref().and_then(|(nav_id_hash, nav)| {
                        (*nav_id_hash == id_hash).then_some(nav)
                    }) {
                iced_nav_scrollable::scroll_to_stored_offset(nav)
            } else {
                Task::none()
            };
            (
                Some(Selection::LogChange {
                    ix,
                    hash,
                    message,
                    file: Some(LogChangeFileSelection {
                        ix: file_ix,

Replacement in inflorescence/src/cursor.rs at line 1120 [2.26]

B:BD[35.43352] → [35.43352:44060]

B:BD[35.44060] → [39.430:518]

∅:D[39.518] → [35.44197:44333]

B:BD[35.44197] → [35.44197:44333]

B:BD[35.44333] → [39.519:607]

∅:D[39.607] → [35.44496:44554]

B:BD[11.20251] → [35.44496:44554]

∅:D[35.44554] → [11.20251:20270]

B:BD[11.20251] → [11.20251:20270]

B:BD[11.20270] → [35.44555:44986]

∅:D[35.44986] → [11.20387:20401]

B:BD[11.20387] → [11.20387:20401]

B:BD[11.20401] → [35.44987:45142]

B:BD[35.45142] → [44.17874:17939]

∅:D[44.17939] → [35.45201:45536]

B:BD[35.45201] → [35.45201:45536]

∅:D[35.45536] → [25.765:839]

B:BD[25.765] → [25.765:839]

B:BD[25.839] → [35.45537:45637]

∅:D[35.45637] → [25.1321:1344]

B:BD[25.1321] → [25.1321:1344]

B:BD[25.1344] → [35.45638:45970]

                    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
                let task = if diff_selected
                    && 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()
                };
                (
                    Some(Selection::LogChange {
                        ix,
                        hash,
                        message,
                        file: Some(LogChangeFileSelection {
                            ix: file_ix,
                            path,
                            diff_selected,
                        }),
                    }),
                    task,
                )
            }
            Some(Selection::LogChange {
                ix,
                hash,
                message,
                file: None,
            }) => {
                let log_entry = repo_state.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,
                            }),
                            Task::none(),
                        )
                    } else {
                        (None, Task::none())
                    };
                (
                    Some(Selection::LogChange {
                        ix,
                        hash,
                        message,
                        file,
                    }),
                    task,
                )
            }
            selection => (selection, Task::none()),
        };

[35.43352]

[40.15804]

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

Replacement in inflorescence/src/cursor.rs at line 1134 [2.26]
B:BD[36.7242] → [36.7242:7286]
```
    log_diffs: &mut diff::LogFilesAndState,
```
[36.7242]
[36.7286]
```
    logs: &mut diff::LogFilesAndState,
```

Replacement in inflorescence/src/cursor.rs at line 1148 [2.26]

∅:D[38.804] → [36.7761:7939]

B:BD[36.7761] → [36.7761:7939]

                    if let Some(nav) = files_diffs
                        .get_mut(&id_hash)
                        .and_then(|state| state.nav.as_mut())
                    {

[38.804]

[36.7939]

                    if let Some(nav) = files_diffs.diffs_nav.as_mut().and_then(
                        |(nav_id_hash, nav)| {
                            (*nav_id_hash == id_hash).then_some(nav)
                        },
                    ) {

Replacement in inflorescence/src/cursor.rs at line 1163 [2.26]

∅:D[38.877] → [36.8297:8475]

B:BD[36.8297] → [36.8297:8475]

                    if let Some(nav) = files_diffs
                        .get_mut(&id_hash)
                        .and_then(|state| state.nav.as_mut())
                    {

[38.877]

[36.8475]

                    if let Some(nav) = files_diffs.diffs_nav.as_mut().and_then(
                        |(nav_id_hash, nav)| {
                            (*nav_id_hash == id_hash).then_some(nav)
                        },
                    ) {

Replacement in inflorescence/src/cursor.rs at line 1183 [2.26]

B:BD[36.9013] → [36.9013:9224]

                    if let Some(nav) = log_diffs
                        .diffs
                        .get_mut(&id_hash)
                        .and_then(|diff| diff.state.nav.as_mut())
                    {

[36.9013]

[36.9224]

                    if let Some(nav) = logs.diffs_nav.as_mut().and_then(
                        |(nav_id_hash, nav)| {
                            (*nav_id_hash == id_hash).then_some(nav)
                        },
                    ) {

Replacement in inflorescence/src/cursor.rs at line 1229 [2.26]

B:BD[39.655] → [39.655:702]

∅:D[39.702] → [35.46979:47072]

B:BD[35.46979] → [35.46979:47072]

B:BD[35.47072] → [39.703:717]

                && let Some(nav) = files_diffs
                    .get(&id_hash)
                    .and_then(|state| state.nav.as_ref())
            {

[39.655]

[39.717]

                && let Some(nav) = files_diffs.diffs_nav.as_ref().and_then(
                    |(nav_id_hash, nav)| {
                        (*nav_id_hash == id_hash).then_some(nav)
                    },
                ) {

Replacement in inflorescence/src/cursor.rs at line 1263 [2.26]

B:BD[39.947] → [39.947:994]

∅:D[39.994] → [35.48340:48433]

B:BD[35.48340] → [35.48340:48433]

B:BD[35.48433] → [39.995:1009]

                && let Some(nav) = files_diffs
                    .get(&id_hash)
                    .and_then(|state| state.nav.as_ref())
            {

[39.947]

[39.1009]

                && let Some(nav) = files_diffs.diffs_nav.as_ref().and_then(
                    |(nav_id_hash, nav)| {
                        (*nav_id_hash == id_hash).then_some(nav)
                    },
                ) {

Replacement in inflorescence/src/cursor.rs at line 1304 [2.26]

B:BD[39.1124] → [39.1124:1172]

∅:D[39.1172] → [35.49833:49981]

B:BD[35.49833] → [35.49833:49981]

B:BD[35.49981] → [39.1173:1195]

                        && let Some(nav) = logs
                            .diffs
                            .get(&id_hash)
                            .and_then(|diff| diff.state.nav.as_ref())
                    {

[39.1124]

[39.1195]

                        && let Some(nav) = logs.diffs_nav.as_ref().and_then(
                            |(nav_id_hash, nav)| {
                                (*nav_id_hash == id_hash).then_some(nav)
                            },
                        ) {

Insertion in inflorescence/src/cursor.rs at line 1355 [2.26]

[44.18659]

}
#[derive(Debug, Clone, Copy)]
pub enum VertDir {
    Up,
    Down,
}
pub fn untracked_file_selection(
    repo: &repo::State,
    status_nav: &NavScrollable,
    ix: usize,
    files: &mut file::State,
    files_diffs: &mut diff::FilesState,
    dir: VertDir,
) -> (Selection, Task<crate::Msg>) {
    let path = repo.untracked_files.iter().nth(ix).unwrap();
    let id_hash = file::id_parts_hash(path, file::Kind::Untracked);
    let nav_task = match file::try_get_src_file(files, id_hash) {
        Some(file_diff) => {
            // If the diff is already loaded init nav for it
            let contents_count = diff::contents_count(file_diff);
            let unchanged_sections = diff::unchanged_sections(file_diff);
            let (nav, nav_task) =
                iced_nav_scrollable::init(contents_count, unchanged_sections);
            files_diffs.diffs_nav = Some((id_hash, nav));
            nav_task.map(move |msg| {
                crate::Msg::View(app::Msg::FileDiff {
                    id_hash,
                    msg: diff::Msg::DiffNav(msg),
                })
            })
        }
        None => {
            // Nav will be initialize once the diff is loaded
            // (`crate::Msg::File`)
            let id = file::Id {
                path: path.clone(),
                file_kind: file::Kind::Untracked,
            };
            file::load_src_file_if_not_cached(files, id);
            Task::none()
        }
    };
    let scroll_task = match dir {
        VertDir::Up => iced_nav_scrollable::scroll_up_to_section(
            status_section_ix(repo, ix, StatusSectionKind::Untracked),
            status_nav,
        ),
        VertDir::Down => iced_nav_scrollable::scroll_down_to_section(
            status_section_ix(repo, ix, StatusSectionKind::Untracked),
            status_nav,
        ),
    };
    let selection = Selection::UntrackedFile {
        ix,
        path: path.clone(),
        diff_selected: false,
    };
    (selection, Task::batch([nav_task, scroll_task]))
}
pub fn changed_file_selection(
    repo: &repo::State,
    status_nav: &NavScrollable,
    ix: usize,
    files: &mut file::State,
    files_diffs: &mut diff::FilesState,
    dir: VertDir,
) -> (Selection, Task<crate::Msg>) {
    let (path, diffs) = repo.changed_files.iter().nth(ix).unwrap();
    let id_hash = file::id_parts_hash(path, file::Kind::Changed);
    let nav_task = match file::try_get_src_file(files, id_hash) {
        Some(file_diff) => {
            // If the diff is already loaded init nav for it
            let contents_count = diff::contents_count(file_diff);
            let unchanged_sections = diff::unchanged_sections(file_diff);
            let (nav, nav_task) =
                iced_nav_scrollable::init(contents_count, unchanged_sections);
            files_diffs.diffs_nav = Some((id_hash, nav));
            nav_task.map(move |msg| {
                crate::Msg::View(app::Msg::FileDiff {
                    id_hash,
                    msg: diff::Msg::DiffNav(msg),
                })
            })
        }
        None => {
            // Nav will be initialize once the diff is loaded
            // (`crate::Msg::File`)
            let id = file::Id {
                path: path.clone(),
                file_kind: file::Kind::Changed,
            };
            if diff::any_diff_has_contents(diffs) {
                file::load_src_file_if_not_cached(files, id);
            }
            Task::none()
        }
    };
    let scroll_task = match dir {
        VertDir::Up => iced_nav_scrollable::scroll_up_to_section(
            status_section_ix(repo, ix, StatusSectionKind::Changed),
            status_nav,
        ),
        VertDir::Down => iced_nav_scrollable::scroll_down_to_section(
            status_section_ix(repo, ix, StatusSectionKind::Changed),
            status_nav,
        ),
    };
    let selection = Selection::ChangedFile {
        ix,
        path: path.clone(),
        diff_selected: false,
    };
    (selection, Task::batch([nav_task, scroll_task]))

Insertion in inflorescence/src/cursor.rs at line 1480 [2.26]

[44.18661]


fn log_selection(
    status_nav: &NavScrollable,
    logs: &mut diff::LogFilesAndState,
    repo: &repo::State,
    ix: usize,
    dir: VertDir,
) -> (Selection, Task<crate::Msg>) {
    let entry = repo.log.get(ix).unwrap();
    let hash = entry.hash;
    let nav_task = match logs.change_file_counts.get(&hash) {
        Some(contents_count) => {
            // Init log changes nav
            let (nav, tasks) =
                iced_nav_scrollable::init(*contents_count, HashSet::new());
            logs.changes_nav = Some((hash, nav));
            tasks.map(move |msg| {
                crate::Msg::View(app::Msg::LogNav { hash, msg })
            })
        }
        None => {
            // If the log is not loaded yet, the nav will be initialized once
            // it's loaded (`repo::MsgOut::GotChangeDifs`)
            Task::done(crate::Msg::View(app::Msg::ToRepo(
                repo::MsgIn::GetChangeDiffs { hash },
            )))
        }
    };
    let scroll_task = match dir {
        VertDir::Up => iced_nav_scrollable::scroll_up_to_section(
            status_section_ix(repo, ix, StatusSectionKind::Log),
            status_nav,
        ),
        VertDir::Down => iced_nav_scrollable::scroll_down_to_section(
            status_section_ix(repo, ix, StatusSectionKind::Log),
            status_nav,
        ),
    };
    let selection = Selection::LogChange {
        ix,
        hash,
        message: entry.message.clone(),
        file: None,
    };
    (selection, Task::batch([nav_task, scroll_task]))
}
fn log_file_selection(
    logs: &mut diff::LogFilesAndState,
    log_entry: &repo::LogEntry,
    hash: repo::ChangeHash,
    file_ix: usize,
) -> (LogChangeFileSelection, Task<crate::Msg>) {
    let path = log_entry.file_paths.get(file_ix).unwrap().clone();
    let id_hash = file::log_id_parts_hash(hash, &path);
    let nav_task = match (logs.diffs.get(&id_hash), logs.diffs_nav.as_ref()) {
        (Some(diff), Some((nav_id_hash, _nav))) if *nav_id_hash != id_hash => {
            let contents_count = diff::contents_count(&diff.file);
            // Init log change diff nav
            let (nav, tasks) =
                iced_nav_scrollable::init(contents_count, HashSet::new());
            logs.diffs_nav = Some((id_hash, nav));
            tasks.map(move |msg| {
                crate::Msg::View(app::Msg::LogChangeFileDiff {
                    id_hash,
                    msg: diff::Msg::DiffNav(msg),
                })
            })
        }
        _ => {
            // If the log is not loaded yet, the nav will be initialized once
            // it's loaded (`repo::MsgOut::GotChangeDifs`)
            Task::none()
        }
    };
    (
        LogChangeFileSelection {
            ix: file_ix,
            path,
            diff_selected: false,
        },
        nav_task,
    )
}

Insertion in iced_utils/src/task/wrappers.rs at line 9 [49.3643]

[28.9465]


/// Produces a [`Task`] that scrolls the [`scrollable::Scrollable`] with the
/// given [`scrollable::Id`] by the provided [`scrollable::AbsoluteOffset`].
pub fn scroll_by<T>(
    id: impl Into<scrollable::Id>,
    offset: scrollable::AbsoluteOffset,
) -> Task<T> {
    #[cfg(not(any(test, feature = "testing")))]
    let task = scrollable::scroll_by(id, offset);

Insertion in iced_utils/src/task/wrappers.rs at line 19 [49.3643]

[28.9466]

    #[cfg(any(test, feature = "testing"))]
    let task = {
        let _ = (id, offset);
        Task::none()
    };
    task
}

Replacement in iced_nav_scrollable/src/lib.rs at line 32 [26.95]
B:BD[27.98] → [27.98:119]
```
    pub offset: f32,
```
[27.98]
[27.160]
```
    pub stored_offset: Option<f32>,
```
Replacement in iced_nav_scrollable/src/lib.rs at line 123 [26.95]
B:BD[27.1268] → [27.1268:1293]
```
            offset: 0.0,
```
[27.1268]
[27.1343]
```
            stored_offset: None,
```

Replacement in iced_nav_scrollable/src/lib.rs at line 219 [26.95]

B:BD[26.2312] → [27.3840:3895]

            nav.offset = viewport.absolute_offset().y;

[26.2312]

[26.2847]

            nav.stored_offset = Some(viewport.absolute_offset().y);

Deletion in iced_nav_scrollable/src/lib.rs at line 225 [26.95]

B:BD[26.3439] → [26.3439:3546]

/// NOTE: call `into_iter()` on the children parameter to make it type-check
/// with `ExactSizeIterator`.

Replacement in iced_nav_scrollable/src/lib.rs at line 250 [26.95]

B:BD[35.51031] → [35.51031:51177]

    task::scroll_to(
        nav.id.clone(),
        scrollable::AbsoluteOffset {
            x: 0.0,
            y: nav.offset,
        },
    )

[35.51031]

[36.10853]

    if let Some(y) = nav.stored_offset {
        task::scroll_to(
            nav.id.clone(),
            scrollable::AbsoluteOffset { x: 0.0, y },
        )
    } else {
        Task::none()
    }

Replacement in iced_nav_scrollable/src/lib.rs at line 274 [26.95]

B:BD[35.51678] → [35.51678:51723]

                    nav.offset + nav.height,

[35.51678]

[35.51723]

                    nav.stored_offset.unwrap_or_default() + nav.height,

Replacement in iced_nav_scrollable/src/lib.rs at line 285 [26.95]

B:BD[36.11212] → [36.11212:11280]

                    Some((nav.offset + offset_delta, Delay::Start))

[36.11212]

[37.8229]

                    Some((
                        nav.stored_offset.unwrap_or_default() + offset_delta,
                        Delay::Start,
                    ))

Replacement in iced_nav_scrollable/src/lib.rs at line 352 [26.95]

B:BD[35.52953] → [35.52953:53022]

                let top_frame = nav.offset + VISIBLE_CONTEXT_HEIGHT;

[35.52953]

[35.53022]

                let top_frame = nav.stored_offset.unwrap_or_default()
                    + VISIBLE_CONTEXT_HEIGHT;

Replacement in iced_nav_scrollable/src/lib.rs at line 363 [26.95]

B:BD[36.12827] → [36.12827:12893]

                        saturating_sub(nav.offset, offset_delta),

[36.12827]

[36.12893]

                        saturating_sub(
                            nav.stored_offset.unwrap_or_default(),
                            offset_delta,
                        ),

Replacement in iced_nav_scrollable/src/lib.rs at line 434 [26.95]
B:BD[37.8431] → [37.8431:8460]
```
    nav: &mut NavScrollable,
```
[37.8431]
[37.8460]
```
    nav: &NavScrollable,
```

Replacement in iced_nav_scrollable/src/lib.rs at line 442 [26.95]

B:BD[37.8649] → [37.8649:8766]

    let y = nav.offset + offset_delta;
    task::scroll_to(nav.id.clone(), scrollable::AbsoluteOffset { x: 0.0, y })

[37.8649]

[37.8766]

    task::scroll_by(
        nav.id.clone(),
        scrollable::AbsoluteOffset {
            x: 0.0,
            y: offset_delta,
        },
    )

Replacement in iced_nav_scrollable/src/lib.rs at line 453 [26.95]
B:BD[37.8855] → [37.8855:8884]
```
    nav: &mut NavScrollable,
```
[37.8855]
[37.8884]
```
    nav: &NavScrollable,
```

Replacement in iced_nav_scrollable/src/lib.rs at line 461 [26.95]

B:BD[37.9073] → [37.9073:9205]

    let y = saturating_sub(nav.offset, offset_delta);
    task::scroll_to(nav.id.clone(), scrollable::AbsoluteOffset { x: 0.0, y })

[37.9073]

[44.18673]

    task::scroll_by(
        nav.id.clone(),
        scrollable::AbsoluteOffset {
            x: 0.0,
            y: -offset_delta,
        },
    )

Replacement in iced_nav_scrollable/src/lib.rs at line 472 [26.95]
B:BD[44.18733] → [44.18733:18762]
```
    nav: &mut NavScrollable,
```
[44.18733]
[44.18762]
```
    nav: &NavScrollable,
```

Replacement in iced_nav_scrollable/src/lib.rs at line 484 [26.95]

B:BD[44.19110] → [44.19110:19275]

        let bottom_frame =
            saturating_sub(nav.offset + nav.height, VISIBLE_CONTEXT_HEIGHT);
        let top_frame = nav.offset + VISIBLE_CONTEXT_HEIGHT;

[44.19110]

[44.19275]

        let bottom_frame = saturating_sub(
            nav.stored_offset.unwrap_or_default() + nav.height,
            VISIBLE_CONTEXT_HEIGHT,
        );
        let top_frame =
            nav.stored_offset.unwrap_or_default() + VISIBLE_CONTEXT_HEIGHT;

Replacement in iced_nav_scrollable/src/lib.rs at line 511 [26.95]
B:BD[44.19815] → [44.19815:19844]
```
    nav: &mut NavScrollable,
```
[44.19815]
[44.19844]
```
    nav: &NavScrollable,
```

Replacement in iced_nav_scrollable/src/lib.rs at line 523 [26.95]

B:BD[44.20184] → [44.20184:20349]

        let bottom_frame =
            saturating_sub(nav.offset + nav.height, VISIBLE_CONTEXT_HEIGHT);
        let top_frame = nav.offset + VISIBLE_CONTEXT_HEIGHT;

[44.20184]

[44.20349]

        let bottom_frame = saturating_sub(
            nav.stored_offset.unwrap_or_default() + nav.height,
            VISIBLE_CONTEXT_HEIGHT,
        );
        let top_frame =
            nav.stored_offset.unwrap_or_default() + VISIBLE_CONTEXT_HEIGHT;

Replacement in iced_nav_scrollable/src/lib.rs at line 599 [26.95]

∅:D[34.3710] → [33.1017:1151]

B:BD[33.1017] → [33.1017:1151]

    if let Some(y) = nav
        .skip_sections
        .contains(&0)
        .then(|| nav.section_offsets.get(1))
        .flatten()

[34.3710]

[33.1151]

    if let Some(y) =
        nav.section_offsets
            .iter()
            .enumerate()
            .find_map(|(ix, offset)| {
                (!nav.skip_sections.contains(&ix)).then_some(*offset)
            })

Replacement in iced_nav_scrollable/src/lib.rs at line 607 [26.95]

B:BD[33.1157] → [35.54023:54083]

        let y = saturating_sub(*y, VISIBLE_CONTEXT_HEIGHT);

[33.1157]

[33.1291]

        let y = saturating_sub(y, VISIBLE_CONTEXT_HEIGHT);

nav for log changes and refactors

Dependencies

In channels

Change contents

Replacement in inflorescence_view/src/diff.rs at line 5 [13.417]

Deletion in inflorescence_view/src/diff.rs at line 16 [13.417]

Insertion in inflorescence_view/src/diff.rs at line 23 [13.417]

Replacement in inflorescence_view/src/diff.rs at line 29 [13.417]

Replacement in inflorescence_view/src/diff.rs at line 32 [13.417]

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

Replacement in inflorescence_view/src/diff.rs at line 92 [13.417]

Replacement in inflorescence_view/src/diff.rs at line 102 [13.417]

Replacement in inflorescence_view/src/diff.rs at line 118 [13.417]

Replacement in inflorescence_view/src/diff.rs at line 138 [13.417]

Replacement in inflorescence_view/src/cursor.rs at line 1 [18.3124]

Replacement in inflorescence_view/src/cursor.rs at line 52 [18.3124]

Replacement in inflorescence_view/src/cursor.rs at line 77 [18.3124]

Replacement in inflorescence_view/src/app.rs at line 11 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 31 [13.12409]

Insertion in inflorescence_view/src/app.rs at line 40 [13.12409]

Insertion in inflorescence_view/src/app.rs at line 63 [13.12409]

Insertion in inflorescence_view/src/app.rs at line 83 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 91 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 94 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 96 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 113 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 132 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 142 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 153 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 157 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 162 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 165 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 181 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 184 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 201 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 209 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 225 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 241 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 244 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 261 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 263 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 279 [13.12409]

Insertion in inflorescence_view/src/app.rs at line 283 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 286 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 290 [13.12409]

Insertion in inflorescence_view/src/app.rs at line 299 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 314 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 316 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 329 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 332 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 334 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 347 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 355 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 357 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 359 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 361 [13.12409]

Insertion in inflorescence_view/src/app.rs at line 363 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 376 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 382 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 410 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 415 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 423 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 462 [13.12409]

Replacement in inflorescence_view/src/app.rs at line 492 [13.12409]

Deletion in inflorescence_view/src/app/test.rs at line 6 [14.4223]

Replacement in inflorescence_view/src/app/test.rs at line 40 [14.4223]

Replacement in inflorescence_view/src/app/test.rs at line 68 [14.4223]

Replacement in inflorescence_view/src/app/test.rs at line 91 [14.4223]

Replacement in inflorescence_view/src/app/test.rs at line 109 [14.4223]

Replacement in inflorescence_view/src/app/test.rs at line 123 [14.4223]

Replacement in inflorescence_view/src/app/test.rs at line 154 [14.4223]

Replacement in inflorescence/src/test.rs at line 721 [46.2521]

Deletion in inflorescence/src/main.rs at line 139 [47.2763]