Compact and slightly reorder author list

More prominent positions are given to authors with more commits, in
steps of magnitude. Authors with 100-999 commits are listed before
authors with 10-99 commits. Yes, this puts me at the head of the list
and is a slight ego trip, but I still think it's the right thing to do.

script/authors.go

@@ -12,9 +12,12 @@
 package main
 
 import (
+	"bytes"
 	"io/ioutil"
 	"log"
+	"math"
 	"os"
+	"os/exec"
 	"regexp"
 	"sort"
 	"strings"
@@ -22,28 +25,65 @@ import (
 
 const htmlFile = "gui/default/syncthing/core/aboutModalView.html"
 
-func main() {
-	bs := readAll("AUTHORS")
-	lines := strings.Split(string(bs), "\n")
-	nameRe := regexp.MustCompile(`(.+?)\s+<`)
-	authors := make([]string, 0, len(lines))
-	for _, line := range lines {
-		if m := nameRe.FindStringSubmatch(line); len(m) == 2 {
-			authors = append(authors, "        <li class=\"auto-generated\">"+m[1]+"</li>")
-		}
-	}
-	sort.Strings(authors)
-	replacement := strings.Join(authors, "\n")
+type author struct {
+	name         string
+	emails       []string
+	commits      int
+	log10commits int
+}
 
-	authorsRe := regexp.MustCompile(`(?s)id="contributor-list">.*?</ul>`)
-	bs = readAll(htmlFile)
-	bs = authorsRe.ReplaceAll(bs, []byte("id=\"contributor-list\">\n"+replacement+"\n      </ul>"))
+func main() {
+	authors := getAuthors()
+	getContributions(authors)
+	sort.Sort(byContributions(authors))
+
+	var lines []string
+	for _, author := range authors {
+		lines = append(lines, author.name)
+	}
+	replacement := strings.Join(lines, ", ")
+
+	authorsRe := regexp.MustCompile(`(?s)id="contributor-list">.*?</div>`)
+	bs := readAll(htmlFile)
+	bs = authorsRe.ReplaceAll(bs, []byte("id=\"contributor-list\">\n"+replacement+"\n    </div>"))
 
 	if err := ioutil.WriteFile(htmlFile, bs, 0644); err != nil {
 		log.Fatal(err)
 	}
 }
 
+func getAuthors() []author {
+	bs := readAll("AUTHORS")
+	lines := strings.Split(string(bs), "\n")
+	var authors []author
+	nameRe := regexp.MustCompile(`(.+?)\s+<`)
+	authorRe := regexp.MustCompile(`<([^>]+)>`)
+	for _, line := range lines {
+		m := nameRe.FindStringSubmatch(line)
+		if len(m) < 2 {
+			continue
+		}
+		name := m[1]
+
+		ms := authorRe.FindAllStringSubmatch(line, -1)
+		if len(ms) == 0 {
+			continue
+		}
+
+		var emails []string
+		for i := range ms {
+			emails = append(emails, ms[i][1])
+		}
+
+		a := author{
+			name:   name,
+			emails: emails,
+		}
+		authors = append(authors, a)
+	}
+	return authors
+}
+
 func readAll(path string) []byte {
 	fd, err := os.Open(path)
 	if err != nil {
@@ -58,3 +98,46 @@ func readAll(path string) []byte {
 
 	return bs
 }
+
+// Add number of commits per author to the author list.
+func getContributions(authors []author) {
+	buf := new(bytes.Buffer)
+	cmd := exec.Command("git", "log", "--pretty=format:%ae")
+	cmd.Stdout = buf
+	err := cmd.Run()
+	if err != nil {
+		log.Fatal(err)
+	}
+
+next:
+	for _, line := range strings.Split(buf.String(), "\n") {
+		for i := range authors {
+			for _, email := range authors[i].emails {
+				if email == line {
+					authors[i].commits++
+					continue next
+				}
+			}
+		}
+	}
+
+	for i := range authors {
+		authors[i].log10commits = int(math.Log10(float64(authors[i].commits + 1)))
+	}
+}
+
+type byContributions []author
+
+func (l byContributions) Len() int { return len(l) }
+
+// Sort first by log10(commits), then by name. This means that we first get
+// an alphabetic list of people with >= 1000 commits, then a list of people
+// with >= 100 commits, and so on.
+func (l byContributions) Less(a, b int) bool {
+	if l[a].log10commits != l[b].log10commits {
+		return l[a].log10commits > l[b].log10commits
+	}
+	return l[a].name < l[b].name
+}
+
+func (l byContributions) Swap(a, b int) { l[a], l[b] = l[b], l[a] }