laumann/pijul - Change RMDMAYRXYBU5OQXV5HSF6LFD4NBMKRNH5EPIVW3K5HAV6D56IG6QC

Adding a root inode (aka supporting submodules)

Created by pmeunier on October 22, 2021

RMDMAYRXYBU5OQXV5HSF6LFD4NBMKRNH5EPIVW3K5HAV6D56IG6QC

Dependencies

In channels

main

Change contents

Insertion in "pijul/src/commands/diff.rs" at line 152 [11.173551]

[6.1413]

                            Hunk::AddRoot { .. } => "root",
                            Hunk::DelRoot { .. } => "unroot",

Insertion in "pijul/src/commands/diff.rs" at line 202 [11.173551]

[5.985]

                    Hunk::AddRoot { .. } | Hunk::DelRoot { .. } => true

Insertion in "libpijul/src/unrecord/working_copy.rs" at line 62 [11.225940]
[11.227747]
[11.227747]
```
        debug!("source = {:?}, dest = {:?}", source, dest);
```

Replacement in "libpijul/src/unrecord/working_copy.rs" at line 93 [11.225940]

B:BD[11.228745] → [11.228745:228839]

            stack.push((source, dest));
            stack.push((grandparent, source_parent));

[11.228745]

[11.228839]

            if grandparent.is_root() || grandparent.start == grandparent.end {
                return_value = restore_inode(txn, changes, source, dest, Inode::ROOT, salt)?;
            } else {
                stack.push((source, dest));
                stack.push((grandparent, source_parent));
            }

Replacement in "libpijul/src/tests/add_file.rs" at line 56 [11.454125]

B:BD[12.30752] → [12.30752:30810]

B:BD[12.30810] → [10.1394:1501]

        let (key, _, name) = it.next().unwrap().unwrap();
        let key_ = get_inode_vertex(&txn, &channel.graph, Position::ROOT)?;
        assert_eq!(key, key_);

[12.30752]

[11.456129]

        let (_, _, name) = it.next().unwrap().unwrap();

Replacement in "libpijul/src/tests/add_file.rs" at line 846 [11.454125]

B:BD[10.2518] → [10.2518:2566]

        let txn = env.arc_txn_begin().unwrap();

[10.2518]

[10.2566]

        let env2 = pristine::sanakirja::Pristine::new_anon()?;
        let txn = env2.arc_txn_begin().unwrap();

Insertion in "libpijul/src/tests/add_file.rs" at line 860 [11.454125]

[10.3132]

    {
        let txn_ = txn.write();
        let mut f = std::fs::File::create("add_file2.dot")?;
        crate::pristine::debug(&*txn_, &txn_.graph(&*channel.read()), &mut f)?;
    }

Insertion in "libpijul/src/tests/add_file.rs" at line 866 [11.454125]

[10.3133]

    // Check that there's a name conflict.
    assert_eq!(repo.list_files().len(), 8);

Insertion in "libpijul/src/record.rs" at line 73 [11.488880]
[13.41156]
[11.489652]
```
    new_root: Arc<Mutex<Option<ChangePosition>>>,
```
Insertion in "libpijul/src/record.rs" at line 106 [11.488880]
[13.41498]
[11.490405]
```
    new_root: Arc<Mutex<Option<ChangePosition>>>,
```
Insertion in "libpijul/src/record.rs" at line 118 [11.488880]
[13.41728]
[11.490934]
```
            new_root: Arc::new(Mutex::new(None)),
```
Insertion in "libpijul/src/record.rs" at line 147 [11.488880]
[13.42400]
[13.42400]
```
            new_root: self.new_root.clone(),
```
Replacement in "libpijul/src/record.rs" at line 346 [11.488880]
B:BD[13.46637] → [13.46637:46638]
[13.46637]
[11.492928]
```
        info!("Starting to record");
```
Insertion in "libpijul/src/record.rs" at line 355 [11.488880]
[14.96917]
[13.46989]
```
            let mut root_vertices = Vec::new();
```
Deletion in "libpijul/src/record.rs" at line 361 [11.488880]
B:BD[11.493385] → [11.493385:493422]
B:BD[11.493422] → [13.47069:47097]
∅:D[13.47127] → [11.493422:493487]
B:BD[11.493422] → [11.493422:493487]
```
                self.recorded_inodes
                    .lock()
                    .insert(Inode::ROOT, Position::OPTION_ROOT);
```

Replacement in "libpijul/src/record.rs" at line 365 [11.488880]

∅:D[14.97005] → [13.47316:47351]

B:BD[13.47316] → [13.47316:47351]

∅:D[13.47351] → [11.493487:493534]

B:BD[11.493487] → [11.493487:493534]

B:BD[11.493534] → [13.47352:47420]

B:BD[13.47420] → [14.97006:97040]

∅:D[13.47463] → [15.0:29]

∅:D[14.97040] → [15.0:29]

B:BD[11.493623] → [15.0:29]

∅:D[15.29] → [11.493623:493660]

B:BD[11.493623] → [11.493623:493660]

B:BD[11.493660] → [11.493660:493696]

B:BD[11.493696] → [12.32844:32864]

∅:D[12.32864] → [11.493715:493753]

B:BD[11.493715] → [11.493715:493753]

                debug!("TAKEN 2");
                self.delete_obsolete_children(
                    &*txn,
                    txn.graph(&channel),
                    working_copy,
                    changes,
                    &item.full_path,
                    Position::ROOT,
                )?;
                Position::OPTION_ROOT

[14.97005]

[14.97041]


                // Test for a "root" vertex below the 0 one.
                let f0 = EdgeFlags::FOLDER | EdgeFlags::BLOCK;
                let f1 = f0 | EdgeFlags::PSEUDO;
                self.recorded_inodes
                    .lock()
                    .insert(Inode::ROOT, Position::ROOT.to_option());
                let mut has_nonempty_root = false;
                for e in iter_adjacent(&*txn, txn.graph(&*channel), Vertex::ROOT, f0, f1)? {
                    let e = e?;
                    let child = txn.find_block(txn.graph(&*channel), e.dest()).unwrap();
                    if child.start == child.end {
                        let grandchild =
                            iter_adjacent(&*txn, txn.graph(&*channel), *child, f0, f1)?
                                .next()
                                .unwrap()?
                                .dest();
                        root_vertices.push(grandchild);
                        self.delete_obsolete_children(
                            &*txn,
                            txn.graph(&channel),
                            working_copy,
                            changes,
                            &item.full_path,
                            grandchild,
                        )?;
                    } else {
                        has_nonempty_root = true
                    }
                }
                if has_nonempty_root && !root_vertices.is_empty() {
                    // This repository is mixed between "zero" roots,
                    // and new-style-roots.
                    root_vertices.push(Position::ROOT)
                }
                Position::ROOT.to_option()

Replacement in "libpijul/src/record.rs" at line 444 [11.488880]

B:BD[11.495196] → [11.495196:495237]

B:BD[11.495237] → [13.49041:49088]

B:BD[13.49088] → [14.97574:97652]

∅:D[13.49184] → [16.11697:11740]

∅:D[14.97652] → [16.11697:11740]

B:BD[11.495237] → [16.11697:11740]

B:BD[16.11740] → [13.49185:49235]

B:BD[13.49235] → [14.97653:97683]

∅:D[13.49274] → [11.495346:495373]

∅:D[14.97683] → [11.495346:495373]

B:BD[11.495346] → [11.495346:495373]

B:BD[11.495373] → [13.49275:49308]

∅:D[13.49308] → [11.495373:495449]

B:BD[11.495373] → [11.495373:495449]

B:BD[11.495449] → [17.1585:1610]

∅:D[17.1610] → [11.495449:495465]

B:BD[11.495449] → [11.495449:495465]

            // Move on to the next step.
            debug!("TAKING LOCK {}", line!());
            let txn = txn.read();
            let channel = channel.r.read();
            self.push_children::<_, _, C>(
                &*txn,
                &*channel,
                working_copy,
                &mut item,
                &mut components,
                vertex,
                &mut stack,
                prefix,
                changes,
            )?;

[11.495196]

[13.49309]

            if root_vertices.is_empty() {
                // Move on to the next step.
                debug!("TAKING LOCK {}", line!());
                let txn = txn.read();
                let channel = channel.r.read();
                self.push_children::<_, _, C>(
                    &*txn,
                    &*channel,
                    working_copy,
                    &mut item,
                    &mut components,
                    vertex,
                    &mut stack,
                    prefix,
                    changes,
                )?;
            } else {
                for vertex in root_vertices {
                    let txn = txn.read();
                    let channel = channel.r.read();
                    self.push_children::<_, _, C>(
                        &*txn,
                        &*channel,
                        working_copy,
                        &mut item,
                        &mut components,
                        vertex.to_option(),
                        &mut stack,
                        prefix,
                        changes,
                    )?;
                }
            }

