Apply a unified diff in the forge tool itself, for the patches the forge's diffpatch refuses (issue 1604)
This commit is contained in:
@@ -0,0 +1,397 @@
|
||||
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) }
|
||||
Reference in New Issue
Block a user