398 lines
11 KiB
Go
398 lines
11 KiB
Go
package main
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"fmt"
|
|
"regexp"
|
|
"sort"
|
|
"strconv"
|
|
"strings"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
// A unified diff applied by the tool itself (novox/hq issue 1604). The forge's diffpatch answers 500 with an empty
|
|
// message when an unchanged context line holds a non-ASCII character, so a patch the forge did not take is applied
|
|
// here: each touched file is read at the commit the commit goes on, its hunks are applied, and the resulting
|
|
// files are committed through the same call a files commit uses. The forge's files call carries no file mode, so
|
|
// a patch that creates an executable file, changes a mode or touches a symlink is not applied here: the tool says so.
|
|
|
|
// fileSource reads a file at the commit the patch is applied to; ok is false when there is no such file.
|
|
type fileSource func(path string) (content []byte, ok bool, err error)
|
|
|
|
// patchFile is one file section of a patch.
|
|
type patchFile struct {
|
|
oldPath, newPath string // "" when /dev/null
|
|
create, remove bool
|
|
renamed bool
|
|
oldSeen bool
|
|
hunks []hunk
|
|
modeBlock string // why the files call cannot carry this section, "" when it can
|
|
}
|
|
|
|
type hunk struct {
|
|
oldStart int
|
|
old, new []string
|
|
oldNoNL, newNoNL bool
|
|
}
|
|
|
|
var hunkHeader = regexp.MustCompile(`^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@`)
|
|
|
|
// gitPath reads a path of a diff header: git quotes one holding unusual bytes in C style.
|
|
func gitPath(s string) string {
|
|
s = strings.TrimRight(s, "\t ")
|
|
if strings.HasPrefix(s, `"`) {
|
|
if u, err := strconv.Unquote(s); err == nil {
|
|
return u
|
|
}
|
|
} else if i := strings.IndexByte(s, '\t'); i >= 0 {
|
|
s = s[:i]
|
|
}
|
|
return s
|
|
}
|
|
|
|
func stripPrefix(p string) string {
|
|
if p == "/dev/null" {
|
|
return ""
|
|
}
|
|
if i := strings.IndexByte(p, '/'); i >= 0 && (p[:i] == "a" || p[:i] == "b") {
|
|
return p[i+1:]
|
|
}
|
|
return p
|
|
}
|
|
|
|
func nonRegular(mode string) bool { return mode != "" && mode != "100644" }
|
|
|
|
// parsePatch reads a unified diff into its file sections.
|
|
func parsePatch(text string) ([]*patchFile, error) {
|
|
lines := strings.Split(text, "\n")
|
|
if n := len(lines); n > 0 && lines[n-1] == "" {
|
|
lines = lines[:n-1]
|
|
}
|
|
var files []*patchFile
|
|
var cur *patchFile
|
|
block := func(f *patchFile, what string) {
|
|
if f.modeBlock == "" {
|
|
f.modeBlock = what
|
|
}
|
|
}
|
|
for i := 0; i < len(lines); i++ {
|
|
l := strings.TrimSuffix(lines[i], "\r")
|
|
switch {
|
|
case strings.HasPrefix(l, "diff --git "):
|
|
cur = &patchFile{}
|
|
files = append(files, cur)
|
|
rest := strings.TrimPrefix(l, "diff --git ")
|
|
if k := strings.Index(rest, " b/"); k > 0 && !strings.HasPrefix(rest, `"`) {
|
|
cur.oldPath, cur.newPath = stripPrefix(rest[:k]), stripPrefix(rest[k+1:])
|
|
}
|
|
case cur != nil && strings.HasPrefix(l, "new file mode "):
|
|
cur.create = true
|
|
if m := strings.TrimPrefix(l, "new file mode "); nonRegular(m) {
|
|
block(cur, "creates a file of mode "+m)
|
|
}
|
|
case cur != nil && strings.HasPrefix(l, "deleted file mode "):
|
|
cur.remove = true
|
|
case cur != nil && strings.HasPrefix(l, "old mode "):
|
|
block(cur, "changes the file mode ("+l+")")
|
|
case cur != nil && strings.HasPrefix(l, "new mode "):
|
|
block(cur, "changes the file mode ("+l+")")
|
|
case cur != nil && strings.HasPrefix(l, "index "):
|
|
if f := strings.Fields(l); len(f) == 3 && nonRegular(f[2]) {
|
|
block(cur, "touches a file of mode "+f[2])
|
|
}
|
|
case cur != nil && strings.HasPrefix(l, "rename from "):
|
|
cur.oldPath, cur.renamed = gitPath(strings.TrimPrefix(l, "rename from ")), true
|
|
case cur != nil && strings.HasPrefix(l, "rename to "):
|
|
cur.newPath, cur.renamed = gitPath(strings.TrimPrefix(l, "rename to ")), true
|
|
case strings.HasPrefix(l, "copy from "), strings.HasPrefix(l, "copy to "):
|
|
return nil, fmt.Errorf("a copy in a patch (%s) is not applied by the tool", l)
|
|
case strings.HasPrefix(l, "GIT binary patch"), strings.HasPrefix(l, "Binary files "):
|
|
return nil, fmt.Errorf("a binary patch is not applied by the tool")
|
|
case strings.HasPrefix(l, "--- "):
|
|
if cur == nil || cur.oldSeen {
|
|
cur = &patchFile{}
|
|
files = append(files, cur)
|
|
}
|
|
p := stripPrefix(gitPath(strings.TrimPrefix(l, "--- ")))
|
|
cur.oldPath = p
|
|
if p == "" {
|
|
cur.create = true
|
|
}
|
|
cur.oldSeen = true
|
|
if i+1 >= len(lines) || !strings.HasPrefix(lines[i+1], "+++ ") {
|
|
return nil, fmt.Errorf("the line %d, %q, is not followed by a +++ line", i+1, l)
|
|
}
|
|
i++
|
|
q := stripPrefix(gitPath(strings.TrimPrefix(strings.TrimSuffix(lines[i], "\r"), "+++ ")))
|
|
cur.newPath = q
|
|
if q == "" {
|
|
cur.remove = true
|
|
}
|
|
case cur != nil && hunkHeader.MatchString(l):
|
|
m := hunkHeader.FindStringSubmatch(l)
|
|
atoi := func(s string, def int) int {
|
|
if s == "" {
|
|
return def
|
|
}
|
|
n, _ := strconv.Atoi(s)
|
|
return n
|
|
}
|
|
h := hunk{oldStart: atoi(m[1], 0)}
|
|
oldN, newN := atoi(m[2], 1), atoi(m[4], 1)
|
|
startLine := i + 1
|
|
noNL := func() { // "\ No newline at end of file" is about the line before it
|
|
prev := lines[i-1]
|
|
switch {
|
|
case prev != "" && prev[0] == '-':
|
|
h.oldNoNL = true
|
|
case prev != "" && prev[0] == '+':
|
|
h.newNoNL = true
|
|
default:
|
|
h.oldNoNL, h.newNoNL = true, true
|
|
}
|
|
}
|
|
for oldN > 0 || newN > 0 {
|
|
i++
|
|
if i >= len(lines) {
|
|
return nil, fmt.Errorf("the hunk of %s at patch line %d ends before its %d old and %d new lines are all there", cur.name(), startLine, oldN, newN)
|
|
}
|
|
b := strings.TrimSuffix(lines[i], "\r")
|
|
if lines[i] == "" {
|
|
b = " " // a blank context line some tools strip to nothing
|
|
}
|
|
switch b[0] {
|
|
case '\\':
|
|
noNL()
|
|
case ' ':
|
|
h.old, h.new = append(h.old, lines[i][min(1, len(lines[i])):]), append(h.new, lines[i][min(1, len(lines[i])):])
|
|
oldN--
|
|
newN--
|
|
case '-':
|
|
h.old = append(h.old, lines[i][1:])
|
|
oldN--
|
|
case '+':
|
|
h.new = append(h.new, lines[i][1:])
|
|
newN--
|
|
default:
|
|
return nil, fmt.Errorf("the hunk of %s at patch line %d has a line %d that is neither context, - nor +: %q", cur.name(), startLine, i+1, lines[i])
|
|
}
|
|
}
|
|
for i+1 < len(lines) && strings.HasPrefix(lines[i+1], `\`) {
|
|
i++
|
|
noNL()
|
|
}
|
|
cur.hunks = append(cur.hunks, h)
|
|
}
|
|
}
|
|
for _, f := range files {
|
|
if f.newPath == "" && f.oldPath == "" {
|
|
return nil, fmt.Errorf("a file section of the patch names no file")
|
|
}
|
|
}
|
|
if len(files) == 0 {
|
|
return nil, fmt.Errorf("the patch holds no file section")
|
|
}
|
|
return files, nil
|
|
}
|
|
|
|
func (f *patchFile) name() string {
|
|
if f.newPath != "" {
|
|
return f.newPath
|
|
}
|
|
return f.oldPath
|
|
}
|
|
|
|
// textFile is a file's content as lines, and whether its last line ends with a newline.
|
|
type textFile struct {
|
|
lines []string
|
|
endNL bool
|
|
}
|
|
|
|
func splitText(b []byte) textFile {
|
|
if len(b) == 0 {
|
|
return textFile{endNL: true}
|
|
}
|
|
s := string(b)
|
|
endNL := strings.HasSuffix(s, "\n")
|
|
s = strings.TrimSuffix(s, "\n")
|
|
return textFile{lines: strings.Split(s, "\n"), endNL: endNL}
|
|
}
|
|
|
|
func (t textFile) bytes() []byte {
|
|
if len(t.lines) == 0 {
|
|
return nil
|
|
}
|
|
s := strings.Join(t.lines, "\n")
|
|
if t.endNL {
|
|
s += "\n"
|
|
}
|
|
return []byte(s)
|
|
}
|
|
|
|
// apply puts one hunk on the file, at where the hunk says or, as git apply does, at the nearest place its old
|
|
// lines are found exactly; delta is how far earlier hunks of this file moved lines.
|
|
func (t textFile) apply(h hunk, delta int) (textFile, int, error) {
|
|
want := h.oldStart - 1 + delta
|
|
if len(h.old) == 0 && h.oldStart > 0 {
|
|
want = h.oldStart + delta // a pure insertion is "after" the line it names
|
|
}
|
|
if want < 0 {
|
|
want = 0
|
|
}
|
|
matches := func(at int) bool {
|
|
if at < 0 || at+len(h.old) > len(t.lines) {
|
|
return false
|
|
}
|
|
for k, l := range h.old {
|
|
if t.lines[at+k] != l {
|
|
return false
|
|
}
|
|
}
|
|
// the old side's last line lacks a newline only when the file's does
|
|
if at+len(h.old) == len(t.lines) && len(h.old) > 0 && h.oldNoNL == t.endNL {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
at := -1
|
|
for d := 0; d <= len(t.lines)+1 && at < 0; d++ {
|
|
switch {
|
|
case matches(want - d):
|
|
at = want - d
|
|
case matches(want + d):
|
|
at = want + d
|
|
}
|
|
}
|
|
if at < 0 {
|
|
return t, delta, fmt.Errorf("the hunk at line %d does not apply: its context and removed lines are not in the file (first of them: %q)", h.oldStart, firstOf(h.old))
|
|
}
|
|
out := append(append(append([]string{}, t.lines[:at]...), h.new...), t.lines[at+len(h.old):]...)
|
|
endNL := t.endNL
|
|
if at+len(h.old) == len(t.lines) && (len(h.new) > 0 || len(h.old) > 0) {
|
|
endNL = !h.newNoNL
|
|
}
|
|
return textFile{lines: out, endNL: endNL}, delta + len(h.new) - len(h.old), nil
|
|
}
|
|
|
|
func firstOf(l []string) string {
|
|
if len(l) == 0 {
|
|
return ""
|
|
}
|
|
return l[0]
|
|
}
|
|
|
|
// patchAsFiles applies the patch to the files read through read, and says the files to commit.
|
|
func patchAsFiles(text string, read fileSource) ([]FileChange, error) {
|
|
sections, err := parsePatch(text)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
for _, s := range sections {
|
|
if s.modeBlock != "" {
|
|
return nil, fmt.Errorf("%s %s, and the forge's files call carries no file mode", s.name(), s.modeBlock)
|
|
}
|
|
}
|
|
work := map[string][]byte{} // the files as they are being changed; nil means absent
|
|
orig := map[string]bool{} // which paths existed
|
|
load := func(p string) error {
|
|
if _, seen := work[p]; seen {
|
|
return nil
|
|
}
|
|
b, ok, err := read(p)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
orig[p] = ok
|
|
if ok {
|
|
if b == nil {
|
|
b = []byte{}
|
|
}
|
|
work[p] = b
|
|
} else {
|
|
work[p] = nil
|
|
}
|
|
return nil
|
|
}
|
|
for _, s := range sections {
|
|
from, to := s.oldPath, s.newPath
|
|
if s.create {
|
|
from = ""
|
|
}
|
|
var t textFile
|
|
if from != "" {
|
|
if err := load(from); err != nil {
|
|
return nil, err
|
|
}
|
|
if work[from] == nil {
|
|
return nil, fmt.Errorf("%s: the file is not there at the commit the patch goes on, so the patch does not apply", from)
|
|
}
|
|
if !utf8.Valid(work[from]) && len(s.hunks) > 0 {
|
|
return nil, fmt.Errorf("%s is not UTF-8 text: the tool applies text patches only", from)
|
|
}
|
|
t = splitText(work[from])
|
|
} else {
|
|
if err := load(to); err != nil {
|
|
return nil, err
|
|
}
|
|
if work[to] != nil {
|
|
return nil, fmt.Errorf("%s: the patch creates it, but it is already there at the commit the patch goes on", to)
|
|
}
|
|
t = textFile{endNL: true}
|
|
}
|
|
delta := 0
|
|
for _, h := range s.hunks {
|
|
if t, delta, err = t.apply(h, delta); err != nil {
|
|
return nil, fmt.Errorf("%s: %w", s.name(), err)
|
|
}
|
|
}
|
|
switch {
|
|
case s.remove:
|
|
if len(t.lines) != 0 {
|
|
return nil, fmt.Errorf("%s: the patch deletes the file, but lines are left after its hunks", from)
|
|
}
|
|
work[from] = nil
|
|
default:
|
|
if s.renamed && from != to {
|
|
work[from] = nil
|
|
if err := load(to); err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
body := t.bytes()
|
|
if body == nil {
|
|
body = []byte{}
|
|
}
|
|
work[to] = body
|
|
}
|
|
}
|
|
var paths []string
|
|
for p := range work {
|
|
paths = append(paths, p)
|
|
}
|
|
sort.Strings(paths)
|
|
var out []FileChange
|
|
for _, p := range paths {
|
|
switch {
|
|
case work[p] == nil && !orig[p]:
|
|
case work[p] == nil:
|
|
out = append(out, FileChange{Path: p, Delete: true})
|
|
default:
|
|
fc := FileChange{Path: p, size: len(work[p])}
|
|
if utf8.Valid(work[p]) {
|
|
s := string(work[p])
|
|
fc.Content = &s
|
|
} else {
|
|
s := base64Std(work[p])
|
|
fc.ContentBase64 = &s
|
|
}
|
|
out = append(out, fc)
|
|
}
|
|
}
|
|
if len(out) == 0 {
|
|
return nil, fmt.Errorf("the patch changes no file")
|
|
}
|
|
return out, nil
|
|
}
|
|
|
|
func base64Std(b []byte) string { return base64.StdEncoding.EncodeToString(b) }
|