feat: inclusion, skip flag support

changes logcategory to handle unclassified(skipped) changes
and also adds skip support for each and flag to print any
combination of the skip and inclusion flag

Author: barelyhuman

logcategory.go

@@ -8,28 +8,48 @@ import (
 )
 
 // logContainer - Container of log strings
-type logContainer []string
+type logContainer struct {
+	include bool
+	commits []string
+}
 
 // logsByCategory - Type to hold logs by each's category
 // to be left as ALLCAPS to be considered as symbols instead of selectors
 type logsByCategory struct {
-	CI       logContainer
-	FIX      logContainer
-	REFACTOR logContainer
-	FEATURE  logContainer
-	DOCS     logContainer
-	CHORE    logContainer
-	TEST     logContainer
-	OTHER    logContainer
+	CI           logContainer
+	FIX          logContainer
+	REFACTOR     logContainer
+	FEATURE      logContainer
+	DOCS         logContainer
+	CHORE        logContainer
+	TEST         logContainer
+	OTHER        logContainer
+	UNCLASSIFIED logContainer
+}
+
+// Setup - Initialize all Log Containers
+func (logs logsByCategory) Setup() {
+	logs.CI.include = true
+	logs.FIX.include = true
+	logs.REFACTOR.include = true
+	logs.FEATURE.include = true
+	logs.DOCS.include = true
+	logs.CHORE.include = true
+	logs.TEST.include = true
+	logs.OTHER.include = true
+	logs.UNCLASSIFIED.include = true
 }
 
 // printLog - loops through the collected logs to write them to string builder
 func (logs logContainer) printLog(out *strings.Builder, title string, skipped bool) {
-	if len(logs) > 0 {
+	if !logs.include {
+		return
+	}
+	if len(logs.commits) > 0 {
 		if !skipped {
 			out.WriteString(fmt.Sprintf("\n\n## %s  \n", title))
 		}
-		for _, item := range logs {
+		for _, item := range logs.commits {
 			out.WriteString(item + "\n")
 		}
 	}
@@ -51,8 +71,68 @@ func (logs *logsByCategory) ToMarkdown(skipped bool) string {
 		logs.TEST.printLog(&markdownString, "Tests", skipped)
 		logs.OTHER.printLog(&markdownString, "Other Changes", skipped)
 	} else {
-		logs.OTHER.printLog(&markdownString, "Other Changes", skipped)
+		logs.UNCLASSIFIED.include = true
+		logs.UNCLASSIFIED.printLog(&markdownString, "Unclassified Changes", skipped)
 	}
 
 	return markdownString.String()
 }
+
+// AddCommit - Add a commit to the needed logContainer based on skip and include flag
+func (logs *logsByCategory) AddCommit(key, commitHash string, skip bool) {
+	var addCommitToContainer *logContainer
+	switch key {
+	case "ci":
+		if logs.CI.include && !skip {
+			addCommitToContainer = &logs.CI
+		} else if skip && logs.CI.include {
+			addCommitToContainer = &logs.UNCLASSIFIED
+		}
+	case "fix":
+		if logs.FIX.include && !skip {
+			addCommitToContainer = &logs.FIX
+		} else if skip && logs.FIX.include {
+			addCommitToContainer = &logs.UNCLASSIFIED
+		}
+	case "refactor":
+		if logs.REFACTOR.include && !skip {
+			addCommitToContainer = &logs.REFACTOR
+		} else if skip && logs.REFACTOR.include {
+			addCommitToContainer = &logs.UNCLASSIFIED
+		}
+	case "feat", "feature":
+		if logs.FEATURE.include && !skip {
+			addCommitToContainer = &logs.FEATURE
+		} else if skip && logs.FEATURE.include {
+			addCommitToContainer = &logs.UNCLASSIFIED
+		}
+	case "docs":
+		if logs.DOCS.include && !skip {
+			addCommitToContainer = &logs.DOCS
+		} else if skip && logs.DOCS.include {
+			addCommitToContainer = &logs.UNCLASSIFIED
+		}
+	case "test":
+		if logs.TEST.include && !skip {
+			addCommitToContainer = &logs.TEST
+		} else if skip && logs.TEST.include {
+			addCommitToContainer = &logs.UNCLASSIFIED
+		}
+	case "chore":
+		if logs.CHORE.include && !skip {
+			addCommitToContainer = &logs.CHORE
+		} else if skip && logs.CHORE.include {
+			addCommitToContainer = &logs.UNCLASSIFIED
+		}
+	default:
+		if logs.OTHER.include && !skip {
+			addCommitToContainer = &logs.OTHER
+		} else if skip && logs.OTHER.include {
+			addCommitToContainer = &logs.UNCLASSIFIED
+		}
+	}
+
+	if addCommitToContainer != nil {
+		addCommitToContainer.commits = append(addCommitToContainer.commits, commitHash)
+	}
+}

main.go

@@ -3,6 +3,7 @@
 package main
 
 import (
+	"bytes"
 	"flag"
 	"fmt"
 	"log"
@@ -18,11 +19,13 @@ type ErrMessage struct {
 	err     error
 }
 
+type commitTypeInclusions [][]byte
+
 func main() {
 	var repoPath = flag.String("p", ".", "path to the repository, points to the current working directory by default")
 	var startCommit = flag.String("s", "", "commit hash string start collecting commit messages from")
 	var endCommit = flag.String("e", "", "commit hash string to stop collecting commit message at")
-	var inclusionFlags = flag.String("i", "", "commit types to be includes, defaults to CI FIX REFACTOR FEATURE DOCS CHORE TEST OTHER")
+	var inclusionFlags = flag.String("i", "ci,docs,fix,feat,test,chore,other", "commit types to be includes, defaults to CI FIX REFACTOR FEATURE DOCS CHORE TEST OTHER")
 	var skipClassification = flag.Bool("skip", false, "if true will skip trying to classify and just give a list of changes")
 
 	flag.Parse()
@@ -76,32 +79,26 @@ func CommitLog(path string, startCommitString string, endCommitString string, in
 		return ErrMessage{"Error getting commits : ", err}
 	}
 
+	var inclusions commitTypeInclusions = bytes.SplitN([]byte(inclusionFlags), []byte(","), -1)
+
 	logContainer := logsByCategory{}
 
+	logContainer.Setup()
+
+	logContainer.CI.include = inclusions.checkInclusion("ci")
+	logContainer.FIX.include = inclusions.checkInclusion("fix")
+	logContainer.REFACTOR.include = inclusions.checkInclusion("refactor")
+	logContainer.FEATURE.include = inclusions.checkInclusion("feat")
+	logContainer.DOCS.include = inclusions.checkInclusion("docs")
+	logContainer.CHORE.include = inclusions.checkInclusion("chore")
+	logContainer.TEST.include = inclusions.checkInclusion("test")
+	logContainer.OTHER.include = inclusions.checkInclusion("other")
+
 	for _, c := range commits {
 		normalizedHash := c.Hash.String() + " - " + normalizeCommit(c.Message)
-		if !skipClassification {
-			switch strings.SplitN(strings.TrimSpace(c.Message), ":", 2)[0] {
-			case "ci":
-				logContainer.CI = append(logContainer.CI, normalizedHash)
-			case "fix":
-				logContainer.FIX = append(logContainer.FIX, normalizedHash)
-			case "refactor":
-				logContainer.REFACTOR = append(logContainer.REFACTOR, normalizedHash)
-			case "feat", "feature":
-				logContainer.FEATURE = append(logContainer.FEATURE, normalizedHash)
-			case "docs":
-				logContainer.DOCS = append(logContainer.DOCS, normalizedHash)
-			case "test":
-				logContainer.TEST = append(logContainer.TEST, normalizedHash)
-			case "chore":
-				logContainer.CHORE = append(logContainer.CHORE, normalizedHash)
-			default:
-				logContainer.OTHER = append(logContainer.OTHER, normalizedHash)
-			}
-		} else {
-			logContainer.OTHER = append(logContainer.OTHER, normalizedHash)
-		}
+		key := strings.SplitN(strings.TrimSpace(c.Message), ":", 2)[0]
+
+		logContainer.AddCommit(key, normalizedHash, skipClassification)
 
 		if endHash == nil && isCommitToNearestTag(currentRepository, c) {
 			break
@@ -113,3 +110,14 @@ func CommitLog(path string, startCommitString string, endCommitString string, in
 
 	return ErrMessage{}
 }
+
+func (inclusions *commitTypeInclusions) checkInclusion(flagToCheck string) bool {
+	if inclusions != nil {
+		for _, flag := range *inclusions {
+			if string(flag) == flagToCheck {
+				return true
+			}
+		}
+	}
+	return false
+}