jcdickinson/pijul - Change HSEYMLO2DJCDGBO4F7T6NFMFSZ4TMSOBH5XGIU5NYOEFKUSV5UKAC

Adding an untracked change iterator

Created by pmeunier on July 11, 2021

HSEYMLO2DJCDGBO4F7T6NFMFSZ4TMSOBH5XGIU5NYOEFKUSV5UKAC

Dependencies

In channels

main

Change contents

Replacement in pijul/src/commands/file_operations.rs at line 144 [5.169058]
B:BD[4.137] → [4.137:170]
```
                    txn.clone(),
```
[4.137]
[4.170]
```
                    &txn,
```
Replacement in pijul/src/commands/diff.rs at line 8 [5.173551]
B:BD[6.2595] → [7.3029:3060]
```
use libpijul::{MutTxnT, TxnT};
```
[6.2595]
[6.2654]
```
use libpijul::{MutTxnT, TxnT, TxnTExt};
```

Insertion in pijul/src/commands/diff.rs at line 30 [5.173551]

[8.49]

[9.3165]

    /// Include the untracked files
    #[clap(long = "untracked")]
    pub untracked: bool,

Replacement in pijul/src/commands/diff.rs at line 112 [5.173551]

B:BD[5.175800] → [5.175800:175893]

B:BD[5.175893] → [10.628:817]

B:BD[10.817] → [11.0:824]

∅:D[11.824] → [10.1663:1755]

B:BD[10.1663] → [10.1663:1755]

            let mut changes = BTreeMap::new();
            for ch in change.changes.iter() {
                changes
                    .entry(ch.path())
                    .or_insert_with(Vec::new)
                    .push(Status {
                        operation: match ch {
                            Hunk::FileMove { .. } => "file move",
                            Hunk::FileDel { .. } => "file del",
                            Hunk::FileUndel { .. } => "file undel",
                            Hunk::SolveNameConflict { .. } => "solve name conflict",
                            Hunk::UnsolveNameConflict { .. } => "unsolve name conflict",
                            Hunk::FileAdd { .. } => "file add",
                            Hunk::Edit { .. } => "edit",
                            Hunk::Replacement { .. } => "replacement",
                            Hunk::SolveOrderConflict { .. } => "solve order conflict",
                            Hunk::UnsolveOrderConflict { .. } => "unsolve order conflict",
                            Hunk::ResurrectZombies { .. } => "resurrect zombies",
                        },
                        line: ch.line(),
                    });

[5.175800]

[5.176894]

            if self.untracked {
                serde_json::to_writer_pretty(
                    &mut std::io::stdout(),
                    &untracked(&repo, &*txn)?.collect::<Vec<_>>(),
                )?;
                writeln!(stdout)?;
            } else {
                let mut changes = BTreeMap::new();
                for ch in change.changes.iter() {
                    changes
                        .entry(ch.path())
                        .or_insert_with(Vec::new)
                        .push(Status {
                            operation: match ch {
                                Hunk::FileMove { .. } => "file move",
                                Hunk::FileDel { .. } => "file del",
                                Hunk::FileUndel { .. } => "file undel",
                                Hunk::SolveNameConflict { .. } => "solve name conflict",
                                Hunk::UnsolveNameConflict { .. } => "unsolve name conflict",
                                Hunk::FileAdd { .. } => "file add",
                                Hunk::Edit { .. } => "edit",
                                Hunk::Replacement { .. } => "replacement",
                                Hunk::SolveOrderConflict { .. } => "solve order conflict",
                                Hunk::UnsolveOrderConflict { .. } => "unsolve order conflict",
                                Hunk::ResurrectZombies { .. } => "resurrect zombies",
                            },
                            line: ch.line(),
                        });
                }
                serde_json::to_writer_pretty(&mut std::io::stdout(), &changes)?;
                writeln!(stdout)?;

Deletion in pijul/src/commands/diff.rs at line 144 [5.173551]

B:BD[5.176908] → [5.176908:176985]

B:BD[5.176985] → [10.1756:1787]

            serde_json::to_writer_pretty(&mut std::io::stdout(), &changes)?;
            writeln!(stdout)?;

Insertion in pijul/src/commands/diff.rs at line 180 [5.173551]

[2.45]

[12.5627]

            }
            for path in untracked(&repo, &*txn)? {
                writeln!(stdout, "U  {}", path.to_str().unwrap())?;

Insertion in pijul/src/commands/diff.rs at line 184 [5.173551]

[12.5641]

[5.177020]

        } else if self.untracked {
            for path in untracked(&repo, &*txn)? {
                writeln!(stdout, "{}", path.to_str().unwrap())?;
            }

Insertion in pijul/src/commands/diff.rs at line 306 [5.173551]

[13.951]

[5.177744]

}
fn untracked<'a, T: TxnTExt>(
    repo: &Repository,
    txn: &'a T,
) -> Result<impl Iterator<Item = PathBuf> + 'a, anyhow::Error> {
    let repo_path = CanonicalPathBuf::canonicalize(&repo.path)?;
    let threads = num_cpus::get();
    Ok(repo
        .working_copy
        .iterate_prefix_rec(repo_path.clone(), repo_path.clone(), threads)?
        .filter_map(move |x| {
            let (path, _) = x.unwrap();
            let path_ = if let Ok(path) = path.as_path().strip_prefix(&repo_path.as_path()) {
                path
            } else {
                return None;
            };
            use path_slash::PathExt;
            let path_str = path_.to_slash_lossy();
            if !txn.is_tracked(&path_str).unwrap() {
                Some(path)
            } else {
                None
            }
        }))

