tzemanovic/inflorescence - Change 23SFYK4Q5NKBPJG53PQNPWQH6UOUU2YKJEL7RLXYBRLJOJYV7AWQC

big view refactor into a new crate

Created by Tomáš Zemanovič on May 14, 2025

23SFYK4Q5NKBPJG53PQNPWQH6UOUU2YKJEL7RLXYBRLJOJYV7AWQC

Dependencies

In channels

main

Change contents

File addition: util.rs (----------)

[52.85]

use iced::Element;
/// A short-named wrapper into `Element`
#[inline(always)]
pub fn el<'a, E, M>(e: E) -> Element<'a, M>
where
    E: Into<Element<'a, M>>,
{
    Into::<Element<M>>::into(e)
}

Replacement in inflorescence_view/src/lib.rs at line 1 [52.102]
B:BD[52.102] → [52.103:122]
```
use iced::Element;
```
[52.102]
[52.122]
```
pub mod app;
pub mod diff;
mod util;
```

Replacement in inflorescence_view/src/lib.rs at line 5 [52.102]

B:BD[52.123] → [52.123:295]

/// A short-named wrapper into `Element`
#[inline(always)]
pub fn el<'a, E, M>(e: E) -> Element<'a, M>
where
    E: Into<Element<'a, M>>,
{
    Into::<Element<M>>::into(e)

[52.123]

[52.295]

use iced::{window, Theme};
pub use util::el;
pub fn theme<S>(_state: &S, _window_id: window::Id) -> Theme {
    Theme::TokyoNight

File addition: diff.rs (----------)

[52.85]

use std::cmp;
use iced::widget::{column, container, row, text};
use iced::{alignment, Background, Color, Element, Font, Length};
use crate::el;
// TODO: maybe use theme
const DELETED_BG_COLOR: Color = Color::from_rgba8(190, 37, 40, 0.15);
const ADDED_BG_COLOR: Color = Color::from_rgba8(47, 148, 11, 0.15);
#[derive(Debug, Default)]
pub struct State {
    pub selected_sections: Vec<usize>,
    pub expanded_unchanged_sections: Vec<usize>,
    pub collapsed_changed_sections: Vec<usize>,
}
#[derive(Debug, Clone)]
pub enum Msg {}
/// [`File`] is not part of [`State`] so it can be stored separately (i.e. in a
/// cache, where it's immutable once set, unlike [`State`] which can change with
/// [`Action`]s)
#[derive(Debug)]
pub enum File {
    Decoded(DecodedFile),
    Undecodable(UndecodableFile),
}
#[derive(Debug)]
pub struct DecodedFile {
    pub combined: Combined,
    pub diffs_without_contents: Vec<DiffWithoutContents>,
}
#[derive(Debug)]
pub struct UndecodableFile {
    pub diffs_with_contents: Vec<DiffWithContents>,
    pub diffs_without_contents: Vec<DiffWithoutContents>,
}
/// A file combined with its diffs into sections
#[derive(Debug)]
pub struct Combined {
    pub sections: Vec<Section>,
    pub max_line_num: usize,
}
#[derive(Debug)]
pub enum DiffWithContents {
    Add,
    Edit {
        line: usize,
        deleted: bool,
        contents: String,
    },
    Replacement {
        line: usize,
        /// Deleted line
        change_contents: String,
        /// Added lines
        replacement_contents: String,
    },
    Del,
    Undel,
}
#[derive(Debug)]
pub enum DiffWithoutContents {
    // _________________________________________________________________________
    // Cases that never have contents:
    Move,
    SolveNameConflict,
    UnsolveNameConflict,
    SolveOrderConflict,
    UnsolveOrderConflict,
    ResurrectZombines,
    AddRoot,
    DelRoot,
    // _________________________________________________________________________
    // Cases that normally have contents, but in these cases the contents are
    // not decodable:
    Edit {
        line: usize,
        deleted: bool,
        contents: UndecodableContents,
    },
    Replacement {
        line: usize,
        /// Deleted line
        change_contents: UndecodableContents,
        /// Added lines
        replacement_contents: UndecodableContents,
    },
}
#[derive(Debug)]
pub enum UndecodableContents {
    /// Short byte sequence of unknown encoding encoded with base64 for
    /// display. Must be shorter than [`crate::repo::MAX_LEN_BASE64_DISPLAY`]
    ShortBase64(String),
    UnknownEncoding,
}
#[derive(Debug)]
pub enum Section {
    Unchanged(Lines),
    /// `deleted` and `added` are together because for
    /// `ChangedFileDiffWithContents::Replacement` they begin on the same line
    /// number
    Changed {
        deleted: Lines,
        added: Lines,
    },
}
/// INVARIANT: There must be no new-lines in any of the strings, the source
/// string must be split on those.
pub type Lines = Vec<String>;
pub fn view<'a>(state: Option<&'a State>, file: &'a File) -> Element<'a, Msg> {
    match file {
        File::Decoded(decoded_file) => view_decoded(state, decoded_file),
        File::Undecodable(undecodable_file) => {
            view_undecodable(state, undecodable_file)
        }
    }
}
pub fn contents_to_lines(contents: &str) -> Lines {
    contents.split('\n').map(str::to_string).collect()
}
fn view_decoded<'a>(
    _state: Option<&'a State>,
    file: &'a DecodedFile,
) -> Element<'a, Msg> {
    let DecodedFile {
        combined,
        diffs_without_contents,
    } = file;
    let line_num_digits = combined.max_line_num.to_string().len();
    // TODO use state to display selection, and control section expansion
    let mut current_line = 1;
    let sections_view = combined.sections.iter().map(|section| match section {
        Section::Unchanged(lines) => {
            let res = lines.iter().enumerate().map(move |(ix, line)| {
                line_view(
                    LineKind::Unchanged,
                    current_line + ix,
                    line_num_digits,
                    line,
                )
            });
            current_line += lines.len();
            el(column(res))
        }
        Section::Changed { deleted, added } => {
            let res = deleted
                .iter()
                .enumerate()
                .map(move |(ix, line)| {
                    line_view(
                        LineKind::Deleted,
                        current_line + ix,
                        line_num_digits,
                        line,
                    )
                })
                .chain(added.iter().enumerate().map(move |(ix, line)| {
                    line_view(
                        LineKind::Added,
                        current_line + ix,
                        line_num_digits,
                        line,
                    )
                }));
            current_line += added.len();
            el(column(res))
        }
    });
    if diffs_without_contents.is_empty() {
        el(column(sections_view))
    } else {
        let diffs_without_contents_view = diffs_without_contents
            .iter()
            .map(view_diff_without_contents);
        el(column([
            el(column(diffs_without_contents_view)),
            el(column(sections_view)),
        ])
        .spacing(10))
    }
}
fn view_undecodable<'a>(
    _state: Option<&'a State>,
    file: &'a UndecodableFile,
) -> Element<'a, Msg> {
    let UndecodableFile {
        diffs_with_contents,
        diffs_without_contents,
    } = file;
    let diffs = diffs_with_contents
        .iter()
        .map(view_diff_with_contents)
        .chain(
            diffs_without_contents
                .iter()
                .map(view_diff_without_contents),
        );
    el(column(diffs).spacing(10))
}
/// View diffs without context (the file contents)
fn view_diff_with_contents(diff: &DiffWithContents) -> Element<'_, Msg> {
    match diff {
        DiffWithContents::Add => el(text("Added")),
        DiffWithContents::Edit {
            line,
            deleted,
            contents,
        } => {
            let line_num = *line;
            let lines = contents_to_lines(contents);
            let max_line_num = line_num + lines.len();
            let line_num_digits = max_line_num.to_string().len();
            let lines_view = lines.into_iter().enumerate().map(|(ix, line)| {
                line_view(
                    if *deleted {
                        LineKind::Deleted
                    } else {
                        LineKind::Added
                    },
                    line_num + ix,
                    line_num_digits,
                    line,
                )
            });
            el(column(lines_view))
        }
        DiffWithContents::Replacement {
            line,
            change_contents,
            replacement_contents,
        } => {
            let line_num = *line;
            let change_lines = contents_to_lines(change_contents);
            let replacement_lines = contents_to_lines(replacement_contents);
            let max_line_num = line_num
                + cmp::max(change_lines.len(), replacement_lines.len());
            let line_num_digits = max_line_num.to_string().len();
            let lines_view = change_lines
                .into_iter()
                .enumerate()
                .map(|(ix, line)| {
                    line_view(
                        LineKind::Deleted,
                        line_num + ix,
                        line_num_digits,
                        line,
                    )
                })
                .chain(replacement_lines.into_iter().enumerate().map(
                    |(ix, line)| {
                        line_view(
                            LineKind::Added,
                            line_num + ix,
                            line_num_digits,
                            line,
                        )
                    },
                ));
            el(column(lines_view))
        }
        DiffWithContents::Del => el(text("Deleted")),
        DiffWithContents::Undel => el(text("Revived")),
    }
}
/// View diffs without context (the file contents)
fn view_diff_without_contents(diff: &DiffWithoutContents) -> Element<'_, Msg> {
    match diff {
        DiffWithoutContents::Move => el(text("Move")),
        DiffWithoutContents::SolveNameConflict => {
            el(text("Solve name conflict"))
        }
        DiffWithoutContents::UnsolveNameConflict => {
            el(text("Unsolve name conflict"))
        }
        DiffWithoutContents::SolveOrderConflict => {
            el(text("Solve order conflict"))
        }
        DiffWithoutContents::UnsolveOrderConflict => {
            el(text("Unsolve order conflict"))
        }
        DiffWithoutContents::ResurrectZombines => el(text("Resurrect zombies")),
        DiffWithoutContents::AddRoot => el(text("Add root")),
        DiffWithoutContents::DelRoot => el(text("Delete root")),
        DiffWithoutContents::Edit {
            line,
            deleted,
            contents,
        } => {
            let line_num = *line;
            let line = undecodable_contents_to_str(contents);
            line_view(
                if *deleted {
                    LineKind::Deleted
                } else {
                    LineKind::Added
                },
                line_num,
                1,
                line,
            )
        }
        DiffWithoutContents::Replacement {
            line,
            change_contents,
            replacement_contents,
        } => {
            let line_num = *line;
            let change_line = undecodable_contents_to_str(change_contents);
            let replacement_line =
                undecodable_contents_to_str(replacement_contents);
            el(column([
                line_view(LineKind::Deleted, line_num, 1, change_line),
                line_view(LineKind::Added, line_num, 1, replacement_line),
            ]))
        }
    }
}
fn mono_text<'a>(txt: impl text::IntoFragment<'a>) -> iced::widget::Text<'a> {
    text(txt)
        .font(Font::MONOSPACE)
        .wrapping(text::Wrapping::WordOrGlyph)
        .align_y(alignment::Vertical::Top)
}
fn line_num_view<'a>(num: usize, digits: usize) -> iced::widget::Text<'a> {
    // Fill the string to the number of digits
    let txt = format!("{num:digits$} ");
    mono_text(txt)
        .font(Font::MONOSPACE)
        .style(move |theme| {
            let palette = theme.extended_palette();
            text::Style {
                color: Some(palette.background.base.text.scale_alpha(0.61)),
            }
        })
        .align_y(alignment::Vertical::Top)
}
#[derive(Debug, Clone, Copy)]
enum LineKind {
    Unchanged,
    Added,
    Deleted,
}
fn line_view<'a>(
    kind: LineKind,
    line_num: usize,
    line_num_digits: usize,
    line: impl text::IntoFragment<'a>,
) -> Element<'a, Msg> {
    let line = container(row([
        el(mono_text(match kind {
            LineKind::Unchanged => "  ",
            LineKind::Added => "+ ",
            LineKind::Deleted => "- ",
        })),
        el(line_num_view(line_num, line_num_digits)),
        el(mono_text(line).width(Length::Fill)),
    ]));
    el(match kind {
        LineKind::Unchanged => line,
        LineKind::Added => line.style(|_theme| {
            container::background(Background::from(ADDED_BG_COLOR))
        }),
        LineKind::Deleted => line.style(|_theme| {
            container::background(Background::from(DELETED_BG_COLOR))
        }),
    })
}
fn undecodable_contents_to_str(contents: &UndecodableContents) -> &str {
    match contents {
        UndecodableContents::ShortBase64(short) => short,
        UndecodableContents::UnknownEncoding => "Unknown encoding",
    }
}

