dblsaiko/pijul - Change ALKSQF2FA5VUUUU3IMCDOWRB5PL4AXINZUA5I27SGNKQPD6Z7J3QC

Return parse errors in the text format when a hunk description is parsed, but the hunk fails to parse

Created by pmeunier on December 17, 2023

ALKSQF2FA5VUUUU3IMCDOWRB5PL4AXINZUA5I27SGNKQPD6Z7J3QC

Dependencies

In channels

main

Change contents

Replacement in libpijul/src/change/parse.rs at line 17 [8.64713]

B:BD[8.65134] → [8.65134:65308]

B:BD[8.65308] → [9.0:51]

    let (i, name) = preceded(space0, parse_string)(i)?;
    let (i, perms) = preceded(space0, parse_perms)(i)?;
    let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
    let (i, _) = tuple((space0, line_ending))(i)?;

[8.65134]

[8.65355]

    let parse = |i, path| -> IResult<&str, PrintableHunk> {
        let (i, name) = preceded(space0, parse_string)(i)?;
        let (i, perms) = preceded(space0, parse_perms)(i)?;
        let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
        let (i, _) = tuple((space0, line_ending))(i)?;

Replacement in libpijul/src/change/parse.rs at line 23 [8.64713]
B:BD[8.65356] → [8.65356:65392]
```
    let (i, del) = parse_edges(i)?;
```
[8.65356]
[8.65392]
```
        let (i, del) = parse_edges(i)?;
```

Replacement in libpijul/src/change/parse.rs at line 25 [8.64713]

B:BD[8.65393] → [8.65393:65559]

B:BD[8.65559] → [9.52:86]

∅:D[9.86] → [8.65589:65786]

B:BD[8.65589] → [8.65589:65786]

    let (i, up_context) = preceded(pair(space0, tag("up")), parse_context)(i)?;
    let (i, down_context) = preceded(pair(space0, tag(", down")), parse_context)(i)?;
    let (i, _) = line_ending(i)?;
    Ok((
        i,
        FileMoveV {
            path,
            name,
            perms,
            pos,
            up_context,
            down_context,
            del,
        },
    ))

[8.65393]

[8.65786]

        let (i, up_context) = preceded(pair(space0, tag("up")), parse_context)(i)?;
        let (i, down_context) = preceded(pair(space0, tag(", down")), parse_context)(i)?;
        let (i, _) = line_ending(i)?;
        Ok((
            i,
            FileMoveV {
                path,
                name,
                perms,
                pos,
                up_context,
                down_context,
                del,
            },
        ))
    };
    parse(i, path)
        .map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

Replacement in libpijul/src/change/parse.rs at line 47 [8.64713]

B:BD[8.65948] → [8.65948:66010]

B:BD[8.66010] → [9.87:138]

    let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
    let (i, _) = tuple((space0, line_ending))(i)?;

[8.65948]

[8.66057]

    let parse = |i, path| -> IResult<&str, PrintableHunk> {
        let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
        let (i, _) = tuple((space0, line_ending))(i)?;

Replacement in libpijul/src/change/parse.rs at line 51 [8.64713]

B:BD[8.66058] → [8.66058:66257]

    let (i, add) = parse_edges(i)?;
    let (i, del) = parse_edges(i)?;
    Ok((
        i,
        FileMoveE {
            path,
            pos,
            add,
            del,
        },
    ))

[8.66058]

[8.66257]

        let (i, add) = parse_edges(i)?;
        let (i, del) = parse_edges(i)?;
        Ok((
            i,
            FileMoveE {
                path,
                pos,
                add,
                del,
            },
        ))
    };
    parse(i, path)
        .map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

Replacement in libpijul/src/change/parse.rs at line 72 [8.64713]

B:BD[8.66447] → [8.66447:66571]

B:BD[8.66571] → [9.139:190]

∅:D[9.190] → [8.66618:66660]

B:BD[8.66618] → [8.66618:66660]

B:BD[8.66660] → [10.0:85]

∅:D[10.85] → [11.0:48]

B:BD[12.115] → [11.0:48]