Insertion in "libpijul/src/record.rs" at line 547 [11.488880]

[13.51363]

            if child.start == child.end {
                // This is an empty name, i.e. the grandchild is a root vertex.
                continue;
            }

Replacement in "libpijul/src/record.rs" at line 617 [11.488880]

B:BD[13.53953] → [13.53953:54005]

        debug!("push_children, item = {:?}", item);

[13.53953]

[13.54005]

        debug!("push_children, vertex = {:?}, item = {:?}", vertex, item);

Replacement in "libpijul/src/record.rs" at line 628 [11.488880]

B:BD[13.54427] → [13.54427:54518]

            if fileid_.parent_inode < fileid.parent_inode || fileid_.basename.is_empty() {

[13.54427]

[13.54518]

            assert!(fileid_.parent_inode >= fileid.parent_inode);
            if fileid_.basename.is_empty() {

Insertion in "libpijul/src/record.rs" at line 648 [11.488880]

[13.55233]

                debug!("full_path = {:?}, meta = {:?}", full_path, meta);

Insertion in "libpijul/src/record.rs" at line 677 [11.488880]
[13.56093]
[13.56093]
```
        debug!("push_children done");
```

Insertion in "libpijul/src/record.rs" at line 706 [11.488880]

[13.56806]

[7.1845]

    fn add_root_if_needed(
        &mut self,
        v_papa: Position<Option<ChangeId>>,
    ) -> Position<Option<ChangeId>> {
        let mut contents = self.contents.lock();
        if v_papa.change == Some(ChangeId::ROOT) {
            let mut new_root = self.new_root.lock();
            if let Some(pos) = *new_root {
                Position { change: None, pos }
            } else {
                contents.push(0);
                let pos = ChangePosition(contents.len().into());
                contents.push(0);
                let pos2 = ChangePosition(contents.len().into());
                contents.push(0);
                self.actions.push(Hunk::FileAdd {
                    add_name: Atom::NewVertex(NewVertex {
                        up_context: vec![v_papa],
                        down_context: vec![],
                        start: pos2,
                        end: pos2,
                        flag: EdgeFlags::FOLDER | EdgeFlags::BLOCK,
                        inode: v_papa,
                    }),
                    add_inode: Atom::NewVertex(NewVertex {
                        up_context: vec![Position {
                            change: None,
                            pos: pos2,
                        }],
                        down_context: vec![],
                        start: pos,
                        end: pos,
                        flag: EdgeFlags::FOLDER | EdgeFlags::BLOCK,
                        inode: v_papa,
                    }),
                    contents: None,
                    path: "/".to_string(),
                    encoding: None,
                });
                *new_root = Some(pos);
                Position { change: None, pos }
            }
        } else {
            v_papa
        }
    }

Insertion in "libpijul/src/record.rs" at line 760 [11.488880]

[11.495974]

[14.97960]


        // If we're inserting at the root, add an extra "root
        // directory" empty vertex.
        let item_v_papa = self.add_root_if_needed(item.v_papa);

Replacement in "libpijul/src/record.rs" at line 812 [11.488880]

B:BD[11.498073] → [11.498073:498120]

                up_context: vec![item.v_papa],

[11.498073]

[11.498120]

                up_context: vec![item_v_papa],

Replacement in "libpijul/src/record.rs" at line 872 [11.488880]

B:BD[11.499734] → [11.499734:499833]

            "record_existing_file {:?}: {:?} {:?}",
            item.full_path, item.inode, vertex

[11.499734]

[11.499833]

            "record_existing_file {:?}: {:?} {:?} {:?}",
            item.full_path, item.inode, vertex, new_papa,

Deletion in "libpijul/src/record.rs" at line 876 [11.488880]

B:BD[11.499882] → [13.58136:58181]

∅:D[13.58181] → [11.499919:500045]

B:BD[11.499919] → [11.499919:500045]

        let mut former_parents = Vec::new();
        let f0 = EdgeFlags::FOLDER | EdgeFlags::PARENT;
        let f1 = EdgeFlags::all();
        let mut is_deleted = true;

Replacement in "libpijul/src/record.rs" at line 878 [11.488880]

∅:D[14.98198] → [13.58270:58442]

B:BD[13.58270] → [13.58270:58442]

∅:D[13.58442] → [18.49753:49796]

B:BD[19.1378] → [18.49753:49796]

∅:D[19.1378] → [12.33350:33382]

∅:D[20.28511] → [12.33350:33382]

∅:D[18.49796] → [12.33350:33382]

B:BD[12.33350] → [12.33350:33382]

B:BD[12.33382] → [18.49797:49892]

∅:D[18.49892] → [12.33439:33479]

B:BD[12.33439] → [12.33439:33479]

B:BD[12.33479] → [18.49893:49952]

∅:D[18.49952] → [11.500308:500452]

B:BD[11.500308] → [11.500308:500452]

B:BD[11.500452] → [13.58443:58546]

∅:D[13.58546] → [21.6515:6542]

B:BD[21.6515] → [21.6515:6542]

B:BD[21.6542] → [17.2008:2180]

∅:D[17.2180] → [23.361:393]

B:BD[23.361] → [23.361:393]

B:BD[23.393] → [22.1397:1469]

∅:D[22.1469] → [21.6645:6677]

∅:D[13.58619] → [21.6645:6677]

B:BD[21.6645] → [21.6645:6677]

B:BD[21.6677] → [17.2181:2212]

∅:D[17.2212] → [21.6708:6726]

B:BD[21.6708] → [21.6708:6726]

∅:D[21.6726] → [16.11969:12022]

∅:D[12.33653] → [16.11969:12022]

∅:D[18.50149] → [16.11969:12022]

B:BD[16.11969] → [16.11969:12022]

B:BD[11.500855] → [24.773:905]

B:BD[24.905] → [13.58620:58744]

∅:D[18.50251] → [25.495:509]

∅:D[13.58744] → [25.495:509]

B:BD[25.495] → [25.495:509]

∅:D[25.509] → [12.33752:33790]

∅:D[19.1571] → [12.33752:33790]

∅:D[20.28702] → [12.33752:33790]

B:BD[12.33752] → [12.33752:33790]

B:BD[12.33790] → [18.50252:50317]

B:BD[18.50317] → [22.1470:1519]

∅:D[22.1519] → [23.394:450]

B:BD[26.204] → [23.394:450]

∅:D[23.450] → [26.238:272]

B:BD[26.238] → [26.238:272]

B:BD[26.272] → [17.2213:2247]

∅:D[17.2247] → [18.50318:50377]

B:BD[26.272] → [18.50318:50377]

∅:D[18.50377] → [26.329:370]

B:BD[26.329] → [26.329:370]

∅:D[26.370] → [11.501198:501222]

B:BD[11.501198] → [11.501198:501222]

        for name_ in iter_adjacent(
            &*txn_,
            txn_.graph(&*channel_),
            vertex.inode_vertex(),
            f0,
            f1,
        )? {
            debug!("name_ = {:?}", name_);
            let name_ = name_?;
            if !name_.flag().contains(EdgeFlags::PARENT) {
                debug!("continue");
                continue;
            }
            if name_.flag().contains(EdgeFlags::DELETED) {
                debug!("is_deleted {:?}: {:?}", item.full_path, name_);
                is_deleted = true;
                break;
            }
            let name_dest = txn_
                .find_block_end(txn_.graph(&*channel_), name_.dest())
                .unwrap();
            let mut meta = Vec::new();
            let FileMetadata {
                basename,
                metadata,
                encoding,
            } = changes
                .get_file_meta(
                    |p| txn_.get_external(&p).unwrap().map(From::from),
                    *name_dest,
                    &mut meta,
                )
                .map_err(RecordError::Changestore)?;
            debug!(
                "former basename of {:?}: {:?} {:?}",
                vertex, basename, metadata
            );
            if let Some(v_papa) =
                iter_adjacent(&*txn_, txn_.graph(&*channel_), *name_dest, f0, f1)?.next()
            {
                let v_papa = v_papa?;
                if !v_papa.flag().contains(EdgeFlags::DELETED) {
                    former_parents.push(Parent {
                        basename: basename.to_string(),
                        metadata,
                        encoding,
                        parent: v_papa.dest().to_option(),
                    })
                }
            }
        }

[14.98198]

[11.501222]

        let (former_parents, is_deleted) =
            collect_former_parents::<C, W, T>(changes, &*txn_, &*channel_, vertex)?;

Replacement in "libpijul/src/record.rs" at line 886 [11.488880]

B:BD[11.501478] → [11.501478:501527]

B:BD[11.501527] → [13.58888:59113]

∅:D[13.59113] → [11.501772:501816]

B:BD[11.501772] → [11.501772:501816]

B:BD[11.501939] → [11.501939:501992]

B:BD[11.501992] → [12.33791:33842]

∅:D[12.33842] → [11.502032:502061]

B:BD[11.502032] → [11.502032:502061]

B:BD[11.502061] → [13.59114:59142]

B:BD[13.59142] → [27.538:570]

∅:D[27.570] → [11.502116:502171]

∅:D[19.1612] → [11.502116:502171]

∅:D[20.28742] → [11.502116:502171]

∅:D[12.33879] → [11.502116:502171]

∅:D[13.59186] → [11.502116:502171]

B:BD[11.502116] → [11.502116:502171]

B:BD[11.502171] → [13.59187:59226]

B:BD[13.59226] → [22.1521:1521]

B:BD[22.1521] → [22.1522:1578]

∅:D[22.1578] → [12.33880:33899]

∅:D[17.2309] → [12.33880:33899]

∅:D[13.59226] → [12.33880:33899]

B:BD[11.502254] → [12.33880:33899]

∅:D[16.12093] → [11.502273:502359]

∅:D[12.33899] → [11.502273:502359]

B:BD[11.502273] → [11.502273:502359]

B:BD[11.502359] → [13.59227:59346]

B:BD[13.59346] → [14.98199:98238]

∅:D[13.59393] → [28.452:517]

∅:D[14.98238] → [28.452:517]

B:BD[28.452] → [28.452:517]

∅:D[28.517] → [11.502452:502466]

∅:D[29.1500] → [11.502452:502466]

∅:D[20.28844] → [11.502452:502466]

B:BD[11.502452] → [11.502452:502466]

B:BD[11.502466] → [13.59394:59475]

∅:D[19.1773] → [11.502529:502569]

∅:D[20.28918] → [11.502529:502569]

∅:D[12.33970] → [11.502529:502569]

∅:D[13.59475] → [11.502529:502569]

B:BD[11.502529] → [11.502529:502569]

B:BD[11.502569] → [30.73:117]

∅:D[30.117] → [31.1102:1160]

B:BD[16.12123] → [31.1102:1160]

∅:D[31.1160] → [16.12179:12236]

B:BD[16.12179] → [16.12179:12236]

∅:D[16.12236] → [11.502635:502673]

B:BD[11.502635] → [11.502635:502673]

B:BD[11.502673] → [13.59476:59522]

∅:D[13.59522] → [11.502723:502779]

B:BD[11.502723] → [11.502723:502779]

B:BD[11.502779] → [13.59523:59583]

∅:D[13.59583] → [11.502834:502914]

B:BD[11.502834] → [11.502834:502914]

B:BD[11.502914] → [32.58:90]

∅:D[32.90] → [11.502914:503008]

B:BD[11.502914] → [11.502914:503008]

B:BD[11.503008] → [30.118:149]

B:BD[30.149] → [9.274:304]

∅:D[30.149] → [11.503008:503028]

∅:D[9.304] → [11.503008:503028]

B:BD[11.503008] → [11.503008:503028]

B:BD[11.503028] → [13.59584:59630]

∅:D[13.59630] → [29.1551:1644]

B:BD[29.1551] → [29.1551:1644]

B:BD[29.1644] → [13.59631:59780]

∅:D[13.59780] → [33.224:257]

B:BD[33.224] → [33.224:257]

B:BD[33.257] → [13.59781:59869]

∅:D[13.59869] → [33.353:379]

B:BD[33.353] → [33.353:379]

∅:D[33.379] → [29.1736:1776]

B:BD[29.1736] → [29.1736:1776]

∅:D[29.1776] → [34.2801:2878]

B:BD[11.503028] → [34.2801:2878]

B:BD[34.2878] → [13.59870:59956]

∅:D[13.59956] → [34.2972:2991]

B:BD[34.2972] → [34.2972:2991]

∅:D[34.2991] → [11.503104:503118]

B:BD[11.503104] → [11.503104:503118]

            debug!("new_meta = {:?}", new_meta);
            if former_parents.len() > 1
                || former_parents[0].basename != item.basename
                || former_parents[0].metadata != item.metadata
                || former_parents[0].parent != item.v_papa
                || is_deleted
            {
                debug!("new_papa = {:?}", new_papa);
                self.record_moved_file::<_, _, W>(
                    changes,
                    &*txn_,
                    &*channel_,
                    &item,
                    vertex,
                    new_papa.unwrap(),
                    former_parents[0].encoding.clone(),
                )?
            }
            if new_meta.is_file()
                && (self.force_rediff
                    || modified_since_last_commit(
                        &*txn_,
                        &*channel_,
                        &working_copy,
                        &item.full_path,
                    )?)
            {
                let mut ret = retrieve(&*txn_, txn_.graph(&*channel_), vertex)?;
                let mut b = Vec::new();
                let encoding = working_copy
                    .decode_file(&item.full_path, &mut b)
                    .map_err(RecordError::WorkingCopy)?;
                debug!("diffing…");
                let len = self.actions.len();
                self.diff(
                    changes,
                    &*txn_,
                    &*channel_,
                    diff_algorithm,
                    item.full_path.clone(),
                    item.inode,
                    vertex.to_option(),
                    &mut ret,
                    &b,
                    &encoding,
                    diff_sep,
                )?;
                if self.actions.len() > len {
                    if let Ok(last_modified) = working_copy.modified_time(&item.full_path) {
                        if self.oldest_change == std::time::SystemTime::UNIX_EPOCH {
                            self.oldest_change = last_modified;
                        } else {
                            self.oldest_change = self.oldest_change.min(last_modified);
                        }
                    }
                }
                debug!(
                    "new actions: {:?}, total {:?}",
                    &self.actions.len() - len,
                    self.actions.len()
                );
            }

[11.501478]

[11.503118]

            self.record_nondeleted(
                &*txn_,
                diff_algorithm,
                diff_sep,
                &*channel_,
                working_copy,
                changes,
                item,
                new_papa,
                vertex,
                new_meta,
                &former_parents,
                is_deleted,
            )?

Insertion in "libpijul/src/record.rs" at line 908 [11.488880]

[20.29100]

[17.2310]

                changes,
            )?
        }
        Ok(())
    }
    fn record_nondeleted<
        T: ChannelTxnT + TreeTxnT<TreeError = <T as GraphTxnT>::GraphError>,
        W: WorkingCopyRead + Clone,
        C: ChangeStore,
    >(
        &mut self,
        txn: &T,
        diff_algorithm: diff::Algorithm,
        diff_sep: &regex::bytes::Regex,
        channel: &T::Channel,
        working_copy: W,
        changes: &C,
        item: &RecordItem,
        new_papa: Option<Position<Option<ChangeId>>>,
        vertex: Position<ChangeId>,
        new_meta: InodeMetadata,
        former_parents: &[Parent],
        is_deleted: bool,
    ) -> Result<(), RecordError<C::Error, W::Error, T::GraphError>>
    where
        <W as crate::working_copy::WorkingCopyRead>::Error: 'static,
    {
        if former_parents.len() > 1
            || former_parents[0].basename != item.basename
            || former_parents[0].metadata != item.metadata
            || former_parents[0].parent != item.v_papa
            || is_deleted
        {
            debug!("new_papa = {:?}", new_papa);
            self.record_moved_file::<_, _, W>(

Insertion in "libpijul/src/record.rs" at line 945 [11.488880]

[17.2335]

[20.29100]

                txn,
                channel,
                &item,
                vertex,
                new_papa.unwrap(),
                former_parents[0].encoding.clone(),

Insertion in "libpijul/src/record.rs" at line 952 [11.488880]

[20.29115]

[11.503301]

        }
        if new_meta.is_file()
            && (self.force_rediff
                || modified_since_last_commit(txn, channel, &working_copy, &item.full_path)?)
        {
            let mut ret = retrieve(txn, txn.graph(channel), vertex)?;
            let mut b = Vec::new();
            let encoding = working_copy
                .decode_file(&item.full_path, &mut b)
                .map_err(RecordError::WorkingCopy)?;
            debug!("diffing…");
            let len = self.actions.len();
            self.diff(
                changes,
                txn,
                channel,
                diff_algorithm,
                item.full_path.clone(),
                item.inode,
                vertex.to_option(),
                &mut ret,
                &b,
                &encoding,
                diff_sep,
            )?;
            if self.actions.len() > len {
                if let Ok(last_modified) = working_copy.modified_time(&item.full_path) {
                    if self.oldest_change == std::time::SystemTime::UNIX_EPOCH {
                        self.oldest_change = last_modified;
                    } else {
                        self.oldest_change = self.oldest_change.min(last_modified);
                    }
                }
            }
            debug!(
                "new actions: {:?}, total {:?}",
                &self.actions.len() - len,
                self.actions.len()
            );

Replacement in "libpijul/src/record.rs" at line 1008 [11.488880]

B:BD[12.36029] → [35.0:48]

        debug!("record_moved_file {:?}", item);

[12.36029]

[14.98271]

        debug!("record_moved_file {:?} {:?}", item, vertex);

Deletion in "libpijul/src/record.rs" at line 1083 [11.488880]
B:BD[32.244] → [32.244:245]

Insertion in "libpijul/src/record.rs" at line 1116 [11.488880]

[36.5]

[11.510565]

fn collect_former_parents<C: ChangeStore, W: WorkingCopyRead, T: ChannelTxnT>(
    changes: &C,
    txn: &T,
    channel: &T::Channel,
    vertex: Position<ChangeId>,
) -> Result<(Vec<Parent>, bool), RecordError<C::Error, W::Error, T::GraphError>>
where
    W::Error: 'static,
{
    let mut former_parents = Vec::new();
    let f0 = EdgeFlags::FOLDER | EdgeFlags::PARENT;
    let f1 = EdgeFlags::all();
    let mut is_deleted = true;
    for name_ in iter_adjacent(txn, txn.graph(channel), vertex.inode_vertex(), f0, f1)? {
        debug!("name_ = {:?}", name_);
        let name_ = name_?;
        if !name_.flag().contains(EdgeFlags::PARENT) {
            debug!("continue");
            continue;
        }
        if name_.flag().contains(EdgeFlags::DELETED) {
            debug!("is_deleted {:?}", name_);
            is_deleted = true;
            break;
        }
        let name_dest = txn
            .find_block_end(txn.graph(channel), name_.dest())
            .unwrap();
        let mut meta = Vec::new();
        let FileMetadata {
            basename,
            metadata,
            encoding,
        } = changes
            .get_file_meta(
                |p| txn.get_external(&p).unwrap().map(From::from),
                *name_dest,
                &mut meta,
            )
            .map_err(RecordError::Changestore)?;
        debug!(
            "former basename of {:?}: {:?} {:?}",
            vertex, basename, metadata
        );
        if let Some(v_papa) = iter_adjacent(txn, txn.graph(channel), *name_dest, f0, f1)?.next() {
            let v_papa = v_papa?;
            if !v_papa.flag().contains(EdgeFlags::DELETED) {
                former_parents.push(Parent {
                    basename: basename.to_string(),
                    metadata,
                    encoding,
                    parent: v_papa.dest().to_option(),
                })
            }
        }
    }
    Ok((former_parents, is_deleted))
}

Replacement in "libpijul/src/record.rs" at line 1288 [11.488880]

B:BD[11.513998] → [11.513998:514044]

                "grandparent_dest {:?} {:?}",

[11.513998]

[11.514044]

                "grandparent_dest {:?} {:?}, parent_pos = {:?}",

Replacement in "libpijul/src/record.rs" at line 1290 [11.488880]

B:BD[11.514078] → [11.514078:514135]

                std::str::from_utf8(&previous_name[2..])

[11.514078]

[11.514135]

                std::str::from_utf8(&previous_name[2..]),
                parent_pos,

Replacement in "libpijul/src/record.rs" at line 1293 [11.488880]

B:BD[11.514150] → [18.52391:52475]

            let grandparent_changed = parent_pos != grandparent.dest().to_option();

[11.514150]

[4.302]

            let grandparent_changed = if parent_pos.change == Some(ChangeId::ROOT) {
                !is_root_vertex(txn, channel, grandparent.dest())?
            } else {
                parent_pos != grandparent.dest().to_option()
            };

Insertion in "libpijul/src/record.rs" at line 1400 [11.488880]

[11.518269]

}
fn is_root_vertex<T: GraphTxnT>(
    txn: &T,
    channel: &T::Graph,
    v: Position<ChangeId>,
) -> Result<bool, TxnErr<T::GraphError>> {
    for parent in iter_adjacent(
        txn,
        channel,
        v.inode_vertex(),
        EdgeFlags::FOLDER | EdgeFlags::PARENT,
        EdgeFlags::FOLDER | EdgeFlags::PARENT | EdgeFlags::PSEUDO | EdgeFlags::BLOCK,
    )? {
        let p = parent?.dest();
        let p = txn.find_block_end(channel, p).unwrap();
        if p.start == p.end {
            return Ok(true);
        } else {
            return Ok(false);
        }
    }
    Ok(false)

Deletion in "libpijul/src/pristine/vertex.rs" at line 172 [11.525242]
B:BD[37.8] → [37.8:9]
Deletion in "libpijul/src/pristine/vertex.rs" at line 173 [11.525242]
B:BD[37.10] → [37.10:11]
Insertion in "libpijul/src/pristine/inode_metadata.rs" at line 9 [11.641569]
[11.641952]
[11.642172]
```
    pub const DIR: Self = InodeMetadata(DIR_BIT);
```

Replacement in "libpijul/src/output/output.rs" at line 168 [11.671807]

∅:D[16.20226] → [11.673931:673967]

∅:D[13.76470] → [11.673931:673967]

∅:D[12.82151] → [11.673931:673967]

B:BD[11.673931] → [11.673931:673967]

    let mut conflicts = Vec::new();

[13.76470]

[13.76471]

    let mut state = OutputState {
        done_vertices: HashMap::default(),
        actual_moves: Vec::new(),
        conflicts: Vec::new(),
        output_name_conflicts,
        work: work.clone(),
        done_inodes: HashSet::new(),
        salt,
        if_modified_after,
        next_prefix_basename: prefix.next(),
        is_following_prefix: true,
        pending_change_id,
    };

Replacement in "libpijul/src/output/output.rs" at line 184 [11.671807]

∅:D[13.76556] → [11.674044:674094]

B:BD[11.674044] → [11.674044:674094]

B:BD[11.674094] → [24.906:980]

B:BD[24.980] → [13.76557:76578]

B:BD[13.76578] → [14.102074:102151]

∅:D[14.102151] → [13.76673:76810]

B:BD[13.76673] → [13.76673:76810]

∅:D[13.76810] → [24.1077:1133]

B:BD[24.1077] → [24.1077:1133]

B:BD[24.1133] → [13.76811:76841]

B:BD[13.76841] → [14.102152:102191]

B:BD[14.102191] → [38.0:76]

∅:D[38.76] → [13.76962:76972]

∅:D[14.102257] → [13.76962:76972]

B:BD[13.76962] → [13.76962:76972]

∅:D[13.76972] → [24.1188:1225]

B:BD[24.1188] → [24.1188:1225]

    let mut next_prefix_basename = prefix.next();
    let mut is_first_none = true;
    if next_prefix_basename.is_none() {
        let dead = {
            let txn_ = txn.read();
            let channel = channel.read();
            let graph = txn_.graph(&*channel);
            collect_dead_files(&*txn_, graph, pending_change_id, Inode::ROOT)?
        };
        debug!("dead (line {}) = {:?}", line!(), dead);
        if !dead.is_empty() {
            let mut txn = txn.write();
            kill_dead_files::<T, R, P>(&mut *txn, &channel, &repo, &dead)?;
        }
        is_first_none = false;
    }

[13.76556]

[13.76973]

    state.kill_dead_files::<_, _, P>(repo, &txn, &channel)?;

Replacement in "libpijul/src/output/output.rs" at line 196 [11.671807]
∅:D[39.431] → [13.77236:77270]
B:BD[13.77236] → [13.77236:77270]
```
            next_prefix_basename,
```
[39.431]
[13.77270]
```
            state.next_prefix_basename,
```

Deletion in "libpijul/src/output/output.rs" at line 201 [11.671807]

B:BD[11.674618] → [13.77313:77359]

B:BD[13.77359] → [40.4546:4634]

    let mut done_inodes = HashSet::default();
    let mut done_vertices: HashMap<_, (Vertex<ChangeId>, String)> = HashMap::default();

Deletion in "libpijul/src/output/output.rs" at line 203 [11.671807]
B:BD[11.674819] → [11.674819:674858]
```
    let mut actual_moves = Vec::new();
```
Replacement in "libpijul/src/output/output.rs" at line 206 [11.671807]
B:BD[11.675018] → [11.675018:675065]
```
        next_prefix_basename = prefix.next();
```
[11.675018]
[11.675065]
```
        state.next_prefix_basename = prefix.next();
```

Replacement in "libpijul/src/output/output.rs" at line 208 [11.671807]

B:BD[11.675107] → [11.675107:675153]

B:BD[11.675153] → [13.77408:77422]

B:BD[13.77422] → [14.102327:102365]

            debug!("files: {:?} {:?}", a, b);
            {
                let txn = txn.read();

[11.675107]

[14.102365]

            sort_conflicting_names(&txn, &channel, &mut b);
            state.output_name(repo, changes, &txn, &channel, &mut next_files, a, b)?;
        }
        std::mem::swap(&mut files, &mut next_files);
    }
    stop.store(true, std::sync::atomic::Ordering::Relaxed);
    let o = output_loop(repo, changes, txn, channel, work, stop, 0);
    for t in threads {
        state.conflicts.extend(t.join().unwrap()?.into_iter());
    }
    state.conflicts.extend(o?.into_iter());
    for (a, b) in state.actual_moves.iter() {
        repo.rename(a, b).map_err(OutputError::WorkingCopy)?
    }
    Ok(state.conflicts)
}
fn sort_conflicting_names<T: ChannelTxnT + Send + Sync + 'static>(
    txn: &ArcTxn<T>,
    channel: &ChannelRef<T>,
    b: &mut [(Vertex<ChangeId>, OutputItem)],
) {
    debug!("files: {:?}", b);
    let txn = txn.read();
    let channel = channel.read();
    b.sort_unstable_by(|u, v| {
        txn.get_changeset(txn.changes(&channel), &u.0.change)
            .unwrap()
            .cmp(
                &txn.get_changeset(txn.changes(&channel), &v.0.change)
                    .unwrap(),
            )
    });
}
struct OutputState<'a> {
    actual_moves: Vec<(String, String)>,
    output_name_conflicts: bool,
    done_vertices: HashMap<Position<ChangeId>, (Vertex<ChangeId>, String)>,
    conflicts: Vec<Conflict>,
    work: Arc<crossbeam_deque::Injector<(OutputItem, String, Option<String>)>>,
    done_inodes: HashSet<Inode>,
    salt: u64,
    if_modified_after: Option<std::time::SystemTime>,
    next_prefix_basename: Option<&'a str>,
    is_following_prefix: bool,
    pending_change_id: ChangeId,
}
impl<'a> OutputState<'a> {
    fn kill_dead_files<
        T: TreeMutTxnT
            + ChannelMutTxnT
            + GraphMutTxnT<GraphError = <T as TreeTxnT>::TreeError>
            + Send
            + Sync
            + 'static,
        R: WorkingCopy + Clone + Send + Sync + 'static,
        P: ChangeStore + Clone + 'static,
    >(
        &mut self,
        repo: &R,
        txn: &ArcTxn<T>,
        channel: &ChannelRef<T>,
    ) -> Result<(), OutputError<P::Error, T::TreeError, R::Error>> {
        if self.next_prefix_basename.is_none() && self.is_following_prefix {
            let dead = {
                let txn_ = txn.read();

Replacement in "libpijul/src/output/output.rs" at line 277 [11.671807]

∅:D[14.102411] → [13.77524:77878]

B:BD[13.77524] → [13.77524:77878]

                b.sort_unstable_by(|u, v| {
                    txn.get_changeset(txn.changes(&channel), &u.0.change)
                        .unwrap()
                        .cmp(
                            &txn.get_changeset(txn.changes(&channel), &v.0.change)
                                .unwrap(),
                        )
                });

[14.102411]

[13.77878]

                let graph = txn_.graph(&*channel);
                collect_dead_files(&*txn_, graph, self.pending_change_id, Inode::ROOT)?
            };
            debug!("dead (line {}) = {:?}", line!(), dead);
            if !dead.is_empty() {
                let mut txn = txn.write();
                kill_dead_files::<T, R, P>(&mut *txn, &channel, &repo, &dead)?;

Replacement in "libpijul/src/output/output.rs" at line 285 [11.671807]

∅:D[13.77892] → [11.675466:675559]

B:BD[11.675466] → [11.675466:675559]

B:BD[11.675559] → [40.4635:4713]

∅:D[24.1332] → [11.675611:675655]

∅:D[40.4713] → [11.675611:675655]

B:BD[11.675611] → [11.675611:675655]

B:BD[11.675655] → [8.120:401]

∅:D[8.401] → [40.4714:4765]

B:BD[11.675741] → [40.4714:4765]

∅:D[40.4765] → [11.675791:675914]

B:BD[11.675791] → [11.675791:675914]

B:BD[11.675914] → [40.4766:4823]

∅:D[40.4823] → [11.675914:676028]

B:BD[11.675914] → [11.675914:676028]

B:BD[11.676028] → [8.402:569]

∅:D[8.569] → [40.4867:4886]

B:BD[40.4867] → [40.4867:4886]

            let mut is_first_name = true;
            for (name_key, mut output_item) in b {
                let name_entry = match done_vertices.entry(output_item.pos) {
                    Entry::Occupied(e) => {
                        debug!(
                            "pos already visited: {:?} {:?} {:?} {:?}",
                            a,
                            output_item.pos,
                            e.get(),
                            name_key
                        );
                        if e.get().0 != name_key {
                            conflicts.push(Conflict::MultipleNames {
                                pos: output_item.pos,
                                path: e.get().1.clone(),
                            });
                        }
                        continue;
                    }
                    Entry::Vacant(e) => {
                        debug!("first visit {:?} {:?}", a, output_item.pos);
                        e
                    }
                };

[13.77892]

[12.82271]

            self.is_following_prefix = false;
        }
        Ok(())
    }

Replacement in "libpijul/src/output/output.rs" at line 290 [11.671807]

B:BD[12.82272] → [13.77893:77935]

B:BD[13.77935] → [14.102412:102454]

∅:D[13.77986] → [18.119905:120070]

∅:D[14.102454] → [18.119905:120070]

B:BD[12.82312] → [18.119905:120070]

∅:D[18.120070] → [12.82474:82532]

B:BD[12.82474] → [12.82474:82532]

B:BD[12.82532] → [13.77987:78028]

                let output_item_inode = {
                    let txn = txn.read();
                    if let Some(inode) = txn.get_revinodes(&output_item.pos, None)? {
                        Some((*inode, *txn.get_inodes(inode, None)?.unwrap()))
                    } else {
                        None
                    }
                };

[12.82272]

[12.82555]

    fn make_inode(
        &mut self,
        a: &str,
        name_key: Vertex<ChangeId>,
        output_item: &mut OutputItem,
        is_first_name: &mut bool,
    ) -> MakeInode {
        let name_entry = match self.done_vertices.entry(output_item.pos) {
            Entry::Occupied(e) => {
                debug!(
                    "pos already visited: {:?} {:?} {:?} {:?}",
                    a,
                    output_item.pos,
                    e.get(),
                    name_key
                );
                if e.get().0 != name_key {
                    // The same inode has more than one name.
                    self.conflicts.push(Conflict::MultipleNames {
                        pos: output_item.pos,
                        path: e.get().1.clone(),
                    });
                }
                return MakeInode::AlreadyOutput;
            }
            Entry::Vacant(e) => {
                debug!("first visit {:?} {:?}", a, output_item.pos);
                e
            }
        };
        let name = if !*is_first_name {
            // Multiple inodes share the same name.
            if self.output_name_conflicts {
                let name = make_conflicting_name(&a, name_key);
                self.conflicts.push(Conflict::Name { path: name.clone() });
                name
            } else {
                debug!("not outputting {:?} {:?}", a, name_key);
                self.conflicts.push(Conflict::Name {
                    path: a.to_string(),
                });
                return MakeInode::NameConflict;
            }
        } else {
            *is_first_name = false;
            a.to_string()
        };
        debug!("name = {:?} {:?}", name, name_key);
        let file_name = path::file_name(&name).unwrap();
        path::push(&mut output_item.path, file_name);
        name_entry.insert((name_key, output_item.path.clone()));
        MakeInode::Ok(name)
    }

Replacement in "libpijul/src/output/output.rs" at line 344 [11.671807]

B:BD[12.82556] → [12.82556:82618]

∅:D[12.82618] → [11.676216:676268]

B:BD[11.676216] → [11.676216:676268]

                if let Some((inode, _)) = output_item_inode {
                    if !done_inodes.insert(inode) {

[12.82556]

[11.676268]

    fn output_name<
        T: TreeMutTxnT
            + ChannelMutTxnT
            + GraphMutTxnT<GraphError = <T as TreeTxnT>::TreeError>
            + Send
            + Sync
            + 'static,
        R: WorkingCopy + Clone + Send + Sync + 'static,
        P: ChangeStore + Send + Clone + 'static,
    >(
        &mut self,
        repo: &R,
        changes: &P,
        txn: &ArcTxn<T>,
        channel: &ChannelRef<T>,
        next_files: &mut HashMap<String, Vec<(Vertex<ChangeId>, OutputItem)>>,
        a: String,
        b: Vec<(Vertex<ChangeId>, OutputItem)>,
    ) -> Result<(), OutputError<P::Error, T::TreeError, R::Error>> {
        let mut is_first_name = true;
        for (name_key, mut output_item) in b {
            debug!("name_key = {:?} {:?}", name_key, output_item);
            let name = match self.make_inode(&a, name_key, &mut output_item, &mut is_first_name) {
                MakeInode::Ok(file_name) => file_name,
                MakeInode::AlreadyOutput => continue,
                MakeInode::NameConflict => break,
            };
            let output_item_inode = {
                let txn = txn.read();
                if let Some(inode) = txn.get_revinodes(&output_item.pos, None)? {
                    if !self.done_inodes.insert(*inode) {

Replacement in "libpijul/src/output/output.rs" at line 378 [11.671807]

B:BD[11.676402] → [11.676402:676982]

                }
                let name = if !is_first_name {
                    if output_name_conflicts {
                        let name = make_conflicting_name(&a, name_key);
                        conflicts.push(Conflict::Name { path: name.clone() });
                        name
                    } else {
                        debug!("not outputting {:?} {:?}", a, name_key);
                        conflicts.push(Conflict::Name {
                            path: a.to_string(),
                        });
                        break;
                    }

[11.676402]

[11.676982]

                    Some((*inode, *txn.get_inodes(inode, None)?.unwrap()))

Replacement in "libpijul/src/output/output.rs" at line 380 [11.671807]

B:BD[11.677007] → [11.677007:677226]

B:BD[11.677226] → [40.4887:4962]

∅:D[40.4962] → [39.432:559]

B:BD[11.677226] → [39.432:559]

∅:D[39.559] → [11.677226:677310]

B:BD[11.677226] → [11.677226:677310]

B:BD[11.677310] → [39.560:614]

∅:D[39.614] → [16.20283:20338]

B:BD[11.677310] → [16.20283:20338]

B:BD[16.20338] → [13.78029:78062]

B:BD[13.78062] → [14.102455:102482]

∅:D[13.78096] → [11.677476:677510]

∅:D[14.102482] → [11.677476:677510]

B:BD[11.677476] → [11.677476:677510]

B:BD[11.677510] → [12.82619:82658]

∅:D[12.82658] → [11.677510:677537]

B:BD[11.677510] → [11.677510:677537]

B:BD[11.677537] → [39.615:645]

∅:D[39.645] → [11.677537:677608]

B:BD[11.677537] → [11.677537:677608]

B:BD[11.677608] → [41.3605:3631]

∅:D[41.3631] → [11.677608:677628]

B:BD[11.677608] → [11.677608:677628]

B:BD[11.677628] → [13.78097:78144]

∅:D[13.78144] → [11.677628:677697]

B:BD[11.677628] → [11.677628:677697]

B:BD[11.677697] → [13.78145:78178]

B:BD[13.78178] → [14.102483:102584]

∅:D[14.102584] → [13.78297:78421]

B:BD[13.78297] → [13.78297:78421]

∅:D[19.4719] → [11.677788:677856]

∅:D[20.58151] → [11.677788:677856]

∅:D[13.78421] → [11.677788:677856]

∅:D[12.82758] → [11.677788:677856]

B:BD[11.677788] → [11.677788:677856]

B:BD[11.677856] → [13.78422:78464]

B:BD[13.78464] → [14.102585:102636]

B:BD[14.102636] → [38.77:165]

∅:D[38.165] → [13.78609:78631]

∅:D[14.102714] → [13.78609:78631]

B:BD[13.78609] → [13.78609:78631]

∅:D[16.20406] → [11.677912:677955]

∅:D[13.78631] → [11.677912:677955]

B:BD[11.677912] → [11.677912:677955]

                    is_first_name = false;
                    a.clone()
                };
                let file_name = path::file_name(&name).unwrap();
                path::push(&mut output_item.path, file_name);
                name_entry.insert((name_key, output_item.path.clone()));
                if let Some(ref mut tmp) = output_item.tmp {
                    path::push(tmp, file_name);
                }
                let path = std::mem::replace(&mut output_item.path, String::new());
                let mut tmp = output_item.tmp.take();
                let inode = move_or_create::<T, R, P>(
                    txn.clone(),
                    &repo,
                    &output_item,
                    output_item_inode,
                    &path,
                    &mut tmp,
                    &file_name,
                    &mut actual_moves,
                    salt,
                )?;
                debug!("inode = {:?}", inode);
                if next_prefix_basename.is_none() && is_first_none {
                    let dead = {
                        let txn_ = txn.read();
                        let channel = channel.read();
                        collect_dead_files(&*txn_, txn_.graph(&*channel), pending_change_id, inode)?
                    };
                    debug!("dead (line {}) = {:?}", line!(), dead);
                    if !dead.is_empty() {
                        let mut txn = txn.write();
                        kill_dead_files::<T, R, P>(&mut *txn, &channel, &repo, &dead)?;
                    }
                    is_first_none = false;

[11.677007]

[11.677955]

                    None

Replacement in "libpijul/src/output/output.rs" at line 382 [11.671807]

B:BD[11.678044] → [11.678044:678091]

                if output_item.meta.is_dir() {

[11.677973]

[39.646]

            };
            let file_name = path::file_name(&name).unwrap();
            let mut tmp = output_item.tmp.take().map(|mut tmp| {
                path::push(&mut tmp, file_name);
                tmp
            });
            let path = std::mem::replace(&mut output_item.path, String::new());
            let inode = move_or_create::<T, R, P>(
                txn.clone(),
                &repo,
                &output_item,
                output_item_inode,
                &path,
                &mut tmp,
                &file_name,
                &mut self.actual_moves,
                self.salt,
            )?;
            debug!("inode = {:?}", inode);
            self.kill_dead_files::<_, _, P>(repo, txn, channel)?;
            if output_item.meta.is_dir() {
                if !path.is_empty() {

Deletion in "libpijul/src/output/output.rs" at line 408 [11.671807]

B:BD[16.20515] → [13.78632:78654]

B:BD[13.78654] → [14.102715:102815]

∅:D[14.102815] → [13.78772:79053]

B:BD[13.78772] → [13.78772:79053]

B:BD[13.79053] → [39.757:801]

∅:D[39.801] → [13.79053:79264]

B:BD[13.79053] → [13.79053:79264]

                    {
                        let txn = txn.read();
                        let channel = channel.read();
                        collect_children(
                            &*txn,
                            &*changes,
                            txn.graph(&*channel),
                            output_item.pos,
                            inode,
                            &path,
                            tmp.as_deref(),
                            next_prefix_basename,
                            &mut next_files,
                        )?;
                    }
                    debug!("setting permissions for {:?}", path);

Deletion in "libpijul/src/output/output.rs" at line 410 [11.671807]
∅:D[13.79405] → [11.678486:678511]
∅:D[12.82824] → [11.678486:678511]
B:BD[11.678486] → [11.678486:678511]
B:BD[11.678511] → [14.102816:102886]
∅:D[14.102886] → [39.882:967]
B:BD[13.79485] → [39.882:967]
∅:D[39.967] → [42.963:1052]
∅:D[28.1297] → [42.963:1052]
∅:D[13.79557] → [42.963:1052]
B:BD[43.2574] → [42.963:1052]
∅:D[42.1052] → [43.2574:2596]
B:BD[43.2574] → [43.2574:2596]
```
                } else {
                    if needs_output(repo, if_modified_after, &path) {
                        work.push((output_item.clone(), path.clone(), tmp.clone()));
                    } else {
                        debug!("Not outputting {:?}", path)
                    }
```

Replacement in "libpijul/src/output/output.rs" at line 411 [11.671807]

B:BD[11.678720] → [11.678720:678892]

                if output_item.is_zombie {
                    conflicts.push(Conflict::ZombieFile {
                        path: name.to_string(),
                    })

[11.678720]

[11.678892]

                let txn = txn.read();
                let channel = channel.read();
                collect_children(
                    &*txn,
                    &*changes,
                    txn.graph(&*channel),
                    output_item.pos,
                    inode,
                    &path,
                    tmp.as_deref(),
                    self.next_prefix_basename,
                    next_files,
                )?;
            } else {
                if needs_output(repo, self.if_modified_after, &path) {
                    self.work
                        .push((output_item.clone(), path.clone(), tmp.clone()));
                } else {
                    debug!("Not outputting {:?}", path)

Insertion in "libpijul/src/output/output.rs" at line 431 [11.671807]

[11.678910]

[11.679059]

            }
            if output_item.is_zombie {
                self.conflicts.push(Conflict::ZombieFile {
                    path: name.to_string(),
                })

Replacement in "libpijul/src/output/output.rs" at line 438 [11.671807]
B:BD[11.679083] → [11.679083:679142]
B:BD[13.79565] → [13.79565:79625]
B:BD[13.79625] → [14.102887:102956]
∅:D[39.1045] → [13.79694:79717]
∅:D[14.102956] → [13.79694:79717]
B:BD[13.79694] → [13.79694:79717]
B:BD[13.79717] → [2.134:192]
∅:D[2.192] → [11.679209:679215]
∅:D[16.21082] → [11.679209:679215]
∅:D[13.79744] → [11.679209:679215]
B:BD[11.679209] → [11.679209:679215]
B:BD[11.679215] → [2.193:231]
∅:D[2.231] → [39.1046:1147]
B:BD[13.79753] → [39.1046:1147]
```
        std::mem::swap(&mut files, &mut next_files);
    }
    stop.store(true, std::sync::atomic::Ordering::Relaxed);
    let o = output_loop(repo, changes, txn, channel, work, stop, 0);
    for t in threads {
        conflicts.extend(t.join().unwrap()?.into_iter());
    }
    conflicts.extend(o?.into_iter());
    for (a, b) in actual_moves.iter() {
        repo.rename(a, b).map_err(OutputError::WorkingCopy)?
```
[11.679083]
[39.1147]
```
        Ok(())
```
Replacement in "libpijul/src/output/output.rs" at line 440 [11.671807]
∅:D[39.1153] → [11.679215:679233]
∅:D[13.79753] → [11.679215:679233]
B:BD[11.679215] → [11.679215:679233]
```
    Ok(conflicts)
```
[39.1153]
[11.679233]
```
}
enum MakeInode {
    AlreadyOutput,
    NameConflict,
    Ok(String),
```
Replacement in "libpijul/src/output/mod.rs" at line 101 [11.686190]
∅:D[16.24839] → [11.686875:686908]
∅:D[12.86337] → [11.686875:686908]
B:BD[11.686875] → [11.686875:686908]
```
    debug!("path = {:?}", path);
```
[12.86337]
[44.56008]
```
    debug!("path = {:?}, inode_pos = {:?}", path, inode_pos);
```
Insertion in "libpijul/src/output/mod.rs" at line 110 [11.686190]
[12.86385]
[18.122019]
```
        debug!("e = {:?}", e);
```

Replacement in "libpijul/src/output/mod.rs" at line 112 [11.686190]

∅:D[44.56162] → [11.687480:687519]

∅:D[20.58558] → [11.687480:687519]

∅:D[12.86454] → [11.687480:687519]

∅:D[18.122089] → [11.687480:687519]

B:BD[11.687480] → [11.687480:687519]

B:BD[11.687519] → [23.1478:1556]

B:BD[23.1556] → [17.3999:4014]

∅:D[17.4014] → [23.1556:1604]

B:BD[23.1556] → [23.1556:1604]

∅:D[23.1604] → [21.17583:17652]

B:BD[21.17583] → [21.17583:17652]

        let mut name_buf = Vec::new();
        let FileMetadata {
            basename,
            metadata: perms,
            ..
        } = changes
            .get_file_meta(
                |h| txn.get_external(&h).unwrap().map(|x| x.into()),

[18.122089]

[21.17652]

        if name_vertex.start != name_vertex.end {
            debug!("name_vertex: {:?} {:?}", e, name_vertex);
            collect(
                txn,
                changes,
                channel,
                inode,
                path,
                tmp,
                prefix_basename,
                files,
                name_vertex,
            )?
        } else {
            let inode_pos = iter_adjacent(
                txn,
                channel,

Replacement in "libpijul/src/output/mod.rs" at line 130 [11.686190]

B:BD[21.17682] → [21.17682:17727]

∅:D[21.17727] → [12.86543:86600]

∅:D[18.122198] → [12.86543:86600]

B:BD[12.86543] → [12.86543:86600]

B:BD[11.687814] → [11.687814:688082]

B:BD[11.688145] → [11.688145:688203]

B:BD[11.688346] → [44.56334:56407]

B:BD[44.56407] → [12.86601:86622]

B:BD[12.86622] → [18.122199:122225]

∅:D[18.122225] → [44.56454:56555]

B:BD[44.56454] → [44.56454:56555]

B:BD[44.56555] → [12.86623:86634]

∅:D[12.86634] → [44.56565:56591]

B:BD[44.56565] → [44.56565:56591]

B:BD[44.56591] → [12.86635:86654]

∅:D[12.86654] → [44.56609:56626]

B:BD[44.56609] → [44.56609:56626]

B:BD[44.56626] → [12.86655:86688]

                &mut name_buf,
            )
            .map_err(PristineOutputError::Changestore)?;
        debug!("filename: {:?} {:?}", perms, basename);
        let mut name = path.to_string();
        if let Some(next) = prefix_basename {
            if next != basename {
                continue;
            }
        }
        path::push(&mut name, basename);
        debug!("name_vertex: {:?} {:?}", e, name_vertex);
        let child = if let Some(child) = iter_adjacent(
            txn,
            channel,
            *name_vertex,
            EdgeFlags::FOLDER,
            EdgeFlags::FOLDER | EdgeFlags::BLOCK | EdgeFlags::PSEUDO,
        )?
        .next()
        {
            child?
        } else {
            let mut edge = None;

[21.17682]

[12.86688]

                EdgeFlags::FOLDER,
                EdgeFlags::FOLDER | EdgeFlags::PSEUDO | EdgeFlags::BLOCK,
            )?
            .next()
            .unwrap()?
            .dest();

Replacement in "libpijul/src/output/mod.rs" at line 139 [11.686190]
B:BD[12.86750] → [18.122226:122256]
```
                *name_vertex,
```
[12.86750]
[11.688474]
```
                inode_pos.inode_vertex(),
```

Replacement in "libpijul/src/output/mod.rs" at line 141 [11.686190]

B:BD[11.688509] → [44.56687:56721]

                EdgeFlags::all(),

[11.688509]

[12.86751]

                EdgeFlags::FOLDER | EdgeFlags::PSEUDO | EdgeFlags::BLOCK,

Replacement in "libpijul/src/output/mod.rs" at line 144 [11.686190]

B:BD[12.86796] → [18.122257:122316]

∅:D[18.122316] → [12.86853:86934]

B:BD[12.86853] → [12.86853:86934]

                if !e.flag().contains(EdgeFlags::PARENT) {
                    edge = Some(e);
                    break;
                }

[12.86796]

[12.86934]

                debug!("e = {:?}", e);
                let name_vertex = txn.find_block(channel, e.dest()).unwrap();
                collect(
                    txn,
                    changes,
                    channel,
                    inode,
                    path,
                    tmp,
                    prefix_basename,
                    files,
                    name_vertex,
                )?

Replacement in "libpijul/src/output/mod.rs" at line 158 [11.686190]
B:BD[12.86948] → [12.86948:86983]
∅:D[12.86983] → [11.688898:688970]
B:BD[11.688898] → [11.688898:688970]
B:BD[11.688970] → [18.122317:122404]
∅:D[45.962] → [11.689072:689115]
∅:D[46.3292] → [11.689072:689115]
∅:D[44.56894] → [11.689072:689115]
∅:D[12.87069] → [11.689072:689115]
∅:D[18.122404] → [11.689072:689115]
B:BD[11.689072] → [11.689072:689115]
```
            let e = edge.unwrap();
            let mut f = std::fs::File::create("debug_output").unwrap();
            debug_root(txn, channel, e.dest().inode_vertex(), &mut f, false).unwrap();
            panic!("no child");
        };
```
[12.86948]
[11.689115]
```
        }
    }
    Ok(())
}
```

Replacement in "libpijul/src/output/mod.rs" at line 163 [11.686190]

B:BD[11.689116] → [11.689116:689154]

B:BD[11.689352] → [47.4958:5018]

∅:D[47.5018] → [11.689409:689426]

B:BD[11.689409] → [11.689409:689426]

        debug!("child: {:?}", child);
        let v = files.entry(name).or_insert_with(Vec::new);
        v.push((

[11.689116]

[18.122405]

fn collect<T: GraphTxnT, P: ChangeStore>(
    txn: &T,
    changes: &P,
    channel: &T::Graph,
    inode: Inode,
    path: &str,
    tmp: Option<&str>,
    prefix_basename: Option<&str>,
    files: &mut HashMap<String, Vec<(Vertex<ChangeId>, OutputItem)>>,
    name_vertex: &Vertex<ChangeId>,
) -> Result<(), PristineOutputError<P::Error, T::GraphError>> {
    let mut name_buf = Vec::new();
    let FileMetadata {
        basename,
        metadata: perms,
        ..
    } = changes
        .get_file_meta(
            |h| txn.get_external(&h).unwrap().map(|x| x.into()),

Replacement in "libpijul/src/output/mod.rs" at line 183 [11.686190]

∅:D[18.122431] → [11.689451:689547]

B:BD[11.689451] → [11.689451:689547]

B:BD[11.689547] → [39.1427:1471]

∅:D[39.1471] → [11.689547:689576]

B:BD[11.689547] → [11.689547:689576]

B:BD[11.689576] → [18.122432:122534]

∅:D[12.87135] → [11.689709:689736]

∅:D[18.122534] → [11.689709:689736]

B:BD[11.689709] → [11.689709:689736]

            OutputItem {
                parent: inode,
                path: path.to_string(),
                tmp: tmp.map(String::from),
                meta: perms,
                pos: child.dest(),
                is_zombie: is_zombie(txn, channel, child.dest())?,
            },
        ));

[18.122431]

[11.689736]

            &mut name_buf,
        )
        .map_err(PristineOutputError::Changestore)?;
    debug!("filename: {:?} {:?}", perms, basename);
    let mut name = path.to_string();
    if let Some(next) = prefix_basename {
        if next != basename {
            return Ok(());
        }

Insertion in "libpijul/src/output/mod.rs" at line 193 [11.686190]

[11.689742]

    path::push(&mut name, basename);
    let child = if let Some(child) = iter_adjacent(
        txn,
        channel,
        *name_vertex,
        EdgeFlags::FOLDER,
        EdgeFlags::FOLDER | EdgeFlags::BLOCK | EdgeFlags::PSEUDO,
    )?
    .next()
    {
        child?
    } else {
        let mut edge = None;
        for e in iter_adjacent(
            txn,
            channel,
            *name_vertex,
            EdgeFlags::FOLDER,
            EdgeFlags::all(),
        )? {
            let e = e?;
            if !e.flag().contains(EdgeFlags::PARENT) {
                edge = Some(e);
                break;
            }
        }
        let e = edge.unwrap();
        let mut f = std::fs::File::create("debug_output").unwrap();
        debug_root(txn, channel, e.dest().inode_vertex(), &mut f, false).unwrap();
        panic!("no child");
    };
    debug!("child: {:?}", child);
    let v = files.entry(name).or_insert_with(Vec::new);
    v.push((
        *name_vertex,
        OutputItem {
            parent: inode,
            path: path.to_string(),
            tmp: tmp.map(String::from),
            meta: perms,
            pos: child.dest(),
            is_zombie: is_zombie(txn, channel, child.dest())?,
        },
    ));

Insertion in "libpijul/src/fs.rs" at line 568 [11.737429]
[11.752522]
[11.752522]
```
    adj2: Option<AdjacentIterator<'txn, T>>,
```

Replacement in "libpijul/src/fs.rs" at line 578 [11.737429]

B:BD[11.752809] → [12.109481:109603]

        let child = match self.adj.next()? {
            Ok(child) => child,
            Err(e) => return Some(Err(e.0)),

[11.752809]

[12.109603]

        let dest = loop {
            debug!("adj2 = {:?}", self.adj2.is_some());
            if let Some(mut adj2) = self.adj2.take() {
                match adj2.next() {
                    None => {}
                    Some(Ok(ch)) => {
                        self.adj2 = Some(adj2);
                        break self.txn.find_block(self.channel, ch.dest()).unwrap();
                    }
                    Some(Err(e)) => return Some(Err(e.0)),
                }
            }
            match self.adj.next() {
                Some(Ok(child)) => {
                    let d = self.txn.find_block(self.channel, child.dest()).unwrap();
                    if d.start == d.end {
                        match iter_adjacent(
                            self.txn,
                            self.channel,
                            *d,
                            EdgeFlags::FOLDER,
                            EdgeFlags::FOLDER | EdgeFlags::PSEUDO | EdgeFlags::BLOCK,
                        )
                        .and_then(|mut it| it.next().unwrap())
                        .and_then(|x| {
                            iter_adjacent(
                                self.txn,
                                self.channel,
                                x.dest().inode_vertex(),
                                EdgeFlags::FOLDER,
                                EdgeFlags::FOLDER | EdgeFlags::PSEUDO | EdgeFlags::BLOCK,
                            )
                        }) {
                            Ok(adj) => self.adj2 = Some(adj),
                            Err(e) => return Some(Err(e.0)),
                        }
                    } else {
                        break d;
                    }
                }
                Some(Err(e)) => return Some(Err(e.0)),
                None => return None,
            }

Replacement in "libpijul/src/fs.rs" at line 622 [11.737429]

B:BD[12.109614] → [18.131879:131956]

        let dest = self.txn.find_block(self.channel, child.dest()).unwrap();

[12.109614]

[12.109690]

        debug!("dest = {:?}", dest);

Insertion in "libpijul/src/fs.rs" at line 685 [11.737429]
[12.110831]
[11.754401]
```
        adj2: None,
```
Replacement in "libpijul/src/fs.rs" at line 907 [11.737429]
B:BD[11.761369] → [11.761369:761401]
```
    while !v.change.is_root() {
```
[11.761369]
[11.761401]
```
    'outer: while !v.change.is_root() {
```

Insertion in "libpijul/src/fs.rs" at line 929 [11.737429]

[12.114156]

[18.133151]

            if name.dest().is_root() {
                break 'outer;
            }

Insertion in "libpijul/src/fs.rs" at line 968 [11.737429]

[11.762898]

        if name.start == name.end {
            // Non-zero root vertex
            assert!(next.change.is_root());
            break;
        }

Insertion in "libpijul/src/change.rs" at line 561 [11.831311]

[11.847507]

[48.2919]

            Hunk::AddRoot { change } => Hunk::DelRoot {
                change: change.inverse(hash),
            },
            Hunk::DelRoot { change } => Hunk::AddRoot {
                change: change.inverse(hash),
            },

Insertion in "libpijul/src/change.rs" at line 755 [11.831311]
[30.2045]
[11.852249]
```
    },
    AddRoot {
        change: Atom,
```
Insertion in "libpijul/src/change.rs" at line 759 [11.831311]
[11.852256]
[11.852256]
```
    DelRoot {
        change: Atom,
    },
```

Insertion in "libpijul/src/change.rs" at line 847 [11.831311]

[48.4889]

[11.855085]

                Hunk::AddRoot { change } | Hunk::DelRoot { change } => Some(change),

Insertion in "libpijul/src/change.rs" at line 910 [11.831311]

[48.5597]

[11.857285]

                Hunk::AddRoot { ref change } | Hunk::DelRoot { ref change } => Some(change),

Insertion in "libpijul/src/change.rs" at line 992 [11.831311]

[48.6340]

[11.860058]

                Hunk::AddRoot { ref change } | Hunk::DelRoot { ref change } => Some(change),

Insertion in "libpijul/src/change.rs" at line 1111 [11.831311]
[48.6947]
[11.863349]
```
            Hunk::AddRoot { .. } | Hunk::DelRoot { .. } => "/",
```

Insertion in "libpijul/src/change.rs" at line 1224 [11.831311]

[11.866586]

[12.122493]

            BaseHunk::AddRoot { change } => BaseHunk::AddRoot { change: f(change)? },
            BaseHunk::DelRoot { change } => BaseHunk::DelRoot { change: f(change)? },

Replacement in "libpijul/src/change/text_changes.rs" at line 453 [16.37976]

∅:D[49.4295] → [23.2861:2981]

B:BD[16.51864] → [23.2861:2981]

B:BD[23.2981] → [17.5417:5444]

B:BD[17.5444] → [3.101:197]

                    let FileMetadata {
                        basename: name,
                        metadata: perms,
                        ..
                    } = FileMetadata::read(&change_contents[n.start.0.into()..n.end.0.into()]);

[49.4295]

[16.52241]

                    let (name, perms) = if n.start == n.end {
                        ("", InodeMetadata::DIR)
                    } else {
                        let FileMetadata {
                            basename: name,
                            metadata: perms,
                            ..
                        } = FileMetadata::read(&change_contents[n.start.0.into()..n.end.0.into()]);
                        (name, perms)
                    };

Insertion in "libpijul/src/change/text_changes.rs" at line 589 [16.37976]

[17.5532]

[16.56555]

            }
            Hunk::AddRoot { change } => {
                writeln!(w, "Root",)?;
                write_atom(&mut w, hashes, &change)?;
            }
            Hunk::DelRoot { change } => {
                writeln!(w, "Unroot",)?;
                write_atom(&mut w, hashes, &change)?;

Insertion in "libpijul/src/change/text_changes.rs" at line 1172 [16.37976]
[16.79917]
[16.79917]
```
                _ => unimplemented!(),
```