Add patch (for github patches) parser.

Author: Yuan Ting

gitdiff/gitdiff.go

@@ -3,6 +3,7 @@ package gitdiff
 import (
 	"fmt"
 	"os"
+	"strings"
 )
 
 // File describes changes to a single file. It can be either a text file or a
@@ -37,6 +38,18 @@ type File struct {
 	ReverseBinaryFragment *BinaryFragment
 }
 
+func (f *File) HasFunc(match func(string)bool) bool {
+	for _, fragment := range f.TextFragments {
+		funcnames := fragment.FuncNames()
+		for _, fname := range funcnames {
+			if match(fname) {
+				return true
+			}
+		}
+	}
+	return false
+}
+
 // TextFragment describes changed lines starting at a specific line in a text file.
 type TextFragment struct {
 	Comment string
@@ -61,6 +74,27 @@ func (f *TextFragment) Header() string {
 	return fmt.Sprintf("@@ -%d,%d +%d,%d @@ %s", f.OldPosition, f.OldLines, f.NewPosition, f.NewLines, f.Comment)
 }
 
+func (f *TextFragment) FuncNames() []string {
+	funcnames := []string{}
+	addname := func(line string) {
+		if strings.HasPrefix(line, "func") {
+			def := strings.TrimRight(line, " {")
+			if strings.Count(def, "(") == 1 {
+				funcnames = append(funcnames, def[5:])
+			} else {
+				low := strings.Index(def, ")") + 2
+				hig := strings.Index(def[low:], "(") + low
+				funcnames = append(funcnames, def[low:hig])
+			}
+		}
+	}
+	addname(f.Comment)
+	for _, line := range f.Lines {
+		addname(line.Line)
+	}
+	return funcnames
+}
+
 // Line is a line in a text fragment.
 type Line struct {
 	Op   LineOp

gitdiff/parser.go

@@ -7,8 +7,109 @@ import (
 	"bufio"
 	"fmt"
 	"io"
+	"strings"
 )
 
+type Commit struct {
+	CommitSha string
+	Content string
+}
+
+func EmitCommit(content string) (Commit, bool) {
+	tokens := strings.Split(content, " ")
+	if len(tokens) < 2 {
+		return Commit{}, false
+	}
+	return Commit{
+		CommitSha: tokens[1],
+		Content:   content,
+	}, true
+}
+
+func (c Commit) Equal(rhs Commit) bool {
+	return c.CommitSha == rhs.CommitSha
+}
+
+
+type Patches struct {
+	FilesToSha map[*File]string
+	ShaToFiles map[string][]*File
+	ShaToCommit map[string]Commit
+}
+
+func (p *Patches) AppendFile(cmt Commit, file *File) {
+	p.FilesToSha[file] = cmt.CommitSha
+	p.ShaToFiles[cmt.CommitSha] = append(p.ShaToFiles[cmt.CommitSha], file)
+	p.ShaToCommit[cmt.CommitSha] = cmt
+}
+
+func (p *Patches) GetFiles(sha string) ([]*File, bool) {
+	files, ok := p.ShaToFiles[sha]
+	return files, ok
+}
+
+func (p *Patches) GetCommit(file *File) (Commit, bool) {
+	sha, ok := p.FilesToSha[file]
+	if !ok {
+		return Commit{}, false
+	}
+	cmt, ok := p.ShaToCommit[sha]
+	if !ok {
+		return Commit{}, false
+	}
+	return cmt, ok
+}
+
+func ParsePatch(r io.Reader) ([]*File, *Patches, error) {
+	p := newParser(r)
+	patches := &Patches{
+		FilesToSha:  make(map[*File]string),
+		ShaToFiles:  make(map[string][]*File),
+		ShaToCommit: make(map[string]Commit),
+	}
+	if err := p.Next(); err != nil {
+		if err == io.EOF {
+			return nil, patches, nil
+		}
+		return nil, patches, err
+	}
+
+	var files []*File
+	lastCommit := Commit{}
+	for {
+		file, pre, err := p.ParseNextFileHeader()
+		if err != nil {
+			return files, patches, err
+		}
+		if file == nil {
+			break
+		}
+
+		for _, fn := range []func(*File) (int, error){
+			p.ParseTextFragments,
+			p.ParseBinaryFragments,
+		} {
+			n, err := fn(file)
+			if err != nil {
+				return files, patches, err
+			}
+			if n > 0 {
+				break
+			}
+		}
+
+		files = append(files, file)
+		if cmt, ok := EmitCommit(pre); ok {
+			patches.AppendFile(cmt, file)
+			lastCommit = cmt
+		} else {
+			patches.AppendFile(lastCommit, file)
+		}
+	}
+
+	return files, patches, nil
+}
+
 // Parse parses a patch with changes to one or more files. Any content before
 // the first file is returned as the second value. If an error occurs while
 // parsing, it returns all files parsed before the error.