From ea5b8bceea20ac6d3eed9c685ace3d03f7910018 Mon Sep 17 00:00:00 2001 From: Billy Keyes Date: Sun, 17 Mar 2019 15:34:03 -0700 Subject: [PATCH] Finish parsing filenames from Git headers Adds "default" name handling, error checks for missing names, and prefix and double-slash stripping. --- README.md | 9 ++- gitdiff/parser.go | 168 ++++++++++++++++++++++++++++------------- gitdiff/parser_test.go | 24 ++++++ 3 files changed, 145 insertions(+), 56 deletions(-) diff --git a/README.md b/README.md index 07603cf..e30f581 100644 --- a/README.md +++ b/README.md @@ -29,8 +29,8 @@ In development, most functionality is currently missing, incomplete, or broken. 1: In practice this library is stricter than `git apply` when given certain types of invalid input, particularly lines that contain garbage -following the valid content. Git seems to ignore this, while this library will -usually return an error. [↩](#a1) +following the valid content. Git seems to ignore this in some cases, while this +library will usually return an error. [↩](#a1) [sourcegraph]: https://github.com/sourcegraph/go-diff [sergi]: https://github.com/sergi/go-diff @@ -38,3 +38,8 @@ usually return an error. [↩](#a1) [seletskiy]: https://github.com/seletskiy/godiff [apply.c]: https://github.com/git/git/blob/master/apply.c + +## Known Issues and Limitations + +1. The translation from C to Go may have introduced inconsistencies in the way + unicode file names are handled; please report any issues of this type. diff --git a/gitdiff/parser.go b/gitdiff/parser.go index a688111..1ab5828 100644 --- a/gitdiff/parser.go +++ b/gitdiff/parser.go @@ -130,8 +130,11 @@ func (p *parser) ParseFileChanges(f *File) error { } func (p *parser) ParseGitFileHeader(f *File, header string) error { - // TODO(bkeyes): parse header line for filename - // necessary to get the filename for mode changes or add/rm empty files + header = strings.TrimPrefix(header, fileHeaderPrefix) + defaultName, err := parseGitHeaderName(header) + if err != nil { + return p.Errorf("git file header: %v", err) + } for { line, err := p.PeekLine() @@ -139,9 +142,9 @@ func (p *parser) ParseGitFileHeader(f *File, header string) error { return err } - end, err := parseGitHeaderData(f, line) + end, err := parseGitHeaderData(f, line, defaultName) if err != nil { - return p.Errorf("header: %v", err) + return p.Errorf("git file header: %v", err) } if end { break @@ -149,6 +152,18 @@ func (p *parser) ParseGitFileHeader(f *File, header string) error { p.Line() } + if f.OldName == "" && f.NewName == "" { + if defaultName == "" { + return p.Errorf("git file header: missing filename information") + } + f.OldName = defaultName + f.NewName = defaultName + } + + if (f.NewName == "" && !f.IsDelete) || (f.OldName == "" && !f.IsNew) { + return p.Errorf("git file header: missing filename information") + } + return nil } @@ -226,7 +241,32 @@ func parseFragmentHeader(f *Fragment, header string) error { return nil } -func parseGitHeaderData(f *File, line string) (end bool, err error) { +// parseGitHeaderName extracts a default file name from the Git file header +// line. This is required for mode-only changes and creation/deletion of empty +// files. Other types of patch include the file name(s) in the header data. +// If the names in the header do not match because the patch is a rename, +// return an empty default name. +func parseGitHeaderName(header string) (string, error) { + firstName, n, err := parseName(header, -1, 1) + if err != nil { + return "", err + } + + secondName, _, err := parseName(header[n:], -1, 1) + if err != nil { + return "", err + } + + if firstName != secondName { + return "", nil + } + return firstName, nil +} + +// parseGitHeaderData parses a single line of metadata from a Git file header. +// It returns true when header parsing is complete; in that case, line was the +// first line of non-header content. +func parseGitHeaderData(f *File, line, defaultName string) (end bool, err error) { if line[len(line)-1] == '\n' { line = line[:len(line)-1] } @@ -234,7 +274,7 @@ func parseGitHeaderData(f *File, line string) (end bool, err error) { for _, hdr := range []struct { prefix string end bool - parse func(*File, string) error + parse func(*File, string, string) error }{ {fragmentHeaderPrefix, true, nil}, {oldFilePrefix, false, parseGitHeaderOldName}, @@ -255,7 +295,7 @@ func parseGitHeaderData(f *File, line string) (end bool, err error) { } { if strings.HasPrefix(line, hdr.prefix) { if hdr.parse != nil { - err = hdr.parse(f, line[len(hdr.prefix):]) + err = hdr.parse(f, line[len(hdr.prefix):], defaultName) } return hdr.end, err } @@ -266,8 +306,8 @@ func parseGitHeaderData(f *File, line string) (end bool, err error) { return true, nil } -func parseGitHeaderOldName(f *File, line string) error { - name, _, err := parseName(line, '\t') +func parseGitHeaderOldName(f *File, line, defaultName string) error { + name, _, err := parseName(line, '\t', 1) if err != nil { return err } @@ -278,8 +318,8 @@ func parseGitHeaderOldName(f *File, line string) error { return nil } -func parseGitHeaderNewName(f *File, line string) error { - name, _, err := parseName(line, '\t') +func parseGitHeaderNewName(f *File, line, defaultName string) error { + name, _, err := parseName(line, '\t', 1) if err != nil { return err } @@ -290,55 +330,53 @@ func parseGitHeaderNewName(f *File, line string) error { return nil } -func parseGitHeaderOldMode(f *File, line string) (err error) { +func parseGitHeaderOldMode(f *File, line, defaultName string) (err error) { f.OldMode, err = parseMode(line) return } -func parseGitHeaderNewMode(f *File, line string) (err error) { +func parseGitHeaderNewMode(f *File, line, defaultName string) (err error) { f.NewMode, err = parseMode(line) return } -func parseGitHeaderDeletedMode(f *File, line string) (err error) { - // TODO(bkeyes): maybe set old name from default? +func parseGitHeaderDeletedMode(f *File, line, defaultName string) error { f.IsDelete = true - f.OldMode, err = parseMode(line) - return + f.OldName = defaultName + return parseGitHeaderOldMode(f, line, defaultName) } -func parseGitHeaderCreatedMode(f *File, line string) (err error) { - // TODO(bkeyes): maybe set new name from default? +func parseGitHeaderCreatedMode(f *File, line, defaultName string) error { f.IsNew = true - f.NewMode, err = parseMode(line) - return + f.NewName = defaultName + return parseGitHeaderNewMode(f, line, defaultName) } -func parseGitHeaderCopyFrom(f *File, line string) (err error) { +func parseGitHeaderCopyFrom(f *File, line, defaultName string) (err error) { f.IsCopy = true - f.OldName, _, err = parseName(line, 0) + f.OldName, _, err = parseName(line, -1, 0) return } -func parseGitHeaderCopyTo(f *File, line string) (err error) { +func parseGitHeaderCopyTo(f *File, line, defaultName string) (err error) { f.IsCopy = true - f.NewName, _, err = parseName(line, 0) + f.NewName, _, err = parseName(line, -1, 0) return } -func parseGitHeaderRenameFrom(f *File, line string) (err error) { +func parseGitHeaderRenameFrom(f *File, line, defaultName string) (err error) { f.IsRename = true - f.OldName, _, err = parseName(line, 0) + f.OldName, _, err = parseName(line, -1, 0) return } -func parseGitHeaderRenameTo(f *File, line string) (err error) { +func parseGitHeaderRenameTo(f *File, line, defaultName string) (err error) { f.IsRename = true - f.NewName, _, err = parseName(line, 0) + f.NewName, _, err = parseName(line, -1, 0) return } -func parseGitHeaderScore(f *File, line string) error { +func parseGitHeaderScore(f *File, line, defaultName string) error { score, err := strconv.ParseInt(line, 10, 32) if err != nil { nerr := err.(*strconv.NumError) @@ -350,7 +388,7 @@ func parseGitHeaderScore(f *File, line string) error { return nil } -func parseGitHeaderIndex(f *File, line string) error { +func parseGitHeaderIndex(f *File, line, defaultName string) error { const minOIDSize = 40 const sep = ".." @@ -369,7 +407,7 @@ func parseGitHeaderIndex(f *File, line string) error { f.OldOID, f.NewOID = oids[0], oids[1] if len(parts) > 1 { - return parseGitHeaderOldMode(f, parts[1]) + return parseGitHeaderOldMode(f, parts[1], defaultName) } return nil } @@ -385,39 +423,42 @@ func parseMode(s string) (os.FileMode, error) { // parseName extracts a file name from the start of a string and returns the // name and the index of the first character after the name. If the name is -// unquoted and term is non-0, parsing stops at the first occurance of term. -// Otherwise parsing of unquoted names stops at the first space or tab. -func parseName(s string, term byte) (name string, n int, err error) { - // TODO(bkeyes): remove double forward slashes in parsed named - +// unquoted and term is non-negative, parsing stops at the first occurance of +// term. Otherwise parsing of unquoted names stops at the first space or tab. +// +// If dropPrefix is greater than zero, that number of prefix components +// separated by forward slashes are dropped from the name. +func parseName(s string, term rune, dropPrefix int) (name string, n int, err error) { if len(s) > 0 && s[0] == '"' { // find matching end quote and then unquote the section for n = 1; n < len(s); n++ { if s[n] == '"' && s[n-1] != '\\' { + n++ break } } - if n == 1 { - err = fmt.Errorf("missing name") - return + if n == 2 { + return "", 0, fmt.Errorf("missing name") } - n++ - name, err = strconv.Unquote(s[:n]) - return - } - - for n = 0; n < len(s); n++ { - if term > 0 && s[n] == term { - break + if name, err = strconv.Unquote(s[:n]); err != nil { + return "", 0, err } - if term == 0 && (s[n] == ' ' || s[n] == '\t') { - break + } else { + // find terminator and take the previous section + for n = 0; n < len(s); n++ { + if term >= 0 && rune(s[n]) == term { + break + } + if term < 0 && (s[n] == ' ' || s[n] == '\t') { + break + } } + if n == 0 { + return "", 0, fmt.Errorf("missing name") + } + name = s[:n] } - if n == 0 { - err = fmt.Errorf("missing name") - } - return + return cleanName(s[:n], dropPrefix), n, nil } // verifyName checks parsed names against state set by previous header lines @@ -435,3 +476,22 @@ func verifyName(parsed, existing string, isNull bool, side string) error { } return nil } + +// cleanName removes double slashes and drops prefix segments. +func cleanName(name string, drop int) string { + var b strings.Builder + for i := 0; i < len(name); i++ { + if name[i] == '/' { + if i < len(name)-1 && name[i+1] == '/' { + continue + } + if drop > 0 { + drop-- + b.Reset() + continue + } + } + b.WriteByte(name[i]) + } + return b.String() +} diff --git a/gitdiff/parser_test.go b/gitdiff/parser_test.go index 474e767..b946594 100644 --- a/gitdiff/parser_test.go +++ b/gitdiff/parser_test.go @@ -129,3 +129,27 @@ func TestParseFragmentHeader(t *testing.T) { }) } } + +func TestCleanName(t *testing.T) { + tests := []struct { + Name string + Input string + Drop int + Expected string + }{ + {Name: "alreadyClean", Input: "a/b/c.txt", Expected: "a/b/c.txt"}, + {Name: "doubleSlashes", Input: "a//b/c.txt", Expected: "a/b/c.txt"}, + {Name: "tripleSlashes", Input: "a///b/c.txt", Expected: "a/b/c.txt"}, + {Name: "dropPrefix", Input: "a/b/c.txt", Drop: 2, Expected: "c.txt"}, + {Name: "removeDoublesBeforeDrop", Input: "a//b/c.txt", Drop: 1, Expected: "b/c.txt"}, + } + + for _, test := range tests { + t.Run(test.Name, func(t *testing.T) { + output := cleanName(test.Input, test.Drop) + if output != test.Expected { + t.Fatalf("incorrect output\nexpected: %s\nactual:%s", test.Expected, output) + } + }) + } +}