// BranchBehind is not yet implemented. Determines if the current branch // behind master and requires that it be "merged up". func (r *Reviewer) BranchBehind() (bool, error) { if r.Repo == nil { return false, errors.New("repo not initialized") } var ( rg runGuard mBranch *gg.Branch mCom *gg.Commit hRef *gg.Reference hCom *gg.Commit behind bool ) defer func() { objs := [...]freeable{ mBranch, mCom, hRef, hCom, } for _, obj := range objs { obj.Free() } }() rg.maybeRun(func() { var err error if mBranch, err = r.Repo.LookupBranch("master", gg.BranchLocal); err != nil { rg.err = err rg.msg = "Issue opening master branch" } }) rg.maybeRun(func() { var err error if mCom, err = r.Repo.LookupCommit(mBranch.Reference.Target()); err != nil { rg.err = err rg.msg = "Issue opening master commit" } }) rg.maybeRun(func() { var err error if hRef, err = r.Repo.Head(); err != nil { rg.err = err rg.msg = "Issue opening HEAD reference" } }) rg.maybeRun(func() { var err error if hCom, err = r.Repo.LookupCommit(hRef.Target()); err != nil { rg.err = err rg.msg = "Issue opening HEAD commit" } }) rg.maybeRun(func() { behind = hCom.Committer().When.Before(mCom.Committer().When) }) return behind, rg.err }
func (r *Repository) makeCommit(c *git2go.Commit) *vcs.Commit { var parents []vcs.CommitID if pc := c.ParentCount(); pc > 0 { parents = make([]vcs.CommitID, pc) for i := 0; i < int(pc); i++ { parents[i] = vcs.CommitID(c.ParentId(uint(i)).String()) } } au, cm := c.Author(), c.Committer() return &vcs.Commit{ ID: vcs.CommitID(c.Id().String()), Author: vcs.Signature{au.Name, au.Email, pbtypes.NewTimestamp(au.When)}, Committer: &vcs.Signature{cm.Name, cm.Email, pbtypes.NewTimestamp(cm.When)}, Message: strings.TrimSuffix(c.Message(), "\n"), Parents: parents, } }
// revWalkSyncHandler adds new commits to the repo graph. // The walk stops when reaching the previous lastest commit in the database. func revWalkSyncHandler(commit *git.Commit) bool { // Get repo path. r := commit.Owner() path := r.Path() // Commit info. hash := commit.Id().String() settings := GetSettings() db, err := neoism.Connect(settings.DbUrl) if err != nil { panic(err) } res := []struct { Hash string `json:"c.hash"` }{} cq := neoism.CypherQuery{ Statement: ` MATCH (:Repository {path: {path}})-[:HAS_COMMIT]->(c:Commit {hash: {hash}}) RETURN c.hash `, Parameters: neoism.Props{ "hash": hash, "path": path, }, Result: &res, } if err = db.Cypher(&cq); err != nil { panic(err) } // When reaching an existing commit in the database, stop the walk. if size := len(res); size > 0 { return false } // Else, add the commit to the database. message := strings.Replace(commit.Message(), "\"", "'", -1) // Parent info. parentCount := commit.ParentCount() var buffer bytes.Buffer for i := uint(0); i < parentCount; i = i + 1 { buffer.WriteString(commit.ParentId(i).String()) if i < parentCount-1 { buffer.WriteString(" ") } } parents := buffer.String() // Author info. authorSig := commit.Author() authorName := authorSig.Name authorEmail := authorSig.Email authorTime := authorSig.When.Format("2006-01-02 15:04:05 +0000") authorTimestamp := strconv.Itoa(int(authorSig.When.Unix())) // Committer info. committerSig := commit.Committer() commitTime := committerSig.When.Format("2006-01-02 15:04:05 +0000") commitTimestamp := strconv.Itoa(int(committerSig.When.Unix())) // Add accoding info to the graph. commitCq := neoism.CypherQuery{ Statement: ` MATCH (r:Repository {path: {path}}) CREATE (r)-[:HAS_COMMIT]->(c:Commit { message: {message}, author_time: {author_time}, author_timestamp: toInt({author_timestamp}), commit_time: {commit_time}, commit_timestamp: toInt({commit_timestamp}), hash: {hash}, parents: split({parents}, ' ')}) MERGE (u:User:Author {email: {author_email}}) ON CREATE SET u.name = {author_name} MERGE (u)-[:AUTHORED]->(c) MERGE (c)-[:AUTHORED_BY]->(u) MERGE (u)-[:CONTRIBUTED_TO]->(r) WITH c WHERE {parents} <> '' FOREACH (parent_hash in split({parents}, ' ') | MERGE (parent:Commit {hash: parent_hash}) MERGE (c)-[:HAS_PARENT]->(parent)) `, Parameters: neoism.Props{ "path": path, "hash": hash, "message": message, "author_name": authorName, "author_email": authorEmail, "author_time": authorTime, "author_timestamp": authorTimestamp, "commit_time": commitTime, "commit_timestamp": commitTimestamp, "parents": parents, }, } if err = db.Cypher(&commitCq); err != nil { return false } return true }
// revWalkHandler goes through each commit and creates relevant info for each // commit. func revWalkHandler(commit *git.Commit) bool { // Commit info. hash := commit.Id().String() if hash == "" { return false } message := strings.Replace(commit.Message(), "\"", "'", -1) // Parent info. parentCount := commit.ParentCount() var buffer bytes.Buffer for i := uint(0); i < parentCount; i = i + 1 { buffer.WriteString(commit.ParentId(i).String()) if i < parentCount-1 { buffer.WriteString(" ") } } parents := buffer.String() // Author info. authorSig := commit.Author() authorName := authorSig.Name authorEmail := authorSig.Email authorTime := authorSig.When.Format("2006-01-02 15:04:05 +0000") authorTimestamp := strconv.Itoa(int(authorSig.When.Unix())) // Committer info. committerSig := commit.Committer() commitTime := committerSig.When.Format("2006-01-02 15:04:05 +0000") commitTimestamp := strconv.Itoa(int(committerSig.When.Unix())) // Write to csvFile r := commit.Owner() csvPath, err := TemporaryCsvPath(r) if err != nil { panic(err) } csvFile, err := os.OpenFile(csvPath, os.O_RDWR|os.O_APPEND, 0666) if err != nil { panic(err) } defer csvFile.Close() w := csv.NewWriter(csvFile) err = w.Write([]string{ hash, message, authorName, authorEmail, authorTime, authorTimestamp, commitTime, commitTimestamp, parents, }) if err != nil { panic(err) } w.Flush() if err = w.Error(); err != nil { panic(err) } return true }
// FindFiles returns a list of paths to files that have been changed // in this branch with respect to `master`. func (r *Reviewer) FindFiles() ([]string, error) { var ( rg runGuard lines []string mBranch *gg.Branch hRef *gg.Reference hCom *gg.Commit mCom *gg.Commit mTree *gg.Tree hTree *gg.Tree opts gg.DiffOptions diff *gg.Diff ) if r.Repo == nil { return lines, errors.New("repo not initialized") } defer func() { objs := [...]freeable{ mBranch, hRef, hCom, mCom, mTree, hTree, } for _, obj := range objs { if obj != nil { obj.Free() } } if err := diff.Free(); err != nil && r.Verbose { fmt.Printf("Issue cleaning up diff: '%s'\n", err) } }() rg.maybeRun(func() { var err error if mBranch, err = r.Repo.LookupBranch("master", gg.BranchLocal); err != nil { rg.err = err rg.msg = "issue opening master branch" } }) rg.maybeRun(func() { var err error if mCom, err = r.Repo.LookupCommit(mBranch.Reference.Target()); err != nil { rg.err = err rg.msg = "issue opening commit at master" } }) rg.maybeRun(func() { var err error if hRef, err = r.Repo.Head(); err != nil { rg.err = err rg.msg = "issue opening repo at HEAD" } }) rg.maybeRun(func() { var err error if hCom, err = r.Repo.LookupCommit(hRef.Target()); err != nil { rg.err = err rg.msg = "issue opening commit at HEAD" } }) rg.maybeRun(func() { var err error if mTree, err = mCom.Tree(); err != nil { rg.err = err rg.msg = "issue opening tree at master" } }) rg.maybeRun(func() { var err error if hTree, err = hCom.Tree(); err != nil { rg.err = err rg.msg = "issue opening tree at HEAD" } }) rg.maybeRun(func() { var err error if opts, err = gg.DefaultDiffOptions(); err != nil { rg.err = err rg.msg = "issue creating diff options" } }) rg.maybeRun(func() { var err error if diff, err = r.Repo.DiffTreeToTree(mTree, hTree, &opts); err != nil { rg.err = err rg.msg = "issue finding diff" } }) rg.maybeRun(func() { diff.ForEach(func(file gg.DiffDelta, progress float64) ( gg.DiffForEachHunkCallback, error) { lines = append(lines, file.OldFile.Path) return nil, nil }, gg.DiffDetailFiles) }) if rg.err != nil && rg.msg != "" && r.Verbose { fmt.Printf("Error finding diff files: '%s'\n", rg.msg) } return lines, rg.err }
func CommitToRef(r *git.Repository, tree *git.Tree, parent *git.Commit, refname, msg string) (*git.Commit, error) { // Retry loop in case of conflict // FIXME: use a custom inter-process lock as a first attempt for performance var ( needMerge bool tmpCommit *git.Commit ) for { if !needMerge { // Create simple commit commit, err := mkCommit(r, refname, msg, tree, parent) if isGitConcurrencyErr(err) { needMerge = true continue } return commit, err } else { if tmpCommit == nil { var err error // Create a temporary intermediary commit, to pass to MergeCommits // NOTE: this commit will not be part of the final history. tmpCommit, err = mkCommit(r, "", msg, tree, parent) if err != nil { return nil, err } defer tmpCommit.Free() } // Lookup tip from ref tip := lookupTip(r, refname) if tip == nil { // Ref may have been deleted after previous merge error needMerge = false continue } // Merge simple commit with the tip opts, err := git.DefaultMergeOptions() if err != nil { return nil, err } idx, err := r.MergeCommits(tmpCommit, tip, &opts) if err != nil { return nil, err } conflicts, err := idx.ConflictIterator() if err != nil { return nil, err } defer conflicts.Free() for { c, err := conflicts.Next() if isGitIterOver(err) { break } else if err != nil { return nil, err } if c.Our != nil { idx.RemoveConflict(c.Our.Path) if err := idx.Add(c.Our); err != nil { return nil, fmt.Errorf("error resolving merge conflict for '%s': %v", c.Our.Path, err) } } } mergedId, err := idx.WriteTreeTo(r) if err != nil { return nil, fmt.Errorf("WriteTree: %v", err) } mergedTree, err := lookupTree(r, mergedId) if err != nil { return nil, err } // Create new commit from merged tree (discarding simple commit) commit, err := mkCommit(r, refname, msg, mergedTree, parent, tip) if isGitConcurrencyErr(err) { // FIXME: enforce a maximum number of retries to avoid infinite loops continue } return commit, err } } return nil, fmt.Errorf("too many failed merge attempts, giving up") }