pijul nest
guest › [sign in] [explore]

Support the old change format (V4)

andybalholm
Apr 7, 2023, 1:05 AM
76US4IF3RV73ZRGTSR7AU2G6G2UUOZROWVC2XTASNY4PJSBLBLKQC

Dependencies

  • [2] HCMPNVNH Handle FileDel hunks
  • [3] EVHNGDT7 parse FileAdd hunk
  • [4] TLR47XSA Parse AddRoot hunk
  • [5] 4JWXOJIP Parse dependencies
  • [6] 6GDPWAD2 Parse Unhashed and Contents of Change
  • [7] 7VEHGTEY Switch from reading text format to reading binary format.
  • [*] 7D7CMNN3 Handle Edit hunks
  • [*] A7XMU2A6 Handle SolveOrderConflict hunks
  • [*] YGCYIX6C Handle Replacement hunks
  • [*] EKAB33DH Start using some parser combinators

Change contents

  • edit in hunk.go at line 189
    [3.3409]
    [2.0]
    case 0:
    return fileMove(data)
  • edit in hunk.go at line 193
    [2.32]
    [3.3409]
    case 2:
    return fileUndel(data)
  • edit in hunk.go at line 197
    [3.3441]
    [9.1322]
    case 4:
    return solveNameConflict(data)
  • edit in hunk.go at line 205
    [10.43]
    [3.0]
    case 10:
    return resurrectZombies(data)
  • edit in hunk.go at line 211
    [3.3515]
    [3.3515]
    }
    }
    func hunkV4(data []byte) ([]byte, Hunk, error) {
    data, tag, err := uint32LE(data)
    if err != nil {
    return data, nil, err
    }
    switch tag {
    case 0:
    return fileMove(data)
    case 1:
    return fileDelV4(data)
    case 2:
    return fileUndelV4(data)
    case 3:
    return fileAddV4(data)
    case 4:
    return solveNameConflict(data)
    case 6:
    return editV4(data)
    case 7:
    return replacementV4(data)
    case 8:
    return solveOrderConflict(data)
    case 10:
    return resurrectZombiesV4(data)
    default:
    return data, nil, fmt.Errorf("unknown tag for Hunk V4: %d", tag)
  • edit in hunk.go at line 280
    [3.37]
    [3.37]
    func fileAddV4(data []byte) ([]byte, FileAdd, error) {
    var f FileAdd
    f.Encoding = "UTF-8"
    data, _, err := tuple(
    assign(&f.AddName, atom),
    assign(&f.AddInode, atom),
    assign(&f.Contents, mapValue(option(atom), func(p *Atom) Atom {
    if p == nil {
    return nil
    }
    return *p
    })),
    assign(&f.Path, toString(lengthData(uint64LE))),
    )(data)
    return data, f, err
    }
  • edit in hunk.go at line 340
    [10.47]
    [10.47]
    func editV4(data []byte) ([]byte, Edit, error) {
    var e Edit
    e.Encoding = "UTF-8"
    data, _, err := tuple(
    assign(&e.Change, atom),
    assign(&e.Local, local),
    )(data)
    return data, e, err
    }
  • edit in hunk.go at line 391
    [11.2352]
    [11.2352]
    )(data)
    return data, r, err
    }
    func replacementV4(data []byte) ([]byte, Replacement, error) {
    var r Replacement
    r.Encoding = "UTF-8"
    data, _, err := tuple(
    assign(&r.Change, atom),
    assign(&r.Replacement, atom),
    assign(&r.Local, local),
  • edit in hunk.go at line 440
    [2.719]
    func fileDelV4(data []byte) ([]byte, FileDel, error) {
    var f FileDel
    f.Encoding = "UTF-8"
    data, _, err := tuple(
    assign(&f.Del, atom),
    assign(&f.Contents, mapValue(option(atom), func(p *Atom) Atom {
    if p == nil {
    return nil
    }
    return *p
    })),
    assign(&f.Path, toString(lengthData(uint64LE))),
    )(data)
    return data, f, err
    }
    type ResurrectZombies struct {
    Change Atom
    Local Local
    Encoding string
    }
    func (r ResurrectZombies) atoms() []Atom {
    return []Atom{r.Change}
    }
    func resurrectZombies(data []byte) ([]byte, ResurrectZombies, error) {
    var r ResurrectZombies
    data, _, err := tuple(
    assign(&r.Change, atom),
    assign(&r.Local, local),
    assign(&r.Encoding, optionalString),
    )(data)
    return data, r, err
    }
    func resurrectZombiesV4(data []byte) ([]byte, ResurrectZombies, error) {
    var r ResurrectZombies
    r.Encoding = "UTF-8"
    data, _, err := tuple(
    assign(&r.Change, atom),
    assign(&r.Local, local),
    )(data)
    return data, r, err
    }
    type FileUndel struct {
    Undel Atom
    Contents Atom
    Path string
    Encoding string
    }
    func (f FileUndel) atoms() []Atom {
    if f.Contents == nil {
    return []Atom{f.Undel}
    }
    return []Atom{f.Undel, f.Contents}
    }
    func fileUndel(data []byte) ([]byte, FileUndel, error) {
    var f FileUndel
    data, _, err := tuple(
    assign(&f.Undel, atom),
    assign(&f.Contents, mapValue(option(atom), func(p *Atom) Atom {
    if p == nil {
    return nil
    }
    return *p
    })),
    assign(&f.Path, toString(lengthData(uint64LE))),
    assign(&f.Encoding, optionalString),
    )(data)
    return data, f, err
    }
    func fileUndelV4(data []byte) ([]byte, FileUndel, error) {
    var f FileUndel
    f.Encoding = "UTF-8"
    data, _, err := tuple(
    assign(&f.Undel, atom),
    assign(&f.Contents, mapValue(option(atom), func(p *Atom) Atom {
    if p == nil {
    return nil
    }
    return *p
    })),
    assign(&f.Path, toString(lengthData(uint64LE))),
    )(data)
    return data, f, err
    }
    type FileMove struct {
    Del Atom
    Add Atom
    Path string
    }
    func (f FileMove) atoms() []Atom {
    return []Atom{f.Del, f.Add}
    }
    func fileMove(data []byte) ([]byte, FileMove, error) {
    var f FileMove
    data, _, err := tuple(
    assign(&f.Del, atom),
    assign(&f.Add, atom),
    assign(&f.Path, rustString),
    )(data)
    return data, f, err
    }
    type SolveNameConflict struct {
    Name Atom
    Path string
    }
    func (s SolveNameConflict) atoms() []Atom {
    return []Atom{s.Name}
    }
    func solveNameConflict(data []byte) ([]byte, SolveNameConflict, error) {
    var s SolveNameConflict
    data, _, err := tuple(
    assign(&s.Name, atom),
    assign(&s.Path, rustString),
    )(data)
    return data, s, err
    }
  • edit in combinators.go at line 301
    [3.7138]
    [3.7138]
    }
    func rustString(data []byte) ([]byte, string, error) {
    return toString(lengthData(uint64LE))(data)
  • edit in combinators.go at line 307
    [3.7141]
    [3.7141]
    func optionalString(data []byte) ([]byte, string, error) {
    return mapValue(option(rustString), func(p *string) string {
    if p == nil {
    return ""
    }
    return *p
    })(data)
    }
  • replacement in change.go at line 107
    [3.2229]→[3.2229:2320](∅→∅)
    return Change{}, fmt.Errorf("error parsing unhashed contents (%q): %w", unhashed, err)
    [3.2229]
    [3.2320]
    c.Unhashed = string(unhashed)
  • edit in change.go at line 130
    [3.2115]
    [3.2115]
    }
    if c.Version != 6 && c.Version != 4 {
    return fmt.Errorf("unknown change file version: %d", c.Version)
  • replacement in change.go at line 155
    [3.1806]→[3.2601:2708](∅→∅),[3.2601]→[3.2601:2708](∅→∅)
    data, c.Authors, err = vec(hashMap(toString(lengthData(uint64LE)), toString(lengthData(uint64LE))))(data)
    [3.1806]
    [3.1807]
    switch c.Version {
    case 6:
    data, c.Authors, err = vec(hashMap(toString(lengthData(uint64LE)), toString(lengthData(uint64LE))))(data)
    case 4:
    data, c.Authors, err = vec(authorV4)(data)
    }
  • replacement in change.go at line 180
    [3.2751]→[3.6499:6539](∅→∅)
    data, c.Changes, err = vec(hunk)(data)
    [3.2751]
    [3.6539]
    switch c.Version {
    case 6:
    data, c.Changes, err = vec(hunk)(data)
    case 4:
    data, c.Changes, err = vec(hunkV4)(data)
    }
  • edit in change.go at line 196
    [3.2763]
    [3.2763]
    }
    func authorV4(data []byte) ([]byte, map[string]string, error) {
    a := make(map[string]string, 3)
    data, name, err := rustString(data)
    if err != nil {
    return data, nil, err
    }
    a["name"] = name
    data, fullName, err := option(rustString)(data)
    if err != nil {
    return data, nil, err
    }
    if fullName != nil {
    a["full_name"] = *fullName
    }
    data, email, err := option(rustString)(data)
    if err != nil {
    return data, nil, err
    }
    if email != nil {
    a["email"] = *email
    }
    return data, a, nil