File addition: app.rs (----------)

[52.85]

//! Main app view
use crate::{diff, el};
use iced::widget::{button, column, row, scrollable, text};
use iced::{font, window, Border, Color, Element, Font, Length, Theme};
use libflorescence::prelude::*;
use libflorescence::repo;
use iced::widget::text_editor;
use std::collections::HashMap;
use std::path::Path;
const SPACING: u32 = 10;
#[derive(Debug)]
pub struct State<'a> {
    pub repo_path: &'a Path,
    pub repo: Option<&'a repo::State>,
    pub cursor: &'a cursor::State,
    pub record_msg: Option<&'a RecordMsg>,
    pub diffs_state: &'a HashMap<file::Id, diff::State>,
}
#[derive(Debug, Clone)]
pub enum Msg {
    Cursor(cursor::Msg),
    ToRepo(repo::MsgIn),
    EditRecordMsg(text_editor::Action),
    DeferRecord,
    SaveRecord,
    AbandonRecord,
    FileDiffsContentsAction {
        id: file::Id,
        action: diff::Msg,
    },
    LogChangeFileDiffAction {
        hash: pijul::Hash,
        file: String,
        action: diff::Msg,
    },
}
pub mod file {
    use crate::diff;
    #[derive(Debug, Clone, Hash, PartialEq, Eq)]
    pub struct Id {
        pub path: String,
        pub file_kind: Kind,
    }
    #[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
    pub enum Kind {
        Untracked,
        Changed,
    }
    #[derive(Debug)]
    pub enum Diff {
        Loading,
        Loaded(diff::File),
    }
}
pub mod cursor {
    use crate::diff;
    use libflorescence::prelude::pijul;
    use std::collections::HashMap;
    #[derive(Debug, Clone)]
    pub enum Msg {
        Down,
        Up,
        Right,
        Left,
        Select(Select),
    }
    #[derive(Debug, Default)]
    pub struct State {
        pub selection: Option<Selection>,
    }
    #[derive(Debug)]
    pub enum Selection {
        UntrackedFile {
            ix: usize,
            path: String,
        },
        ChangedFile {
            ix: usize,
            path: String,
        },
        LogChange {
            ix: usize,
            hash: pijul::Hash,
            message: String,
            /// All the diffs in this change keyed by file path. Loaded async
            /// and set to None only while loading. The
            /// `diff::State` is also in here so that is it
            /// preserved while navigating between files.
            diffs: Option<HashMap<String, (diff::File, diff::State)>>,
            file: Option<LogChangeFileSelection>,
        },
    }
    #[derive(Debug)]
    pub struct LogChangeFileSelection {
        pub ix: usize,
        pub path: String,
    }
    #[derive(Debug, Clone)]
    pub enum Select {
        UntrackedFile {
            ix: usize,
            path: String,
        },
        ChangedFile {
            ix: usize,
            path: String,
        },
        LogChange {
            ix: usize,
            hash: pijul::Hash,
            message: String,
        },
        LogChangeFile {
            ix: usize,
            path: String,
        },
    }
}
#[derive(Debug)]
pub enum RecordMsg {
    Typing(text_editor::Content),
    Canceled { old_msg: String },
}
pub fn view<'a, F>(
    state: State<'a>,
    _window_id: window::Id,
    get_file_diff: F,
) -> Element<'a, Msg>
where
    F: Fn(&file::Id) -> Option<&'a file::Diff>,
{
    if let Some(repo) = state.repo.as_ref() {
        let repo_info = el(row([
            el(text(&repo.dir_name)),
            el(text(": ")),
            el(
                button(text(&repo.channel)), /* TODO
                                              * .on_press(Message) */
            ),
        ]));
        let untracked_files = || {
            el(column(repo.untracked_files.iter().enumerate().map(
            |(ix, path)| {
                let is_selected = matches!(state.cursor.selection.as_ref() ,
                    Some(cursor::Selection::UntrackedFile{ ix: selected_ix, .. }) if &ix == selected_ix
                );
                el(
                    button(text(path))
                        .on_press(Msg::Cursor(cursor::Msg::Select(
                            cursor::Select::UntrackedFile{ix, path: path.clone()},
                        )))
                        .style(selectable_button_style(is_selected)),
                )
            },
        )))
        };
        let changed_files = || {
            el(column(repo.changed_files.iter().enumerate().map(
            |(ix, (file_path, _diffs))| {
                let is_selected = matches!(state.cursor.selection.as_ref(),
                    Some(cursor::Selection::ChangedFile{ ix: selected_ix, .. }) if &ix == selected_ix
                );
                el(
                    button(
                text(file_path))
                        .on_press(Msg::Cursor(cursor::Msg::Select(
                            cursor::Select::ChangedFile{ix, path: file_path.clone()},
                        )))
                        .style(selectable_button_style(is_selected)),
                )
            },
        )))
        };
        let log = || {
            el(column(repo.log.iter().enumerate().map(
            |(ix, repo::LogEntry {
                 hash,
                 message,
                 file_paths: _,
             })| {
                let short_hash = display_short_hash(hash);
                let is_selected = matches!(state.cursor.selection.as_ref(),
                    Some(cursor::Selection::LogChange { ix: selected_ix, .. }) if &ix == selected_ix
                );
                el(row([
                    el(button(text(short_hash).font(Font::MONOSPACE))
                        .on_press(Msg::Cursor(cursor::Msg::Select(
                            cursor::Select::LogChange { ix, hash: *hash, message: message.clone() },
                        )))
                        .style(selectable_button_style(is_selected))),
                    el(text(message)),
                ])
                .spacing(SPACING))
            },
        )))
        };
        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([]))
        };
        let selection_details = match state.cursor.selection.as_ref() {
            Some(cursor::Selection::UntrackedFile { ix: _, path }) => {
                let id = file::Id {
                    path: path.clone(),
                    file_kind: file::Kind::Untracked,
                };
                let diffs = match get_file_diff(&id) {
                    Some(file::Diff::Loaded(file)) => {
                        let selection_state = state.diffs_state.get(&id);
                        diff::view(selection_state, file).map(move |msg| {
                            Msg::FileDiffsContentsAction {
                                id: id.clone(),
                                action: msg,
                            }
                        })
                    }
                    None | Some(file::Diff::Loading) => {
                        el(text("Loading diff..."))
                    }
                };
                el(column([
                    view_diff_header(format!(
                        "Untracked file {path} contents:"
                    )),
                    el(scrollable(diffs)),
                ])
                .spacing(SPACING))
            }
            Some(cursor::Selection::ChangedFile { path, ix: _ }) => {
                let id = file::Id {
                    path: path.clone(),
                    file_kind: file::Kind::Changed,
                };
                let diffs = match get_file_diff(&id) {
                    Some(file::Diff::Loaded(file)) => {
                        let selection_state = state.diffs_state.get(&id);
                        diff::view(selection_state, file).map(move |msg| {
                            Msg::FileDiffsContentsAction {
                                id: id.clone(),
                                action: msg,
                            }
                        })
                    }
                    None | Some(file::Diff::Loading) => {
                        el(text("Loading diff..."))
                    }
                };
                el(column([
                    view_diff_header(format!("Changed file {path} diff:")),
                    el(scrollable(diffs)),
                ])
                .spacing(SPACING))
            }
            Some(cursor::Selection::LogChange {
                ix,
                hash,
                message,
                diffs: _,
                file,
            }) => {
                let entry = state.repo.as_ref().unwrap().log.get(*ix).unwrap();
                let short_hash = display_short_hash(hash);
                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);
                    el(button(text(path)).on_press_with(move || {
                        Msg::Cursor(cursor::Msg::Select(cursor::Select::LogChangeFile { ix, path: path.clone() }))
                    }).style(selectable_button_style(is_selected)))
                });
                el(column([
                    view_diff_header(format!("{short_hash} message:")),
                    el(text(message)),
                    view_diff_header("Changed files:".to_string()),
                    el(scrollable(column(files))),
                ])
                .spacing(SPACING))
            }
            None => el(row([])),
        };
        let left_view = match state.cursor.selection.as_ref() {
            Some(cursor::Selection::LogChange {
                ix: _,
                hash,
                message: _,
                diffs,
                file: Some(cursor::LogChangeFileSelection { ix: _, path }),
            }) => el(column([
                view_diff_header(format!(
                    "{path} changes in {}:",
                    display_short_hash(hash)
                )),
                match diffs {
                    Some(diffs) => {
                        let (file, state) = diffs.get(path).unwrap();
                        diff::view(Some(state), file).map(|action| {
                            Msg::LogChangeFileDiffAction {
                                hash: *hash,
                                file: path.clone(),
                                action,
                            }
                        })
                    }
                    None => el(text("Loading diff..")),
                },
            ])
            .width(Length::FillPortion(1))
            .spacing(SPACING)),
            Some(cursor::Selection::UntrackedFile { .. })
            | Some(cursor::Selection::ChangedFile { .. })
            | Some(cursor::Selection::LogChange { .. })
            | None => el(column([
                repo_info,
                el(column([el(text("Untracked files:")), untracked_files()])),
                el(column([el(text("Changed files:")), changed_files()])),
                el(column([el(text("Recent changes:")), log()])),
            ])
            .width(Length::FillPortion(1))
            .spacing(SPACING)),
        };
        let right_view = el(column([record_msg_editor, selection_details])
            .width(Length::FillPortion(1)));
        el(row([left_view, right_view]).spacing(SPACING))
    } else {
        el(text("Loading repo..."))
    }
}
fn view_diff_header(header: String) -> Element<'static, Msg> {
    el(text(header).font(Font {
        weight: font::Weight::Bold,
        ..default()
    }))
}
fn selectable_button_style(
    is_selected: bool,
) -> impl Fn(&Theme, button::Status) -> button::Style {
    move |theme, status| -> button::Style {
        button::Style {
            border: Border {
                color: if is_selected {
                    Color::WHITE
                } else {
                    Color::TRANSPARENT
                },
                width: 1.0,
                ..default()
            },
            ..button::Catalog::style(
                theme,
                &<Theme as button::Catalog>::default(),
                status,
            )
        }
    }
}
fn display_short_hash(hash: &pijul::Hash) -> String {
    let mut short_hash = pijul::Base32::to_base32(hash);
    short_hash.truncate(8);
    short_hash
}

