tzemanovic/inflorescence - Change BFN2VHZS7VCBUHQ4S3CQ3LFQV2V4M6VANNAF32XMRFQVWRGYSZ6AC

refactor file stuff into sub-mod

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

BFN2VHZS7VCBUHQ4S3CQ3LFQV2V4M6VANNAF32XMRFQVWRGYSZ6AC

Dependencies

In channels

main

Change contents

Insertion in inflorescence/src/main.rs at line 3 [2.2763]
[24.32]
[16.1219]
```
mod file;
```
Insertion in inflorescence/src/main.rs at line 6 [2.2763]
[21.41]
[32.18]
```
use std::cmp;
```
Deletion in inflorescence/src/main.rs at line 8 [2.2763]
∅:D[32.49] → [21.73:96]
B:BD[21.73] → [21.73:96]
```
use std::num::NonZero;
```
Deletion in inflorescence/src/main.rs at line 10 [2.2763]
B:BD[21.140] → [23.53:74]
```
use std::{cmp, mem};
```
Deletion in inflorescence/src/main.rs at line 15 [2.2763]
B:BD[4.1025] → [21.163:199]
```
use clru::{CLruCache, WeightScale};
```
Deletion in inflorescence/src/main.rs at line 28 [2.2763]
B:BD[9.4810] → [21.293:322]
∅:D[21.322] → [2.2834:2835]
∅:D[7.467] → [2.2834:2835]
∅:D[6.508] → [2.2834:2835]
∅:D[4.1060] → [2.2834:2835]
∅:D[9.4810] → [2.2834:2835]
∅:D[5.4970] → [2.2834:2835]
∅:D[3.5849] → [2.2834:2835]
B:BD[2.2834] → [2.2834:2835]
B:BD[2.2835] → [17.83:174]
```
use tokio_stream::StreamExt;
// Invariant: Must be non-zero
const SRC_FILES_CACHE_CAPACITY: usize = 1024 * 1024 * 1024;
```

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

B:BD[11.677] → [11.677:678]

B:BD[11.678] → [23.151:412]

∅:D[17.333] → [14.1795:1840]

∅:D[23.412] → [14.1795:1840]

B:BD[14.1795] → [14.1795:1840]

B:BD[14.1840] → [23.413:747]

∅:D[17.515] → [14.2084:2126]

∅:D[23.747] → [14.2084:2126]

B:BD[14.2084] → [14.2084:2126]

B:BD[14.2126] → [17.516:608]


    let (src_file_load_tx, src_file_load_rx) = watch::channel((
        FileId {
            path: "".to_string(),
            file_kind: FileKind::Untracked,
        },
        0,
    ));
    let src_file_load_rx = WatchStream::from_changes(src_file_load_rx);
    let repo_path_clone = repo_path.clone();
    let src_file_load_task = Task::run(
        src_file_load_rx
            .map(move |(id, cache_counter): (FileId, usize)| {
                (repo_path_clone.clone(), id, cache_counter)
            })
            .then(|(repo_path, id, cache_counter)| async move {
                load_src_file(repo_path, id, cache_counter).await
            }),
        |msg| msg,
    );
    let src_files_cache_capacity =
        NonZero::new(SRC_FILES_CACHE_CAPACITY).unwrap();

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

B:BD[14.2127] → [23.748:933]

    let diffs_cache = DiffsCache {
        counter: 0,
        inner: DiffsCacheInner::with_scale(
            src_files_cache_capacity,
            DiffsCacheWeight,
        ),
    };

[14.2127]

[23.933]

    let (files, files_task) = file::init(repo_path.clone());

Replacement in inflorescence/src/main.rs at line 78 [2.2763]
B:BD[14.2225] → [23.935:963]
```
        src_file_load_task,
```
[14.2225]
[14.2259]
```
        files_task.map(Message::File),
```
Replacement in inflorescence/src/main.rs at line 90 [2.2763]
B:BD[17.754] → [17.754:784]
B:BD[17.784] → [23.966:991]
```
            src_file_load_tx,
            diffs_cache,
```
[8.130]
[32.50]
```
            files,
```

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

B:BD[13.58] → [23.992:1075]

B:BD[23.1075] → [32.92:139]

∅:D[32.139] → [13.58:60]

∅:D[23.1075] → [13.58:60]

∅:D[16.1620] → [13.58:60]

∅:D[14.2459] → [13.58:60]

B:BD[13.58] → [13.58:60]

∅:D[17.965] → [13.60:78]

B:BD[13.60] → [13.60:78]

B:BD[13.78] → [23.1076:1224]

    src_file_load_tx: watch::Sender<(FileId, usize)>,
    diffs_cache: DiffsCache,
    diffs_state: HashMap<FileId, diff::State>,
}
#[derive(Debug)]
struct DiffsCache {
    /// Used to prevent race-conditions between file loading and clearing cache
    counter: usize,
    inner: DiffsCacheInner,

[13.58]

[17.1025]

