laumann/pijul - Change FGIVSUFHH7DN65DYQHDGGDDCHHIB5Z7KKQWI4I3WMERE3BY6IMRQC

Fixing conflicts with the new patch parsing code, and introducing AddRoot

Created by pmeunier on November 23, 2021

FGIVSUFHH7DN65DYQHDGGDDCHHIB5Z7KKQWI4I3WMERE3BY6IMRQC

Dependencies

In channels

main

Change contents

File move: libpijul → libpijul
BF:BFD[1.0] → [4.55:65]
[1.0]
[5.198139]

Replacement in libpijul/src/change.rs at line 569 [5.831311]

B:BD[5.847507] → [2.27193:27295]

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

[5.847507]

[2.27295]

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

Replacement in libpijul/src/change.rs at line 573 [5.831311]

B:BD[2.27310] → [2.27310:27412]

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

[2.27310]

[2.27412]

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

Replacement in libpijul/src/change.rs at line 767 [5.831311]
B:BD[2.27449] → [2.27449:27471]
```
        change: Atom,
```
[2.27449]
[5.852249]
```
        name: Atom,
        inode: Atom,
```
Replacement in libpijul/src/change.rs at line 771 [5.831311]
B:BD[2.27486] → [2.27486:27508]
```
        change: Atom,
```
[2.27486]
[2.27508]
```
        name: Atom,
        inode: Atom,
```

Replacement in libpijul/src/change.rs at line 859 [5.831311]

B:BD[6.4889] → [2.27516:27601]

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

[6.4889]

[5.855085]

                Hunk::AddRoot { inode, name } | Hunk::DelRoot { inode, name } => {
                    self.extra = Some(inode);
                    Some(name)
                },

Replacement in libpijul/src/change.rs at line 925 [5.831311]

B:BD[6.5597] → [2.27602:27695]

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

[6.5597]

[5.857285]

                Hunk::AddRoot { ref inode, ref name } | Hunk::DelRoot { ref inode, ref name } => {
                    self.extra = Some(inode);
                    Some(name)
                },

Replacement in libpijul/src/change.rs at line 1010 [5.831311]

B:BD[6.6340] → [2.27696:27789]

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

[6.6340]

[5.860058]

                Hunk::AddRoot { ref name, ref inode } | Hunk::DelRoot { ref name, ref inode } => {
                    self.extra = Some(inode);
                    Some(name)
                },

Replacement in libpijul/src/change.rs at line 1245 [5.831311]

B:BD[5.866586] → [2.27855:28027]

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

[5.866586]

[7.122493]

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

Insertion in libpijul/src/change/text_changes_old.rs at line 583 [3.506]
[3.21762]
[3.21762]
```
            _ => {}
```

Insertion in libpijul/src/change/text_changes_old.rs at line 1158 [3.506]

[3.47139]

                _ => {
                    unimplemented!()
                },

Deletion in libpijul/src/change/text_changes.rs at line 198 [9.37976]
B:BD[8.10709] → [8.10709:10732]
```
        dbg!(&header);
```
Deletion in libpijul/src/change/text_changes.rs at line 201 [9.37976]
B:BD[8.10837] → [8.10837:10858]
```
        dbg!(&deps);
```
Deletion in libpijul/src/change/text_changes.rs at line 204 [9.37976]
B:BD[8.10950] → [8.10950:10972]
```
        dbg!(&hunks);
```
Insertion in libpijul/src/change/text_changes.rs at line 258 [9.37976]
[8.12288]
[8.12288]
```
            debug!("res = {:?}", res);
```
Deletion in libpijul/src/change/text_changes.rs at line 444 [9.37976]
B:BD[10.2940] → [8.17300:17334]
BD:BD[10.2940] → [8.17300:17334]
```
                        metadata,
```

Resurrecting zombie bytes in libpijul/src/change/text_changes.rs at line 444 [9.37976]

B:B[11.197] → [8.17335:17495]