Insertion in inflorescence_view/Cargo.toml at line 16 [52.330]
[52.644]
[52.644]
```
workspace = true
[dependencies.iced_test]
```
Replacement in inflorescence/src/main.rs at line 11 [2.2763]
B:BD[32.162] → [52.700:728]
```
use inflorescence_view::el;
```
[32.162]
[38.365]
```
use inflorescence_view::app::RecordMsg;
use inflorescence_view::{app, theme};
```
Replacement in inflorescence/src/main.rs at line 17 [2.2763]
∅:D[32.199] → [24.1316:1394]
B:BD[19.1523] → [24.1316:1394]
B:BD[24.1394] → [27.22:34]
B:BD[27.34] → [53.21:108]
∅:D[53.108] → [27.109:112]
∅:D[34.150] → [27.109:112]
∅:D[32.292] → [27.109:112]
B:BD[27.109] → [27.109:112]
```
use iced::widget::{self, button, column, row, scrollable, text, text_editor};
use iced::{
    font, window, Border, Color, Element, Font, Length, Subscription, Task,
    Theme,
};
```
[3.1025]
[16.4438]
```
use iced::widget::text_editor;
use iced::{widget, window, Element, Subscription, Task};
```
Deletion in inflorescence/src/main.rs at line 23 [2.2763]
B:BD[7.351] → [37.4544:4563]
```
use pijul::Base32;
```
Deletion in inflorescence/src/main.rs at line 29 [2.2763]
B:BD[28.175] → [31.22:47]
∅:D[31.47] → [24.1453:1454]
B:BD[24.1453] → [24.1453:1454]
```
const SPACING: u32 = 10;
```
Replacement in inflorescence/src/main.rs at line 51 [2.2763]
B:BD[2.2962] → [3.1086:1124]
```
fn init() -> (State, Task<Message>) {
```
[2.2962]
[53.163]
```
fn init() -> (State, Task<Msg>) {
```
Replacement in inflorescence/src/main.rs at line 74 [2.2763]
∅:D[14.138] → [13.5743:5775]
B:BD[13.5743] → [13.5743:5775]
```
        Message::RepoTaskExited
```
[14.138]
[13.5775]
```
        Msg::RepoTaskExited
```

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

B:BD[13.5848] → [13.5848:5919]

    let repo_msg_out_task = Task::run(repo_rx_out, Message::FromRepo);

[13.5848]

[8.1996]

    let repo_msg_out_task = Task::run(repo_rx_out, Msg::FromRepo);

Replacement in inflorescence/src/main.rs at line 81 [2.2763]
B:BD[15.639] → [16.4532:4572]
```
        Message::LoadedId(Box::new(id))
```
[15.639]
[15.669]
```
        Msg::LoadedId(Box::new(id))
```

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

B:BD[19.2157] → [53.655:708]

        open_window_task.map(Message::WindowOpened),

[19.2157]

[53.708]

        open_window_task.map(Msg::WindowOpened),

Replacement in inflorescence/src/main.rs at line 92 [2.2763]
B:BD[19.2225] → [50.105:144]
```
        files_task.map(Message::File),
```
[19.2225]
[19.2259]
```
        files_task.map(Msg::File),
```
Deletion in inflorescence/src/main.rs at line 97 [2.2763]
B:BD[7.1460] → [53.732:755]
```
            window_id,
```
Deletion in inflorescence/src/main.rs at line 113 [2.2763]
B:BD[3.1363] → [53.756:783]
```
    window_id: window::Id,
```
Deletion in inflorescence/src/main.rs at line 124 [2.2763]
B:BD[28.1073] → [34.1324:1341]
∅:D[23.525] → [17.78:163]
∅:D[19.2723] → [17.78:163]
B:BD[17.78] → [17.78:163]
B:BD[2.3039] → [2.3039:3042]
```
#[derive(Debug)]
enum RecordMsg {
    Typing(text_editor::Content),
    Canceled { old_msg: String },
}
```
Replacement in inflorescence/src/main.rs at line 125 [2.2763]
B:BD[2.3066] → [5.653:668]
```
enum Message {
```
[2.3066]
[53.784]
```
enum Msg {
    View(app::Msg),
```
Deletion in inflorescence/src/main.rs at line 131 [2.2763]
B:BD[13.6224] → [13.6224:6249]
B:BD[13.6249] → [49.17:42]
```
    ToRepo(repo::MsgIn),
    Cursor(cursor::Msg),
```
Deletion in inflorescence/src/main.rs at line 134 [2.2763]
B:BD[11.190] → [11.190:230]
B:BD[11.230] → [17.164:216]
```
    EditRecordMsg(text_editor::Action),
    DeferRecord,
    SaveRecord,
    AbandonRecord,
```
Deletion in inflorescence/src/main.rs at line 135 [2.2763]
∅:D[50.260] → [34.3034:3064]
B:BD[28.2502] → [34.3034:3064]
B:BD[34.3064] → [50.261:283]
∅:D[50.283] → [35.331:361]
B:BD[34.3084] → [35.331:361]
∅:D[35.361] → [24.1914:1921]
∅:D[34.3120] → [24.1914:1921]
B:BD[24.1914] → [24.1914:1921]
B:BD[24.1921] → [48.18:134]
```
    FileDiffsContentsAction {
        id: file::Id,
        action: diff::Action,
    },
    LogChangeFileDiffAction {
        hash: pijul::Hash,
        file: String,
        action: diff::Action,
    },
```

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

B:BD[2.3099] → [13.6250:6312]

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

[2.3099]

[13.6702]

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

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

B:BD[13.6718] → [53.815:866]

∅:D[53.866] → [17.217:252]

∅:D[19.3253] → [17.217:252]