B:BD[11.48] → [7.0:214]

    let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
    let (i, encoding) = preceded(space0, parse_encoding)(i)?;
    let (i, _) = tuple((space0, line_ending))(i)?;
    let (i, del_edges) = parse_edges(i)?;
    let (i, content_edges) = map(opt(parse_edges), |o| o.unwrap_or(Vec::new()))(i)?;
    let (i, contents) = if encoding.is_none() {
        debug!("encoding none");
        // If the encoding is binary, we may have a base64 version of
        // the file.
        if let Ok((i, c)) = parse_contents('-', encoding.clone(), i) {
            (i, c)

[8.66447]

[7.214]

    let parse = |i, path| -> IResult<&str, PrintableHunk> {
        let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
        let (i, encoding) = preceded(space0, parse_encoding)(i)?;
        let (i, _) = tuple((space0, line_ending))(i)?;
        let (i, del_edges) = parse_edges(i)?;
        let (i, content_edges) = map(opt(parse_edges), |o| o.unwrap_or(Vec::new()))(i)?;
        let (i, contents) = if encoding.is_none() {
            debug!("encoding none");
            // If the encoding is binary, we may have a base64 version of
            // the file.
            if let Ok((i, c)) = parse_contents('-', encoding.clone(), i) {
                (i, c)
            } else {
                (i, Vec::new())
            }

Replacement in libpijul/src/change/parse.rs at line 88 [8.64713]

B:BD[7.231] → [7.231:269]

∅:D[7.269] → [11.72:135]

B:BD[11.72] → [11.72:135]

            (i, Vec::new())
        }
    } else {
        parse_contents('-', encoding.clone(), i)?

[7.231]

[11.135]

            parse_contents('-', encoding.clone(), i)?
        };
        Ok((
            i,
            FileDel {
                path,
                pos,
                encoding,
                del_edges,
                content_edges,
                contents,
            },
        ))

Replacement in libpijul/src/change/parse.rs at line 102 [8.64713]

B:BD[11.142] → [10.86:86]

∅:D[10.86] → [8.66773:66958]

∅:D[11.142] → [8.66773:66958]

B:BD[8.66773] → [8.66773:66958]

    Ok((
        i,
        FileDel {
            path,
            pos,
            encoding,
            del_edges,
            content_edges,
            contents,
        },
    ))

[11.142]

[8.66958]

    parse(i, path)
        .map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

Replacement in libpijul/src/change/parse.rs at line 111 [8.64713]

B:BD[8.67153] → [8.67153:67277]

B:BD[8.67277] → [9.191:242]

∅:D[9.242] → [8.67324:67368]

B:BD[8.67324] → [8.67324:67368]

B:BD[8.67368] → [13.970:1055]

B:BD[13.1055] → [5.0:182]

    let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
    let (i, encoding) = preceded(space0, parse_encoding)(i)?;
    let (i, _) = tuple((space0, line_ending))(i)?;
    let (i, undel_edges) = parse_edges(i)?;
    let (i, content_edges) = map(opt(parse_edges), |o| o.unwrap_or(Vec::new()))(i)?;
    let (i, contents) = if let Ok(x) = parse_contents('+', encoding.clone(), i) {
        x
    } else {
        // Contents is optional for FileUndel hunks.
        (i, Vec::new())

[8.67153]

[5.182]

    let parse = |i, path| -> IResult<&str, PrintableHunk> {
        let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
        let (i, encoding) = preceded(space0, parse_encoding)(i)?;
        let (i, _) = tuple((space0, line_ending))(i)?;
        let (i, undel_edges) = parse_edges(i)?;
        let (i, content_edges) = map(opt(parse_edges), |o| o.unwrap_or(Vec::new()))(i)?;
        let (i, contents) = if let Ok(x) = parse_contents('+', encoding.clone(), i) {
            x
        } else {
            // Contents is optional for FileUndel hunks.
            (i, Vec::new())
        };
        Ok((
            i,
            FileUndel {
                path,
                pos,
                encoding,
                undel_edges,
                content_edges,
                contents,
            },
        ))

Replacement in libpijul/src/change/parse.rs at line 135 [8.64713]

∅:D[5.189] → [8.67481:67670]

B:BD[8.67481] → [8.67481:67670]

    Ok((
        i,
        FileUndel {
            path,
            pos,
            encoding,
            undel_edges,
            content_edges,
            contents,
        },
    ))

[5.189]

[8.67670]

    parse(i, path)
        .map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

Replacement in libpijul/src/change/parse.rs at line 144 [8.64713]

B:BD[8.67865] → [8.67865:68071]

B:BD[8.68071] → [9.243:307]

    let (i, parent) = preceded(delimited(space1, tag("in"), space1), parse_string)(i)?;
    let (i, perms) = preceded(space0, parse_perms)(i)?;
    let (i, encoding) = preceded(space0, parse_encoding)(i)?;
    let (i, _) = tuple((space0, line_ending, multispace0))(i)?;

[8.67865]

[8.68131]

    let parse = |i, name| -> IResult<&str, PrintableHunk> {
        let (i, parent) = preceded(delimited(space1, tag("in"), space1), parse_string)(i)?;
        let (i, perms) = preceded(space0, parse_perms)(i)?;
        let (i, encoding) = preceded(space0, parse_encoding)(i)?;
        let (i, _) = tuple((space0, line_ending, multispace0))(i)?;

Replacement in libpijul/src/change/parse.rs at line 150 [8.64713]

B:BD[8.68132] → [8.68132:68198]

B:BD[8.68198] → [14.0:95]

B:BD[14.95] → [3.0:150]

    let (i, up_context) = preceded(tag("up"), parse_context)(i)?;
    let (i, (start, end)) = delimited(space0, parse_start_end, pair(space0, line_ending))(i)?;
    let (i, contents) = if let PrintablePerms::IsDir = perms {
        (i, Vec::new())
    } else {
        parse_contents('+', encoding.clone(), i)?

[8.68132]

[3.150]

        let (i, up_context) = preceded(tag("up"), parse_context)(i)?;
        let (i, (start, end)) = delimited(space0, parse_start_end, pair(space0, line_ending))(i)?;
        let (i, contents) = if let PrintablePerms::IsDir = perms {
            (i, Vec::new())
        } else {
            parse_contents('+', encoding.clone(), i)?
        };
        Ok((
            i,
            FileAddition {
                name,
                parent,
                perms,
                encoding,
                up_context,
                start,
                end,
                contents,
            },
        ))

Replacement in libpijul/src/change/parse.rs at line 171 [8.64713]

∅:D[3.157] → [14.96:96]

B:BD[13.1123] → [14.96:96]

∅:D[14.96] → [8.68356:68578]

∅:D[12.389] → [8.68356:68578]

∅:D[13.1123] → [8.68356:68578]

B:BD[8.68356] → [8.68356:68578]

    Ok((
        i,
        FileAddition {
            name,
            parent,
            perms,
            encoding,
            up_context,
            start,
            end,
            contents,
        },
    ))

[3.157]

[8.68578]

    parse(i, name)
        .map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

Replacement in libpijul/src/change/parse.rs at line 179 [8.64713]

B:BD[8.68765] → [8.68765:68939]

B:BD[8.68939] → [9.404:455]

∅:D[9.455] → [8.68986:69024]

B:BD[8.68986] → [8.68986:69024]

B:BD[8.69024] → [13.1124:1318]

B:BD[13.1318] → [15.0:39]

B:BD[15.83] → [15.83:228]

    let (i, line) = preceded(char(':'), u64)(i)?;
    let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
    let (i, encoding) = preceded(space0, parse_encoding)(i)?;
    let (i, _) = tuple((space0, line_ending))(i)?;
    let (i, change) = parse_atom(i)?;
    let (i, contents_plus) = parse_contents('+', encoding.clone(), i)?;
    let (i, contents_minus) = parse_contents('-', encoding.clone(), i)?;
    let contents = if contents_plus.is_empty() {
        if contents_minus.is_empty() {
            return Err(nom::Err::Error(nom::error::Error::new(
                i,
                nom::error::ErrorKind::Verify,
            )))

[8.68765]

[6.0]

    let parse = |i, path| -> IResult<&str, PrintableHunk> {
        let (i, line) = preceded(char(':'), u64)(i)?;
        let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
        let (i, encoding) = preceded(space0, parse_encoding)(i)?;
        let (i, _) = tuple((space0, line_ending))(i)?;
        let (i, change) = parse_atom(i)?;
        let (i, contents_plus) = parse_contents('+', encoding.clone(), i)?;
        let (i, contents_minus) = parse_contents('-', encoding.clone(), i)?;
        let contents = if contents_plus.is_empty() {
            if contents_minus.is_empty() {
                return Err(nom::Err::Error(nom::error::Error::new(
                    i,
                    nom::error::ErrorKind::Verify,
                )));
            } else {
                contents_minus
            }

Replacement in libpijul/src/change/parse.rs at line 197 [8.64713]

B:BD[6.17] → [6.17:44]

∅:D[6.44] → [15.228:238]

B:BD[15.228] → [15.228:238]

∅:D[15.238] → [16.446:459]

∅:D[12.513] → [16.446:459]

∅:D[13.1341] → [16.446:459]

B:BD[16.446] → [16.446:459]

B:BD[16.459] → [13.1342:1364]

            contents_minus
        }
    } else {
        contents_plus

[6.17]

[16.509]

            contents_plus
        };
        Ok((
            i,
            Edit {
                path,
                line: line as usize,
                pos,
                encoding,
                change,
                contents,
            },
        ))

Replacement in libpijul/src/change/parse.rs at line 211 [8.64713]

∅:D[16.516] → [8.69091:69276]

B:BD[8.69091] → [8.69091:69276]

    Ok((
        i,
        Edit {
            path,
            line: line as usize,
            pos,
            encoding,
            change,
            contents,
        },
    ))

[16.516]

[8.69276]

    parse(i, path)
        .map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

Replacement in libpijul/src/change/parse.rs at line 220 [8.64713]

B:BD[8.69465] → [8.69465:69639]

B:BD[8.69639] → [9.456:562]

∅:D[9.562] → [8.69737:70232]

B:BD[8.69737] → [8.69737:70232]

    let (i, line) = preceded(char(':'), u64)(i)?;
    let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
    let (i, encoding) = preceded(space0, parse_encoding)(i)?;
    let (i, _) = tuple((space0, line_ending))(i)?;
    // TODO: allow line_endings in between these lines
    let (i, change) = parse_edges(i)?;
    let (i, replacement) = parse_new_vertex(i)?;
    let (i, change_contents) = parse_contents('-', encoding.clone(), i)?;
    let (i, replacement_contents) = parse_contents('+', encoding.clone(), i)?;
    Ok((
        i,
        Replace {
            path,
            line: line as usize,
            pos,
            encoding,
            change,
            replacement,
            change_contents,
            replacement_contents,
        },
    ))

[8.69465]

[8.70232]

    let parse = |i, path| -> IResult<&str, PrintableHunk> {
        let (i, line) = preceded(char(':'), u64)(i)?;
        let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
        let (i, encoding) = preceded(space0, parse_encoding)(i)?;
        let (i, _) = tuple((space0, line_ending))(i)?;
        // TODO: allow line_endings in between these lines
        let (i, change) = parse_edges(i)?;
        let (i, replacement) = parse_new_vertex(i)?;
        let (i, change_contents) = parse_contents('-', encoding.clone(), i)?;
        let (i, replacement_contents) = parse_contents('+', encoding.clone(), i)?;
        Ok((
            i,
            Replace {
                path,
                line: line as usize,
                pos,
                encoding,
                change,
                replacement,
                change_contents,
                replacement_contents,
            },
        ))
    };
    parse(i, path)
        .map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

Replacement in libpijul/src/change/parse.rs at line 253 [8.64713]

B:BD[8.70440] → [8.70440:70651]

B:BD[8.70651] → [9.563:614]

∅:D[9.614] → [8.70698:70875]

B:BD[8.70698] → [8.70698:70875]

    let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
    let (i, _) = tuple((space0, char(':'), space0))(i)?;
    let (i, names) = separated_list0(tuple((space0, char(','), space0)), parse_string)(i)?;
    let (i, _) = tuple((space0, line_ending))(i)?;
    let (i, edges) = parse_edges(i)?;
    Ok((
        i,
        SolveNameConflict {
            path,
            pos,
            names,
            edges,
        },
    ))

[8.70440]

[8.70875]

    let parse = |i, path| -> IResult<&str, PrintableHunk> {
        let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
        let (i, _) = tuple((space0, char(':'), space0))(i)?;
        let (i, names) = separated_list0(tuple((space0, char(','), space0)), parse_string)(i)?;
        let (i, _) = tuple((space0, line_ending))(i)?;
        let (i, edges) = parse_edges(i)?;
        Ok((
            i,
            SolveNameConflict {
                path,
                pos,
                names,
                edges,
            },
        ))
    };
    parse(i, path)
        .map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

Replacement in libpijul/src/change/parse.rs at line 278 [8.64713]

B:BD[8.71088] → [8.71088:71299]

B:BD[8.71299] → [9.615:666]

∅:D[9.666] → [8.71346:71525]

B:BD[8.71346] → [8.71346:71525]

    let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
    let (i, _) = tuple((space0, char(':'), space0))(i)?;
    let (i, names) = separated_list0(tuple((space0, char(','), space0)), parse_string)(i)?;
    let (i, _) = tuple((space0, line_ending))(i)?;
    let (i, edges) = parse_edges(i)?;
    Ok((
        i,
        UnsolveNameConflict {
            path,
            pos,
            names,
            edges,
        },
    ))

[8.71088]

[8.71525]

    let parse = |i, path| -> IResult<&str, PrintableHunk> {
        let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
        let (i, _) = tuple((space0, char(':'), space0))(i)?;
        let (i, names) = separated_list0(tuple((space0, char(','), space0)), parse_string)(i)?;
        let (i, _) = tuple((space0, line_ending))(i)?;
        let (i, edges) = parse_edges(i)?;
        Ok((
            i,
            UnsolveNameConflict {
                path,
                pos,
                names,
                edges,
            },
        ))
    };
    parse(i, path)
        .map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

Replacement in libpijul/src/change/parse.rs at line 303 [8.64713]

B:BD[8.71736] → [8.71736:71910]

B:BD[8.71910] → [9.667:718]

∅:D[9.718] → [8.71957:72267]

B:BD[8.71957] → [8.71957:72267]

    let (i, line) = preceded(char(':'), u64)(i)?;
    let (i, pos) = preceded(space1, parse_printable_pos)(i)?;
    let (i, encoding) = preceded(space0, parse_encoding)(i)?;
    let (i, _) = tuple((space0, line_ending))(i)?;
    let (i, change) = parse_new_vertex(i)?;
    let (i, contents) = parse_contents('+', encoding.clone(), i)?;
    Ok((
        i,
        SolveOrderConflict {
            path,
            line: line as usize,
            pos,
            encoding,
            change,
            contents,
        },
    ))

[8.71736]

[8.72267]

    let parse = |i, path| -> IResult<&str, PrintableHunk> {
        let (i, line) = preceded(char(':'), u64)(i)?;
        let (i, pos) = preceded(space1, parse_printable_pos)(i)?;
        let (i, encoding) = preceded(space0, parse_encoding)(i)?;
        let (i, _) = tuple((space0, line_ending))(i)?;
        let (i, change) = parse_new_vertex(i)?;
        let (i, contents) = parse_contents('+', encoding.clone(), i)?;
        Ok((
            i,
            SolveOrderConflict {
                path,
                line: line as usize,
                pos,
                encoding,
                change,
                contents,
            },
        ))
    };
    parse(i, path)
        .map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

Replacement in libpijul/src/change/parse.rs at line 331 [8.64713]

B:BD[8.72483] → [8.72483:72657]

B:BD[8.72657] → [9.719:770]

∅:D[9.770] → [8.72704:73011]

B:BD[8.72704] → [8.72704:73011]

    let (i, line) = preceded(char(':'), u64)(i)?;
    let (i, pos) = preceded(space1, parse_printable_pos)(i)?;
    let (i, encoding) = preceded(space0, parse_encoding)(i)?;
    let (i, _) = tuple((space0, line_ending))(i)?;
    let (i, change) = parse_edges(i)?;
    let (i, contents) = parse_contents('-', encoding.clone(), i)?;
    Ok((
        i,
        UnsolveOrderConflict {
            path,
            line: line as usize,
            pos,
            encoding,
            change,
            contents,
        },
    ))

[8.72483]

[8.73011]

    let parse = |i, path| -> IResult<&str, PrintableHunk> {
        let (i, line) = preceded(char(':'), u64)(i)?;
        let (i, pos) = preceded(space1, parse_printable_pos)(i)?;
        let (i, encoding) = preceded(space0, parse_encoding)(i)?;
        let (i, _) = tuple((space0, line_ending))(i)?;
        let (i, change) = parse_edges(i)?;
        let (i, contents) = parse_contents('-', encoding.clone(), i)?;
        Ok((
            i,
            UnsolveOrderConflict {
                path,
                line: line as usize,
                pos,
                encoding,
                change,
                contents,
            },
        ))
    };
    parse(i, path)
        .map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

Replacement in libpijul/src/change/parse.rs at line 359 [8.64713]

B:BD[8.73219] → [8.73219:73393]

B:BD[8.73393] → [9.771:822]

∅:D[9.822] → [8.73440:73743]

B:BD[8.73440] → [8.73440:73743]

    let (i, line) = preceded(char(':'), u64)(i)?;
    let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
    let (i, encoding) = preceded(space0, parse_encoding)(i)?;
    let (i, _) = tuple((space0, line_ending))(i)?;
    let (i, change) = parse_edges(i)?;
    let (i, contents) = parse_contents('+', encoding.clone(), i)?;
    Ok((
        i,
        ResurrectZombies {
            path,
            line: line as usize,
            pos,
            encoding,
            change,
            contents,
        },
    ))

[8.73219]

[8.73743]

    let parse = |i, path| -> IResult<&str, PrintableHunk> {
        let (i, line) = preceded(char(':'), u64)(i)?;
        let (i, pos) = preceded(space0, parse_printable_pos)(i)?;
        let (i, encoding) = preceded(space0, parse_encoding)(i)?;
        let (i, _) = tuple((space0, line_ending))(i)?;
        let (i, change) = parse_edges(i)?;
        let (i, contents) = parse_contents('+', encoding.clone(), i)?;
        Ok((
            i,
            ResurrectZombies {
                path,
                line: line as usize,
                pos,
                encoding,
                change,
                contents,
            },
        ))
    };
    parse(i, path)
        .map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

Replacement in libpijul/src/change/parse.rs at line 385 [8.64713]

B:BD[17.6983] → [9.823:887]

∅:D[9.887] → [17.7043:7173]

B:BD[17.7043] → [17.7043:7173]

B:BD[17.7173] → [9.888:983]

∅:D[9.983] → [17.7264:7380]

B:BD[17.7264] → [17.7264:7380]

B:BD[17.7380] → [2.4250:4296]

    let (i, _) = tuple((space0, line_ending, 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, line_ending))(i)?;
    debug!("root add {:?}", i);
    assert_eq!(&up_context[..], &[PrintablePos(1, 0)]);
    assert_eq!(start, end);
    Ok((i, PrintableHunk::AddRoot { start }))

[17.6983]

[17.7469]

    let parse = |i| -> IResult<&str, PrintableHunk> {
        let (i, _) = tuple((space0, line_ending, 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, line_ending))(i)?;
        debug!("root add {:?}", i);
        assert_eq!(&up_context[..], &[PrintablePos(1, 0)]);
        assert_eq!(start, end);
        Ok((i, PrintableHunk::AddRoot { start }))
    };
    parse(i)
        .map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

Replacement in libpijul/src/change/parse.rs at line 402 [8.64713]

B:BD[17.7609] → [9.984:1035]

∅:D[9.1035] → [17.7656:7731]

B:BD[17.7656] → [17.7656:7731]

    let (i, _) = tuple((space0, line_ending))(i)?;
    let (i, name) = parse_edges(i)?;
    let (i, inode) = parse_edges(i)?;

[17.7609]

[17.7731]

    let parse = |i| -> IResult<&str, PrintableHunk> {
        let (i, _) = tuple((space0, line_ending))(i)?;
        let (i, name) = parse_edges(i)?;
        let (i, inode) = parse_edges(i)?;

Replacement in libpijul/src/change/parse.rs at line 407 [8.64713]

B:BD[17.7732] → [2.4297:4349]

    Ok((i, PrintableHunk::DelRoot { inode, name }))

[17.7732]

[17.7827]

        Ok((i, PrintableHunk::DelRoot { inode, name }))
    };
    parse(i)
        .map_err(|_| nom::Err::Error(nom::error::Error::new(i, nom::error::ErrorKind::Verify)))

Replacement in libpijul/src/change/parse.rs at line 446 [8.64713]
B:BD[4.161] → [4.161:177]
```
            )))
```
[4.161]
[4.177]
```
            )));
```