    files: file::State,
    diffs_state: HashMap<file::Id, diff::State>,

Deletion in inflorescence/src/main.rs at line 110 [2.2763]
B:BD[17.1028] → [23.1225:1323]
∅:D[23.1323] → [17.1072:1073]
B:BD[17.1072] → [17.1072:1073]
```
type DiffsCacheInner =
    CLruCache<FileId, FileDiff, std::hash::RandomState, DiffsCacheWeight>;
```

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

B:BD[23.1341] → [23.1341:1370]

B:BD[23.1370] → [24.33:57]

∅:D[24.57] → [17.1770:1773]

∅:D[23.1403] → [17.1770:1773]

B:BD[17.1770] → [17.1770:1773]

B:BD[17.1773] → [23.1404:1508]

∅:D[23.1508] → [15.505:507]

B:BD[15.505] → [15.505:507]

B:BD[16.1689] → [17.1791:1792]

B:BD[19.259] → [19.259:276]

B:BD[19.276] → [23.1509:1534]

∅:D[19.401] → [18.134:135]

∅:D[23.1534] → [18.134:135]

B:BD[18.134] → [18.134:135]

B:BD[18.135] → [23.1535:1824]

B:BD[23.1824] → [24.58:114]

∅:D[24.114] → [23.1898:1928]

B:BD[23.1898] → [23.1898:1928]

B:BD[23.1928] → [24.115:156]

∅:D[24.156] → [23.1978:2338]

B:BD[23.1978] → [23.1978:2338]

B:BD[23.2338] → [24.157:330]

∅:D[24.330] → [23.2580:2787]

B:BD[23.2580] → [23.2580:2787]

∅:D[20.52] → [17.2139:2142]

∅:D[23.2787] → [17.2139:2142]

B:BD[17.2139] → [17.2139:2142]

B:BD[17.2142] → [23.2788:2883]

∅:D[23.2883] → [17.2378:2380]

B:BD[17.2378] → [17.2378:2380]

B:BD[16.1802] → [16.1802:1803]

∅:D[16.1803] → [15.508:525]

B:BD[15.508] → [15.508:525]

enum FileDiff {
    Loading,
    Loaded(diff::File),
}
#[derive(Debug, Clone, Hash, PartialEq, Eq)]
struct FileId {
    path: String,
    file_kind: FileKind,
}
#[derive(Debug)]
struct DiffsCacheWeight;
impl WeightScale<FileId, FileDiff> for DiffsCacheWeight {
    fn weight(&self, key: &FileId, value: &FileDiff) -> usize {
        let key_weight = key.path.len();
        let val_weight = match value {
            FileDiff::Loading => 0,
            FileDiff::Loaded(file) => match file {
                diff::File::Decoded(diff::DecodedFile {
                    combined:
                        diff::Combined {
                            sections,
                            max_line_num: _,
                        },
                    diffs_without_contents,
                }) => {
                    mem::size_of_val(sections)
                        + mem::size_of::<usize>()
                        + mem::size_of_val(diffs_without_contents)
                }
                diff::File::Undecodable(diff::UndecodableFile {
                    diffs_with_contents,
                    diffs_without_contents,
                }) => {
                    mem::size_of_val(diffs_with_contents)
                        + mem::size_of_val(diffs_without_contents)
                }
            },
        };
        key_weight + val_weight
    }
}
#[derive(Debug, Clone, Copy, Hash, PartialEq, Eq)]
enum FileKind {
    Untracked,
    Changed,
}
#[derive(Debug)]

Deletion in inflorescence/src/main.rs at line 118 [2.2763]
B:BD[6.668] → [14.2724:2734]
```
    NoOp,
```

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

B:BD[13.216] → [17.2381:2401]

B:BD[17.2401] → [23.2919:3033]

∅:D[23.3033] → [15.574:640]

B:BD[15.574] → [15.574:640]

B:BD[17.2495] → [17.2495:2502]

    LoadedSrcFile {
        /// The cache counter value when the file was requested
        cache_counter: usize,
        id: FileId,
        data: Vec<u8>,
        encoding: Option<pijul::Encoding>,
    },

[13.216]

[23.3034]