B:BD[13.6718] → [17.217:252]

        Message::WindowOpened(id) => Task::none(),
        Message::LoadedId(id) => {

[13.6718]

[17.252]

        Msg::View(msg) => update_from_app_view(state, msg),
        Msg::WindowOpened(_id) => Task::none(),
        Msg::LoadedId(id) => {

Replacement in inflorescence/src/main.rs at line 145 [2.2763]
∅:D[17.321] → [13.6718:6755]
B:BD[13.6718] → [13.6718:6755]
```
        Message::RepoTaskExited => {
```
[17.321]
[13.6755]
```
        Msg::RepoTaskExited => {
```
Replacement in inflorescence/src/main.rs at line 149 [2.2763]
B:BD[13.6830] → [13.6830:6866]
```
        Message::FromRepo(msg) => {
```
[13.6830]
[13.6866]
```
        Msg::FromRepo(msg) => {
```
Deletion in inflorescence/src/main.rs at line 152 [2.2763]
B:BD[13.6949] → [13.6949:6993]
B:BD[13.6993] → [16.4597:4646]
∅:D[16.4646] → [12.1273:1298]
∅:D[13.7041] → [12.1273:1298]
B:BD[8.3765] → [12.1273:1298]
```
        }
        Message::ToRepo(msg) => {
            state.repo_tx_in.send(msg).unwrap();
            Task::none()
```

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

B:BD[7.1724] → [49.43:122]

B:BD[49.122] → [50.284:314]

∅:D[50.314] → [49.158:191]

B:BD[49.158] → [49.158:191]

B:BD[49.228] → [49.228:286]

∅:D[49.286] → [9.6406:6445]

∅:D[39.9672] → [9.6406:6445]

B:BD[5.2657] → [9.6406:6445]

        Message::Cursor(msg) => cursor::update(
            &mut state.cursor,
            &mut state.files,
            state.repo.as_ref(),
            msg,
        )
        .map(Message::ToRepo),
        Message::AddUntrackedFile => {

[7.1724]

[13.11225]

        Msg::AddUntrackedFile => {

Replacement in inflorescence/src/main.rs at line 191 [2.2763]
B:BD[9.7537] → [10.650:684]
```
        Message::RmAddedFile => {
```
[9.7537]
[13.12419]
```
        Msg::RmAddedFile => {
```
Replacement in inflorescence/src/main.rs at line 236 [2.2763]
B:BD[11.265] → [11.265:294]
```
        Message::Record => {
```
[11.265]
[13.13952]
```
        Msg::Record => {
```

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

B:BD[10.2051] → [11.604:648]

        Message::EditRecordMsg(action) => {

[10.2051]

[17.1079]

        Msg::File(msg) => {
            file::update(&mut state.files, state.repo.as_ref(), msg);
            Task::none()
        }
    }
}
fn update_from_app_view(state: &mut State, msg: app::Msg) -> Task<Msg> {
    match msg {
        app::Msg::Cursor(msg) => cursor::update(
            &mut state.cursor,
            &mut state.files,
            state.repo.as_ref(),
            msg,
        )
        .map(|msg| Msg::View(app::Msg::ToRepo(msg))),
        app::Msg::ToRepo(msg) => {
            state.repo_tx_in.send(msg).unwrap();
            Task::none()
        }
        app::Msg::EditRecordMsg(action) => {

Replacement in inflorescence/src/main.rs at line 292 [2.2763]
B:BD[11.782] → [17.1193:1226]
```
        Message::SaveRecord => {
```
[11.782]
[17.1226]
```
        app::Msg::SaveRecord => {
```
Replacement in inflorescence/src/main.rs at line 320 [2.2763]
B:BD[13.14755] → [17.1384:1418]
```
        Message::DeferRecord => {
```
[13.14755]
[17.1418]
```
        app::Msg::DeferRecord => {
```
Replacement in inflorescence/src/main.rs at line 333 [2.2763]
B:BD[17.1823] → [17.1823:1859]
```
        Message::AbandonRecord => {
```
[17.1823]
[17.1859]
```
        app::Msg::AbandonRecord => {
```

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

B:BD[24.2062] → [34.13077:13138]

        Message::FileDiffsContentsAction { id, action } => {

[24.2062]

[34.13138]

        app::Msg::FileDiffsContentsAction { id, action } => {

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

B:BD[19.7404] → [48.135:204]

        Message::LogChangeFileDiffAction { hash, file, action } => {

[19.7404]

[48.204]

        app::Msg::LogChangeFileDiffAction { hash, file, action } => {

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

B:BD[48.884] → [50.511:648]

        Message::File(msg) => {
            file::update(&mut state.files, state.repo.as_ref(), msg);
            Task::none()
        }

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

B:BD[13.14764] → [13.14764:14841]

fn update_from_repo(state: &mut State, msg: repo::MsgOut) -> Task<Message> {

[13.14764]

[13.14841]

fn update_from_repo(state: &mut State, msg: repo::MsgOut) -> Task<Msg> {

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

B:BD[14.1555] → [14.1555:1633]

                Message::ToRepo(repo::MsgIn::RefreshChangedAndUntrackedFiles)

[14.1555]

[14.1633]

                Msg::View(app::Msg::ToRepo(
                    repo::MsgIn::RefreshChangedAndUntrackedFiles,
                ))

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

B:BD[46.9505] → [46.9505:9568]

                        let task = Task::done(Message::ToRepo(

[46.9505]

[46.9568]

                        let task = Task::done(Msg::View(app::Msg::ToRepo(

Replacement in inflorescence/src/main.rs at line 497 [2.2763]
B:BD[46.9634] → [46.9634:9662]
```
                        ));
```
[46.9634]
[46.9662]
```
                        )));
```
Replacement in inflorescence/src/main.rs at line 571 [2.2763]
B:BD[5.2666] → [5.2666:2717]
```
fn subs(_state: &State) -> Subscription<Message> {
```
[24.4299]
[25.22]
```
fn subs(_state: &State) -> Subscription<Msg> {
```

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

B:BD[5.2903] → [17.1991:2051]

B:BD[17.2051] → [51.17:292]

∅:D[51.292] → [17.2052:2102]

∅:D[49.789] → [17.2052:2102]

∅:D[41.5791] → [17.2052:2102]

B:BD[5.3009] → [17.2052:2102]

∅:D[17.2102] → [10.2052:2107]

B:BD[9.7598] → [10.2052:2107]

                    "a" => Some(Message::AddUntrackedFile),
                    "j" => Some(Message::Cursor(cursor::Msg::Down)),
                    "k" => Some(Message::Cursor(cursor::Msg::Up)),
                    "h" => Some(Message::Cursor(cursor::Msg::Left)),
                    "l" => Some(Message::Cursor(cursor::Msg::Right)),
                    "r" => Some(Message::Record),
                    "x" => Some(Message::RmAddedFile),

[5.2903]

[5.3009]

                    "a" => Some(Msg::AddUntrackedFile),
                    "j" => Some(Msg::View(app::Msg::Cursor(cursor::Msg::Down))),
                    "k" => Some(Msg::View(app::Msg::Cursor(cursor::Msg::Up))),
                    "h" => Some(Msg::View(app::Msg::Cursor(cursor::Msg::Left))),
                    "l" => {
                        Some(Msg::View(app::Msg::Cursor(cursor::Msg::Right)))
                    }
                    "r" => Some(Msg::Record),
                    "x" => Some(Msg::RmAddedFile),

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

B:BD[49.845] → [51.293:354]

                    Some(Message::Cursor(cursor::Msg::Down))

[49.845]

[49.912]

                    Some(Msg::View(app::Msg::Cursor(cursor::Msg::Down)))

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

B:BD[49.983] → [51.355:414]

                    Some(Message::Cursor(cursor::Msg::Up))

[49.983]

[49.1048]

                    Some(Msg::View(app::Msg::Cursor(cursor::Msg::Up)))

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

B:BD[49.1121] → [51.415:476]

                    Some(Message::Cursor(cursor::Msg::Left))

[49.1121]

[49.1188]

                    Some(Msg::View(app::Msg::Cursor(cursor::Msg::Left)))

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

B:BD[41.5928] → [51.477:539]

                    Some(Message::Cursor(cursor::Msg::Right))

[41.5928]

[41.5975]

                    Some(Msg::View(app::Msg::Cursor(cursor::Msg::Right)))

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

B:BD[17.2159] → [17.2159:2212]

                        Some(Message::AbandonRecord)

[17.2159]

[17.2212]

                        Some(Msg::View(app::Msg::AbandonRecord))

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

B:BD[17.2290] → [17.2290:2341]

                        Some(Message::DeferRecord)

[17.2290]

[17.2341]

                        Some(Msg::View(app::Msg::DeferRecord))
                    }
                    "s" if mods == Modifiers::CTRL => {
                        Some(Msg::View(app::Msg::SaveRecord))

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

B:BD[17.2363] → [17.2363:2444]

                    "s" if mods == Modifiers::CTRL => Some(Message::SaveRecord),

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

∅:D[5.3183] → [2.3221:3224]

∅:D[4.5139] → [2.3221:3224]

∅:D[19.8474] → [2.3221:3224]

B:BD[2.3221] → [2.3221:3224]

B:BD[2.3224] → [53.867:927]

∅:D[53.927] → [45.16960:16982]

B:BD[45.16960] → [45.16960:16982]

∅:D[30.3294] → [29.6096:6099]

∅:D[34.16535] → [29.6096:6099]

∅:D[45.16982] → [29.6096:6099]

B:BD[29.6096] → [29.6096:6099]

B:BD[29.6099] → [53.928:997]

∅:D[53.997] → [13.16477:16523]

B:BD[3.1501] → [13.16477:16523]

B:BD[13.16523] → [17.2445:2560]

∅:D[17.2560] → [13.16682:16833]

B:BD[13.16682] → [13.16682:16833]

∅:D[13.16833] → [5.3530:3531]

B:BD[4.5403] → [5.3530:3531]

B:BD[5.3531] → [45.16983:17085]

∅:D[17.2624] → [8.7755:7859]

∅:D[13.16938] → [8.7755:7859]

∅:D[45.17085] → [8.7755:7859]

B:BD[8.7755] → [8.7755:7859]

B:BD[8.7859] → [39.10971:11075]

∅:D[39.11075] → [8.7965:7984]

∅:D[34.16652] → [8.7965:7984]

B:BD[8.7965] → [8.7965:7984]

B:BD[8.7984] → [17.2625:2645]

∅:D[17.2645] → [8.8015:8054]

B:BD[8.8015] → [8.8015:8054]

B:BD[8.8054] → [51.540:611]

∅:D[51.611] → [34.16653:16736]

∅:D[49.1353] → [34.16653:16736]

B:BD[8.8111] → [34.16653:16736]

B:BD[34.16736] → [49.1354:1382]

∅:D[49.1382] → [8.8224:8327]

B:BD[8.8224] → [8.8224:8327]

B:BD[8.8327] → [45.17086:17109]

∅:D[45.17109] → [8.8340:8341]

B:BD[8.8340] → [8.8340:8341]

B:BD[8.8341] → [45.17110:17208]

∅:D[45.17208] → [22.4521:4563]

B:BD[17.2707] → [22.4521:4563]

B:BD[22.4563] → [39.11076:11254]

∅:D[6.1118] → [5.3822:3841]

∅:D[8.8446] → [5.3822:3841]

∅:D[39.11254] → [5.3822:3841]

∅:D[34.16850] → [5.3822:3841]

B:BD[5.3822] → [5.3822:3841]

B:BD[5.3841] → [17.2708:2728]

B:BD[17.2728] → [18.1047:1075]

B:BD[18.1075] → [26.298:331]

B:BD[26.331] → [51.612:683]

∅:D[51.683] → [34.16851:16937]

∅:D[49.1460] → [34.16851:16937]

B:BD[5.3968] → [34.16851:16937]

B:BD[34.16937] → [49.1461:1489]

∅:D[49.1489] → [5.4052:4155]

B:BD[5.4052] → [5.4052:4155]

B:BD[5.4155] → [45.17209:17232]

∅:D[45.17232] → [5.4168:4169]

B:BD[5.4168] → [5.4168:4169]

B:BD[5.4169] → [45.17233:17311]

∅:D[45.17311] → [39.11316:11451]

B:BD[39.11316] → [39.11316:11451]

B:BD[39.11451] → [45.17312:17371]

∅:D[45.17371] → [39.11452:11648]

B:BD[37.5173] → [39.11452:11648]

∅:D[39.11648] → [37.5238:5333]

B:BD[37.5238] → [37.5238:5333]

B:BD[37.5333] → [51.684:755]

∅:D[51.755] → [45.17372:17473]

∅:D[49.1567] → [45.17372:17473]

B:BD[37.5390] → [45.17372:17473]

B:BD[45.17473] → [49.1568:1596]

∅:D[49.1596] → [37.5485:5664]

B:BD[37.5485] → [37.5485:5664]

B:BD[37.5664] → [45.17474:17497]

∅:D[17.2825] → [13.17203:17204]

∅:D[37.5677] → [13.17203:17204]

∅:D[45.17497] → [13.17203:17204]

B:BD[13.17203] → [13.17203:17204]

B:BD[13.17204] → [17.2826:3500]

B:BD[17.3500] → [19.8475:8559]

B:BD[19.8559] → [47.1782:1854]

B:BD[47.1854] → [50.1239:1275]

∅:D[50.1275] → [34.17129:17169]

B:BD[34.17129] → [34.17129:17169]

B:BD[34.17169] → [50.1276:1330]

∅:D[50.1330] → [34.17221:17240]

B:BD[34.17221] → [34.17221:17240]

B:BD[34.17240] → [50.1331:1463]

∅:D[50.1463] → [47.1855:1929]

B:BD[34.17364] → [47.1855:1929]

∅:D[47.1929] → [35.1245:1383]

B:BD[34.17364] → [35.1245:1383]

∅:D[35.1383] → [34.17510:17603]

B:BD[34.17510] → [34.17510:17603]

B:BD[34.17603] → [35.1384:1441]

∅:D[35.1441] → [34.17660:17682]

B:BD[34.17660] → [34.17660:17682]

B:BD[34.17682] → [50.1464:1522]

∅:D[50.1522] → [45.17554:17628]

B:BD[45.17554] → [45.17554:17628]

∅:D[28.6889] → [19.9266:9285]

∅:D[45.17628] → [19.9266:9285]

∅:D[34.17760] → [19.9266:9285]

B:BD[19.9266] → [19.9266:9285]

B:BD[19.9285] → [34.17761:17789]

B:BD[34.17789] → [45.17629:17757]

∅:D[45.17757] → [34.17852:17895]

B:BD[34.17852] → [34.17852:17895]

B:BD[34.17895] → [45.17758:17812]

∅:D[27.380] → [19.9339:9353]

∅:D[20.1352] → [19.9339:9353]

∅:D[45.17812] → [19.9339:9353]

∅:D[34.17915] → [19.9339:9353]

B:BD[19.9339] → [19.9339:9353]

B:BD[19.9353] → [47.1930:2000]

B:BD[47.2000] → [50.1523:1559]

∅:D[50.1559] → [34.18105:18145]

B:BD[34.18105] → [34.18105:18145]

B:BD[34.18145] → [50.1560:1612]

∅:D[50.1612] → [34.18195:18214]

B:BD[34.18195] → [34.18195:18214]

B:BD[34.18214] → [50.1613:1745]

∅:D[50.1745] → [47.2001:2075]

B:BD[34.18338] → [47.2001:2075]

∅:D[47.2075] → [35.1442:1580]

B:BD[34.18338] → [35.1442:1580]

∅:D[35.1580] → [34.18484:18577]

B:BD[34.18484] → [34.18484:18577]

B:BD[34.18577] → [35.1581:1638]

∅:D[35.1638] → [33.4823:4845]

∅:D[34.18604] → [33.4823:4845]

B:BD[33.4823] → [33.4823:4845]

B:BD[33.4845] → [50.1746:1804]

∅:D[50.1804] → [45.17869:17943]

B:BD[45.17869] → [45.17869:17943]

∅:D[45.17943] → [34.18683:18730]

B:BD[34.18683] → [34.18683:18730]

B:BD[34.18730] → [45.17944:18020]

∅:D[45.18020] → [34.18793:18836]

B:BD[34.18793] → [34.18793:18836]

B:BD[34.18836] → [45.18021:18075]

∅:D[45.18075] → [37.5678:5692]

B:BD[34.18856] → [37.5678:5692]

B:BD[37.5692] → [45.18076:18191]

B:BD[45.18191] → [46.11660:11686]

∅:D[46.11686] → [45.18191:18313]

B:BD[45.18191] → [45.18191:18313]

∅:D[45.18313] → [39.11827:11828]

B:BD[39.11827] → [39.11827:11828]

B:BD[39.11828] → [45.18314:18373]

∅:D[45.18373] → [39.11923:11924]

B:BD[39.11923] → [39.11923:11924]

B:BD[39.11924] → [41.5994:6077]

B:BD[41.6077] → [45.18374:18518]

∅:D[45.18518] → [41.6078:6144]

B:BD[39.12134] → [41.6078:6144]

B:BD[41.6144] → [51.756:875]

∅:D[51.875] → [39.12270:12386]

∅:D[49.1722] → [39.12270:12386]

∅:D[41.6248] → [39.12270:12386]

B:BD[39.12270] → [39.12270:12386]

B:BD[39.12386] → [45.18519:18698]

∅:D[45.18698] → [39.12466:12517]

B:BD[39.12466] → [39.12466:12517]

B:BD[39.12517] → [45.18699:18753]

∅:D[21.515] → [19.9691:9738]

∅:D[33.4970] → [19.9691:9738]

∅:D[37.5774] → [19.9691:9738]

∅:D[39.12537] → [19.9691:9738]

∅:D[45.18753] → [19.9691:9738]

∅:D[34.18856] → [19.9691:9738]

B:BD[19.9691] → [19.9691:9738]

∅:D[19.9738] → [17.3500:3511]

B:BD[17.3500] → [17.3500:3511]

∅:D[17.3511] → [5.4170:4171]

∅:D[13.17593] → [5.4170:4171]

B:BD[4.5731] → [5.4170:4171]

B:BD[5.4171] → [45.18754:18939]

B:BD[45.18939] → [46.11687:11786]

∅:D[46.11786] → [45.19021:19203]

B:BD[45.19021] → [45.19021:19203]

B:BD[45.19203] → [46.11787:11924]

B:BD[46.11924] → [48.885:1211]

∅:D[48.1211] → [45.19347:19740]

∅:D[47.2152] → [45.19347:19740]

B:BD[45.19347] → [45.19347:19740]

∅:D[45.19740] → [17.3553:3580]

B:BD[17.3553] → [17.3553:3580]

B:BD[17.3580] → [45.19741:19961]

∅:D[37.5839] → [17.3863:3878]

∅:D[45.19961] → [17.3863:3878]

B:BD[17.3863] → [17.3863:3878]

B:BD[17.3878] → [24.5482:5557]

B:BD[24.5557] → [45.19962:20153]

∅:D[24.5596] → [11.1940:1953]

∅:D[13.18286] → [11.1940:1953]

∅:D[45.20153] → [11.1940:1953]

B:BD[11.1940] → [11.1940:1953]

B:BD[11.1953] → [17.3999:4035]

∅:D[17.4035] → [13.18334:18340]

B:BD[13.18334] → [13.18334:18340]

B:BD[13.18340] → [27.445:611]

}
fn theme(_state: &State, _window_id: window::Id) -> Theme {
    Theme::TokyoNight
}
fn view(state: &State, _window_id: window::Id) -> Element<Message> {
    if let Some(repo) = state.repo.as_ref() {
        let repo_info = el(row([
            el(text(&repo.dir_name)),
            el(text(": ")),
            el(
                button(text(&repo.channel)), /* TODO
                                              * .on_press(Message) */
            ),
        ]));
        let untracked_files = || {
            el(column(repo.untracked_files.iter().enumerate().map(
            |(ix, path)| {
                let is_selected = matches!(state.cursor.selection.as_ref() ,
                    Some(cursor::Selection::UntrackedFile{ ix: selected_ix, .. }) if &ix == selected_ix
                );
                el(
                    button(text(path))
                        .on_press(Message::Cursor(cursor::Msg::Select(
                            cursor::Select::UntrackedFile{ix, path: path.clone()},
                        )))
                        .style(selectable_button_style(is_selected)),
                )
            },
        )))
        };
        let changed_files = || {
            el(column(repo.changed_files.iter().enumerate().map(
            |(ix, (file_path, _diffs))| {
                let is_selected = matches!(state.cursor.selection.as_ref(),
                    Some(cursor::Selection::ChangedFile{ ix: selected_ix, .. }) if &ix == selected_ix
                );
                el(
                    button(
                text(file_path))
                        .on_press(Message::Cursor(cursor::Msg::Select(
                            cursor::Select::ChangedFile{ix, path: file_path.clone()},
                        )))
                        .style(selectable_button_style(is_selected)),
                )
            },
        )))
        };
        let log = || {
            el(column(repo.log.iter().enumerate().map(
            |(ix, repo::LogEntry {
                 hash,
                 message,
                 file_paths: _,
             })| {
                let short_hash = display_short_hash(hash);
                let is_selected = matches!(state.cursor.selection.as_ref(),
                    Some(cursor::Selection::LogChange { ix: selected_ix, .. }) if &ix == selected_ix
                );
                el(row([
                    el(button(text(short_hash).font(Font::MONOSPACE))
                        .on_press(Message::Cursor(cursor::Msg::Select(
                            cursor::Select::LogChange { ix, hash: *hash, message: message.clone() },
                        )))
                        .style(selectable_button_style(is_selected))),
                    el(text(message)),
                ])
                .spacing(SPACING))
            },
        )))
        };
        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(Message::EditRecordMsg)),
                el(row([
                    el(button(text("Save")).on_press(Message::SaveRecord)),
                    el(button(text("Defer")).on_press(Message::DeferRecord)),
                    el(button(text("Abandon"))
                        .on_press(Message::AbandonRecord)),
                ])),
            ]))
        } else {
            el(row([]))
        };
        let selection_details = match state.cursor.selection.as_ref() {
            Some(cursor::Selection::UntrackedFile { ix: _, path }) => {
                let id = file::Id {
                    path: path.clone(),
                    file_kind: file::Kind::Untracked,
                };
                let diffs = match state.files.diffs_cache.inner.peek(&id) {
                    Some(file::Diff::Loaded(file)) => {
                        let selection_state = state.diffs_state.get(&id);
                        diff::view(selection_state, file).map(move |msg| {
                            Message::FileDiffsContentsAction {
                                id: id.clone(),
                                action: msg,
                            }
                        })
                    }
                    None | Some(file::Diff::Loading) => {
                        el(text("Loading diff..."))
                    }
                };
                el(column([
                    view_diff_header(format!(
                        "Untracked file {path} contents:"
                    )),
                    el(scrollable(diffs)),
                ])
                .spacing(SPACING))
            }
            Some(cursor::Selection::ChangedFile { path, ix: _ }) => {
                let id = file::Id {
                    path: path.clone(),
                    file_kind: file::Kind::Changed,
                };
                let diffs = match state.files.diffs_cache.inner.peek(&id) {
                    Some(file::Diff::Loaded(file)) => {
                        let selection_state = state.diffs_state.get(&id);
                        diff::view(selection_state, file).map(move |msg| {
                            Message::FileDiffsContentsAction {
                                id: id.clone(),
                                action: msg,
                            }
                        })
                    }
                    None | Some(file::Diff::Loading) => {
                        el(text("Loading diff..."))
                    }
                };
                el(column([
                    view_diff_header(format!("Changed file {path} diff:")),
                    el(scrollable(diffs)),
                ])
                .spacing(SPACING))
            }
            Some(cursor::Selection::LogChange {
                ix,
                hash,
                message,
                diffs: _,
                file,
            }) => {
                let entry = state.repo.as_ref().unwrap().log.get(*ix).unwrap();
                let short_hash = display_short_hash(hash);
                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);
                    el(button(text(path)).on_press_with(move || {
                        Message::Cursor(cursor::Msg::Select(cursor::Select::LogChangeFile { ix, path: path.clone() }))
                    }).style(selectable_button_style(is_selected)))
                });
                el(column([
                    view_diff_header(format!("{short_hash} message:")),
                    el(text(message)),
                    view_diff_header("Changed files:".to_string()),
                    el(scrollable(column(files))),
                ])
                .spacing(SPACING))
            }
            None => el(row([])),
        };
        let left_view = match state.cursor.selection.as_ref() {
            Some(cursor::Selection::LogChange {
                ix: _,
                hash,
                message: _,
                diffs,
                file: Some(cursor::LogChangeFileSelection { ix: _, path }),
            }) => el(column([
                view_diff_header(format!(
                    "{path} changes in {}:",
                    display_short_hash(hash)
                )),
                match diffs {
                    Some(diffs) => {
                        let (file, state) = diffs.get(path).unwrap();
                        diff::view(Some(state), file).map(|action| {
                            Message::LogChangeFileDiffAction {
                                hash: *hash,
                                file: path.clone(),
                                action,
                            }
                        })
                    }
                    None => el(text("Loading diff..")),
                },
            ])
            .width(Length::FillPortion(1))
            .spacing(SPACING)),
            Some(cursor::Selection::UntrackedFile { .. })
            | Some(cursor::Selection::ChangedFile { .. })
            | Some(cursor::Selection::LogChange { .. })
            | None => el(column([
                repo_info,
                el(column([el(text("Untracked files:")), untracked_files()])),
                el(column([el(text("Changed files:")), changed_files()])),
                el(column([el(text("Recent changes:")), log()])),
            ])
            .width(Length::FillPortion(1))
            .spacing(SPACING)),
        };
        let right_view = el(column([record_msg_editor, selection_details])
            .width(Length::FillPortion(1)));
        el(row([left_view, right_view]).spacing(SPACING))
    } else {
        el(text("Loading repo..."))
    }
}
fn view_diff_header(header: String) -> Element<'static, Message> {
    el(text(header).font(Font {
        weight: font::Weight::Bold,
        ..default()
    }))

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

∅:D[24.6306] → [5.4175:4777]

B:BD[5.4175] → [5.4175:4777]

fn selectable_button_style(
    is_selected: bool,
) -> impl Fn(&Theme, button::Status) -> button::Style {
    move |theme, status| -> button::Style {
        button::Style {
            border: Border {
                color: if is_selected {
                    Color::WHITE
                } else {
                    Color::TRANSPARENT
                },
                width: 1.0,
                ..default()
            },
            ..button::Catalog::style(
                theme,
                &<Theme as button::Catalog>::default(),
                status,
            )
        }
    }

[5.4175]

[45.20154]

fn view(state: &State, window_id: window::Id) -> Element<Msg> {
    let State {
        id: _,
        repo_fs_watch: _,
        repo_path,
        repo_tx_in: _,
        repo,
        cursor,
        record_msg,
        files,
        diffs_state,
    } = state;
    app::view(
        app::State {
            repo_path,
            repo: repo.as_ref(),
            cursor,
            record_msg: record_msg.as_ref(),
            diffs_state,
        },
        window_id,
        |id| files.diffs_cache.inner.peek(id),
    )
    .map(Msg::View)

Deletion in inflorescence/src/main.rs at line 648 [2.2763]
B:BD[45.20156] → [45.20156:20297]
∅:D[3.1579] → [2.3333:3335]
∅:D[17.4129] → [2.3333:3335]
∅:D[5.4777] → [2.3333:3335]
∅:D[4.6123] → [2.3333:3335]
∅:D[45.20297] → [2.3333:3335]
B:BD[2.3333] → [2.3333:3335]
```
fn display_short_hash(hash: &pijul::Hash) -> String {
    let mut short_hash = hash.to_base32();
    short_hash.truncate(8);
    short_hash
}
```
Insertion in inflorescence/src/file.rs at line 2 [50.1806]
[50.1869]
[50.1869]
```
pub use inflorescence_view::app::file::{Diff, Id, Kind};
```

Deletion in inflorescence/src/file.rs at line 49 [50.1806]

B:BD[50.2898] → [50.2898:3180]


#[derive(Debug)]
pub enum Diff {
    Loading,
    Loaded(diff::File),
}
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
pub struct Id {
    pub path: String,
    pub file_kind: Kind,
}
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
pub enum Kind {
    Untracked,
    Changed,
}

Replacement in inflorescence/src/diff.rs at line 3 [33.5018]
B:BD[33.5056] → [34.19159:19181]
∅:D[34.19181] → [33.5056:5070]
B:BD[33.5056] → [33.5056:5070]
```
use std::borrow::Cow;
use std::cmp;
```
[33.5056]
[52.731]
```
pub use inflorescence_view::diff::*;
```
Deletion in inflorescence/src/diff.rs at line 5 [33.5018]
B:BD[52.732] → [52.732:760]
∅:D[52.760] → [33.5070:5071]
B:BD[33.5070] → [33.5070:5071]
B:BD[33.5071] → [42.19:69]
B:BD[42.69] → [45.20299:20364]
```
use inflorescence_view::el;
use iced::widget::{column, container, row, text};
use iced::{alignment, Background, Color, Element, Font, Length};
```

Replacement in inflorescence/src/diff.rs at line 7 [33.5018]

B:BD[33.5154] → [42.124:287]

// TODO: maybe use theme
const DELETED_BG_COLOR: Color = Color::from_rgba8(190, 37, 40, 0.15);
const ADDED_BG_COLOR: Color = Color::from_rgba8(47, 148, 11, 0.15);

[33.5154]

[42.287]

use std::borrow::Cow;
use std::cmp;

Replacement in inflorescence/src/diff.rs at line 10 [33.5018]

∅:D[42.288] → [35.1744:1927]

B:BD[35.1744] → [35.1744:1927]

#[derive(Debug, Default)]
pub struct State {
    pub selected_sections: Vec<usize>,
    pub expanded_unchanged_sections: Vec<usize>,
    pub collapsed_changed_sections: Vec<usize>,
}

[42.288]

[35.1927]

pub fn update(_state: &mut State, _msg: Msg) {}

Deletion in inflorescence/src/diff.rs at line 12 [33.5018]

B:BD[35.1928] → [35.1928:2027]

B:BD[35.2027] → [47.2154:2248]

∅:D[47.2248] → [35.2102:2395]

B:BD[35.2102] → [35.2102:2395]

B:BD[35.2395] → [36.23:121]

∅:D[36.121] → [33.5154:5171]

∅:D[35.2489] → [33.5154:5171]

B:BD[33.5154] → [33.5154:5171]

B:BD[33.5171] → [34.19212:19291]

#[derive(Debug, Clone)]
pub enum Action {}
pub fn update(_state: &mut State, _action: Action) {}
pub fn view<'a>(
    state: Option<&'a State>,
    file: &'a File,
) -> Element<'a, Action> {
    match file {
        File::Decoded(decoded_file) => view_decoded(state, decoded_file),
        File::Undecodable(undecodable_file) => {
            view_undecodable(state, undecodable_file)
        }
    }
}
/// [`File`] is not part of [`State`] so it can be stored separately (i.e. in a
/// cache, where it's immutable once set, unlike [`State`] which can change with
/// [`Action`]s)
#[derive(Debug)]
pub enum File {
    Decoded(DecodedFile),
    Undecodable(UndecodableFile),
}

Deletion in inflorescence/src/diff.rs at line 13 [33.5018]
B:BD[34.19308] → [34.19308:19419]
∅:D[34.19419] → [33.5517:5537]
B:BD[33.5517] → [33.5517:5537]
B:BD[33.5537] → [34.19420:19559]
∅:D[34.19559] → [33.5767:5770]
B:BD[33.5767] → [33.5767:5770]
B:BD[33.5770] → [34.19560:19609]
∅:D[34.19609] → [33.5770:5787]
B:BD[33.5770] → [33.5770:5787]
B:BD[33.5787] → [34.19610:19632]
∅:D[34.19632] → [33.5806:5887]
B:BD[33.5806] → [33.5806:5887]
```
pub struct DecodedFile {
    pub combined: Combined,
    pub diffs_without_contents: Vec<DiffWithoutContents>,
}
#[derive(Debug)]
pub struct UndecodableFile {
    pub diffs_with_contents: Vec<DiffWithContents>,
    pub diffs_without_contents: Vec<DiffWithoutContents>,
}
/// A file combined with its diffs into sections
#[derive(Debug)]
pub struct Combined {
    pub sections: Vec<Section>,
    pub max_line_num: usize,
}
#[derive(Debug)]
```

Deletion in inflorescence/src/diff.rs at line 16 [33.5018]

B:BD[35.2511] → [35.2511:2842]

}
#[derive(Debug)]
pub enum DiffWithContents {
    Add,
    Edit {
        line: usize,
        deleted: bool,
        contents: String,
    },
    Replacement {
        line: usize,
        /// Deleted line
        change_contents: String,
        /// Added lines
        replacement_contents: String,
    },
    Del,
    Undel,

Deletion in inflorescence/src/diff.rs at line 18 [33.5018]

B:BD[35.2915] → [35.2915:3717]

B:BD[35.3787] → [35.3787:4010]

∅:D[35.4010] → [34.19687:19708]

B:BD[34.19687] → [34.19687:19708]

B:BD[34.19708] → [35.4011:4288]

∅:D[35.4288] → [34.19708:19710]

B:BD[34.19708] → [34.19708:19710]

B:BD[34.19710] → [35.4289:4431]

∅:D[35.4431] → [34.19710:19711]

B:BD[34.19710] → [34.19710:19711]

#[derive(Debug)]
pub enum DiffWithoutContents {
    // _________________________________________________________________________
    // Cases that never have contents:
    Move,
    SolveNameConflict,
    UnsolveNameConflict,
    SolveOrderConflict,
    UnsolveOrderConflict,
    ResurrectZombines,
    AddRoot,
    DelRoot,
    // _________________________________________________________________________
    // Cases that normally have contents, but in these cases the contents are
    // not decodable:
    Edit {
        line: usize,
        deleted: bool,
        contents: UndecodableContents,
    },
    Replacement {
        line: usize,
        /// Deleted line
        change_contents: UndecodableContents,
        /// Added lines
        replacement_contents: UndecodableContents,
    },
}
#[derive(Debug)]
pub enum UndecodableContents {
    /// Short byte sequence of unknown encoding encoded with base64 for
    /// display. Must be shorter than [`crate::repo::MAX_LEN_BASE64_DISPLAY`]
    ShortBase64(String),
    UnknownEncoding,
}
#[derive(Debug)]
pub enum Section {
    Unchanged(Lines),
    /// `deleted` and `added` are together because for
    /// `ChangedFileDiffWithContents::Replacement` they begin on the same line
    /// number
    Changed {
        deleted: Lines,
        added: Lines,
    },
}
/// INVARIANT: There must be no new-lines in any of the strings, the source
/// string must be split on those.
pub type Lines = Vec<String>;

Deletion in inflorescence/src/diff.rs at line 247 [33.5018]

B:BD[33.9933] → [33.9933:9939]

B:BD[34.25625] → [34.25625:25628]

B:BD[34.27679] → [34.27679:27782]

B:BD[34.27782] → [43.19:242]

    }
}
fn contents_to_lines(contents: &str) -> Lines {
    contents.split('\n').map(str::to_string).collect()
}
fn undecodable_contents_to_str(contents: &UndecodableContents) -> &str {
    match contents {
        UndecodableContents::ShortBase64(short) => short,
        UndecodableContents::UnknownEncoding => "Unknown encoding",

Deletion in inflorescence/src/diff.rs at line 263 [33.5018]

∅:D[34.28144] → [33.10832:10833]

B:BD[33.10832] → [33.10832:10833]

B:BD[33.10833] → [35.8703:8724]

B:BD[35.8724] → [47.2249:2280]

∅:D[47.2280] → [34.28193:28220]

B:BD[34.28193] → [34.28193:28220]

B:BD[34.28220] → [35.8725:8752]

B:BD[35.8752] → [42.289:444]

∅:D[42.444] → [34.28244:28318]

∅:D[35.8752] → [34.28244:28318]

B:BD[34.28244] → [34.28244:28318]

∅:D[34.28318] → [33.10886:10916]

B:BD[33.10886] → [33.10886:10916]

B:BD[33.10916] → [44.163:556]

∅:D[44.556] → [33.11717:11718]

B:BD[33.11717] → [33.11717:11718]

B:BD[33.11718] → [44.557:1339]

∅:D[44.1339] → [33.12921:12922]

B:BD[33.12921] → [33.12921:12922]

B:BD[33.12922] → [44.1340:1427]

∅:D[44.1427] → [42.1849:2223]

B:BD[33.13042] → [42.1849:2223]

∅:D[42.2223] → [34.28439:28442]

B:BD[33.13072] → [34.28439:28442]

B:BD[34.28442] → [35.8753:8778]

B:BD[35.8778] → [47.2281:2312]

∅:D[47.2312] → [34.28494:28525]

B:BD[34.28494] → [34.28494:28525]

B:BD[34.28525] → [35.8779:8806]

B:BD[35.8806] → [42.2224:2553]

B:BD[42.2553] → [45.20365:20399]

∅:D[45.20399] → [42.2575:3093]

B:BD[42.2575] → [42.2575:3093]

B:BD[42.3093] → [44.1428:1817]

∅:D[44.1817] → [42.3422:3977]

B:BD[42.3422] → [42.3422:3977]

B:BD[42.4025] → [42.4025:4067]

B:BD[42.4067] → [44.1818:1847]

∅:D[44.1847] → [42.4091:4156]

B:BD[42.4091] → [42.4091:4156]

B:BD[42.4156] → [44.1848:2054]

∅:D[44.2054] → [42.4611:4630]

B:BD[42.4611] → [42.4611:4630]

B:BD[42.4630] → [44.2055:2125]

∅:D[44.2125] → [42.4695:4730]

B:BD[42.4695] → [42.4695:4730]

B:BD[42.4730] → [44.2126:2354]

∅:D[44.2354] → [42.5223:5427]

B:BD[42.5223] → [42.5223:5427]

∅:D[42.5427] → [33.13072:13075]

∅:D[34.28618] → [33.13072:13075]

B:BD[33.13072] → [33.13072:13075]

B:BD[33.13075] → [42.5428:5586]

B:BD[42.5586] → [43.249:948]

∅:D[43.948] → [42.6031:6128]

B:BD[42.6031] → [42.6031:6128]

B:BD[42.6128] → [43.949:1061]

B:BD[43.1061] → [44.2355:2607]

∅:D[44.2607] → [43.1270:1280]

B:BD[43.1270] → [43.1270:1280]

∅:D[43.1280] → [42.6150:6274]

B:BD[42.6150] → [42.6150:6274]

B:BD[42.6274] → [43.1281:1533]

B:BD[43.1533] → [44.2608:2755]

∅:D[44.2755] → [43.1952:1978]

B:BD[43.1952] → [43.1952:1978]

∅:D[43.1978] → [42.6296:6305]

B:BD[42.6296] → [42.6296:6305]

B:BD[42.6305] → [44.2756:2835]

B:BD[44.2835] → [45.20400:20535]

∅:D[45.20535] → [33.13185:13187]

B:BD[33.13185] → [33.13185:13187]

B:BD[33.13187] → [42.6385:6509]

B:BD[42.6509] → [45.20536:20880]

∅:D[45.20880] → [42.6789:6791]

B:BD[42.6789] → [42.6789:6791]

B:BD[42.6791] → [44.2899:3777]


fn view_decoded<'a>(
    _state: Option<&'a State>,
    file: &'a DecodedFile,
) -> Element<'a, Action> {
    let DecodedFile {
        combined,
        diffs_without_contents,
    } = file;
    let line_num_digits = combined.max_line_num.to_string().len();
    // TODO use state to display selection, and control section expansion
    let mut current_line = 1;
    let sections_view = combined.sections.iter().map(|section| match section {
        Section::Unchanged(lines) => {
            let res = lines.iter().enumerate().map(move |(ix, line)| {
                line_view(
                    LineKind::Unchanged,
                    current_line + ix,
                    line_num_digits,
                    line,
                )
            });
            current_line += lines.len();
            el(column(res))
        }
        Section::Changed { deleted, added } => {
            let res = deleted
                .iter()
                .enumerate()
                .map(move |(ix, line)| {
                    line_view(
                        LineKind::Deleted,
                        current_line + ix,
                        line_num_digits,
                        line,
                    )
                })
                .chain(added.iter().enumerate().map(move |(ix, line)| {
                    line_view(
                        LineKind::Added,
                        current_line + ix,
                        line_num_digits,
                        line,
                    )
                }));
            current_line += added.len();
            el(column(res))
        }
    });
    if diffs_without_contents.is_empty() {
        el(column(sections_view))
    } else {
        let diffs_without_contents_view = diffs_without_contents
            .iter()
            .map(view_diff_without_contents);
        el(column([
            el(column(diffs_without_contents_view)),
            el(column(sections_view)),
        ])
        .spacing(10))
    }
}
fn view_undecodable<'a>(
    _state: Option<&'a State>,
    file: &'a UndecodableFile,
) -> Element<'a, Action> {
    let UndecodableFile {
        diffs_with_contents,
        diffs_without_contents,
    } = file;
    let diffs = diffs_with_contents
        .iter()
        .map(view_diff_with_contents)
        .chain(
            diffs_without_contents
                .iter()
                .map(view_diff_without_contents),
        );
    el(column(diffs).spacing(10))
}
/// View diffs without context (the file contents)
fn view_diff_with_contents(diff: &DiffWithContents) -> Element<'_, Action> {
    match diff {
        DiffWithContents::Add => el(text("Added")),
        DiffWithContents::Edit {
            line,
            deleted,
            contents,
        } => {
            let line_num = *line;
            let lines = contents_to_lines(contents);
            let max_line_num = line_num + lines.len();
            let line_num_digits = max_line_num.to_string().len();
            let lines_view = lines.into_iter().enumerate().map(|(ix, line)| {
                line_view(
                    if *deleted {
                        LineKind::Deleted
                    } else {
                        LineKind::Added
                    },
                    line_num + ix,
                    line_num_digits,
                    line,
                )
            });
            el(column(lines_view))
        }
        DiffWithContents::Replacement {
            line,
            change_contents,
            replacement_contents,
        } => {
            let line_num = *line;
            let change_lines = contents_to_lines(change_contents);
            let replacement_lines = contents_to_lines(replacement_contents);
            let max_line_num = line_num
                + cmp::max(change_lines.len(), replacement_lines.len());
            let line_num_digits = max_line_num.to_string().len();
            let lines_view = change_lines
                .into_iter()
                .enumerate()
                .map(|(ix, line)| {
                    line_view(
                        LineKind::Deleted,
                        line_num + ix,
                        line_num_digits,
                        line,
                    )
                })
                .chain(replacement_lines.into_iter().enumerate().map(
                    |(ix, line)| {
                        line_view(
                            LineKind::Added,
                            line_num + ix,
                            line_num_digits,
                            line,
                        )
                    },
                ));
            el(column(lines_view))
        }
        DiffWithContents::Del => el(text("Deleted")),
        DiffWithContents::Undel => el(text("Revived")),
    }
}
/// View diffs without context (the file contents)
fn view_diff_without_contents(
    diff: &DiffWithoutContents,
) -> Element<'_, Action> {
    match diff {
        DiffWithoutContents::Move => el(text("Move")),
        DiffWithoutContents::SolveNameConflict => {
            el(text("Solve name conflict"))
        }
        DiffWithoutContents::UnsolveNameConflict => {
            el(text("Unsolve name conflict"))
        }
        DiffWithoutContents::SolveOrderConflict => {
            el(text("Solve order conflict"))
        }
        DiffWithoutContents::UnsolveOrderConflict => {
            el(text("Unsolve order conflict"))
        }
        DiffWithoutContents::ResurrectZombines => el(text("Resurrect zombies")),
        DiffWithoutContents::AddRoot => el(text("Add root")),
        DiffWithoutContents::DelRoot => el(text("Delete root")),
        DiffWithoutContents::Edit {
            line,
            deleted,
            contents,
        } => {
            let line_num = *line;
            let line = undecodable_contents_to_str(contents);
            line_view(
                if *deleted {
                    LineKind::Deleted
                } else {
                    LineKind::Added
                },
                line_num,
                1,
                line,
            )
        }
        DiffWithoutContents::Replacement {
            line,
            change_contents,
            replacement_contents,
        } => {
            let line_num = *line;
            let change_line = undecodable_contents_to_str(change_contents);
            let replacement_line =
                undecodable_contents_to_str(replacement_contents);
            el(column([
                line_view(LineKind::Deleted, line_num, 1, change_line),
                line_view(LineKind::Added, line_num, 1, replacement_line),
            ]))
        }
    }
}
fn mono_text<'a>(txt: impl text::IntoFragment<'a>) -> iced::widget::Text<'a> {
    text(txt)
        .font(Font::MONOSPACE)
        .wrapping(text::Wrapping::WordOrGlyph)
        .align_y(alignment::Vertical::Top)
}
fn line_num_view<'a>(num: usize, digits: usize) -> iced::widget::Text<'a> {
    // Fill the string to the number of digits
    let txt = format!("{num:digits$} ");
    mono_text(txt)
        .font(Font::MONOSPACE)
        .style(move |theme| {
            let palette = theme.extended_palette();
            text::Style {
                color: Some(palette.background.base.text.scale_alpha(0.61)),
            }
        })
        .align_y(alignment::Vertical::Top)
}
#[derive(Debug, Clone, Copy)]
enum LineKind {
    Unchanged,
    Added,
    Deleted,
}
fn line_view<'a>(
    kind: LineKind,
    line_num: usize,
    line_num_digits: usize,
    line: impl text::IntoFragment<'a>,
) -> Element<'a, Action> {
    let line = container(row([
        el(mono_text(match kind {
            LineKind::Unchanged => "  ",
            LineKind::Added => "+ ",
            LineKind::Deleted => "- ",
        })),
        el(line_num_view(line_num, line_num_digits)),
        el(mono_text(line).width(Length::Fill)),
    ]));
    el(match kind {
        LineKind::Unchanged => line,
        LineKind::Added => line.style(|_theme| {
            container::background(Background::from(ADDED_BG_COLOR))
        }),
        LineKind::Deleted => line.style(|_theme| {
            container::background(Background::from(DELETED_BG_COLOR))
        }),
    })
}

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