BD:B[11.197] → [8.17335:17495]


                    let contents = if let Some(Atom::NewVertex(ref n)) = contents {
                        change_contents[n.start.us()..n.end.us()].to_vec()

Insertion in libpijul/src/change/text_changes.rs at line 444 [9.37976]

[12.4295]

[8.17335]

                    let (name, metadata) = 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)
                    };

Deletion in libpijul/src/change/text_changes.rs at line 556 [9.37976]
B:BD[13.5532] → [2.28493:28507]
BD:BD[13.5532] → [2.28493:28507]
B:BD[2.28549] → [2.28549:28588]
BD:BD[2.28549] → [2.28549:28588]
B:BD[2.28642] → [2.28642:28656]
BD:BD[2.28642] → [2.28642:28656]
B:BD[2.28698] → [2.28698:28739]
BD:BD[2.28698] → [2.28698:28739]
```
            }
                writeln!(w, "Root",)?;
            }
                writeln!(w, "Unroot",)?;
```

Insertion in libpijul/src/change/text_changes.rs at line 564 [9.37976]

[8.21567]

[9.56569]

            Hunk::AddRoot { name, .. } => {
                if let Atom::NewVertex(ref n) = name {
                    PrintableHunk::AddRoot {
                        start: n.start.0 .0,
                    }
                } else {
                    unreachable!()
                }
            }
            Hunk::DelRoot { inode, name } => PrintableHunk::DelRoot {
                name: to_printable_edge_map(name, hashes),
                inode: to_printable_edge_map(inode, hashes),
            },

Insertion in libpijul/src/change/text_changes.rs at line 591 [9.37976]
[8.21697]
[8.21766]
```
        debug!("from_printable {:?}", hunk);
```

Replacement in libpijul/src/change/text_changes.rs at line 701 [9.37976]

B:BD[8.25991] → [3.59250:59352]

                add_name.up_context = from_printable_pos_vec_offsets(changes, offsets, &up_context)?;

[8.25991]

                add_name.up_context =
                    from_printable_pos_vec_offsets(changes, offsets, &up_context)?;

Replacement in libpijul/src/change/text_changes.rs at line 731 [9.37976]

B:BD[8.27090] → [3.59389:59471]

                    path: if parent == "" { name } else { parent + "/" + &name },

[8.27090]

[13.5933]

                    path: if parent == "" {
                        name
                    } else {
                        parent + "/" + &name
                    },

Replacement in libpijul/src/change/text_changes.rs at line 791 [9.37976]

B:BD[8.29063] → [3.59472:59704]

                        x.up_context = from_printable_pos_vec_offsets(changes, offsets, &new_vertex.up_context)?;
                        x.down_context = from_printable_pos_vec_offsets(changes, offsets, &new_vertex.down_context)?;

[8.29063]

[8.29261]

                        x.up_context = from_printable_pos_vec_offsets(
                            changes,
                            offsets,
                            &new_vertex.up_context,
                        )?;
                        x.down_context = from_printable_pos_vec_offsets(
                            changes,
                            offsets,
                            &new_vertex.down_context,
                        )?;

Replacement in libpijul/src/change/text_changes.rs at line 835 [9.37976]

B:BD[8.30426] → [3.59749:59975]

                    x.up_context = from_printable_pos_vec_offsets(changes, offsets, &replacement.up_context)?;
                    x.down_context = from_printable_pos_vec_offsets(changes, offsets, &replacement.down_context)?;

[8.30426]

[8.30618]

                    x.up_context =
                        from_printable_pos_vec_offsets(changes, offsets, &replacement.up_context)?;
                    x.down_context = from_printable_pos_vec_offsets(
                        changes,
                        offsets,
                        &replacement.down_context,
                    )?;

Replacement in libpijul/src/change/text_changes.rs at line 894 [9.37976]

B:BD[8.32463] → [3.60012:60220]

                c.up_context = from_printable_pos_vec_offsets(changes, offsets, &change.up_context)?;
                c.down_context = from_printable_pos_vec_offsets(changes, offsets, &change.down_context)?;