    File(file::Msg),

Replacement in inflorescence/src/main.rs at line 132 [2.2763]
B:BD[23.3064] → [23.3064:3084]
```
        id: FileId,
```
[23.3064]
[24.331]
```
        id: file::Id,
```
Deletion in inflorescence/src/main.rs at line 144 [2.2763]
B:BD[9.6718] → [14.3214:3253]
```
        Message::NoOp => Task::none(),
```
Replacement in inflorescence/src/main.rs at line 162 [2.2763]
B:BD[35.122] → [35.122:158]
```
            &mut state.diffs_cache,
```
[35.122]
[35.158]
```
            &mut state.files,
```
Deletion in inflorescence/src/main.rs at line 164 [2.2763]
B:BD[35.191] → [35.191:228]
```
            &state.src_file_load_tx,
```

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

B:BD[14.6371] → [23.11128:11180]

∅:D[23.11180] → [17.4301:4354]

B:BD[17.4301] → [17.4301:4354]

                            &mut state.diffs_cache,
                            &state.src_file_load_tx,

[14.6371]

[14.6494]

                            &mut state.files,

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

B:BD[18.3535] → [23.11419:11479]

∅:D[23.11479] → [18.3599:3660]

B:BD[18.3599] → [18.3599:3660]

                                    &mut state.diffs_cache,
                                    &state.src_file_load_tx,

[18.3535]

[18.3660]