Insertion in libpijul/src/working_copy/filesystem.rs at line 87 [5.208900]

[14.3771]

    #[error(transparent)]
    Txn(#[from] T),
}
pub struct Untracked {
    join: Option<std::thread::JoinHandle<Result<(), std::io::Error>>>,
    receiver: std::sync::mpsc::Receiver<(PathBuf, bool)>,
}
impl Iterator for Untracked {
    type Item = Result<(PathBuf, bool), std::io::Error>;
    fn next(&mut self) -> Option<Self::Item> {
        if let Ok(x) = self.receiver.recv() {
            return Some(Ok(x));
        } else if let Some(j) = self.join.take() {
            if let Ok(Err(e)) = j.join() {
                return Some(Err(e));
            }
        }
        None
    }

Replacement in libpijul/src/working_copy/filesystem.rs at line 164 [5.208900]
B:BD[15.1702] → [3.758:782]
```
        txn: ArcTxn<T>,
```
[15.1702]
[16.1756]
```
        txn: &ArcTxn<T>,
```

Insertion in libpijul/src/working_copy/filesystem.rs at line 170 [5.208900]

[17.19679]

[15.1935]

        let mut txn = txn.write();
        for p in self.iterate_prefix_rec(repo_path.clone(), full.clone(), threads)? {
            let (path, is_dir) = p?;
            info!("Adding {:?}", path);
            use path_slash::PathExt;
            let path_str = path.to_slash_lossy();
            match txn.add(&path_str, is_dir, salt) {
                Ok(()) => {}
                Err(crate::fs::FsError::AlreadyInRepo(_)) => {}
                Err(e) => return Err(e.into()),
            }
        }
        Ok(())
    }
    pub fn iterate_prefix_rec(
        &self,
        repo_path: CanonicalPathBuf,
        full: CanonicalPathBuf,
        threads: usize,
    ) -> Result<Untracked, std::io::Error> {

Replacement in libpijul/src/working_copy/filesystem.rs at line 202 [5.208900]

B:BD[18.268] → [18.268:295]

            return Ok(());

[18.268]

[19.175]

            return Ok(Untracked {
                join: None,
                receiver,
            });

Replacement in libpijul/src/working_copy/filesystem.rs at line 207 [5.208900]

∅:D[19.185] → [17.19680:19764]

B:BD[16.1902] → [17.19680:19764]

        let t = std::thread::spawn(move || -> Result<(), AddError<T::GraphError>> {

[19.185]

[19.186]

        let t = std::thread::spawn(move || -> Result<(), std::io::Error> {

Replacement in libpijul/src/working_copy/filesystem.rs at line 254 [5.208900]

B:BD[20.2857] → [20.2857:2858]

B:BD[20.2858] → [3.783:818]

∅:D[3.818] → [20.2858:2955]

∅:D[21.28110] → [20.2858:2955]

B:BD[20.2858] → [20.2858:2955]

B:BD[20.2955] → [22.1036:1123]

B:BD[22.1123] → [23.1895:1948]

∅:D[22.1170] → [24.1988:2143]

∅:D[23.1948] → [24.1988:2143]

B:BD[24.1988] → [24.1988:2143]

∅:D[24.2143] → [20.3045:3105]

B:BD[20.3045] → [20.3045:3105]

∅:D[25.1570] → [5.210920:210945]

∅:D[20.3105] → [5.210920:210945]

∅:D[15.3735] → [5.210920:210945]

B:BD[5.210920] → [5.210920:210945]


        let mut txn = txn.write();
        while let Ok((path, is_dir)) = receiver.recv() {
            info!("Adding {:?}", path);
            use path_slash::PathExt;
            let path_str = path.to_slash_lossy();
            match txn.add(&path_str, is_dir, salt) {
                Ok(()) => {}
                Err(crate::fs::FsError::AlreadyInRepo(_)) => {}
                Err(e) => return Err(e.into()),
            }
        }
        if let Ok(t) = t.join() {
            t?
        }
        Ok(())

[20.2857]

[5.210945]

        Ok(Untracked {
            join: Some(t),
            receiver,
        })

Replacement in libpijul/src/working_copy/filesystem.rs at line 278 [5.208900]

B:BD[4.390] → [23.1969:2044]

        self.add_prefix_rec(txn.clone(), repo_path, full, threads, salt)?;

[4.390]

[4.459]

        {
            let path = if let Ok(path) = full.as_path().strip_prefix(&repo_path.as_path()) {
                path
            } else {
                return Ok(());
            };
            use path_slash::PathExt;
            let path_str = path.to_slash_lossy();
            if !txn.read().is_tracked(&path_str)? {
                self.add_prefix_rec(&txn, repo_path, full, threads, salt)?;
            }
        }

File addition: .ignore (----------)
[1.0]
```
target
```