[5.26]

[50.8494]

pub use inflorescence_view::app::cursor::{
    LogChangeFileSelection, Msg, Select, Selection, State,
};

Deletion in inflorescence/src/cursor.rs at line 6 [5.26]
B:BD[50.8519] → [50.8519:8551]
```
use libflorescence::prelude::*;
```
Deletion in inflorescence/src/cursor.rs at line 8 [5.26]
∅:D[50.8578] → [46.11927:11959]
B:BD[5.26] → [46.11927:11959]
```
use std::collections::HashMap;
```
Deletion in inflorescence/src/cursor.rs at line 9 [5.26]
∅:D[49.2147] → [34.18884:18885]
∅:D[35.8825] → [34.18884:18885]
B:BD[34.18884] → [34.18884:18885]
∅:D[34.18885] → [5.27:113]
B:BD[5.26] → [5.27:113]
B:BD[5.113] → [49.2148:2187]
B:BD[49.2187] → [51.879:938]
∅:D[51.938] → [49.2276:2279]
B:BD[49.2276] → [49.2276:2279]
∅:D[49.2279] → [34.18886:18903]
B:BD[5.113] → [34.18886:18903]
∅:D[34.18903] → [5.137:158]
B:BD[5.137] → [5.137:158]
B:BD[5.158] → [34.18904:18965]
∅:D[35.8854] → [34.19002:19068]
B:BD[34.19002] → [34.19002:19068]
B:BD[35.8883] → [37.5872:5879]
B:BD[37.5879] → [39.12540:12575]
∅:D[39.12575] → [37.5892:5919]
B:BD[37.5892] → [37.5892:5919]
B:BD[37.5919] → [45.20882:20907]
B:BD[45.20907] → [46.11960:12251]
∅:D[46.12251] → [39.12576:12622]
∅:D[45.20907] → [39.12576:12622]
B:BD[37.5919] → [39.12576:12622]
∅:D[37.5919] → [34.19105:19112]
∅:D[35.8883] → [34.19105:19112]
∅:D[39.12622] → [34.19105:19112]
B:BD[34.19105] → [34.19105:19112]
B:BD[34.19112] → [39.12623:12720]
∅:D[39.12720] → [34.19112:19114]
∅:D[45.20978] → [34.19112:19114]
B:BD[34.19112] → [34.19112:19114]
```
#[derive(Debug, Default)]
pub struct State {
    pub selection: Option<Selection>,
}
#[derive(Debug, Clone)]
pub enum Msg {
    Down,
    Up,
    Right,
    Left,
    Select(Select),
}
#[derive(Debug)]
pub enum Selection {
    UntrackedFile {
        ix: usize,
        path: String,
    },
    ChangedFile {
        ix: usize,
        path: String,
    },
    LogChange {
        ix: usize,
        hash: pijul::Hash,
        message: String,
        /// All the diffs in this change keyed by file path. Loaded async and
        /// set to None only while loading. The `diff::State` is also
        /// in here so that is it preserved while navigating between files.
        diffs: Option<HashMap<String, (diff::File, diff::State)>>,
        file: Option<LogChangeFileSelection>,
    },
}
#[derive(Debug)]
pub struct LogChangeFileSelection {
    pub ix: usize,
    pub path: String,
}
```

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