                                    &mut state.files,

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

B:BD[13.1976] → [13.1976:1990]

∅:D[13.1990] → [11.1020:1055]

∅:D[12.5568] → [11.1020:1055]

B:BD[11.1020] → [11.1020:1055]

B:BD[11.1055] → [17.4355:4388]

B:BD[17.4388] → [23.11480:11523]

∅:D[23.11523] → [15.705:760]

B:BD[15.705] → [15.705:760]

B:BD[15.760] → [23.11524:11738]

B:BD[23.11738] → [24.570:630]

∅:D[24.630] → [15.1411:1433]

∅:D[23.11807] → [15.1411:1433]

B:BD[15.1411] → [15.1411:1433]

B:BD[15.1433] → [24.631:695]

∅:D[24.695] → [23.11881:11982]

B:BD[23.11881] → [23.11881:11982]

B:BD[23.11982] → [24.696:813]

∅:D[24.813] → [23.12117:12539]

B:BD[23.12117] → [23.12117:12539]

B:BD[23.12539] → [24.814:947]

∅:D[24.947] → [23.12797:13074]

B:BD[23.12797] → [23.12797:13074]

∅:D[17.5181] → [16.1995:2013]

∅:D[23.13074] → [16.1995:2013]

B:BD[15.1696] → [16.1995:2013]

            }
            Task::none()
        }
        Message::LoadedSrcFile {
            cache_counter,
            id,
            data,
            encoding,
        } => {
            if state.diffs_cache.counter == cache_counter {
                let file_content = match encoding {
                    Some(encoding) => {
                        let decoded = encoding.decode(&data);
                        diff::FileContent::Decoded(decoded)
                    }
                    None => diff::FileContent::UnknownEncoding,
                };
                match id.file_kind {
                    FileKind::Untracked => {
                        let file_diff: diff::File =
                            diff::init_file(file_content, None);
                        diffs_cache_put(
                            &mut state.diffs_cache,
                            id,
                            FileDiff::Loaded(file_diff),
                        );
                    }
                    FileKind::Changed => {
                        if let Some(repo) = state.repo.as_ref() {
                            let changed_file = repo.changed_files.get(&id.path);
                            let file_diff: diff::File =
                                diff::init_file(file_content, changed_file);
                            diffs_cache_put(
                                &mut state.diffs_cache,
                                id,
                                FileDiff::Loaded(file_diff),
                            );
                        }
                    }
                }

Deletion in inflorescence/src/main.rs at line 331 [2.2763]
B:BD[16.2027] → [23.13075:13076]
Replacement in inflorescence/src/main.rs at line 338 [2.2763]
∅:D[32.1323] → [23.13362:13407]
B:BD[23.13362] → [23.13362:13407]
```
                        FileKind::Untracked,
```
[32.1323]
[23.13407]
```
                        file::Kind::Untracked,
```
Replacement in inflorescence/src/main.rs at line 345 [2.2763]
∅:D[32.1475] → [23.13639:13682]
B:BD[23.13639] → [23.13639:13682]
```
                        FileKind::Changed,
```
[32.1475]
[23.13682]
```
                        file::Kind::Changed,
```

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

[33.884]

[9.14755]

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

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

B:BD[9.14932] → [23.13912:13967]

            diffs_cache_clear(&mut state.diffs_cache);

[9.14932]

[10.359]

            file::diffs_cache_clear(&mut state.files.diffs_cache);

Replacement in inflorescence/src/main.rs at line 431 [2.2763]
∅:D[30.2245] → [23.13968:14023]
∅:D[28.9759] → [23.13968:14023]
B:BD[9.15249] → [23.13968:14023]
```
            diffs_cache_clear(&mut state.diffs_cache);
```
[30.2245]
[9.15249]
```
            file::diffs_cache_clear(&mut state.files.diffs_cache);
```

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

∅:D[32.1629] → [17.5310:5363]

∅:D[23.14201] → [17.5310:5363]

B:BD[14.7479] → [17.5310:5363]

B:BD[17.5363] → [23.14202:14254]

∅:D[23.14254] → [17.5419:5472]

B:BD[17.5419] → [17.5419:5472]

B:BD[17.5472] → [23.14255:14292]

                        load_src_file_if_not_cached(
                            &mut state.diffs_cache,
                            &state.src_file_load_tx,
                            FileId {

[32.1629]

[23.14292]

                        file::load_src_file_if_not_cached(
                            &mut state.files,
                            file::Id {

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

B:BD[23.14344] → [23.14344:14408]

                                file_kind: FileKind::Untracked,

[23.14344]

[23.14408]

                                file_kind: file::Kind::Untracked,

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

∅:D[35.489] → [23.14830:15057]

B:BD[23.14830] → [23.14830:15057]

                                load_src_file_if_not_cached(
                                    &mut state.diffs_cache,
                                    &state.src_file_load_tx,
                                    FileId {

[35.489]

[23.15057]

                                file::load_src_file_if_not_cached(
                                    &mut state.files,
                                    file::Id {

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

B:BD[23.15117] → [23.15117:15187]

                                        file_kind: FileKind::Changed,

[23.15117]

[23.15187]

                                        file_kind: file::Kind::Changed,

Deletion in inflorescence/src/main.rs at line 613 [2.2763]
B:BD[6.3183] → [14.8143:8146]
B:BD[14.8146] → [23.15369:15474]
∅:D[17.5610] → [14.8227:8257]
∅:D[23.15474] → [14.8227:8257]
B:BD[14.8227] → [14.8227:8257]
B:BD[14.8257] → [23.15475:15500]
∅:D[23.15500] → [14.8284:8337]
B:BD[14.8284] → [14.8284:8337]
B:BD[14.8337] → [15.1697:1756]
B:BD[15.1756] → [17.5611:5644]
B:BD[17.5644] → [23.15501:15517]
∅:D[23.15517] → [14.8405:8423]
B:BD[14.8405] → [14.8405:8423]
B:BD[14.8423] → [15.1757:1779]
B:BD[15.1779] → [23.15518:15545]
∅:D[15.1779] → [14.8423:8474]
∅:D[23.15545] → [14.8423:8474]
B:BD[14.8423] → [14.8423:8474]
```
}
async fn load_src_file(
    repo_path: PathBuf,
    id: FileId,
    cache_counter: usize,
) -> Message {
    let mut path = repo_path;
    path.push(&id.path);
    if let Ok(data) = tokio::fs::read(&path).await {
        let encoding = pijul::change::get_encoding(&data);
        Message::LoadedSrcFile {
            id,
            data,
            encoding,
            cache_counter,
        }
    } else {
        Message::NoOp
    }
```

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

B:BD[2.3224] → [17.5645:5677]

B:BD[17.5677] → [23.15546:15636]

∅:D[23.15636] → [17.5761:5765]

B:BD[17.5761] → [17.5761:5765]

B:BD[17.5765] → [23.15637:15788]

∅:D[23.15788] → [17.5917:5926]

B:BD[17.5917] → [17.5917:5926]

B:BD[17.5926] → [23.15789:16233]

∅:D[23.16233] → [17.6353:6392]

B:BD[17.6353] → [17.6353:6392]

B:BD[17.6392] → [23.16234:16306]

B:BD[23.16306] → [25.22:73]

B:BD[23.16535] → [29.16921:16924]

fn load_src_file_if_not_cached(
    cache: &mut DiffsCache,
    load_tx: &watch::Sender<(FileId, usize)>,
    id: FileId,
) {
    if !cache.inner.contains(&id) {
        diffs_cache_put(cache, id.clone(), FileDiff::Loading);
        load_tx.send((id, cache.counter)).unwrap();
    }
}
fn diffs_cache_put(cache: &mut DiffsCache, key: FileId, value: FileDiff) {
    if let Err((key, value)) = cache.inner.put_with_weight(key, value) {
        let kv_weight = DiffsCacheWeight.weight(&key, &value);
        info!("Source file cache is too small to hold {}. Resizing cache to to {kv_weight} fit it.", key.path);
        cache.inner.resize(NonZero::new(kv_weight).unwrap());
        let res = cache.inner.put_with_weight(key, value);
        assert!(res.is_ok());
    }
}
fn diffs_cache_clear(cache: &mut DiffsCache) {
    cache.inner.clear();
    cache.counter = cache.counter.wrapping_add(1);
}

Replacement in inflorescence/src/main.rs at line 709 [2.2763]
∅:D[32.1854] → [23.17095:17129]
B:BD[23.17095] → [23.17095:17129]
```
                let id = FileId {
```
[32.1854]
[23.17129]
```
                let id = file::Id {
```

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

B:BD[23.17169] → [23.17169:17221]

                    file_kind: FileKind::Untracked,

[23.17169]

[23.17221]

                    file_kind: file::Kind::Untracked,

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

B:BD[23.17240] → [23.17240:17364]

                let diffs = match state.diffs_cache.inner.peek(&id) {
                    Some(FileDiff::Loaded(file)) => {

[23.17240]

[32.1855]

                let diffs = match state.files.diffs_cache.inner.peek(&id) {
                    Some(file::Diff::Loaded(file)) => {

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

B:BD[23.17682] → [29.17498:17554]

                    None | Some(FileDiff::Loading) => {

[23.17682]

[29.17554]

                    None | Some(file::Diff::Loading) => {

Replacement in inflorescence/src/main.rs at line 736 [2.2763]
∅:D[32.2000] → [23.18071:18105]
B:BD[23.18071] → [23.18071:18105]
```
                let id = FileId {
```
[32.2000]
[23.18105]
```
                let id = file::Id {
```

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

B:BD[23.18145] → [23.18145:18195]

                    file_kind: FileKind::Changed,

[23.18145]

[23.18195]

                    file_kind: file::Kind::Changed,

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

B:BD[23.18214] → [23.18214:18338]

                let diffs = match state.diffs_cache.inner.peek(&id) {
                    Some(FileDiff::Loaded(file)) => {

[23.18214]

[32.2001]

                let diffs = match state.files.diffs_cache.inner.peek(&id) {
                    Some(file::Diff::Loaded(file)) => {

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

B:BD[22.4845] → [29.17813:17869]

                    None | Some(FileDiff::Loading) => {

[22.4845]

[29.17869]

                    None | Some(file::Diff::Loading) => {

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

[34.364]

//! Provides a way to load files from disk and to cache them.
use crate::diff;
use libflorescence::prelude::*;
use libflorescence::repo;
use std::mem;
use std::num::NonZero;
use std::path::PathBuf;
use clru::{CLruCache, WeightScale};
use iced::Task;
use tokio::sync::watch;
use tokio_stream::wrappers::WatchStream;
use tokio_stream::StreamExt;
// Invariant: Must be non-zero
const SRC_FILES_CACHE_CAPACITY: usize = 1024 * 1024 * 1024;
#[derive(Debug)]
pub struct State {
    pub file_load_tx: watch::Sender<(Id, usize)>,
    pub diffs_cache: DiffsCache,
}
#[derive(Debug, Clone)]
pub enum Msg {
    LoadedSrcFile {
        /// The cache counter value when the file was requested
        cache_counter: usize,
        id: Id,
        data: Vec<u8>,
        encoding: Option<pijul::Encoding>,
    },
    NoOp,
}
#[derive(Debug)]
pub struct DiffsCache {
    /// Used to prevent race-conditions between file loading and clearing cache
    pub counter: usize,
    pub inner: DiffsCacheInner,
}
pub type DiffsCacheInner =
    CLruCache<Id, Diff, std::hash::RandomState, DiffsCacheWeight>;
#[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,
}
#[derive(Debug)]
pub struct DiffsCacheWeight;
pub fn init(repo_path: PathBuf) -> (State, Task<Msg>) {
    let (src_file_load_tx, src_file_load_rx) = watch::channel((
        Id {
            path: "".to_string(),
            file_kind: Kind::Untracked,
        },
        0,
    ));
    let src_file_load_rx = WatchStream::from_changes(src_file_load_rx);
    let src_file_load_task = Task::run(
        src_file_load_rx
            .map(move |(id, cache_counter): (Id, usize)| {
                (repo_path.clone(), id, cache_counter)
            })
            .then(|(repo_path, id, cache_counter)| async move {
                load_src_file(repo_path, id, cache_counter).await
            }),
        |msg| msg,
    );
    let src_files_cache_capacity =
        NonZero::new(SRC_FILES_CACHE_CAPACITY).unwrap();
    let diffs_cache = DiffsCache {
        counter: 0,
        inner: DiffsCacheInner::with_scale(
            src_files_cache_capacity,
            DiffsCacheWeight,
        ),
    };
    let state = State {
        file_load_tx: src_file_load_tx,
        diffs_cache,
    };
    (state, src_file_load_task)
}
pub fn update(state: &mut State, repo: Option<&repo::State>, msg: Msg) {
    match msg {
        Msg::LoadedSrcFile {
            cache_counter,
            id,
            data,
            encoding,
        } => {
            if state.diffs_cache.counter == cache_counter {
                let file_content = match encoding {
                    Some(encoding) => {
                        let decoded = encoding.decode(&data);
                        diff::FileContent::Decoded(decoded)
                    }
                    None => diff::FileContent::UnknownEncoding,
                };
                match id.file_kind {
                    Kind::Untracked => {
                        let file_diff: diff::File =
                            diff::init_file(file_content, None);
                        diffs_cache_put(
                            &mut state.diffs_cache,
                            id,
                            Diff::Loaded(file_diff),
                        );
                    }
                    Kind::Changed => {
                        if let Some(repo) = repo {
                            let changed_file = repo.changed_files.get(&id.path);
                            let file_diff: diff::File =
                                diff::init_file(file_content, changed_file);
                            diffs_cache_put(
                                &mut state.diffs_cache,
                                id,
                                Diff::Loaded(file_diff),
                            );
                        }
                    }
                }
            }
        }
        Msg::NoOp => {}
    }
}
pub async fn load_src_file(
    repo_path: PathBuf,
    id: Id,
    cache_counter: usize,
) -> Msg {
    let mut path = repo_path;
    path.push(&id.path);
    if let Ok(data) = tokio::fs::read(&path).await {
        let encoding = pijul::change::get_encoding(&data);
        Msg::LoadedSrcFile {
            id,
            data,
            encoding,
            cache_counter,
        }
    } else {
        Msg::NoOp
    }
}
pub fn load_src_file_if_not_cached(state: &mut State, id: Id) {
    if !state.diffs_cache.inner.contains(&id) {
        diffs_cache_put(&mut state.diffs_cache, id.clone(), Diff::Loading);
        state
            .file_load_tx
            .send((id, state.diffs_cache.counter))
            .unwrap();
    }
}
pub fn diffs_cache_clear(cache: &mut DiffsCache) {
    cache.inner.clear();
    cache.counter = cache.counter.wrapping_add(1);
}
fn diffs_cache_put(cache: &mut DiffsCache, key: Id, value: Diff) {
    if let Err((key, value)) = cache.inner.put_with_weight(key, value) {
        let kv_weight = DiffsCacheWeight.weight(&key, &value);
        info!("Source file cache is too small to hold {}. Resizing cache to to {kv_weight} fit it.", key.path);
        cache.inner.resize(NonZero::new(kv_weight).unwrap());
        let res = cache.inner.put_with_weight(key, value);
        assert!(res.is_ok());
    }
}
impl WeightScale<Id, Diff> for DiffsCacheWeight {
    fn weight(&self, key: &Id, value: &Diff) -> usize {
        let key_weight = key.path.len();
        let val_weight = match value {
            Diff::Loading => 0,
            Diff::Loaded(file) => match file {
                diff::File::Decoded(diff::DecodedFile {
                    combined:
                        diff::Combined {
                            sections,
                            max_line_num: _,
                        },
                    diffs_without_contents,
                }) => {
                    mem::size_of_val(sections)
                        + mem::size_of::<usize>()
                        + mem::size_of_val(diffs_without_contents)
                }
                diff::File::Undecodable(diff::UndecodableFile {
                    diffs_with_contents,
                    diffs_without_contents,
                }) => {
                    mem::size_of_val(diffs_with_contents)
                        + mem::size_of_val(diffs_without_contents)
                }
            },
        };
        key_weight + val_weight
    }
}

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

[6.26]

[31.11927]

use crate::{diff, file};
use libflorescence::prelude::*;
use libflorescence::repo;

Deletion in inflorescence/src/cursor.rs at line 8 [6.26]
B:BD[35.2004] → [35.2004:2044]
```
use libflorescence::{prelude::*, repo};
```
Deletion in inflorescence/src/cursor.rs at line 9 [6.26]
∅:D[27.613] → [26.5870:5871]
∅:D[35.2068] → [26.5870:5871]
B:BD[26.5870] → [26.5870:5871]
B:BD[26.5871] → [35.2069:2147]
```
use crate::{diff, load_src_file_if_not_cached, DiffsCache, FileId, FileKind};
```
Replacement in inflorescence/src/cursor.rs at line 75 [6.26]
B:BD[35.2319] → [35.2319:2353]
```
    diffs_cache: &mut DiffsCache,
```
[35.2319]
[35.2353]
```
    files: &mut file::State,
```
Deletion in inflorescence/src/cursor.rs at line 77 [6.26]
B:BD[35.2385] → [35.2385:2440]
```
    src_file_load_tx: &watch::Sender<(FileId, usize)>,
```

Replacement in inflorescence/src/cursor.rs at line 90 [6.26]

B:BD[35.3023] → [35.3023:3339]

                                    let selection = changed_file_selection(
                                        repo,
                                        ix,
                                        diffs_cache,
                                        src_file_load_tx,
                                    );

[35.3023]

[35.3339]

                                    let selection =
                                        changed_file_selection(repo, ix, files);

Replacement in inflorescence/src/cursor.rs at line 99 [6.26]

B:BD[35.3741] → [35.3741:3942]

                                        repo,
                                        ix,
                                        diffs_cache,
                                        src_file_load_tx,

[35.3741]

[35.3942]

                                        repo, ix, files,

Replacement in inflorescence/src/cursor.rs at line 105 [6.26]

B:BD[35.4163] → [35.4163:4457]

                                let selection = untracked_file_selection(
                                    repo,
                                    ix,
                                    diffs_cache,
                                    src_file_load_tx,
                                );

[35.4163]

[35.4457]

                                let selection =
                                    untracked_file_selection(repo, ix, files);

Replacement in inflorescence/src/cursor.rs at line 121 [6.26]

B:BD[35.5213] → [35.5213:5414]

                                        repo,
                                        ix,
                                        diffs_cache,
                                        src_file_load_tx,

[35.5213]

[35.5414]

                                        repo, ix, files,

Replacement in inflorescence/src/cursor.rs at line 126 [6.26]

B:BD[35.5604] → [35.5604:5920]

                                    let selection = changed_file_selection(
                                        repo,
                                        ix,
                                        diffs_cache,
                                        src_file_load_tx,
                                    );

[35.5604]

[35.5920]

                                    let selection =
                                        changed_file_selection(repo, ix, files);

Replacement in inflorescence/src/cursor.rs at line 132 [6.26]

B:BD[35.6102] → [35.6102:6394]

                                let selection = changed_file_selection(
                                    repo,
                                    ix,
                                    diffs_cache,
                                    src_file_load_tx,
                                );

[35.6102]

[35.6394]

                                let selection =
                                    changed_file_selection(repo, ix, files);

Replacement in inflorescence/src/cursor.rs at line 188 [6.26]

B:BD[35.8750] → [35.8750:8983]

                                                repo,
                                                ix,
                                                diffs_cache,
                                                src_file_load_tx,

[35.8750]

[35.8983]

                                                repo, ix, files,

Replacement in inflorescence/src/cursor.rs at line 194 [6.26]

B:BD[35.9307] → [35.9307:9524]

                                            repo,
                                            ix,
                                            diffs_cache,
                                            src_file_load_tx,

[35.9307]

[35.9524]

                                            repo, ix, files,

Replacement in inflorescence/src/cursor.rs at line 211 [6.26]

B:BD[35.10232] → [35.10232:11599]

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

[35.10232]

[35.11599]

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

Replacement in inflorescence/src/cursor.rs at line 250 [6.26]

B:BD[35.12414] → [35.12414:12706]

                                let selection = changed_file_selection(
                                    repo,
                                    ix,
                                    diffs_cache,
                                    src_file_load_tx,
                                );

[35.12414]

[35.12706]

                                let selection =
                                    changed_file_selection(repo, ix, files);

Replacement in inflorescence/src/cursor.rs at line 255 [6.26]

B:BD[35.12874] → [35.12874:13168]

                                let selection = untracked_file_selection(
                                    repo,
                                    ix,
                                    diffs_cache,
                                    src_file_load_tx,
                                );

[35.12874]

[35.13168]

                                let selection =
                                    untracked_file_selection(repo, ix, files);

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

B:BD[35.13334] → [35.13334:13604]

                            let selection = untracked_file_selection(
                                repo,
                                ix,
                                diffs_cache,
                                src_file_load_tx,
                            );

[35.13334]

[35.13604]

                            let selection =
                                untracked_file_selection(repo, ix, files);

Replacement in inflorescence/src/cursor.rs at line 271 [6.26]

B:BD[35.14025] → [35.14025:14319]

                                let selection = untracked_file_selection(
                                    repo,
                                    ix,
                                    diffs_cache,
                                    src_file_load_tx,
                                );

[35.14025]

[35.14319]

                                let selection =
                                    untracked_file_selection(repo, ix, files);

Replacement in inflorescence/src/cursor.rs at line 279 [6.26]

B:BD[35.14663] → [35.14663:14955]

                                let selection = changed_file_selection(
                                    repo,
                                    ix,
                                    diffs_cache,
                                    src_file_load_tx,
                                );

[35.14663]

[35.14955]

                                let selection =
                                    changed_file_selection(repo, ix, files);

Replacement in inflorescence/src/cursor.rs at line 285 [6.26]

B:BD[35.15121] → [35.15121:15389]

                            let selection = changed_file_selection(
                                repo,
                                ix,
                                diffs_cache,
                                src_file_load_tx,
                            );

[35.15121]

[35.15389]

                            let selection =
                                changed_file_selection(repo, ix, files);

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

B:BD[35.17312] → [35.17312:17529]

                                            repo,
                                            ix,
                                            diffs_cache,
                                            src_file_load_tx,

[35.17312]

[35.17529]

                                            repo, ix, files,

Replacement in inflorescence/src/cursor.rs at line 336 [6.26]

B:BD[35.17926] → [35.17926:18159]

                                                repo,
                                                ix,
                                                diffs_cache,
                                                src_file_load_tx,

[35.17926]

[35.18159]

                                                repo, ix, files,

Replacement in inflorescence/src/cursor.rs at line 359 [6.26]

B:BD[35.19282] → [35.19282:19550]

                            let selection = changed_file_selection(
                                repo,
                                ix,
                                diffs_cache,
                                src_file_load_tx,
                            );

[35.19282]

[35.19550]

                            let selection =
                                changed_file_selection(repo, ix, files);

Replacement in inflorescence/src/cursor.rs at line 364 [6.26]

B:BD[35.19748] → [35.19748:20018]

                            let selection = untracked_file_selection(
                                repo,
                                ix,
                                diffs_cache,
                                src_file_load_tx,
                            );

[35.19748]

[35.20018]

                            let selection =
                                untracked_file_selection(repo, ix, files);

Replacement in inflorescence/src/cursor.rs at line 446 [6.26]

B:BD[35.23290] → [35.23290:23451]

                    load_src_file_if_not_cached(
                        diffs_cache,
                        src_file_load_tx,
                        FileId {

[35.23290]

[35.23451]

                    file::load_src_file_if_not_cached(
                        files,
                        file::Id {

Replacement in inflorescence/src/cursor.rs at line 450 [6.26]

B:BD[35.23499] → [35.23499:23559]

                            file_kind: FileKind::Untracked,

[35.23499]

[35.23559]

                            file_kind: file::Kind::Untracked,

Replacement in inflorescence/src/cursor.rs at line 461 [6.26]

B:BD[35.23999] → [35.23999:24192]

                            load_src_file_if_not_cached(
                                diffs_cache,
                                src_file_load_tx,
                                FileId {

[35.23999]

[35.24192]

                            file::load_src_file_if_not_cached(
                                files,
                                file::Id {

Replacement in inflorescence/src/cursor.rs at line 465 [6.26]

B:BD[35.24248] → [35.24248:24314]

                                    file_kind: FileKind::Changed,

[35.24248]

[35.24314]

                                    file_kind: file::Kind::Changed,

Replacement in inflorescence/src/cursor.rs at line 521 [6.26]

B:BD[35.26304] → [35.26304:26393]

    diffs_cache: &mut DiffsCache,
    src_file_load_tx: &watch::Sender<(FileId, usize)>,

[35.26304]

[35.26393]

    files: &mut file::State,

Replacement in inflorescence/src/cursor.rs at line 525 [6.26]
B:BD[35.26480] → [35.26480:26502]
```
    let id = FileId {
```
[35.26480]
[35.26502]
```
    let id = file::Id {
```
Replacement in inflorescence/src/cursor.rs at line 527 [6.26]
B:BD[35.26530] → [35.26530:26570]
```
        file_kind: FileKind::Untracked,
```
[35.26530]
[35.26570]
```
        file_kind: file::Kind::Untracked,
```

Replacement in inflorescence/src/cursor.rs at line 529 [6.26]

B:BD[35.26577] → [35.26577:26645]

    load_src_file_if_not_cached(diffs_cache, src_file_load_tx, id);

[35.26577]

[35.26645]

    file::load_src_file_if_not_cached(files, id);

Replacement in inflorescence/src/cursor.rs at line 537 [6.26]

B:BD[35.26761] → [35.26761:26850]

    diffs_cache: &mut DiffsCache,
    src_file_load_tx: &watch::Sender<(FileId, usize)>,

[35.26761]

[35.26850]

    files: &mut file::State,

Replacement in inflorescence/src/cursor.rs at line 542 [6.26]
B:BD[35.26980] → [35.26980:27006]
```
        let id = FileId {
```
[35.26980]
[35.27006]
```
        let id = file::Id {
```
Replacement in inflorescence/src/cursor.rs at line 544 [6.26]
B:BD[35.27038] → [35.27038:27080]
```
            file_kind: FileKind::Changed,
```
[35.27038]
[35.27080]
```
            file_kind: file::Kind::Changed,
```

Replacement in inflorescence/src/cursor.rs at line 546 [6.26]

B:BD[35.27091] → [35.27091:27163]

        load_src_file_if_not_cached(diffs_cache, src_file_load_tx, id);

[35.27091]

[35.27163]

        file::load_src_file_if_not_cached(files, id);

refactor file stuff into sub-mod

Dependencies

In channels

Change contents

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

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

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

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

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

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