[8.32463]

[8.32637]

                c.up_context =
                    from_printable_pos_vec_offsets(changes, offsets, &change.up_context)?;
                c.down_context =
                    from_printable_pos_vec_offsets(changes, offsets, &change.down_context)?;

Deletion in libpijul/src/change/text_changes.rs at line 924 [9.37976]
B:BD[9.79917] → [2.28794:28833]
BD:BD[9.79917] → [2.28794:28833]
```
                _ => unimplemented!(),
```

Insertion in libpijul/src/change/text_changes.rs at line 941 [9.37976]

[8.34280]

[9.79931]

            PrintableHunk::AddRoot { start } => {
                contents_.push(0);
                let root_inode = Position {
                    change: Some(Hash::None),
                    pos: ChangePosition(contents_.len().into()),
                };
                contents_.push(0);
                let inode = contents_.len();
                contents_.push(0);
                if let Entry::Occupied(mut e) = updatables.entry(hunk_id as usize) {
                    if let crate::InodeUpdate::Add { ref mut pos, .. } = e.get_mut() {
                        offsets.insert(pos.0.into(), ChangePosition((start + 1).into()));
                        *pos = ChangePosition((start + 1).into())
                    }
                }
                Ok(Hunk::AddRoot {
                    name: Atom::NewVertex(NewVertex {
                        up_context: vec![root_inode],
                        down_context: Vec::new(),
                        start: ChangePosition(start.into()),
                        end: ChangePosition(start.into()),
                        flag: EdgeFlags::FOLDER | EdgeFlags::BLOCK,
                        inode: root_inode,
                    }),
                    inode: Atom::NewVertex(NewVertex {
                        up_context: vec![Position {
                            change: None,
                            pos: ChangePosition(start.into()),
                        }],
                        down_context: Vec::new(),
                        start: ChangePosition(inode.into()),
                        end: ChangePosition(inode.into()),
                        flag: EdgeFlags::FOLDER | EdgeFlags::BLOCK,
                        inode: root_inode,
                    })
                })
            }
            PrintableHunk::DelRoot { name, inode } => {
                let root_inode = PrintablePos(1, 0);
                Ok(Hunk::DelRoot {
                    name: Atom::EdgeMap(EdgeMap {
                        edges: from_printable_edge_map(&name, changes)?,
                        inode: from_printable_pos(changes, root_inode)?,
                    }),
                    inode: Atom::EdgeMap(EdgeMap {
                        edges: from_printable_edge_map(&inode, changes)?,
                        inode: from_printable_pos(changes, root_inode)?,
                    }),
                })
            }

Deletion in libpijul/src/change/text_changes.rs at line 1147 [9.37976]

B:BD[12.4295] → [2.28028:28090]

BD:BD[12.4295] → [2.28028:28090]

B:BD[2.28090] → [2.28090:28492]

BD:BD[2.28090] → [2.28090:28492]

                    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)
                    };

Solving an order conflict in libpijul/src/change/text_changes.rs at line 1147 [9.37976]
[9.88449]

Insertion in libpijul/src/change/printable.rs at line 157 [8.36296]