B:BD[34.19115] → [34.19115:19157]

B:BD[34.19157] → [45.20979:21275]

∅:D[6.47] → [5.188:190]

∅:D[18.661] → [5.188:190]

∅:D[40.796] → [5.188:190]

∅:D[8.1691] → [5.188:190]

∅:D[22.3191] → [5.188:190]

∅:D[37.5954] → [5.188:190]

∅:D[41.6298] → [5.188:190]

∅:D[45.21275] → [5.188:190]

B:BD[5.188] → [5.188:190]

B:BD[5.190] → [49.2280:2281]

#[derive(Debug, Clone)]
pub enum Select {
    UntrackedFile {
        ix: usize,
        path: String,
    },
    ChangedFile {
        ix: usize,
        path: String,
    },
    LogChange {
        ix: usize,
        hash: pijul::Hash,
        message: String,
    },
    LogChangeFile {
        ix: usize,
        path: String,
    },
}

Insertion in Cargo.toml at line 41 [2.3754]

[53.1060]

[2.4347]

[workspace.dependencies.iced_test]
git = "https://github.com/iced-rs/iced"
rev = "50cc94d944ada88bf3d7fcd1d2741b7104b9b1d1"

Insertion in Cargo.lock at line 2397 [2.4495]

[2.41150]

