tzemanovic/inflorescence - Change UPWS6J3BIHQKXSSWHD7CFLJOXWT3MRABFRVQ4T4NRYFALBAKJOOQC

filter to-record changes from selection

Created by Tomáš Zemanovič on November 21, 2025

UPWS6J3BIHQKXSSWHD7CFLJOXWT3MRABFRVQ4T4NRYFALBAKJOOQC

Dependencies

In channels

main

Change contents

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

[14.31]

use libpijul::HashMap;
use crate::{diff, repo};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Pick {
    Include,
    Exclude,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum PickSet {
    #[default]
    Include,
    Exclude,
    Partial,
}
#[derive(Clone, Debug, Default)]
pub struct State {
    /// State of all files
    pub overall: PickSet,
    /// Map from file name to its changes state. This is preserved even when
    /// `overall` selection changes.
    pub files: HashMap<String, PickSet>,
    /// Map from file name to its individual change state. This is preserved
    /// even when `overall` and `files` selection changes
    pub changes: HashMap<String, PartialFile>,
}
#[derive(Clone, Debug, Default)]
pub struct PartialFile {
    /// Map from file name to its state
    // NOTE: When it's possible to select individual lines/chars to record,
    // then the value would be `PickSet` and the inner-most value of
    // selected ranges would be `Pick`
    pub changes: HashMap<diff::IdHash, Pick>,
}
/// Determine the default value for a file that is not explicitly set.
pub fn default_pick_set(state: &State) -> PickSet {
    match default_pick(state) {
        Pick::Include => PickSet::Include,
        Pick::Exclude => PickSet::Exclude,
    }
}
/// Determine the default value for a change that is not explicitly set.
pub fn default_pick(state: &State) -> Pick {
    let State {
        overall,
        files,
        changes: _,
    } = state;
    if matches!(overall, PickSet::Partial)
        || files
            .values()
            .any(|pick| matches!(pick, PickSet::Partial | PickSet::Exclude))
    {
        Pick::Exclude
    } else {
        Pick::Include
    }
}
pub fn determine_file(
    state: &State,
    file: &str,
    changed_files: &repo::ChangedFiles,
) -> PickSet {
    match state.overall {
        PickSet::Include => PickSet::Include,
        PickSet::Exclude => PickSet::Exclude,
        PickSet::Partial => {
            if let Some(pick) = state.files.get(file) {
                *pick
            } else if file_has_any_partial_change(file, state, changed_files) {
                PickSet::Partial
            } else {
                default_pick_set(state)
            }
        }
    }
}
pub fn determine_change(
    file: &str,
    diff_id: diff::IdHash,
    state: &State,
) -> Pick {
    match state.overall {
        PickSet::Include => return Pick::Include,
        PickSet::Exclude => return Pick::Exclude,
        PickSet::Partial => {}
    }
    if let Some(pick) = state.files.get(file) {
        match pick {
            PickSet::Include => return Pick::Include,
            PickSet::Exclude => return Pick::Exclude,
            PickSet::Partial => {}
        }
    }
    let explicit = state
        .changes
        .get(file)
        .and_then(|file| file.changes.get(&diff_id))
        .copied();
    dbg!(&explicit);
    explicit.unwrap_or_else(|| default_pick(state))
}
pub fn file_has_any_partial_change(
    file: &str,
    state: &State,
    changed_files: &repo::ChangedFiles,
) -> bool {
    let changes = changed_files.get(file).unwrap();
    let (mut has_include, mut has_exclude) = (false, false);
    state
        .changes
        .get(file)
        .map(|file| {
            if file.changes.len() == changes.len() {
                // The number of of changes in selection is the same as number
                // of actual changes, we need to have both exclude and include
                // to be partial
                file.changes.values().any(|pick| {
                    has_exclude |= matches!(pick, Pick::Exclude);
                    has_include |= matches!(pick, Pick::Include);
                    has_include && has_exclude
                })
            } else {
                // There is the same number of changes in selection is not the
                // same as number of actual changes, we only need to find 1
                // exclusion to be partial
                file.changes
                    .values()
                    .any(|pick| matches!(pick, Pick::Exclude))
            }
        })
        .unwrap_or_default()
}

Replacement in libflorescence/src/testing.rs at line 85 [15.5]

B:BD[16.323] → [22.62:139]

    repo::record(&internal, "Initialized".to_string(), None, skey).unwrap();

[16.323]

[15.1856]

    let to_record = crate::to_record::State::default();
    repo::record(&internal, "Initialized".to_string(), None, skey, to_record)
        .unwrap();

Insertion in libflorescence/src/repo.rs at line 9 [2.7]
[13.62]
[13.62]
```
use crate::{diff, to_record};
```
Insertion in libflorescence/src/repo.rs at line 65 [2.7]
[19.413]
[19.413]
```
        to_record: to_record::State,
```

Replacement in libflorescence/src/repo.rs at line 188 [2.7]

B:BD[6.726] → [18.219:289]

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

[6.726]

[12.119]

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

Replacement in libflorescence/src/repo.rs at line 317 [2.7]

B:BD[6.2830] → [21.106:151]

        MsgIn::Record { msg, desc, sk } => {

[6.2830]

[22.1472]

        MsgIn::Record {
            msg,
            desc,
            sk,
            to_record,
        } => {

Replacement in libflorescence/src/repo.rs at line 326 [2.7]

B:BD[22.1582] → [22.1582:1642]

                    record(internal_state, msg, desc, sk)?;

[22.1582]

[22.1642]

                    record(internal_state, msg, desc, sk, to_record)?;

Insertion in libflorescence/src/repo.rs at line 564 [2.7]
[21.320]
[22.4338]
```
    to_record: to_record::State,
```

Insertion in libflorescence/src/repo.rs at line 567 [2.7]

[5.389]

[22.4365]


    // These two variable are needed to for `to_record` change filter.
    let diff = diff(repo)?;
    let changed_files = changed_files(&diff, &repo.changes)?;

Insertion in libflorescence/src/repo.rs at line 652 [2.7]

[22.5474]

[7.2453]


        // Filter changes using `to_record`
        match to_record.overall {
            to_record::PickSet::Exclude => {
                bail!("Nothing to record")
            }
            to_record::PickSet::Partial => {
                change.changes.retain(|hunk| {
                    if let Ok((path, diff)) =
                        pijul_change_to_diff(&diff, hunk, &repo.changes)
                    {
                        match to_record::determine_file(
                            &to_record,
                            &path,
                            &changed_files,
                        ) {
                            to_record::PickSet::Exclude => {
                                return false;
                            }
                            to_record::PickSet::Partial => {
                                let diff_id = diff::id_parts_hash(&diff);
                                match to_record::determine_change(
                                    &path, diff_id, &to_record,
                                ) {
                                    to_record::Pick::Exclude => {
                                        return false;
                                    }
                                    to_record::Pick::Include => {}
                                }
                            }
                            to_record::PickSet::Include => {}
                        }
                    }
                    true
                });
            }
            to_record::PickSet::Include => {}
        }

Replacement in libflorescence/src/repo.rs at line 859 [2.7]

B:BD[18.504] → [18.504:527]

∅:D[9.457] → [4.1758:1815]

∅:D[18.527] → [4.1758:1815]

∅:D[8.535] → [4.1758:1815]

B:BD[2.3019] → [4.1758:1815]

B:BD[4.1815] → [25.250:999]

∅:D[9.642] → [2.3081:3113]

∅:D[25.999] → [2.3081:3113]

∅:D[4.1988] → [2.3081:3113]

B:BD[2.3081] → [2.3081:3113]

B:BD[2.3113] → [4.1989:2013]

B:BD[4.2013] → [25.1000:1026]

∅:D[25.1026] → [2.3160:3182]

∅:D[4.2042] → [2.3160:3182]

B:BD[2.3160] → [2.3160:3182]

B:BD[2.3182] → [25.1027:1053]

∅:D[25.1053] → [9.643:662]

B:BD[4.2072] → [9.643:662]

B:BD[9.662] → [25.1054:1464]

        match change {
            BaseHunk::FileMove {
                del: _,
                add,
                path: old_path,
            } => match add {
                change::Atom::NewVertex(add) => {
                    let FileMetadata {
                        basename: new_path,
                        metadata: _,
                        ..
                    } = FileMetadata::read(
                        &diff.contents[add.start.0.into()..add.end.0.into()],
                    );
                    changes.entry(new_path.to_string()).or_default().insert(
                        ChangedFileDiff::Move {
                            old_path: old_path.clone(),
                        },
                    );
                }
                change::Atom::EdgeMap(_edge_map) => todo!(),
            },
            BaseHunk::FileDel {
                del: _,
                contents,
                path,
                encoding,
            } => {
                let contents = if let Some(contents) = contents.as_ref() {
                    let raw_contents = get_change_contents(
                        repo_changes,
                        contents,
                        &diff.contents,
                    )?;
                    Some(try_decode_contents(raw_contents, encoding))
                } else {
                    None
                };

[18.504]

[25.1464]

        let (path, diff) = pijul_change_to_diff(diff, change, repo_changes)?;
        changes.entry(path).or_default().insert(diff);
    }
    Ok(changes)
}

Replacement in libflorescence/src/repo.rs at line 865 [2.7]

∅:D[25.1465] → [9.662:761]

B:BD[9.662] → [9.662:761]

B:BD[9.761] → [25.1466:1530]

∅:D[25.1530] → [9.812:826]

B:BD[9.812] → [9.812:826]

∅:D[9.826] → [2.3234:3268]

∅:D[4.2198] → [2.3234:3268]

B:BD[2.3234] → [2.3234:3268]

B:BD[2.3268] → [4.2199:2254]

∅:D[4.2254] → [2.3317:3339]

B:BD[2.3317] → [2.3317:3339]

B:BD[2.3339] → [4.2255:2284]

B:BD[4.2284] → [9.827:1012]

∅:D[9.1012] → [2.3391:3423]

∅:D[4.2412] → [2.3391:3423]

B:BD[2.3391] → [2.3391:3423]

B:BD[2.3502] → [2.3502:3524]

B:BD[2.3524] → [4.2413:2530]

B:BD[4.2530] → [9.1013:1682]

∅:D[9.1682] → [2.3712:3741]

∅:D[4.3028] → [2.3712:3741]

B:BD[2.3712] → [2.3712:3741]

B:BD[2.3765] → [2.3765:3788]

B:BD[2.3788] → [8.536:560]

B:BD[8.560] → [10.491:517]

∅:D[10.517] → [8.561:580]

B:BD[4.3085] → [8.561:580]

B:BD[8.633] → [8.633:1058]

B:BD[8.1058] → [10.518:553]

B:BD[10.553] → [22.7946:8026]

∅:D[22.8026] → [10.554:630]

B:BD[8.1202] → [10.554:630]

∅:D[10.630] → [8.1202:1203]

B:BD[8.1202] → [8.1202:1203]

B:BD[8.1203] → [11.179:411]

                changes
                    .entry(path.clone())
                    .or_default()
                    .insert(ChangedFileDiff::Del { contents });
            }
            BaseHunk::FileUndel {
                undel: _,
                contents: _,
                path,
                encoding: _,
            } => {
                changes
                    .entry(path.clone())
                    .or_default()
                    .insert(ChangedFileDiff::Undel);
            }
            BaseHunk::FileAdd {
                path,
                add_name: _,
                add_inode: _,
                contents: _,
                encoding: _,
            } => {
                changes
                    .entry(path.clone())
                    .or_default()
                    .insert(ChangedFileDiff::Add);
            }
            BaseHunk::SolveNameConflict { name: _, path } => {
                changes
                    .entry(path.clone())
                    .or_default()
                    .insert(ChangedFileDiff::SolveNameConflict);
            }
            BaseHunk::UnsolveNameConflict { name: _, path } => {
                changes
                    .entry(path.clone())
                    .or_default()
                    .insert(ChangedFileDiff::UnsolveNameConflict);
            }
            BaseHunk::Edit {
                local,
                change,
                encoding,
            } => {
                let line = local.line;
                let deleted = if let change::Atom::EdgeMap(map) = change {
                    map.edges
                        .first()
                        .map(|edge| edge.flag.is_deleted())
                        .unwrap_or_default()
                } else {
                    false
                };
                // TODO: This fn isn't public in upstream pijul, contrib
                let raw_contents =
                    get_change_contents(repo_changes, change, &diff.contents)?;
                let contents = try_decode_contents(raw_contents, encoding);
                let diff = ChangedFileDiff::Edit {
                    line,
                    deleted,
                    contents,
                };
                changes.entry(local.path.clone()).or_default().insert(diff);

[25.1465]

[8.1447]

// Get the file name and diff from a Pijul hunk
fn pijul_change_to_diff(
    diff: &Diff,
    hunk: &DiffHunk,
    repo_changes: &FileSystem,
) -> anyhow::Result<(String, ChangedFileDiff)> {
    let changed_file = match hunk {
        BaseHunk::FileMove {
            del: _,
            add,
            path: old_path,
        } => match add {
            change::Atom::NewVertex(add) => {
                let FileMetadata {
                    basename: new_path,
                    metadata: _,
                    ..
                } = FileMetadata::read(
                    &diff.contents[add.start.0.into()..add.end.0.into()],
                );
                (
                    new_path.to_string(),
                    ChangedFileDiff::Move {
                        old_path: old_path.clone(),
                    },
                )

Replacement in libflorescence/src/repo.rs at line 892 [2.7]

∅:D[8.1461] → [2.3851:3887]

∅:D[4.3218] → [2.3851:3887]

B:BD[2.3851] → [2.3851:3887]

B:BD[2.3887] → [11.412:465]

∅:D[11.465] → [2.3940:3963]

∅:D[4.3278] → [2.3940:3963]

B:BD[2.3940] → [2.3940:3963]

B:BD[2.3963] → [11.466:492]

∅:D[11.492] → [9.1819:1838]

B:BD[4.3308] → [9.1819:1838]

B:BD[9.1838] → [11.493:574]

B:BD[11.574] → [22.8027:8107]

∅:D[22.8107] → [11.687:866]

B:BD[11.687] → [11.687:866]

            BaseHunk::Replacement {
                change,
                replacement,
                local,
                encoding,
            } => {
                let line = local.line;
                let raw_change_contents =
                    get_change_contents(repo_changes, change, &diff.contents)?;
                let change_contents =
                    try_decode_contents(raw_change_contents, encoding);
                let raw_replacement_contents = get_change_contents(

[8.1461]

[11.866]

            change::Atom::EdgeMap(_edge_map) => todo!(),
        },
        BaseHunk::FileDel {
            del: _,
            contents,
            path,
            encoding,
        } => {
            let contents = if let Some(contents) = contents.as_ref() {
                let raw_contents = get_change_contents(

Replacement in libflorescence/src/repo.rs at line 903 [2.7]
B:BD[11.900] → [11.900:933]
```
                    replacement,
```
[11.900]
[11.933]
```
                    contents,
```

Replacement in libflorescence/src/repo.rs at line 906 [2.7]

∅:D[22.8128] → [11.1014:1134]

B:BD[11.1014] → [11.1014:1134]

                let replacement_contents =
                    try_decode_contents(raw_replacement_contents, encoding);

[22.8128]

[11.1134]

                Some(try_decode_contents(raw_contents, encoding))
            } else {
                None
            };

Replacement in libflorescence/src/repo.rs at line 911 [2.7]

B:BD[11.1135] → [11.1135:1394]

∅:D[11.1394] → [9.2002:2268]

B:BD[9.2002] → [9.2002:2268]

∅:D[9.2268] → [4.3643:3712]

B:BD[4.3643] → [4.3643:3712]

B:BD[4.3712] → [9.2269:2442]

∅:D[9.2442] → [4.3871:3885]

B:BD[4.3871] → [4.3871:3885]

∅:D[4.3885] → [2.4159:4200]

B:BD[2.4159] → [2.4159:4200]

B:BD[2.4200] → [4.3886:3913]

∅:D[4.3913] → [2.4224:4247]

B:BD[2.4224] → [2.4224:4247]

B:BD[2.4247] → [4.3914:3943]

B:BD[4.3943] → [9.2443:3114]

                let diff = ChangedFileDiff::Replacement {
                    line,
                    change_contents,
                    replacement_contents,
                };
                changes.entry(local.path.clone()).or_default().insert(diff);
            }
            BaseHunk::SolveOrderConflict { change: _, local } => {
                changes
                    .entry(local.path.clone())
                    .or_default()
                    .insert(ChangedFileDiff::SolveOrderConflict);
            }
            BaseHunk::UnsolveOrderConflict { change: _, local } => {
                changes
                    .entry(local.path.clone())
                    .or_default()
                    .insert(ChangedFileDiff::UnsolveOrderConflict);
            }
            BaseHunk::ResurrectZombies {
                change: _,
                local,
                encoding: _,
            } => {
                changes
                    .entry(local.path.clone())
                    .or_default()
                    .insert(ChangedFileDiff::ResurrectZombines);
            }
            BaseHunk::AddRoot { name: _, inode: _ } => {
                changes
                    .entry(ROOT_FILE.to_string())
                    .or_default()
                    .insert(ChangedFileDiff::AddRoot);
            }
            BaseHunk::DelRoot { name: _, inode: _ } => {
                changes
                    .entry(ROOT_FILE.to_string())
                    .or_default()
                    .insert(ChangedFileDiff::DelRoot);
            }

[11.1135]

[9.3114]

            (path.clone(), ChangedFileDiff::Del { contents })

Replacement in libflorescence/src/repo.rs at line 913 [2.7]

B:BD[9.3124] → [9.3124:3130]

B:BD[9.3130] → [22.8129:8145]

    }
    Ok(changes)

[9.3124]

[3.574]

        BaseHunk::FileUndel {
            undel: _,
            contents: _,
            path,
            encoding: _,
        } => (path.clone(), ChangedFileDiff::Undel),
        BaseHunk::FileAdd {
            path,
            add_name: _,
            add_inode: _,
            contents: _,
            encoding: _,
        } => (path.clone(), ChangedFileDiff::Add),
        BaseHunk::SolveNameConflict { name: _, path } => {
            (path.clone(), ChangedFileDiff::SolveNameConflict)
        }
        BaseHunk::UnsolveNameConflict { name: _, path } => {
            (path.clone(), ChangedFileDiff::UnsolveNameConflict)
        }
        BaseHunk::Edit {
            local,
            change,
            encoding,
        } => {
            let line = local.line;
            let deleted = if let change::Atom::EdgeMap(map) = change {
                map.edges
                    .first()
                    .map(|edge| edge.flag.is_deleted())
                    .unwrap_or_default()
            } else {
                false
            };
            // TODO: This fn isn't public in upstream pijul, contrib
            let raw_contents =
                get_change_contents(repo_changes, change, &diff.contents)?;
            let contents = try_decode_contents(raw_contents, encoding);
            let diff = ChangedFileDiff::Edit {
                line,
                deleted,
                contents,
            };
            (local.path.clone(), diff)
        }
        BaseHunk::Replacement {
            change,
            replacement,
            local,
            encoding,
        } => {
            let line = local.line;
            let raw_change_contents =
                get_change_contents(repo_changes, change, &diff.contents)?;
            let change_contents =
                try_decode_contents(raw_change_contents, encoding);
            let raw_replacement_contents =
                get_change_contents(repo_changes, replacement, &diff.contents)?;
            let replacement_contents =
                try_decode_contents(raw_replacement_contents, encoding);
            let diff = ChangedFileDiff::Replacement {
                line,
                change_contents,
                replacement_contents,
            };
            (local.path.clone(), diff)
        }
        BaseHunk::SolveOrderConflict { change: _, local } => {
            (local.path.clone(), ChangedFileDiff::SolveOrderConflict)
        }
        BaseHunk::UnsolveOrderConflict { change: _, local } => {
            (local.path.clone(), ChangedFileDiff::UnsolveOrderConflict)
        }
        BaseHunk::ResurrectZombies {
            change: _,
            local,
            encoding: _,
        } => (local.path.clone(), ChangedFileDiff::ResurrectZombines),
        BaseHunk::AddRoot { name: _, inode: _ } => {
            (ROOT_FILE.to_string(), ChangedFileDiff::AddRoot)
        }
        BaseHunk::DelRoot { name: _, inode: _ } => {
            (ROOT_FILE.to_string(), ChangedFileDiff::DelRoot)
        }
    };
    Ok(changed_file)

Replacement in libflorescence/src/repo/test.rs at line 116 [27.1959]

B:BD[21.574] → [22.10423:10490]

    repo::record(&internal, msg.to_string(), None, skey).unwrap();

[21.574]

[17.862]

    let to_record = crate::to_record::State::default();
    repo::record(&internal, msg.to_string(), None, skey, to_record).unwrap();

Insertion in libflorescence/src/lib.rs at line 10 [28.1776]
[15.2186]
[18.680]
```
pub mod to_record;
```

Replacement in inflorescence_view/src/diff.rs at line 106 [29.417]

B:BD[26.3798] → [26.3798:3875]

                to_record::determine_change_pick(path, *diff_id, to_record);

[26.3798]

[26.3875]

                to_record::determine_change(path, *diff_id, to_record);

Insertion in inflorescence_model/src/to_record.rs at line 6 [23.2488]

[23.2557]

pub use libflorescence::to_record::{
    determine_change, determine_file, PartialFile, Pick, PickSet, State,
};

Insertion in inflorescence_model/src/to_record.rs at line 11 [23.2488]

[23.2589]

[26.5893]

use libflorescence::to_record::{
    default_pick, default_pick_set, file_has_any_partial_change,
};

Deletion in inflorescence_model/src/to_record.rs at line 16 [23.2488]
B:BD[23.2616] → [23.2616:2648]
```
use std::collections::HashMap;
```

Deletion in inflorescence_model/src/to_record.rs at line 21 [23.2488]

∅:D[26.6019] → [23.2854:2857]

B:BD[23.2854] → [23.2854:2857]

B:BD[23.2857] → [24.1889:1934]

∅:D[24.1934] → [23.2887:2932]

B:BD[23.2887] → [23.2887:2932]

B:BD[23.2932] → [24.1935:1989]

∅:D[24.1989] → [23.2971:3774]

B:BD[23.2971] → [23.2971:3774]

B:BD[23.3774] → [26.6020:6066]

∅:D[26.6066] → [23.3829:4378]

B:BD[23.3829] → [23.3829:4378]

B:BD[23.4378] → [26.6067:6768]

}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Pick {
    Include,
    Exclude,
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum PickSet {
    #[default]
    Include,
    Exclude,
    Partial,
}
#[derive(Clone, Debug, Default)]
pub struct State {
    /// State of all files
    pub overall: PickSet,
    /// Map from file name to its changes state. This is preserved even when
    /// `overall` selection changes.
    pub files: HashMap<String, PickSet>,
    /// Map from file name to its individual change state. This is preserved
    /// even when `overall` and `files` selection changes
    pub changes: HashMap<String, PartialFile>,
}
#[derive(Clone, Debug, Default)]
pub struct PartialFile {
    /// Map from file name to its state
    // NOTE: When it's possible to select individual lines/chars to record,
    // then the value would be `PickSet` and the inner-most value of
    // selected ranges would be `Pick`
    pub changes: HashMap<diff::IdHash, Pick>,
}
pub fn determine_file(
    state: &State,
    file: &str,
    changed_files: &repo::ChangedFiles,
) -> PickSet {
    match state.overall {
        PickSet::Include => PickSet::Include,
        PickSet::Exclude => PickSet::Exclude,
        PickSet::Partial => {
            if let Some(pick) = state.files.get(file) {
                *pick
            } else if file_has_any_partial_change(file, state, changed_files) {
                PickSet::Partial
            } else {
                default_pick_set(state)
            }
        }
    }
}
pub fn determine_change_pick(
    file: &str,
    diff_id: diff::IdHash,
    state: &State,
) -> Pick {
    match state.overall {
        PickSet::Include => return Pick::Include,
        PickSet::Exclude => return Pick::Exclude,
        PickSet::Partial => {}
    }
    if let Some(pick) = state.files.get(file) {
        match pick {
            PickSet::Include => return Pick::Include,
            PickSet::Exclude => return Pick::Exclude,
            PickSet::Partial => {}
        }
    }
    let explicit = state
        .changes
        .get(file)
        .and_then(|file| file.changes.get(&diff_id))
        .copied();
    dbg!(&explicit);
    explicit.unwrap_or_else(|| default_pick(state))

Deletion in inflorescence_model/src/to_record.rs at line 186 [23.2488]

B:BD[23.7516] → [23.7516:7762]

    }
}
/// Determine the default value for a file that is not explicitly set.
fn default_pick_set(state: &State) -> PickSet {
    match default_pick(state) {
        Pick::Include => PickSet::Include,
        Pick::Exclude => PickSet::Exclude,

Deletion in inflorescence_model/src/to_record.rs at line 189 [23.2488]

B:BD[23.7771] → [23.7771:7933]

B:BD[23.7933] → [24.4901:4921]

∅:D[24.4921] → [23.7950:8125]

B:BD[23.7950] → [23.7950:8125]

B:BD[23.8287] → [23.8287:8359]

/// Determine the default value for a change that is not explicitly set.
fn default_pick(state: &State) -> Pick {
    let State {
        overall,
        files,
        changes: _,
    } = state;
    if matches!(overall, PickSet::Partial)
        || files
            .values()
            .any(|pick| matches!(pick, PickSet::Partial | PickSet::Exclude))
    {
        Pick::Exclude
    } else {
        Pick::Include
    }
}

Deletion in inflorescence_model/src/to_record.rs at line 212 [23.2488]

B:BD[23.9168] → [23.9168:10360]

fn file_has_any_partial_change(
    file: &str,
    state: &State,
    changed_files: &repo::ChangedFiles,
) -> bool {
    let changes = changed_files.get(file).unwrap();
    let (mut has_include, mut has_exclude) = (false, false);
    state
        .changes
        .get(file)
        .map(|file| {
            if file.changes.len() == changes.len() {
                // The number of of changes in selection is the same as number
                // of actual changes, we need to have both exclude and include
                // to be partial
                file.changes.values().any(|pick| {
                    has_exclude |= matches!(pick, Pick::Exclude);
                    has_include |= matches!(pick, Pick::Include);
                    has_include && has_exclude
                })
            } else {
                // There is the same number of changes in selection is not the
                // same as number of actual changes, we only need to find 1
                // exclusion to be partial
                file.changes
                    .values()
                    .any(|pick| matches!(pick, Pick::Exclude))
            }
        })
        .unwrap_or_default()
}

Insertion in inflorescence/src/main.rs at line 917 [28.2763]
[19.89079]
[19.89099]
```
        to_record,
```

Replacement in inflorescence/src/main.rs at line 939 [28.2763]

B:BD[20.11165] → [21.12817:12878]

                .send(repo::MsgIn::Record { msg, desc, sk })

[20.11165]

[20.11220]

                .send(repo::MsgIn::Record {
                    msg,
                    desc,
                    sk,
                    to_record: to_record.clone(),
                })