feat: git change detection works on any commit

Author: snakster

cmd/terramate/cli/cli.go

@@ -588,9 +588,9 @@ func (c *cli) setupGit() {
 		}
 
 		if c.parsedArgs.GitChangeBase != "" {
-			c.prj.baseRef = c.parsedArgs.GitChangeBase
+			c.prj.baseRev = c.parsedArgs.GitChangeBase
 		} else {
-			c.prj.baseRef = c.prj.defaultBaseRef()
+			c.prj.baseRev, _ = c.prj.defaultBaseRev()
 		}
 	}
 }
@@ -712,7 +712,7 @@ func (c *cli) triggerStackByFilter() {
 		fatal(errors.E("trigger command expects either a stack path or the --experimental-status flag"))
 	}
 
-	mgr := stack.NewManager(c.cfg(), c.prj.baseRef)
+	mgr := stack.NewManager(c.cfg(), c.prj.baseRev)
 	status := parseStatusFilter(c.parsedArgs.Experimental.Trigger.ExperimentalStatus)
 	stacksReport, err := c.listStacks(mgr, false, status)
 	if err != nil {
@@ -1261,7 +1261,7 @@ func (c *cli) printStacks() {
 		log.Fatal().Msg("the --why flag must be used together with --changed")
 	}
 
-	mgr := stack.NewManager(c.cfg(), c.prj.baseRef)
+	mgr := stack.NewManager(c.cfg(), c.prj.baseRev)
 
 	status := parseStatusFilter(c.parsedArgs.List.ExperimentalStatus)
 	report, err := c.listStacks(mgr, c.parsedArgs.Changed, status)
@@ -1301,7 +1301,7 @@ func parseStatusFilter(strStatus string) cloudstack.FilterStatus {
 }
 
 func (c *cli) printRunEnv() {
-	mgr := stack.NewManager(c.cfg(), c.prj.baseRef)
+	mgr := stack.NewManager(c.cfg(), c.prj.baseRev)
 	report, err := c.listStacks(mgr, c.parsedArgs.Changed, cloudstack.NoFilter)
 	if err != nil {
 		fatal(err, "listing stacks")
@@ -1529,7 +1529,7 @@ func (c *cli) generateDebug() {
 }
 
 func (c *cli) printStacksGlobals() {
-	mgr := stack.NewManager(c.cfg(), c.prj.baseRef)
+	mgr := stack.NewManager(c.cfg(), c.prj.baseRev)
 	report, err := c.listStacks(mgr, c.parsedArgs.Changed, cloudstack.NoFilter)
 	if err != nil {
 		fatal(err, "listing stacks globals: listing stacks")
@@ -1563,7 +1563,7 @@ func (c *cli) printMetadata() {
 		Str("action", "cli.printMetadata()").
 		Logger()
 
-	mgr := stack.NewManager(c.cfg(), c.prj.baseRef)
+	mgr := stack.NewManager(c.cfg(), c.prj.baseRev)
 	report, err := c.listStacks(mgr, c.parsedArgs.Changed, cloudstack.NoFilter)
 	if err != nil {
 		fatal(err, "loading metadata: listing stacks")
@@ -1627,7 +1627,7 @@ func (c *cli) checkGenCode() bool {
 }
 
 func (c *cli) ensureStackID() {
-	mgr := stack.NewManager(c.cfg(), c.prj.baseRef)
+	mgr := stack.NewManager(c.cfg(), c.prj.baseRev)
 	report, err := c.listStacks(mgr, false, cloudstack.NoFilter)
 	if err != nil {
 		fatal(err, "listing stacks")
@@ -1872,7 +1872,7 @@ func (c *cli) friendlyFmtDir(dir string) (string, bool) {
 }
 
 func (c *cli) computeSelectedStacks(ensureCleanRepo bool) (config.List[*config.SortableStack], error) {
-	mgr := stack.NewManager(c.cfg(), c.prj.baseRef)
+	mgr := stack.NewManager(c.cfg(), c.prj.baseRev)
 
 	report, err := c.listStacks(mgr, c.parsedArgs.Changed, cloudstack.NoFilter)
 	if err != nil {

cmd/terramate/cli/project.go

@@ -20,7 +20,7 @@ type project struct {
 	wd             string
 	isRepo         bool
 	root           config.Root
-	baseRef        string
+	baseRev        string
 	normalizedRepo string
 
 	git struct {
@@ -59,25 +59,6 @@ func (p *project) prettyRepo() string {
 	return p.normalizedRepo
 }
 
-func (p *project) localDefaultBranchCommit() string {
-	if p.git.localDefaultBranchCommit != "" {
-		return p.git.localDefaultBranchCommit
-	}
-	logger := log.With().
-		Str("action", "localDefaultBranchCommit()").
-		Logger()
-
-	gitcfg := p.gitcfg()
-	refName := gitcfg.DefaultRemote + "/" + gitcfg.DefaultBranch
-	val, err := p.git.wrapper.RevParse(refName)
-	if err != nil {
-		logger.Fatal().Err(err).Send()
-	}
-
-	p.git.localDefaultBranchCommit = val
-	return val
-}
-
 func (p *project) headCommit() string {
 	if p.git.headCommit != "" {
 		return p.git.headCommit
@@ -119,35 +100,84 @@ func (p *project) remoteDefaultCommit() string {
 	return p.git.remoteDefaultBranchCommit
 }
 
-func (p *project) isDefaultBranch() bool {
-	git := p.gitcfg()
-	branch, err := p.git.wrapper.CurrentBranch()
-	if err != nil {
-		// WHY?
-		// The current branch name (the symbolic-ref of the HEAD) is not always
-		// available, in this case we naively check if HEAD == local origin/main.
-		// This case usually happens in the git setup of CIs.
-		return p.localDefaultBranchCommit() == p.headCommit()
+type baseRevMode int
+
+const (
+	pending baseRevMode = iota
+	deployed
+	historic
+)
+
+// defaultBaseRev returns the revision used for change comparison based on the current Git state.
+func (p *project) defaultBaseRev() (string, baseRevMode) {
+	// Details:
+	// Given origin/main is the default remote/branch, at commit C.
+	// We assume C is the state that ran the last deployment. HEAD is at commit H.
+	//
+	// There's three scenarios, selected if one of the respective cases match, evaluated in order of definition.
+	//
+	//   - Pending changes should be compared to origin/main to find out what has changed since the last deployment.
+	//
+	//     Case 1: H != C and H is not an ancestor of C -- an undeployed, unmerged commit
+	//     Case 2: H == C and symbolic-ref(HEAD) != main -- a new, yet empty branch (=> no changes yet)
+	//
+	//   - Deployed changes should be compared to the previous deployment to find out what changed.
+	//     If we assume that every commit on the main branch is a deployment, that means compare to HEAD^.
+	//
+	//     Case 3: H == C -- latest main commit
+	//     Case 4: H is a first-parent ancestor of main -- previous main commit
+	//
+	//   - Historic changes are all other non-deployed and non-pending, i.e. commits from an already merged and deployed branch.
+	//     They should be compared to the fork point with origin/main.
+	//
+	//     Case 5: H has a fork point with origin/main -- a merged branch commit
+	gitcfg := p.gitcfg()
+	gw := p.git.wrapper
+
+	remoteDefaultBranchRef := p.remoteDefaultBranchRef()
+	headRev, _ := gw.RevParse("HEAD")
+	remoteDefaultRev, _ := gw.RevParse(remoteDefaultBranchRef)
+
+	isRemoteDefaultRev := headRev != "" && headRev == remoteDefaultRev
+
+	isRemoteDefaultRevAncestor, _ := gw.IsAncestor("HEAD", remoteDefaultBranchRef)
+	if !isRemoteDefaultRev && !isRemoteDefaultRevAncestor {
+		// Case 1 (pending)
+		return remoteDefaultBranchRef, pending
 	}
 
-	return branch == git.DefaultBranch
-}
+	branch, _ := gw.CurrentBranch()
+	isBranchRef := branch != ""
+	isDefaultBranch := isBranchRef && branch == gitcfg.DefaultBranch
+	isEmptyPendingBranch := isBranchRef && isRemoteDefaultRev && !isDefaultBranch
 
-// defaultBaseRef returns the baseRef for the current git environment.
-func (p *project) defaultBaseRef() string {
-	git := p.gitcfg()
-	if p.isDefaultBranch() &&
-		p.remoteDefaultCommit() == p.headCommit() {
-		_, err := p.git.wrapper.RevParse(git.DefaultBranchBaseRef)
-		if err == nil {
-			return git.DefaultBranchBaseRef
-		}
+	if isEmptyPendingBranch {
+		// Case 2 (pending)
+		return remoteDefaultBranchRef, pending
+	}
+
+	if isRemoteDefaultRev {
+		// Case 3 (deployed)
+		return gitcfg.DefaultBranchBaseRef, deployed
+	}
+
+	isRemoteDefaultBranchAncestor, _ := gw.IsFirstParentAncestor("HEAD", remoteDefaultBranchRef)
+	if isRemoteDefaultBranchAncestor {
+		// Case 4 (deployed)
+		return gitcfg.DefaultBranchBaseRef, deployed
+	}
+
+	forkPoint, _ := gw.FindForkPoint(remoteDefaultBranchRef, "HEAD")
+	if forkPoint != "" {
+		// Case 5 (historic)
+		return forkPoint, historic
 	}
 
-	return p.defaultBranchRef()
+	// Fallback to pending strategy
+	return remoteDefaultBranchRef, pending
 }
 
-func (p project) defaultBranchRef() string {
+func (p project) remoteDefaultBranchRef() string {
 	git := p.gitcfg()
 	return git.DefaultRemote + "/" + git.DefaultBranch
 }