hugo

git.go (5567B)

 // Copyright 2017-present The Hugo Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 package releaser
 
 import (
 	"fmt"
 	"regexp"
 	"sort"
 	"strconv"
 	"strings"
 
 	"github.com/gohugoio/hugo/common/hexec"
 )
 
 var issueRe = regexp.MustCompile(`(?i)(?:Updates?|Closes?|Fix.*|See) #(\d+)`)
 
 type changeLog struct {
 	Version string
 	Notes   gitInfos
 	All     gitInfos
 	Docs    gitInfos
 
 	// Overall stats
 	Repo             *gitHubRepo
 	ContributorCount int
 	ThemeCount       int
 }
 
 func newChangeLog(infos, docInfos gitInfos) *changeLog {
 	log := &changeLog{
 		Docs: docInfos,
 	}
 
 	for _, info := range infos {
 		// TODO(bep) improve
 		if regexp.MustCompile("(?i)deprecate|note").MatchString(info.Subject) {
 			log.Notes = append(log.Notes, info)
 		}
 
 		log.All = append(log.All, info)
 		info.Subject = strings.TrimSpace(info.Subject)
 
 	}
 
 	return log
 }
 
 type gitInfo struct {
 	Hash    string
 	Author  string
 	Subject string
 	Body    string
 
 	GitHubCommit *gitHubCommit
 }
 
 func (g gitInfo) Issues() []int {
 	return extractIssues(g.Body)
 }
 
 func (g gitInfo) AuthorID() string {
 	if g.GitHubCommit != nil {
 		return g.GitHubCommit.Author.Login
 	}
 	return g.Author
 }
 
 func extractIssues(body string) []int {
 	var i []int
 	m := issueRe.FindAllStringSubmatch(body, -1)
 	for _, mm := range m {
 		issueID, err := strconv.Atoi(mm[1])
 		if err != nil {
 			continue
 		}
 		i = append(i, issueID)
 	}
 	return i
 }
 
 type gitInfos []gitInfo
 
 func git(args ...string) (string, error) {
 	cmd, _ := hexec.SafeCommand("git", args...)
 	out, err := cmd.CombinedOutput()
 	if err != nil {
 		return "", fmt.Errorf("git failed: %q: %q (%q)", err, out, args)
 	}
 	return string(out), nil
 }
 
 func getGitInfos(tag, repo, repoPath string, remote bool) (gitInfos, error) {
 	return getGitInfosBefore("HEAD", tag, repo, repoPath, remote)
 }
 
 type countribCount struct {
 	Author       string
 	GitHubAuthor gitHubAuthor
 	Count        int
 }
 
 func (c countribCount) AuthorLink() string {
 	if c.GitHubAuthor.HTMLURL != "" {
 		return fmt.Sprintf("[@%s](%s)", c.GitHubAuthor.Login, c.GitHubAuthor.HTMLURL)
 	}
 
 	if !strings.Contains(c.Author, "@") {
 		return c.Author
 	}
 
 	return c.Author[:strings.Index(c.Author, "@")]
 }
 
 type contribCounts []countribCount
 
 func (c contribCounts) Less(i, j int) bool { return c[i].Count > c[j].Count }
 func (c contribCounts) Len() int           { return len(c) }
 func (c contribCounts) Swap(i, j int)      { c[i], c[j] = c[j], c[i] }
 
 func (g gitInfos) ContribCountPerAuthor() contribCounts {
 	var c contribCounts
 
 	counters := make(map[string]countribCount)
 
 	for _, gi := range g {
 		authorID := gi.AuthorID()
 		if count, ok := counters[authorID]; ok {
 			count.Count = count.Count + 1
 			counters[authorID] = count
 		} else {
 			var ghA gitHubAuthor
 			if gi.GitHubCommit != nil {
 				ghA = gi.GitHubCommit.Author
 			}
 			authorCount := countribCount{Count: 1, Author: gi.Author, GitHubAuthor: ghA}
 			counters[authorID] = authorCount
 		}
 	}
 
 	for _, v := range counters {
 		c = append(c, v)
 	}
 
 	sort.Sort(c)
 	return c
 }
 
 func getGitInfosBefore(ref, tag, repo, repoPath string, remote bool) (gitInfos, error) {
 	client := newGitHubAPI(repo)
 	var g gitInfos
 
 	log, err := gitLogBefore(ref, tag, repoPath)
 	if err != nil {
 		return g, err
 	}
 
 	log = strings.Trim(log, "\n\x1e'")
 	entries := strings.Split(log, "\x1e")
 
 	for _, entry := range entries {
 		items := strings.Split(entry, "\x1f")
 		gi := gitInfo{}
 
 		if len(items) > 0 {
 			gi.Hash = items[0]
 		}
 		if len(items) > 1 {
 			gi.Author = items[1]
 		}
 		if len(items) > 2 {
 			gi.Subject = items[2]
 		}
 		if len(items) > 3 {
 			gi.Body = items[3]
 		}
 
 		if remote && gi.Hash != "" {
 			gc, err := client.fetchCommit(gi.Hash)
 			if err == nil {
 				gi.GitHubCommit = &gc
 			}
 		}
 		g = append(g, gi)
 	}
 
 	return g, nil
 }
 
 // Ignore autogenerated commits etc. in change log. This is a regexp.
 const ignoredCommits = "snapcraft:|Merge commit|Squashed"
 
 func gitLogBefore(ref, tag, repoPath string) (string, error) {
 	var prevTag string
 	var err error
 	if tag != "" {
 		prevTag = tag
 	} else {
 		prevTag, err = gitVersionTagBefore(ref)
 		if err != nil {
 			return "", err
 		}
 	}
 
 	defaultArgs := []string{"log", "-E", fmt.Sprintf("--grep=%s", ignoredCommits), "--invert-grep", "--pretty=format:%x1e%h%x1f%aE%x1f%s%x1f%b", "--abbrev-commit", prevTag + ".." + ref}
 
 	var args []string
 
 	if repoPath != "" {
 		args = append([]string{"-C", repoPath}, defaultArgs...)
 	} else {
 		args = defaultArgs
 	}
 
 	log, err := git(args...)
 	if err != nil {
 		return ",", err
 	}
 
 	return log, err
 }
 
 func gitVersionTagBefore(ref string) (string, error) {
 	return gitShort("describe", "--tags", "--abbrev=0", "--always", "--match", "v[0-9]*", ref+"^")
 }
 
 func gitShort(args ...string) (output string, err error) {
 	output, err = git(args...)
 	return strings.Replace(strings.Split(output, "\n")[0], "'", "", -1), err
 }
 
 func tagExists(tag string) (bool, error) {
 	out, err := git("tag", "-l", tag)
 	if err != nil {
 		return false, err
 	}
 
 	if strings.Contains(out, tag) {
 		return true, nil
 	}
 
 	return false, nil
 }