From 7797a86a489b3a8926b3bb5fd621969460c549db Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Julian=20T=C3=B6lle?= <julian.toelle97@gmail.com>
Date: Thu, 8 Aug 2024 18:29:34 +0200
Subject: [PATCH] refactor: interface for commit message analyzer

---
 commits.go      | 30 +++++++++++++++++++-----------
 commits_test.go | 17 ++++-------------
 forge.go        |  2 +-
 3 files changed, 24 insertions(+), 25 deletions(-)

diff --git a/commits.go b/commits.go
index 565deb7..28f9f4a 100644
--- a/commits.go
+++ b/commits.go
@@ -15,24 +15,36 @@ type AnalyzedCommit struct {
 	BreakingChange bool
 }
 
-func AnalyzeCommits(commits []Commit) ([]AnalyzedCommit, conventionalcommits.VersionBump, error) {
+type CommitParser interface {
+	Analyze(commits []Commit) ([]AnalyzedCommit, error)
+}
+
+type ConventionalCommitsParser struct {
+	machine conventionalcommits.Machine
+}
+
+func NewConventionalCommitsParser() *ConventionalCommitsParser {
 	parserMachine := parser.NewMachine(
 		parser.WithBestEffort(),
 		parser.WithTypes(conventionalcommits.TypesConventional),
 	)
 
+	return &ConventionalCommitsParser{
+		machine: parserMachine,
+	}
+}
+
+func (c *ConventionalCommitsParser) AnalyzeCommits(commits []Commit) ([]AnalyzedCommit, error) {
 	analyzedCommits := make([]AnalyzedCommit, 0, len(commits))
 
-	highestVersionBump := conventionalcommits.UnknownVersion
-
 	for _, commit := range commits {
-		msg, err := parserMachine.Parse([]byte(commit.Message))
+		msg, err := c.machine.Parse([]byte(commit.Message))
 		if err != nil {
-			return nil, conventionalcommits.UnknownVersion, fmt.Errorf("failed to parse message of commit %q: %w", commit.Hash, err)
+			return nil, fmt.Errorf("failed to parse message of commit %q: %w", commit.Hash, err)
 		}
 		conventionalCommit, ok := msg.(*conventionalcommits.ConventionalCommit)
 		if !ok {
-			return nil, conventionalcommits.UnknownVersion, fmt.Errorf("unable to get ConventionalCommit from parser result: %T", msg)
+			return nil, fmt.Errorf("unable to get ConventionalCommit from parser result: %T", msg)
 		}
 
 		commitVersionBump := conventionalCommit.VersionBump(conventionalcommits.DefaultStrategy)
@@ -47,11 +59,7 @@ func AnalyzeCommits(commits []Commit) ([]AnalyzedCommit, conventionalcommits.Ver
 			})
 		}
 
-		if commitVersionBump > highestVersionBump {
-			// Get max version bump from all releasable commits
-			highestVersionBump = commitVersionBump
-		}
 	}
 
-	return analyzedCommits, highestVersionBump, nil
+	return analyzedCommits, nil
 }
diff --git a/commits_test.go b/commits_test.go
index 0e686e6..0725b32 100644
--- a/commits_test.go
+++ b/commits_test.go
@@ -3,7 +3,6 @@ package rp
 import (
 	"testing"
 
-	"github.com/leodido/go-conventionalcommits"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -12,14 +11,12 @@ func TestAnalyzeCommits(t *testing.T) {
 		name            string
 		commits         []Commit
 		expectedCommits []AnalyzedCommit
-		expectedBump    conventionalcommits.VersionBump
 		wantErr         assert.ErrorAssertionFunc
 	}{
 		{
 			name:            "empty commits",
 			commits:         []Commit{},
 			expectedCommits: []AnalyzedCommit{},
-			expectedBump:    conventionalcommits.UnknownVersion,
 			wantErr:         assert.NoError,
 		},
 		{
@@ -30,7 +27,6 @@ func TestAnalyzeCommits(t *testing.T) {
 				},
 			},
 			expectedCommits: nil,
-			expectedBump:    conventionalcommits.UnknownVersion,
 			wantErr:         assert.Error,
 		},
 		{
@@ -41,7 +37,6 @@ func TestAnalyzeCommits(t *testing.T) {
 				},
 			},
 			expectedCommits: []AnalyzedCommit{},
-			expectedBump:    conventionalcommits.UnknownVersion,
 			wantErr:         assert.NoError,
 		},
 		{
@@ -61,8 +56,7 @@ func TestAnalyzeCommits(t *testing.T) {
 					Description: "blabla",
 				},
 			},
-			expectedBump: conventionalcommits.PatchVersion,
-			wantErr:      assert.NoError,
+			wantErr: assert.NoError,
 		},
 		{
 			name: "highest bump (minor)",
@@ -86,8 +80,7 @@ func TestAnalyzeCommits(t *testing.T) {
 					Description: "foobar",
 				},
 			},
-			expectedBump: conventionalcommits.MinorVersion,
-			wantErr:      assert.NoError,
+			wantErr: assert.NoError,
 		},
 
 		{
@@ -113,19 +106,17 @@ func TestAnalyzeCommits(t *testing.T) {
 					BreakingChange: true,
 				},
 			},
-			expectedBump: conventionalcommits.MajorVersion,
-			wantErr:      assert.NoError,
+			wantErr: assert.NoError,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			analyzedCommits, versionBump, err := AnalyzeCommits(tt.commits)
+			analyzedCommits, err := NewConventionalCommitsParser().AnalyzeCommits(tt.commits)
 			if !tt.wantErr(t, err) {
 				return
 			}
 
 			assert.Equal(t, tt.expectedCommits, analyzedCommits)
-			assert.Equal(t, tt.expectedBump, versionBump)
 		})
 	}
 }
diff --git a/forge.go b/forge.go
index 8a3c9bb..99e65a3 100644
--- a/forge.go
+++ b/forge.go
@@ -308,7 +308,7 @@ func (g *GitHub) Changesets(ctx context.Context, commits []Commit) ([]Changeset,
 		log = log.With("pullrequest.id", pullrequest.GetID())
 
 		// TODO: Parse PR description for overrides
-		changelogEntries, _, err := AnalyzeCommits([]Commit{commit})
+		changelogEntries, err := NewConventionalCommitsParser().AnalyzeCommits([]Commit{commit})
 		if err != nil {
 			log.Warn("unable to parse changelog entries", "error", err)
 			continue