name = "iced_test"
version = "0.14.0-dev"
source = "git+https://github.com/iced-rs/iced?rev=50cc94d944ada88bf3d7fcd1d2741b7104b9b1d1#50cc94d944ada88bf3d7fcd1d2741b7104b9b1d1"
dependencies = [
 "iced_renderer",
 "iced_runtime",
 "png",
 "sha2 0.10.8",
 "thiserror 1.0.69",
]
[[package]]

Insertion in Cargo.lock at line 2734 [2.4495]
[52.1043]
[52.1043]
```
 "iced_test",
```
Replacement in Cargo.lock at line 3578 [2.4495]
B:BD[2.50945] → [31.13169:13196]
```
 "proc-macro-crate 3.3.0",
```
[2.50945]
[2.50966]
```
 "proc-macro-crate 1.3.1",
```
Replacement in Cargo.lock at line 5742 [2.4495]
B:BD[3.20948] → [3.20948:20963]
```
 "rand 0.8.5",
```
[3.20948]
[3.20963]
```
 "rand 0.7.3",
```

big view refactor into a new crate

Dependencies

In channels

Change contents

File addition: util.rs (----------)

Replacement in inflorescence_view/src/lib.rs at line 1 [52.102]

Replacement in inflorescence_view/src/lib.rs at line 5 [52.102]

