Merge branch 'main' into master

Author: Dhia Ayachi

cmd/changelog-build/main.go

@@ -74,6 +74,12 @@ func main() {
 			sort.Slice(in, changelog.SortNotes(in))
 			return in
 		},
+		"sortByDate": func(in []changelog.Note) []changelog.Note {
+			sort.Slice(in, func(i, j int) bool {
+				return in[i].Date.Before(in[j].Date)
+			})
+			return in
+		},
 		"combineTypes": func(in ...[]changelog.Note) []changelog.Note {
 			count := 0
 			for _, i := range in {
@@ -108,11 +114,12 @@ func main() {
 	}
 	var notes []changelog.Note
 	notesByType := map[string][]changelog.Note{}
-	for _, entry := range entries {
+	for i := 0; i < entries.Len(); i++ {
+		entry := entries.Get(i)
 		if strings.HasSuffix(entry.Issue, ".txt") {
 			entry.Issue = strings.TrimSuffix(entry.Issue, ".txt")
 		}
-		notes = append(notes, changelog.NotesFromEntry(entry)...)
+		notes = append(notes, changelog.NotesFromEntry(*entry)...)
 	}
 	for _, note := range notes {
 		notesByType[note.Type] = append(notesByType[note.Type], note)

entry.go

@@ -1,9 +1,14 @@
 package changelog
 
 import (
+	"fmt"
 	"io/ioutil"
 	"path/filepath"
 	"sort"
+	"sync"
+	"time"
+
+	"golang.org/x/sync/errgroup"
 
 	"github.com/go-git/go-billy/v5/memfs"
 	"github.com/go-git/go-git/v5"
@@ -24,9 +29,92 @@ var TypeValues = []string{"enhancement",
 type Entry struct {
 	Issue string
 	Body  string
+	Date  time.Time
+	Hash  string
+}
+
+// EntryList provides thread-safe operations on a list of Entry values
+type EntryList struct {
+	mu sync.RWMutex
+	es []*Entry
+}
+
+// NewEntryList returns an EntryList with capacity c
+func NewEntryList(c int) *EntryList {
+	return &EntryList{
+		es: make([]*Entry, 0, c),
+	}
+}
+
+// Append appends entries to the EntryList
+func (el *EntryList) Append(entries ...*Entry) {
+	el.mu.Lock()
+	defer el.mu.Unlock()
+	el.es = append(el.es, entries...)
+}
+
+// Get returns the Entry at index i
+func (el *EntryList) Get(i int) *Entry {
+	el.mu.RLock()
+	defer el.mu.RUnlock()
+	if i >= len(el.es) || i < 0 {
+		return nil
+	}
+	return el.es[i]
+}
+
+// Set sets the Entry at index i. The list will be resized if i is larger than
+// the current list capacity.
+func (el *EntryList) Set(i int, e *Entry) {
+	if i < 0 {
+		panic("invalid slice index")
+	}
+	el.mu.Lock()
+	defer el.mu.Unlock()
+
+	if i > (cap(el.es) - 1) {
+		// resize the slice
+		newEntries := make([]*Entry, i)
+		copy(newEntries, el.es)
+		el.es = newEntries
+	}
+	el.es[i] = e
+}
+
+// Len returns the number of items in the EntryList
+func (el *EntryList) Len() int {
+	el.mu.RLock()
+	defer el.mu.RUnlock()
+	return len(el.es)
+}
+
+// SortByIssue does an in-place sort of the entries by their issue number.
+func (el *EntryList) SortByIssue() {
+	el.mu.Lock()
+	defer el.mu.Unlock()
+	sort.Slice(el.es, func(i, j int) bool {
+		return el.es[i].Issue < el.es[j].Issue
+	})
 }
 
-func Diff(repo, ref1, ref2, dir string) ([]Entry, error) {
+type changelog struct {
+	content []byte
+	hash    string
+	date    time.Time
+}
+
+// Diff returns the slice of Entry values that represent the difference of
+// entries in the dir directory within repo from ref1 revision to ref2 revision.
+// ref1 and ref2 should be valid git refs as strings and dir should be a valid
+// directory path in the repository.
+//
+// The function calculates the diff by first checking out ref2 and collecting
+// the set of all entries in dir. It then checks out ref1 and subtracts the
+// entries found in dir. The resulting set of entries is then filtered to
+// exclude any entries that came before the commit date of ref1.
+//
+// Along the way, if any git or filesystem interactions fail, an error is returned.
+func Diff(repo, ref1, ref2, dir string) (*EntryList, error) {
 	r, err := git.Clone(memory.NewStorage(), memfs.New(), &git.CloneOptions{
 		URL: repo,
 	})
@@ -35,42 +123,34 @@ func Diff(repo, ref1, ref2, dir string) ([]Entry, error) {
 	}
 	rev2, err := r.ResolveRevision(plumbing.Revision(ref2))
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("could not resolve revision %s: %w", ref2, err)
 	}
 	var rev1 *plumbing.Hash
 	if ref1 != "-" {
 		rev1, err = r.ResolveRevision(plumbing.Revision(ref1))
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("could not resolve revision %s: %w", ref1, err)
 		}
 	}
 	wt, err := r.Worktree()
 	if err != nil {
 		return nil, err
 	}
-	err = wt.Checkout(&git.CheckoutOptions{
+	if err := wt.Checkout(&git.CheckoutOptions{
 		Hash:  *rev2,
 		Force: true,
-	})
-	if err != nil {
-		return nil, err
+  }); err != nil {
+		return nil, fmt.Errorf("could not checkout repository at %s: %w", ref2, err)
 	}
 	entriesAfterFI, err := wt.Filesystem.ReadDir(dir)
 	if err != nil {
-		return nil, err
+		return nil, fmt.Errorf("could not read repository directory %s: %w", dir, err)
 	}
-	entriesAfter := make(map[string][]byte, len(entriesAfterFI))
+	// a set of all entries at rev2 (this release); the set of entries at ref1
+	// will then be subtracted from it to arrive at a set of 'candidate' entries.
+	entryCandidates := make(map[string]bool, len(entriesAfterFI))
 	for _, i := range entriesAfterFI {
-		f, err := wt.Filesystem.Open(filepath.Join(dir, i.Name()))
-		if err != nil {
-			return nil, err
-		}
-		contents, err := ioutil.ReadAll(f)
-		f.Close()
-		if err != nil {
-			return nil, err
-		}
-		entriesAfter[i.Name()] = contents
+		entryCandidates[i.Name()] = true
 	}
 	if rev1 != nil {
 		err = wt.Checkout(&git.CheckoutOptions{
@@ -82,22 +162,56 @@ func Diff(repo, ref1, ref2, dir string) ([]Entry, error) {
 		}
 		entriesBeforeFI, err := wt.Filesystem.ReadDir(dir)
 		if err != nil {
-			return nil, err
+			return nil, fmt.Errorf("could not read repository directory %s: %w", dir, err)
 		}
 		for _, i := range entriesBeforeFI {
-			delete(entriesAfter, i.Name())
+			delete(entryCandidates, i.Name())
+		}
+		// checkout rev2 so that we can read files later
+		if err := wt.Checkout(&git.CheckoutOptions{
+			Hash:  *rev2,
+			Force: true,
+		}); err != nil {
+			return nil, fmt.Errorf("could not checkout repository at %s: %w", ref2, err)
 		}
 	}
-	entries := make([]Entry, 0, len(entriesAfter))
-	for name, contents := range entriesAfter {
-		entries = append(entries, Entry{
-			Issue: name,
-			Body:  string(contents),
+
+	entries := NewEntryList(len(entryCandidates))
+	errg := new(errgroup.Group)
+	for name := range entryCandidates {
+		name := name // https://golang.org/doc/faq#closures_and_goroutines
+		errg.Go(func() error {
+			fp := filepath.Join(dir, name)
+			f, err := wt.Filesystem.Open(fp)
+			if err != nil {
+				return fmt.Errorf("error opening file at %s: %w", name, err)
+			}
+			contents, err := ioutil.ReadAll(f)
+			f.Close()
+			if err != nil {
+				return fmt.Errorf("error reading file at %s: %w", name, err)
+			}
+			log, err := r.Log(&git.LogOptions{FileName: &fp})
+			if err != nil {
+				return fmt.Errorf("error fetching git log for %s: %w", name, err)
+			}
+			lastChange, err := log.Next()
+			if err != nil {
+				return fmt.Errorf("error fetching next git log: %w", err)
+			}
+			entries.Append(&Entry{
+				Issue: name,
+				Body:  string(contents),
+				Date:  lastChange.Author.When,
+				Hash:  lastChange.Hash.String(),
+			})
+			return nil
 		})
 	}
-	sort.Slice(entries, func(i, j int) bool {
-		return entries[i].Issue < entries[j].Issue
-	})
+	if err := errg.Wait(); err != nil {
+		return nil, err
+	}
+	entries.SortByIssue()
 	return entries, nil
 }
 

note.go

@@ -4,12 +4,15 @@ import (
 	"regexp"
 	"sort"
 	"strings"
+	"time"
 )
 
 type Note struct {
 	Type  string
 	Body  string
 	Issue string
+	Hash  string
+	Date  time.Time
 }
 
 var textInBodyREs = []*regexp.Regexp{
@@ -53,6 +56,8 @@ func NotesFromEntry(entry Entry) []Note {
 				Type:  typ,
 				Body:  note,
 				Issue: entry.Issue,
+				Hash:  entry.Hash,
+				Date:  entry.Date,
 			})
 		}
 	}