[8.40076]

    },
    AddRoot {
        start: u64,
    },
    DelRoot {
        name: Vec<PrintableEdge>,
        inode: Vec<PrintableEdge>,

Insertion in libpijul/src/change/printable.rs at line 565 [8.36296]

[8.52014]

            AddRoot {
                start
            } => {
                writeln!(
                    w,
                    "Root add\n  up {}, new {}:{}",
                    PrintablePos(1, 0),
                    start, start,
                )?;
            }
            DelRoot {
                name, inode
            } => {
                writeln!(
                    w,
                    "Root del",
                )?;
                writeln!(w, "{}", PrintableAtom::Edges(name.to_vec()))?;
                writeln!(w, "{}", PrintableAtom::Edges(inode.to_vec()))?;
            }

Insertion in libpijul/src/change/parse.rs at line 300 [8.64713]

[8.73746]

fn parse_root_addition_hunk(i: &str) -> IResult<&str, PrintableHunk> {
    debug!("root add {:?}", i);
    let (i, _) = delimited(space0, tag("Root add"), space0)(i)?;
    let (i, _) = tuple((space0, newline, multispace0))(i)?;
    debug!("root add {:?}", i);
    let (i, up_context) = preceded(tag("up"), parse_context)(i)?;
    debug!("root add {:?}", i);
    let (i, (start, end)) = delimited(space0, parse_start_end, pair(space0, newline))(i)?;
    debug!("root add {:?}", i);
    assert_eq!(&up_context[..], &[PrintablePos(1, 0)]);
    assert_eq!(start, end);
    Ok((
        i,
        PrintableHunk::AddRoot {
            start
        },
    ))
}
fn parse_root_deletion_hunk(i: &str) -> IResult<&str, PrintableHunk> {
    let (i, _) = delimited(space0, tag("Root del"), space0)(i)?;
    let (i, _) = tuple((space0, newline))(i)?;
    let (i, name) = parse_edges(i)?;
    let (i, inode) = parse_edges(i)?;
    Ok((
        i,
        PrintableHunk::DelRoot {
            inode, name
        },
    ))
}

Insertion in libpijul/src/change/parse.rs at line 400 [8.64713]
[8.75620]
[8.75620]
```
    debug!("parse_hunk {:?}", input);
```

Insertion in libpijul/src/change/parse.rs at line 414 [8.64713]

[8.76020]

        parse_root_addition_hunk,
        parse_root_deletion_hunk,

Replacement in libpijul/src/record.rs at line 721 [5.488880]

B:BD[2.5233] → [2.5233:5341]

                self.actions.push(Hunk::FileAdd {
                    add_name: Atom::NewVertex(NewVertex {

[2.5233]

[2.5341]

                self.actions.push(Hunk::AddRoot {
                    name: Atom::NewVertex(NewVertex {

Replacement in libpijul/src/record.rs at line 725 [5.488880]

B:BD[2.5437] → [2.5437:5509]

                        start: pos2,
                        end: pos2,

[2.5437]

[2.5509]

                        start: pos,
                        end: pos,

Replacement in libpijul/src/record.rs at line 730 [5.488880]

B:BD[2.5640] → [2.5640:5699]

                    add_inode: Atom::NewVertex(NewVertex {

[2.5640]

[2.5699]

                    inode: Atom::NewVertex(NewVertex {

Replacement in libpijul/src/record.rs at line 733 [5.488880]

B:BD[2.5793] → [2.5793:5832]

                            pos: pos2,

[2.5793]

[2.5832]

                            pos,

Replacement in libpijul/src/record.rs at line 736 [5.488880]

B:BD[2.5906] → [2.5906:5976]

                        start: pos,
                        end: pos,

[2.5906]

[2.5976]

                        start: pos2,
                        end: pos2,

Deletion in libpijul/src/record.rs at line 741 [5.488880]

B:BD[2.6107] → [2.6107:6222]

                    contents: None,
                    path: "/".to_string(),
                    encoding: None,

Replacement in libpijul/src/record.rs at line 742 [5.488880]

B:BD[2.6242] → [2.6242:6328]

                *new_root = Some(pos);
                Position { change: None, pos }

[2.6242]

[2.6328]


                self.updatables
                    .insert(self.actions.len(), InodeUpdate::Add { inode: Inode::ROOT, pos: pos2 });
                *new_root = Some(pos2);
                Position { change: None, pos: pos2 }

Fixing conflicts with the new patch parsing code, and introducing AddRoot

Dependencies

In channels

Change contents

File move: libpijul → libpijul

Replacement in libpijul/src/change.rs at line 569 [5.831311]

Replacement in libpijul/src/change.rs at line 573 [5.831311]

Replacement in libpijul/src/change.rs at line 767 [5.831311]

Replacement in libpijul/src/change.rs at line 771 [5.831311]