finchie/editor - Change B7YKJDKD7ZQ2JV4FLKZUHMIH6BQXH57ALGQOGQ4YTFGITBYMWY4QC

Handle untracked files

The refactoring from this change makes things a lot cleaner, so it should also come with a few less bugs

Created by finchie on June 21, 2023

B7YKJDKD7ZQ2JV4FLKZUHMIH6BQXH57ALGQOGQ4YTFGITBYMWY4QC

Dependencies

In channels

main

Change contents

Insertion in src/lib.rs at line 1 [3.585]
[3.585]
[4.0]
```
#![feature(map_try_insert)]
```

Replacement in src/lib.rs at line 6 [3.585]

B:BD[3.611] → [4.83:118]

use canonical_path::CanonicalPath;

[3.611]

[4.118]

use canonical_path::{CanonicalPath, CanonicalPathBuf};

Insertion in src/lib.rs at line 8 [3.585]
[4.155]
[4.155]
```
use libpijul::TxnTExt;
```

Replacement in src/lib.rs at line 21 [3.585]

B:BD[4.307] → [4.307:531]

fn get_hunks(
    cx: &mut FunctionContext,
    path: Option<PathBuf>,
    stop_early: bool,
) -> Result<Vec<PrintableHunk>, anyhow::Error> {
    let repo = Repository::find_root(path.clone()).expect("Could not find root");

[4.307]

[4.531]

fn get_hunks(path: &Path, stop_early: bool) -> Result<Vec<PrintableHunk>, anyhow::Error> {
    let repo = Repository::find_root(Some(path.to_owned())).expect("Could not find root");

Replacement in src/lib.rs at line 31 [3.585]

B:BD[4.786] → [4.786:1023]

    let prefix = if let Some(path) = path {
        path.strip_prefix(&repo.path)?.to_string_lossy().to_string()
    } else {
        String::new()
    };
    console_log(cx, format!("Prefix: {prefix} root: {:?}", repo.path)).unwrap();

[4.786]

[4.1023]

    let prefix = path.strip_prefix(&repo.path)?.to_string_lossy().to_string();

Deletion in src/lib.rs at line 44 [3.585]
B:BD[4.1375] → [4.1375:1419]
```
    let recorded = record_builder.finish();
```
Insertion in src/lib.rs at line 45 [3.585]
[4.1420]
[4.1420]
```
    let recorded = record_builder.finish();
```
Replacement in src/lib.rs at line 101 [3.585]
B:BD[4.2792] → [4.2792:2817]
```
#[derive(Eq, PartialEq)]
```
[4.2792]
[4.2817]
```
#[derive(Debug, Eq, PartialEq)]
```
Deletion in src/lib.rs at line 103 [3.585]
B:BD[4.2839] → [4.2839:2850]
```
    Added,
```

Replacement in src/lib.rs at line 106 [3.585]

B:BD[4.2867] → [4.2867:2885]

impl Annotation {

[4.2867]

[2.0]

#[derive(Debug, Eq, PartialEq)]
pub enum State {
    Tracked(Vec<Annotation>),
    Added,
    Untracked,
    Ignored,
}
impl State {

Replacement in src/lib.rs at line 117 [3.585]

B:BD[4.2940] → [4.2940:3019]

            Annotation::Added => "A",
            Annotation::Modified => "M",

[4.2940]

[4.3019]

            Self::Tracked(annotations) => annotations
                .iter()
                .map(|annotation| {
                    match annotation {
                        Annotation::Modified => "M",
                    }
                    .to_string()
                })
                .collect::<Vec<String>>()
                .join(", "),
            Self::Added => String::from("A"),
            Self::Untracked => String::from("U"),
            Self::Ignored => String::new(),

Deletion in src/lib.rs at line 131 [3.585]
B:BD[4.3029] → [4.3029:3050]
```
        .to_string()
```

Replacement in src/lib.rs at line 135 [3.585]

B:BD[4.3112] → [4.3112:3202]

            Annotation::Added => "Added",
            Annotation::Modified => "Modified",

[4.3112]

[4.3202]

            Self::Tracked(annotations) => annotations
                .iter()
                .map(|annotation| {
                    match annotation {
                        Annotation::Modified => "Modified",
                    }
                    .to_string()
                })
                .collect::<Vec<String>>()
                .join(", "),
            Self::Added => String::from("Added"),
            Self::Untracked => String::from("Untracked"),
            Self::Ignored => String::new(),

Deletion in src/lib.rs at line 149 [3.585]
B:BD[4.3212] → [4.3212:3233]
```
        .to_string()
```

Replacement in src/lib.rs at line 152 [3.585]

B:BD[4.3242] → [4.3242:3490]

fn short_diff(mut cx: FunctionContext) -> JsResult<JsArray> {
    let path: Handle<JsString> = cx.argument(0)?;
    let path = PathBuf::from(path.value(&mut cx));
    let hunks = get_hunks(&mut cx, Some(path), true).expect("Unable to load hunks");

[4.3242]

[4.3490]

pub fn untracked(path: &Path) -> Result<Vec<PathBuf>, anyhow::Error> {
    let repo = Repository::find_root(Some(path.to_owned())).expect("Could not find root");
    let txn = repo.pristine.arc_txn_begin()?;
    let channel_name = txn
        .read()
        .current_channel()
        .unwrap_or(libpijul::DEFAULT_CHANNEL)
        .to_string();
    let channel = txn.write().open_or_create_channel(&channel_name)?;
    let prefix = path.strip_prefix(&repo.path)?.to_string_lossy().to_string();
    let mut record_builder = RecordBuilder::new();
    if let Err(libpijul::record::RecordError::PathNotInRepo(_)) = record_builder.record(
        txn.clone(),
        libpijul::Algorithm::default(),
        true,
        &libpijul::DEFAULT_SEPARATOR,
        channel.clone(),
        &repo.working_copy,
        &repo.changes,
        &prefix,
        std::thread::available_parallelism()?.into(),
    ) {
        // `path` is a single file, no more work needed
        assert!(path.is_file());
        return Ok(vec![path.to_owned()]);
    }

Replacement in src/lib.rs at line 180 [3.585]

B:BD[4.3491] → [4.3491:3848]

    let mut annotations: HashMap<String, Vec<Annotation>> = HashMap::new();
    console_log(&mut cx, format!("Hunk length: {}", hunks.len()))?;
    for hunk in hunks.iter() {
        let (path, annotation) = match hunk {
            PrintableHunk::FileAddition { name, parent, .. } => {
                (PathBuf::from(parent).join(name), Annotation::Added)

[4.3491]

[4.3848]

    let repo_path = CanonicalPathBuf::canonicalize(&repo.path)?;
    let given_path = CanonicalPathBuf::canonicalize(&path)?;
    let threads = std::thread::available_parallelism()?.into();
    Ok(repo
        .working_copy
        .iterate_prefix_rec(repo_path.clone(), given_path.clone(), false, threads)?
        .filter_map(move |x| {
            let (path, _) = x.unwrap();
            use path_slash::PathExt;
            let path_str = path.to_slash_lossy();
            let read_txn = &*txn.read();
            if !read_txn.is_tracked(&path_str).unwrap_or(false) {
                Some(path)
            } else {
                None

Replacement in src/lib.rs at line 196 [3.585]

B:BD[4.3862] → [4.3862:4089]

            PrintableHunk::Replace { path, .. } => (PathBuf::from(path), Annotation::Modified),
            PrintableHunk::Edit { path, .. } => (PathBuf::from(path), Annotation::Modified),
            _ => continue,
        };

[4.3862]

[4.4089]

        })
        .collect())
}
pub fn annotate_path(path: PathBuf) -> Result<HashMap<String, State>, anyhow::Error> {
    let untracked = untracked(&path).unwrap();
    let mut annotations: HashMap<String, State> = HashMap::new();
    if path.is_file() && untracked == vec![path.clone()] {
        annotations.insert(path.to_string_lossy().to_string(), State::Untracked);
    } else {
        let hunks = get_hunks(&path, true).expect("Unable to load hunks");
        for hunk in hunks.iter() {
            match hunk {
                PrintableHunk::FileAddition { name, parent, .. } => {
                    let path = PathBuf::from(parent).join(name);
                    annotations
                        .try_insert(path.to_string_lossy().to_string(), State::Added)
                        .expect("File additions should be a unique hunk");
                }
                PrintableHunk::Replace { path, .. } | PrintableHunk::Edit { path, .. } => {
                    if let State::Tracked(tracked) = annotations
                        .entry(path.to_owned())
                        .or_insert(State::Tracked(vec![]))
                    {
                        tracked.push(Annotation::Modified);
                    } else {
                        unreachable!();
                    }
                }
                _ => continue,
            };
        }

Replacement in src/lib.rs at line 232 [3.585]

B:BD[4.4090] → [4.4090:4287]

        let entry = annotations
            .entry(path.to_string_lossy().to_string())
            .or_insert(vec![]);
        if !entry.contains(&annotation) {
            entry.push(annotation);

[4.4090]

[4.4287]

        for untracked_file in untracked {
            let key = untracked_file.to_string_lossy().to_string();
            debug_assert!(annotations.get(&key).is_none());
            annotations.insert(key, State::Untracked);

Insertion in src/lib.rs at line 238 [3.585]

[4.4303]


    Ok(annotations)
}
fn short_diff(mut cx: FunctionContext) -> JsResult<JsArray> {
    let path: Handle<JsString> = cx.argument(0)?;
    let path = PathBuf::from(path.value(&mut cx));

Insertion in src/lib.rs at line 246 [3.585]

[4.4304]

    let annotations = annotate_path(path).expect("Failed to get annotations");

Insertion in src/lib.rs at line 248 [3.585]
[4.4350]
[4.4350]

Replacement in src/lib.rs at line 253 [3.585]

B:BD[4.4506] → [2.33:76]

∅:D[2.76] → [4.4551:4604]

B:BD[4.4551] → [4.4551:4604]

B:BD[4.4604] → [2.77:113]

∅:D[2.113] → [4.4642:4942]

B:BD[4.4642] → [4.4642:4942]

        let badge_annotations = cx.string(
            file_annotations
                .iter()
                .map(|i| i.badge())
                .collect::<Vec<String>>()
                .join(", "),
        );
        let tooltip_annotations = cx.string(
            file_annotations
                .iter()
                .map(|i| i.tooltip())
                .collect::<Vec<String>>()
                .join(", "),
        );

[4.4506]

[4.4942]

        let badge_annotations = cx.string(file_annotations.badge());
        let tooltip_annotations = cx.string(file_annotations.tooltip());

Replacement in src/lib.rs at line 260 [3.585]

B:BD[4.5127] → [2.178:221]

        let untracked = cx.boolean(false);

[4.5127]

[2.221]

        let untracked = cx.boolean(matches!(file_annotations, State::Untracked));

Replacement in src/extension.ts at line 73 [3.2222]

B:BD[2.2174] → [2.2174:2221]

            console.assert(diffs.length <= 1);

[2.2174]

[2.2221]

            console.assert(diffs.length <= 1, `Length greater than 1: got ${diffs.length}`);

Replacement in src/extension.ts at line 84 [3.2222]

B:BD[2.2559] → [2.2559:2610]

                return new FileDecoration('', '');

[2.2559]

[2.2610]

                return;

Insertion in Cargo.toml at line 15 [3.5967]
[4.10740]
[3.6160]
```
path-slash = "0.2.1"
```
Replacement in Cargo.lock at line 722 [3.6341]
B:BD[3.24277] → [3.24277:24292]
```
 "path-slash",
```
[3.24277]
[3.24292]
```
 "path-slash 0.1.5",
```

Insertion in Cargo.lock at line 939 [3.6341]

[3.29675]

name = "path-slash"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e91099d4268b0e11973f036e885d652fb0b21fedcf69738c627f94db6a44f42"
[[package]]

Insertion in Cargo.lock at line 975 [3.6341]
[3.30137]
[3.30137]
```
 "path-slash 0.2.1",
```

Handle untracked files

Dependencies

In channels

Change contents

Insertion in src/lib.rs at line 1 [3.585]

Replacement in src/lib.rs at line 6 [3.585]

Insertion in src/lib.rs at line 8 [3.585]

Replacement in src/lib.rs at line 21 [3.585]

Replacement in src/lib.rs at line 31 [3.585]

Deletion in src/lib.rs at line 44 [3.585]

Insertion in src/lib.rs at line 45 [3.585]

Replacement in src/lib.rs at line 101 [3.585]

Deletion in src/lib.rs at line 103 [3.585]