andybalholm/pijul-go - Change 76US4IF3RV73ZRGTSR7AU2G6G2UUOZROWVC2XTASNY4PJSBLBLKQC

Support the old change format (V4)

Created by andybalholm on April 6, 2023

76US4IF3RV73ZRGTSR7AU2G6G2UUOZROWVC2XTASNY4PJSBLBLKQC

Dependencies

In channels

main

Change contents

Insertion in hunk.go at line 189 [3.32]
[3.3409]
[2.0]
```
	case 0:
		return fileMove(data)
```
Insertion in hunk.go at line 193 [3.32]
[2.32]
[3.3409]
```
	case 2:
		return fileUndel(data)
```
Insertion in hunk.go at line 197 [3.32]
[3.3441]
[4.1322]
```
	case 4:
		return solveNameConflict(data)
```
Insertion in hunk.go at line 205 [3.32]
[5.43]
[6.0]
```
	case 10:
		return resurrectZombies(data)
```

Insertion in hunk.go at line 211 [3.32]

[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)

Insertion in hunk.go at line 280 [3.32]

[6.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
}

Insertion in hunk.go at line 340 [3.32]

[5.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
}

Insertion in hunk.go at line 391 [3.32]

[7.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),

Insertion in hunk.go at line 440 [3.32]

[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
}

Insertion in combinators.go at line 301 [9.39]

[8.7138]

}
func rustString(data []byte) ([]byte, string, error) {
	return toString(lengthData(uint64LE))(data)

Insertion in combinators.go at line 307 [9.39]

[8.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 [8.740]

B:BD[6.2229] → [6.2229:2320]

				return Change{}, fmt.Errorf("error parsing unhashed contents (%q): %w", unhashed, err)

[6.2229]

[6.2320]

				c.Unhashed = string(unhashed)

Insertion in change.go at line 130 [8.740]

[8.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 [8.740]

∅:D[10.1806] → [8.2601:2708]

B:BD[8.2601] → [8.2601:2708]

	data, c.Authors, err = vec(hashMap(toString(lengthData(uint64LE)), toString(lengthData(uint64LE))))(data)

[10.1806]

[10.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 [8.740]

B:BD[8.2751] → [3.6499:6539]

	data, c.Changes, err = vec(hunk)(data)

[8.2751]

[3.6539]

	switch c.Version {
	case 6:
		data, c.Changes, err = vec(hunk)(data)
	case 4:
		data, c.Changes, err = vec(hunkV4)(data)
	}

Insertion in change.go at line 196 [8.740]

[8.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