| // Copyright 2015 The Go Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style |
| // license that can be found in the LICENSE file. |
| |
| /* |
| CL prints a list of open Go code reviews (also known as change lists, or CLs). |
| |
| Usage: |
| |
| cl [-closed] [-dnr] [-r] [-url] [-cl 12345] [-project build] |
| |
| CL searches Gerrit for CLs matching the query and then |
| prints a line for each CL that is waiting for review |
| (as opposed to waiting for revisions by the author). |
| |
| The output line looks like: |
| |
| CL 9225 0/ 2d go rsc austin* cmd/internal/gc: emit write barrier |
| |
| From left to right, the columns show the CL number, |
| the number of days the CL has been in the current waiting state |
| (waiting for author or waiting for review), |
| the number of days since the CL was created, |
| the project name ("go" or the name of a subrepository), |
| the author, the reviewer, and the subject. |
| If the CL is waiting for revisions by the author, |
| the author column has an asterisk. |
| If the CL is waiting for a reviewer, the reviewer column |
| has an asterisk. |
| If the CL has been reviewed by the reviewer, |
| the reviewer column shows the current score. |
| |
| By default, CL omits closed CLs, those with an R=close reply |
| and no subsequent upload of a new patch set. |
| If the -closed flag is specified, CL adds closed CLs to the output. |
| |
| By default, CL omits CLs containing ``DO NOT REVIEW'' in the |
| latest patch's commit message. |
| If the -dnr flag is specified, CL includes those CLs in its output. |
| |
| If the -r flag is specified, CL shows only CLs that need review, |
| not those waiting for the author. In this mode, the |
| redundant ``waiting for reviewer'' asterisk is elided. |
| |
| If the -url flag is specified, CL replaces "CL 1234" at the beginning |
| of each output line with a full URL, "https://golang.org/cl/1234". |
| |
| If the -cl flag is specified, CL prints the status of just one particular CL. |
| |
| If the -project flag is specified, CL prints the CLs only from the given project. |
| |
| By default, CL sorts the output first by the combination of |
| project name and change subject. |
| The -sort flag changes the sort order. The choices are |
| "delay", to sort by the time the change has been in the current |
| waiting state, and "age", to sort by creation time. |
| When sorting, ties are broken by CL number. |
| |
| TODO: Support do-not-review, output as JSON. |
| */ |
| package main |
| |
| import ( |
| "bytes" |
| "context" |
| "flag" |
| "fmt" |
| "log" |
| "os" |
| "sort" |
| "strconv" |
| "strings" |
| "time" |
| |
| "golang.org/x/build/maintner" |
| "golang.org/x/build/maintner/godata" |
| ) |
| |
| var ( |
| flagClosed = flag.Bool("closed", false, "include CLs that are closed or DO NOT REVIEW") |
| flagDoNotReview = flag.Bool("dnr", false, "print only CLs in need of review") |
| flagNeedsReview = flag.Bool("r", false, "print only CLs in need of review") |
| flagJSON = flag.Bool("json", false, "print CLs in JSON format") |
| flagURL = flag.Bool("url", false, "print full URLs for CLs") |
| flagSort = flag.String("sort", "", "sort by `order` (age or delay) instead of project+subject") |
| flagCL = flag.Int("cl", 0, "include only the CL specified (-cl 2130)") |
| flagProject = flag.String("project", "", "include only CLs from the project specified") |
| ) |
| |
| func usage() { |
| fmt.Fprintf(os.Stderr, "usage: cl [query]\n") |
| fmt.Fprintf(os.Stderr, "Flags:\n") |
| flag.PrintDefaults() |
| os.Exit(2) |
| } |
| |
| var now = time.Now() // so time stays the same during computations. |
| |
| // CL is a wrapper for a GerritCL object. |
| // It holds some meta information which is required for writing the output. |
| type CL struct { |
| // gerritCL is the actual CL object as returned by the Corpus. |
| gerritCL *maintner.GerritCL |
| |
| // needsReview indicates whether or not this CL requires a review. |
| needsReview bool |
| |
| // needsReviewChanged is the last time when needsReview was set. |
| needsReviewChanged time.Time |
| |
| // reviewerEmail is the email address of the person responsible for reviewing this CL. |
| reviewerEmail string |
| closed bool |
| closedReason string |
| |
| // scores is a map of the last scores given |
| // by the reviewers for this particular CL (+1, -1, +2, -2). |
| // It is keyed by the reviewer's email address. |
| scores map[string]int |
| } |
| |
| func (cl *CL) age(now time.Time) time.Duration { |
| return now.Sub(cl.gerritCL.Created) |
| } |
| |
| func (cl *CL) delaySinceLastUpdated(now time.Time) time.Duration { |
| return now.Sub(cl.needsReviewChanged) |
| } |
| |
| const maxUsernameLen = 12 |
| |
| func main() { |
| log.SetFlags(0) |
| log.SetPrefix("cl: ") |
| |
| flag.Usage = usage |
| flag.Parse() |
| |
| gerritAccounts := &GerritAccounts{} |
| |
| if err := gerritAccounts.Initialize(); err != nil { |
| log.Fatal("couldn't initialise Gerrit account mapping", err) |
| } |
| |
| switch *flagSort { |
| case "", "age", "delay": |
| // ok |
| default: |
| log.Fatal("unknown sort order") |
| } |
| |
| corpus, err := godata.Get(context.Background()) |
| if err != nil { |
| log.Fatal("couldn't initialise the Corpus", err) |
| } |
| |
| cls := []*CL{} |
| |
| corpus.Gerrit().ForeachProjectUnsorted(func(gp *maintner.GerritProject) error { |
| if *flagProject != "" && *flagProject != gp.Project() { |
| return nil |
| } |
| |
| gp.ForeachCLUnsorted(func(cl *maintner.GerritCL) error { |
| if cl.Status == "abandoned" { // Don't display abandoned CLs. |
| return nil |
| } |
| |
| if cl.Meta == nil { // Occurs infrequently. See https://golang.org/issue/22060. |
| return nil |
| } |
| |
| if *flagCL > 0 && int32(*flagCL) != cl.Number { |
| return nil |
| } |
| |
| ourCL := &CL{gerritCL: cl} |
| updateReviewStatus(ourCL, gerritAccounts) |
| |
| if (*flagNeedsReview && !ourCL.needsReview) || (!*flagClosed && cl.Status == "merged") { |
| return nil |
| } |
| |
| cls = append(cls, ourCL) |
| |
| return nil |
| }) |
| |
| return nil |
| }) |
| |
| switch *flagSort { |
| case "": |
| sort.Sort(byRepoAndSubject(cls)) |
| case "age": |
| sort.Sort(byAge(cls)) |
| case "delay": |
| sort.Sort(byDelay(cls)) |
| } |
| |
| clPrefix := "CL " |
| if *flagURL { |
| clPrefix = "https://golang.org/cl/" |
| } |
| |
| var projectLen, authorLen, reviewerLen int |
| for _, cl := range cls { |
| projectLen = max(projectLen, len(cl.gerritCL.Project.Project())) |
| authorLen = max(authorLen, len(cl.gerritCL.Meta.Author.Email())) |
| if cl.reviewerEmail != "" { |
| reviewerLen = max(reviewerLen, len(cl.reviewerEmail)) |
| } |
| } |
| |
| if authorLen > maxUsernameLen { |
| authorLen = maxUsernameLen |
| } |
| |
| if reviewerLen > maxUsernameLen { |
| reviewerLen = maxUsernameLen |
| } |
| |
| authorLen += 1 // For *. |
| reviewerLen += 3 // For +2*. |
| |
| var buf bytes.Buffer |
| for _, cl := range cls { |
| fmt.Fprintf(&buf, "%s%-5d %3.0f/%3.0fd %-*s %-*s %-*s %s\n", |
| clPrefix, cl.gerritCL.Number, |
| cl.delaySinceLastUpdated(now).Hours()/24, cl.age(now).Hours()/24, |
| projectLen, cl.gerritCL.Project.Project(), |
| authorLen, authorString(cl, gerritAccounts, authorLen), |
| reviewerLen, reviewerString(cl, reviewerLen), |
| cl.gerritCL.Subject()) |
| } |
| os.Stdout.Write(buf.Bytes()) |
| } |
| |
| const tagCodeReview = "Label: Code-Review=" |
| |
| // updateReviewStatus guesses the reviewer, and then decides |
| // whether or not the given CL is waiting for a review or not. |
| func updateReviewStatus(cl *CL, gerritAccounts *GerritAccounts) { |
| var initialReviewer, firstResponder string |
| |
| cl.scores = map[string]int{} |
| |
| authorEmail, err := gerritAccounts.LookupByGerritEmail(cl.gerritCL.MetaCommits[0].Author.Email(), true) |
| if err != nil { |
| return // We can't resolve the author. |
| } |
| |
| // Find the initial reviewer, and the first responder (always exclude the author in both cases). |
| // Also update the scores map. |
| for _, metaCommit := range cl.gerritCL.MetaCommits { |
| if firstResponder == "" { |
| responder, err := gerritAccounts.LookupByGerritEmail(metaCommit.Author.Email(), true) |
| if err == nil && responder.Email != authorEmail.Email { |
| firstResponder = responder.Email |
| } |
| } |
| |
| if metaCommit.Reviewer == nil { |
| continue |
| } |
| |
| reviewer, err := gerritAccounts.LookupByGerritEmail(metaCommit.Reviewer.Email(), true) |
| if err != nil { |
| continue |
| } |
| |
| codeReviewIdx := strings.Index(metaCommit.Msg, tagCodeReview) |
| |
| if codeReviewIdx > 0 { |
| prefix := len(tagCodeReview) |
| // Extract and convert the point(s). This line takes the form "Label: Code-Review=+1". |
| val, err := strconv.Atoi(metaCommit.Msg[codeReviewIdx+prefix : codeReviewIdx+prefix+2]) |
| if err == nil { |
| cl.scores[reviewer.Email] = val |
| } |
| } |
| |
| if initialReviewer == "" && reviewer.Email != "" && authorEmail.Email != reviewer.Email { |
| initialReviewer = reviewer.Email |
| } |
| } |
| |
| if initialReviewer != "" { |
| cl.reviewerEmail = initialReviewer |
| } |
| |
| // maybe sets the reviewerEmail if it's not set yet. |
| maybe := func(who string) { |
| // The initial reviewer always gets the highest priority. |
| if cl.reviewerEmail == "" || who == initialReviewer { |
| cl.reviewerEmail = who |
| } |
| } |
| |
| // Determine reviewer, in priority order. |
| |
| // 1. Anyone who -2'ed the CL. |
| for who, score := range cl.scores { |
| if score == -2 { |
| maybe(who) |
| } |
| } |
| |
| // 2. Anyone who +2'ed the CL. |
| for who, score := range cl.scores { |
| if score == +2 { |
| maybe(who) |
| } |
| } |
| |
| // 3. Whoever responds first. |
| if firstResponder != "" { |
| maybe(firstResponder) |
| } |
| |
| // Now that we know who the reviewer is, |
| // figure out whether the CL is in need of review |
| // (or else is waiting for the author to do more work). |
| for _, metaCommit := range cl.gerritCL.MetaCommits { |
| if metaCommit.Author == nil { // Happens for Gerrit-generated messages. |
| continue |
| } |
| |
| accountInfo, err := gerritAccounts.LookupByGerritEmail(metaCommit.Author.Email(), true) |
| if err != nil { |
| continue |
| } |
| |
| if strings.Contains(metaCommit.Msg, "Uploaded patch set ") || accountInfo.Email != cl.reviewerEmail { |
| cl.needsReview = true |
| cl.needsReviewChanged = metaCommit.CommitTime |
| } |
| |
| if accountInfo.Email == cl.reviewerEmail { |
| cl.needsReview = false |
| cl.needsReviewChanged = metaCommit.CommitTime |
| } |
| } |
| |
| // TODO: Support do not review, close, and postpone to next go release |
| } |
| |
| func max(i, j int) int { |
| if i < j { |
| return j |
| } |
| return i |
| } |
| |
| // authorString returns the author column, limited to n bytes. |
| func authorString(cl *CL, gerritAccounts *GerritAccounts, n int) string { |
| suffix := "" |
| if !cl.needsReview { |
| suffix = "*" |
| } |
| |
| first := cl.gerritCL.Meta |
| |
| for first.Parents != nil && len(first.Parents) > 0 { |
| first = first.Parents[0] |
| } |
| |
| // Lookup the real account ID. |
| accountInfo, err := gerritAccounts.LookupByGerritEmail(first.Author.Email(), true) |
| if err != nil { |
| return "" |
| } |
| |
| return truncate(username(accountInfo.Email), n-len(suffix)) + suffix |
| } |
| |
| // username returns the ideal username from the email address. |
| // This might not be the actual username of the person, but merely a short name |
| // that can be displayed in the output. |
| func username(email string) string { |
| idx := strings.Index(email, "@") |
| if idx != -1 { |
| return email[0:idx] |
| } |
| |
| return email |
| } |
| |
| // reviewerString returns the reviewer column, limited to n bytes. |
| func reviewerString(cl *CL, n int) string { |
| suffix := "" |
| if cl.needsReview && !*flagNeedsReview { |
| suffix = "*" |
| } |
| |
| if score := (cl.scores)[cl.reviewerEmail]; score != 0 { |
| suffix = fmt.Sprintf("%+d", score) + suffix |
| } |
| return truncate(username(cl.reviewerEmail), n-len(suffix)) + suffix |
| } |
| |
| // truncate returns the name truncated to n bytes. |
| func truncate(text string, n int) string { |
| if len(text) <= n { |
| return text |
| } |
| return text[:n-3] + "..." |
| } |
| |
| // Sort interfaces. |
| |
| type byRepoAndSubject []*CL |
| |
| func (x byRepoAndSubject) Len() int { return len(x) } |
| func (x byRepoAndSubject) Swap(i, j int) { x[i], x[j] = x[j], x[i] } |
| func (x byRepoAndSubject) Less(i, j int) bool { |
| if x[i].gerritCL.Project.Project() != x[j].gerritCL.Project.Project() { |
| return projectOrder(x[i].gerritCL.Project.Project()) < projectOrder(x[j].gerritCL.Project.Project()) |
| } |
| |
| if x[i].gerritCL.Subject() != x[j].gerritCL.Subject() { |
| return x[i].gerritCL.Subject() < x[j].gerritCL.Subject() |
| } |
| return x[i].gerritCL.Number < x[j].gerritCL.Number |
| } |
| |
| type byAge []*CL |
| |
| func (x byAge) Len() int { return len(x) } |
| func (x byAge) Swap(i, j int) { x[i], x[j] = x[j], x[i] } |
| func (x byAge) Less(i, j int) bool { |
| if !x[i].gerritCL.Created.Equal(x[j].gerritCL.Created) { |
| return x[i].gerritCL.Created.Before(x[j].gerritCL.Created) |
| } |
| return x[i].gerritCL.Number > x[j].gerritCL.Number |
| } |
| |
| type byDelay []*CL |
| |
| func (x byDelay) Len() int { return len(x) } |
| func (x byDelay) Swap(i, j int) { x[i], x[j] = x[j], x[i] } |
| func (x byDelay) Less(i, j int) bool { |
| if !x[i].needsReviewChanged.Equal(x[j].needsReviewChanged) { |
| return x[i].needsReviewChanged.Before(x[j].needsReviewChanged) |
| } |
| return x[i].gerritCL.Number < x[j].gerritCL.Number |
| } |
| |
| func projectOrder(name string) string { |
| if name == "go" { |
| return "\x00" // Sort before everything except empty string. |
| } |
| return name |
| } |