feat: monorepo configuration now support multiple paths, also added several refactors.

Among the refactors:
- Configuration is now single-handedly handled using
  appcontext.AppContext (Viper/Cobra populate the appcontext.AppContext
  which is used as a source of truth)
- Code readability improvements (use of constants throughout the code,
  octal permissions, etc.)

Author: s0ders

cmd/release.go

@@ -3,6 +3,7 @@ package cmd
 import (
 	"bytes"
 	"context"
+	"encoding/json"
 	"fmt"
 	"os"
 
@@ -11,7 +12,6 @@ import (
 	"github.com/spf13/cobra"
 
 	"github.com/s0ders/go-semver-release/v6/internal/appcontext"
-	"github.com/s0ders/go-semver-release/v6/internal/branch"
 	"github.com/s0ders/go-semver-release/v6/internal/ci"
 	"github.com/s0ders/go-semver-release/v6/internal/gpg"
 	"github.com/s0ders/go-semver-release/v6/internal/parser"
@@ -20,6 +20,12 @@ import (
 	"github.com/s0ders/go-semver-release/v6/internal/tag"
 )
 
+const (
+	MessageDryRun       string = "dry-run enabled, next release found"
+	MessageNewRelease   string = "new release found"
+	MessageNoNewRelease string = "no new release"
+)
+
 func NewReleaseCmd(ctx *appcontext.AppContext) *cobra.Command {
 	releaseCmd := &cobra.Command{
 		Use:   "release <REPOSITORY_PATH_OR_URL>",
@@ -37,14 +43,17 @@ func NewReleaseCmd(ctx *appcontext.AppContext) *cobra.Command {
 				return fmt.Errorf("configuring GPG key: %w", err)
 			}
 
-			ctx.Rules, err = configureRules(ctx)
-			if err != nil {
-				return fmt.Errorf("loading rules configuration: %w", err)
-			}
+			if ctx.RulesCfg.String() == "{}" {
+				ctx.Logger.Debug().Msg("no rules configuration provided, using default release rules")
 
-			ctx.Branches, err = configureBranches(ctx)
-			if err != nil {
-				return fmt.Errorf("loading branches configuration: %w", err)
+				b, err := json.Marshal(rule.Default)
+				if err != nil {
+					return fmt.Errorf("marshalling default rules: %w", err)
+				}
+
+				if err = ctx.RulesCfg.Set(string(b)); err != nil {
+					return fmt.Errorf("setting default rules flag: %w", err)
+				}
 			}
 
 			origin = remote.New(ctx.RemoteName, ctx.AccessToken)
@@ -69,7 +78,7 @@ func NewReleaseCmd(ctx *appcontext.AppContext) *cobra.Command {
 
 				err = ci.GenerateGitHubOutput(semver, output.Branch, ci.WithNewRelease(release), ci.WithTagPrefix(ctx.TagPrefix), ci.WithProject(project))
 				if err != nil {
-					return fmt.Errorf("generating github output: %w", err)
+					return fmt.Errorf("generating GitHub output: %w", err)
 				}
 
 				logEvent := ctx.Logger.Info()
@@ -85,11 +94,11 @@ func NewReleaseCmd(ctx *appcontext.AppContext) *cobra.Command {
 
 				switch {
 				case !release:
-					logEvent.Msg("no new release")
+					logEvent.Msg(MessageNoNewRelease)
 				case release && ctx.DryRun:
-					logEvent.Msg("dry-run enabled, next release found")
+					logEvent.Msg(MessageDryRun)
 				default:
-					logEvent.Msg("new release found")
+					logEvent.Msg(MessageNewRelease)
 
 					err = tagger.TagRepository(repository, semver, commitHash)
 					if err != nil {
@@ -112,34 +121,6 @@ func NewReleaseCmd(ctx *appcontext.AppContext) *cobra.Command {
 	return releaseCmd
 }
 
-func configureRules(ctx *appcontext.AppContext) (rule.Rules, error) {
-	flag := ctx.RulesFlag
-
-	if flag.String() == "{}" {
-		return rule.Default, nil
-	}
-
-	rulesJSON := map[string][]string(flag)
-
-	unmarshalledRules, err := rule.Unmarshall(rulesJSON)
-	if err != nil {
-		return unmarshalledRules, fmt.Errorf("parsing rules configuration: %w", err)
-	}
-
-	return unmarshalledRules, nil
-}
-
-func configureBranches(ctx *appcontext.AppContext) ([]branch.Branch, error) {
-	branchesJSON := []map[string]any(ctx.BranchesFlag)
-
-	unmarshalledBranches, err := branch.Unmarshall(branchesJSON)
-	if err != nil {
-		return nil, fmt.Errorf("parsing branches configuration: %w", err)
-	}
-
-	return unmarshalledBranches, nil
-}
-
 func configureGPGKey(ctx *appcontext.AppContext) (*openpgp.Entity, error) {
 	flag := ctx.GPGKeyPath
 

cmd/release_test.go

@@ -15,9 +15,7 @@ import (
 	assertion "github.com/stretchr/testify/assert"
 
 	"github.com/s0ders/go-semver-release/v6/internal/appcontext"
-	"github.com/s0ders/go-semver-release/v6/internal/branch"
 	"github.com/s0ders/go-semver-release/v6/internal/gittest"
-	"github.com/s0ders/go-semver-release/v6/internal/rule"
 	"github.com/s0ders/go-semver-release/v6/internal/tag"
 )
 
@@ -48,13 +46,15 @@ func TestReleaseCmd_ConfigurationAsEnvironmentVariable(t *testing.T) {
 	assert.Equal(accessToken, th.Ctx.AccessToken, "access token flag value should be equal to environment variable value")
 }
 
+// TODO: add monorepo config key
+
 func TestReleaseCmd_ConfigurationAsFile(t *testing.T) {
 	assert := assertion.New(t)
 
 	taggerName := "My CI Robot"
 	taggerEmail := "my-robot@release.ci"
 
-	// Create configuration file
+	// Create a configuration file
 	cfgContent := []byte(`
 git-name: ` + taggerName + `
 git-email: ` + taggerEmail + `
@@ -85,7 +85,7 @@ rules:
 	err = os.WriteFile(cfgFilePath, cfgContent, 0o644)
 	checkErr(t, err, "writing configuration file")
 
-	// Create test repository
+	// Create a test repository
 	masterCommits := []string{
 		"fix",      // 0.0.1
 		"feat!",    // 1.0.0 (breaking change)
@@ -855,45 +855,87 @@ func TestReleaseCmd_Monorepo_MixedRelease(t *testing.T) {
 	assert.Equal(len(expectedOutputs), i)
 }
 
-func TestReleaseCmd_ConfigureRules_DefaultRules(t *testing.T) {
+func TestReleaseCmd_Monorepo_ProjectWithPaths(t *testing.T) {
 	assert := assertion.New(t)
-	ctx := appcontext.New()
 
-	rules, err := configureRules(ctx)
-	checkErr(t, err, "configuring rules")
+	testRepository, err := gittest.NewRepository()
+	checkErr(t, err, "creating sample repository")
 
-	assert.Equal(rule.Default, rules)
-}
+	defer func() {
+		err = testRepository.Remove()
+		checkErr(t, err, "removing repository")
+	}()
 
-func TestReleaseCmd_ConfigureBranches_NoBranches(t *testing.T) {
-	assert := assertion.New(t)
-	ctx := appcontext.New()
+	// "bar" commits, "foo" has no applicable commits
+	_, err = testRepository.AddCommitWithSpecificFile("feat!", "./bar/foo.txt")
+	checkErr(t, err, "adding commit")
+	_, err = testRepository.AddCommitWithSpecificFile("fix", "./bar2/foo2.txt")
+	checkErr(t, err, "adding commit")
+	_, err = testRepository.AddCommitWithSpecificFile("fix", "./bar2/foo2.txt")
+	checkErr(t, err, "adding commit")
 
-	_, err := configureBranches(ctx)
-	assert.ErrorIs(err, branch.ErrNoBranch)
-}
+	th := NewTestHelper(t)
+	err = th.SetFlags(map[string]string{
+		BranchesConfiguration: `[{"name": "master"}]`,
+		MonorepoConfiguration: `[{"name": "bar", "paths": ["bar", "bar2"]}]`,
+	})
+	checkErr(t, err, "setting flags")
 
-func TestReleaseCmd_InvalidCustomRules(t *testing.T) {
-	assert := assertion.New(t)
-	ctx := appcontext.New()
+	out, err := th.ExecuteCommand("release", testRepository.Path)
+	checkErr(t, err, "executing command")
 
-	ctx.RulesFlag = map[string][]string{
-		"minor": {"feat"},
-		"patch": {"feat"},
+	i := 0
+	expectedOutputs := []cmdOutput{
+		{
+			Message:    "new release found",
+			Version:    "1.0.2",
+			NewRelease: true,
+			Branch:     "master",
+			Project:    "bar",
+		},
 	}
 
-	_, err := configureRules(ctx)
-	assert.ErrorIs(err, rule.ErrDuplicateReleaseRule, "should have failed parsing invalid custom rule")
+	scanner := bufio.NewScanner(bytes.NewReader(out))
+
+	for scanner.Scan() {
+		rawOutput := scanner.Bytes()
+
+		actualOutput := cmdOutput{}
+
+		err = json.Unmarshal(rawOutput, &actualOutput)
+		checkErr(t, err, "unmarshalling output")
+
+		assert.Equal(expectedOutputs[i], actualOutput)
+		i++
+	}
+	err = scanner.Err()
+	checkErr(t, err, "scanning error")
+	assert.Equal(len(expectedOutputs), i)
 }
 
-func TestReleaseCmd_InvalidBranch(t *testing.T) {
+func TestReleaseCmd_Monorepo_ExclusivePathAndPaths(t *testing.T) {
 	assert := assertion.New(t)
-	ctx := appcontext.New()
 
-	ctx.BranchesFlag = []map[string]any{{"prerelease": true}}
+	testRepository, err := gittest.NewRepository()
+	checkErr(t, err, "creating sample repository")
+
+	defer func() {
+		err = testRepository.Remove()
+		checkErr(t, err, "removing repository")
+	}()
+
+	// "bar" commits, "foo" has no applicable commits
+	_, err = testRepository.AddCommitWithSpecificFile("feat!", "./bar/foo.txt")
+	checkErr(t, err, "adding commit")
+
+	th := NewTestHelper(t)
+	err = th.SetFlags(map[string]string{
+		BranchesConfiguration: `[{"name": "master"}]`,
+		MonorepoConfiguration: `[{"name": "bar", "path": "bar", "paths": ["./bar/", "./bar2/"]}]`,
+	})
 
-	_, err := configureBranches(ctx)
-	assert.ErrorIs(err, branch.ErrNoName, "should have failed parsing branch with no name")
+	// TODO: refine to target specific monorepo.ErrExlusive...
+	assert.Error(err, "should have failed trying to set exclusive path and paths")
 }
 
 func TestReleaseCmd_InvalidArmoredKeyPath(t *testing.T) {

cmd/root.go

@@ -54,16 +54,16 @@ func NewRootCommand(ctx *appcontext.AppContext) *cobra.Command {
 	}
 
 	rootCmd.PersistentFlags().StringVar(&ctx.AccessToken, AccessTokenConfiguration, "", "Access token used to push tag to Git remote")
-	rootCmd.PersistentFlags().VarP(&ctx.BranchesFlag, BranchesConfiguration, "b", "An array of branches such as [{\"name\": \"main\"}, {\"name\": \"rc\", \"prerelease\": true}]")
-	rootCmd.PersistentFlags().StringVar(&ctx.BuildMetadata, BuildMetadataConfiguration, "", "Build metadata (e.g. build number) that will be appended to the SemVer")
+	rootCmd.PersistentFlags().VarP(&ctx.BranchesCfg, BranchesConfiguration, "b", "An array of branches configuration such as [{\"name\": \"main\"}, {\"name\": \"rc\", \"prerelease\": true}]")
+	rootCmd.PersistentFlags().StringVar(&ctx.BuildMetadata, BuildMetadataConfiguration, "", "Build metadata that will be appended to the SemVer")
 	rootCmd.PersistentFlags().StringVar(&ctx.CfgFile, "config", "", "Configuration file path (default \"./"+defaultConfigFile+"."+configFileFormat+"\")")
 	rootCmd.PersistentFlags().BoolVarP(&ctx.DryRun, DryRunConfiguration, "d", false, "Only compute the next SemVer, do not push any tag")
 	rootCmd.PersistentFlags().StringVar(&ctx.GitEmail, GitEmailConfiguration, "go-semver@release.ci", "Email used in semantic version tags")
-	rootCmd.PersistentFlags().StringVar(&ctx.GitName, GitNameConfiguration, "Go Semver Release", "Name used in semantic version tags")
-	rootCmd.PersistentFlags().StringVar(&ctx.GPGKeyPath, GPGPathConfiguration, "", "Path to an armored GPG key used to sign produced tags")
-	rootCmd.PersistentFlags().Var(&ctx.MonorepositoryCfg, MonorepoConfiguration, "An array of branches such as [{\"name\": \"foo\", \"path\": \"./foo/\"}]")
+	rootCmd.PersistentFlags().StringVar(&ctx.GitName, GitNameConfiguration, "Go Semver Release", "Name used in semantic version Git tags")
+	rootCmd.PersistentFlags().StringVar(&ctx.GPGKeyPath, GPGPathConfiguration, "", "Path to an armored GPG key used to sign produced Git tags")
+	rootCmd.PersistentFlags().Var(&ctx.MonorepositoryCfg, MonorepoConfiguration, "An array of monorepository configuration such as [{\"name\": \"foo\", \"path\": \"./foo/\"}]")
 	rootCmd.PersistentFlags().StringVar(&ctx.RemoteName, RemoteNameConfiguration, "origin", "Name of the Git repository remote")
-	rootCmd.PersistentFlags().Var(&ctx.RulesFlag, RulesConfiguration, "A hashmap of array such as {\"minor\": [\"feat\"], \"patch\": [\"fix\", \"perf\"]} ]")
+	rootCmd.PersistentFlags().Var(&ctx.RulesCfg, RulesConfiguration, "A hashmap of array such as {\"minor\": [\"feat\"], \"patch\": [\"fix\", \"perf\"]} ]")
 	rootCmd.PersistentFlags().StringVar(&ctx.TagPrefix, TagPrefixConfiguration, "v", "Prefix added to the version tag name")
 	rootCmd.PersistentFlags().BoolVarP(&ctx.Verbose, "verbose", "v", false, "Verbose output")
 
@@ -76,6 +76,13 @@ func NewRootCommand(ctx *appcontext.AppContext) *cobra.Command {
 	return rootCmd
 }
 
+// initializeConfig manages how the configuration variables of the application are initialized.
+// It loads configuration with the following order of precedence:
+// (1) command line flags, (2) environment variables, (3) viper configuration file.
+// The key point to understand how configuration management is handled throughout this application is that everything
+// ends up being mapped to the variable inside appcontext.AppContext that are either populated by Cobra using CLI flag
+// values, or by Viper using configuration file or environment variables. Viper is only used to bind flags and
+// configuration file values.
 func initializeConfig(cmd *cobra.Command, ctx *appcontext.AppContext) error {
 	if ctx.CfgFile != "" {
 		ctx.Viper.SetConfigFile(ctx.CfgFile)

internal/appcontext/app_context.go

@@ -15,11 +15,9 @@ import (
 
 type AppContext struct {
 	Viper             *viper.Viper
-	Branches          []branch.Branch
-	Rules             rule.Rules
-	BranchesFlag      branch.Flag
+	BranchesCfg       branch.Flag
 	MonorepositoryCfg monorepo.Flag
-	RulesFlag         rule.Flag
+	RulesCfg          rule.Flag
 	Logger            zerolog.Logger
 	CfgFile           string
 	GitName           string

internal/branch/branch.go

@@ -3,53 +3,18 @@ package branch
 
 import (
 	"errors"
-	"fmt"
 )
 
+type Config struct {
+	Items []Item `yaml:"branches" mapstructure:"branches"`
+}
+
+type Item struct {
+	Name       string `yaml:"name" json:"name" mapstructure:"name"`
+	Prerelease bool   `yaml:"prerelease" json:"prerelease" mapstructure:"prerelease"`
+}
+
 var (
 	ErrNoBranch = errors.New("no branch configuration")
 	ErrNoName   = errors.New("no name in branch configuration")
 )
-
-type Branch struct {
-	Name       string
-	Prerelease bool
-}
-
-// Unmarshall takes a raw Viper configuration and returns a slice of Branch representing a branch configuration.
-func Unmarshall(input []map[string]any) ([]Branch, error) {
-	if len(input) == 0 {
-		return nil, ErrNoBranch
-	}
-
-	branches := make([]Branch, len(input))
-
-	for i, b := range input {
-
-		name, ok := b["name"]
-		if !ok {
-			return nil, ErrNoName
-		}
-
-		stringName, ok := name.(string)
-		if !ok {
-			return nil, fmt.Errorf("could not assert that the \"name\" property of the branch configuration is a string")
-		}
-
-		branch := Branch{Name: stringName}
-
-		prerelease, ok := b["prerelease"]
-		if ok {
-			boolPrerelease, ok := prerelease.(bool)
-			if !ok {
-				return nil, fmt.Errorf("could not assert that the \"prerelease\" property of the branch configuration is a bool")
-			}
-
-			branch.Prerelease = boolPrerelease
-		}
-
-		branches[i] = branch
-	}
-
-	return branches, nil
-}