File addition: diff.rs (----------)

File addition: app.rs (----------)

Insertion in inflorescence_view/Cargo.toml at line 16 [52.330]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Insertion in inflorescence/src/file.rs at line 2 [50.1806]

Deletion in inflorescence/src/file.rs at line 49 [50.1806]

Replacement in inflorescence/src/diff.rs at line 3 [33.5018]

Deletion in inflorescence/src/diff.rs at line 5 [33.5018]

Replacement in inflorescence/src/diff.rs at line 7 [33.5018]

Replacement in inflorescence/src/diff.rs at line 10 [33.5018]

Deletion in inflorescence/src/diff.rs at line 12 [33.5018]

Deletion in inflorescence/src/diff.rs at line 13 [33.5018]

Deletion in inflorescence/src/diff.rs at line 16 [33.5018]

Deletion in inflorescence/src/diff.rs at line 18 [33.5018]

Deletion in inflorescence/src/diff.rs at line 247 [33.5018]

Deletion in inflorescence/src/diff.rs at line 263 [33.5018]

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

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

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

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

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

Insertion in Cargo.toml at line 41 [2.3754]

Insertion in Cargo.lock at line 2397 [2.4495]

Insertion in Cargo.lock at line 2734 [2.4495]

Replacement in Cargo.lock at line 3578 [2.4495]

Replacement in Cargo.lock at line 5742 [2.4495]