chore: release v0.1.6

Author: anirbanfaith

analyze.go

@@ -15,6 +15,11 @@ type analysis struct {
 	commitType    string
 	addedFuncs    []string
 	removedFuncs  []string
+	renamedFuncs  [][2]string
+	addedVars     []string
+	removedVars   []string
+	renamedFiles  [][2]string
+	branchHint    string
 	patterns      []string
 	isMigration   bool
 	isDepUpdate   bool
@@ -23,6 +28,7 @@ type analysis struct {
 	isConfigOnly  bool
 	isDeleteOnly  bool
 	isNewFiles    bool
+	isRenameOnly  bool
 }
 
 var (
@@ -67,6 +73,13 @@ var (
 	reRmFuncPy = regexp.MustCompile(`^-def\s+(\w+)\s*\(`)
 	reRmFuncRs = regexp.MustCompile(`^-(?:pub\s+)?fn\s+(\w+)\s*[<(]`)
 
+	reVarGoAdd = regexp.MustCompile(`^\+(?:var|const)\s+(\w{2,})\b`)
+	reVarGoRm  = regexp.MustCompile(`^-(?:var|const)\s+(\w{2,})\b`)
+	reVarJSAdd = regexp.MustCompile(`^\+(?:const|let|var)\s+(\w{2,})\s*[=;]`)
+	reVarJSRm  = regexp.MustCompile(`^-(?:const|let|var)\s+(\w{2,})\s*[=;]`)
+	reVarPyAdd = regexp.MustCompile(`^\+([A-Z][A-Z0-9_]{2,})\s*=`)
+	reVarPyRm  = regexp.MustCompile(`^-([A-Z][A-Z0-9_]{2,})\s*=`)
+
 	reErrorHandling = regexp.MustCompile(`^\+.*(?:err|error|Error|exception|Exception|catch|rescue)\b`)
 	reLogging       = regexp.MustCompile(`^\+.*(?:log\.|logger\.|console\.log|fmt\.Print|println!|logging\.)`)
 	reRmLogging     = regexp.MustCompile(`^-.*(?:console\.log|fmt\.Print|println!|log\.Debug)`)
@@ -75,13 +88,19 @@ var (
 )
 
 func analyzeDiff(diff string) analysis {
+	return analyzeDiffWithBranch(diff, "")
+}
+
+func analyzeDiffWithBranch(diff string, branch string) analysis {
 	a := analysis{}
+	a.branchHint = branch
 
 	lines := strings.Split(diff, "\n")
 	currentFile := ""
 	isDeleted := false
 	isNew := false
 	isRename := false
+	renameFrom := ""
 
 	for _, line := range lines {
 		if strings.HasPrefix(line, "deleted file mode") {
@@ -105,33 +124,36 @@ func analyzeDiff(diff string) analysis {
 			isDeleted = false
 			isNew = false
 			isRename = false
+			renameFrom = ""
 			currentFile = parseDiffGitPath(line)
 			continue
 		}
 
-		if strings.HasPrefix(line, "rename to ") {
-			isRename = true
-			path := strings.TrimPrefix(line, "rename to ")
-			path = strings.TrimSpace(path)
-			a.filesModified = appendUnique(a.filesModified, path)
-			currentFile = path
+		if strings.HasPrefix(line, "rename from ") {
+			renameFrom = strings.TrimSpace(strings.TrimPrefix(line, "rename from "))
 			continue
 		}
-		if strings.HasPrefix(line, "rename from ") {
+
+		if strings.HasPrefix(line, "rename to ") {
+			isRename = true
+			renameTo := strings.TrimSpace(strings.TrimPrefix(line, "rename to "))
+			a.filesModified = appendUnique(a.filesModified, renameTo)
+			if renameFrom != "" {
+				a.renamedFiles = append(a.renamedFiles, [2]string{renameFrom, renameTo})
+			}
+			currentFile = renameTo
 			continue
 		}
 
 		if strings.HasPrefix(line, "--- a/") && isDeleted {
-			path := strings.TrimPrefix(line, "--- a/")
-			path = strings.TrimSpace(path)
+			path := strings.TrimSpace(strings.TrimPrefix(line, "--- a/"))
 			a.filesDeleted = appendUnique(a.filesDeleted, path)
 			currentFile = path
 			continue
 		}
 
 		if strings.HasPrefix(line, "+++ b/") {
-			currentFile = strings.TrimPrefix(line, "+++ b/")
-			currentFile = strings.TrimSpace(currentFile)
+			currentFile = strings.TrimSpace(strings.TrimPrefix(line, "+++ b/"))
 			if isDeleted || isRename {
 				continue
 			}
@@ -161,6 +183,13 @@ func analyzeDiff(diff string) analysis {
 			a.removedFuncs = appendUnique(a.removedFuncs, funcs)
 		}
 
+		if v := extractVarName(line, currentFile, true); v != "" {
+			a.addedVars = appendUnique(a.addedVars, v)
+		}
+		if v := extractVarName(line, currentFile, false); v != "" {
+			a.removedVars = appendUnique(a.removedVars, v)
+		}
+
 		if reErrorHandling.MatchString(line) {
 			a.patterns = appendUnique(a.patterns, "error-handling")
 		}
@@ -186,12 +215,19 @@ func analyzeDiff(diff string) analysis {
 		a.filesDeleted = appendUnique(a.filesDeleted, currentFile)
 	}
 
+	detectRenamedFuncs(&a)
+
 	a.filesChanged = len(a.filesAdded) + len(a.filesDeleted) + len(a.filesModified)
 
 	if len(a.filesDeleted) > 0 && len(a.filesAdded) == 0 && len(a.filesModified) == 0 {
 		a.isDeleteOnly = true
 	}
 
+	if len(a.renamedFiles) > 0 && len(a.filesAdded) == 0 && len(a.filesDeleted) == 0 &&
+		len(a.addedFuncs) == 0 && len(a.removedFuncs) == 0 {
+		a.isRenameOnly = true
+	}
+
 	a.primaryScope = inferScope(a)
 	a.commitType = inferType(a)
 
@@ -243,6 +279,74 @@ func categorizeFile(a *analysis, path string) {
 	a.isConfigOnly = false
 }
 
+func extractVarName(line, file string, added bool) string {
+	ext := strings.ToLower(filepath.Ext(file))
+	var re *regexp.Regexp
+
+	if added {
+		switch ext {
+		case ".go":
+			re = reVarGoAdd
+		case ".js", ".ts", ".jsx", ".tsx":
+			re = reVarJSAdd
+		case ".py":
+			re = reVarPyAdd
+		}
+	} else {
+		switch ext {
+		case ".go":
+			re = reVarGoRm
+		case ".js", ".ts", ".jsx", ".tsx":
+			re = reVarJSRm
+		case ".py":
+			re = reVarPyRm
+		}
+	}
+
+	if re == nil {
+		return ""
+	}
+	if m := re.FindStringSubmatch(line); len(m) > 1 {
+		name := m[1]
+		if len(name) <= 1 {
+			return ""
+		}
+		return name
+	}
+	return ""
+}
+
+func detectRenamedFuncs(a *analysis) {
+	if len(a.addedFuncs) == 0 || len(a.removedFuncs) == 0 {
+		return
+	}
+	used := map[string]bool{}
+	for _, added := range a.addedFuncs {
+		for _, removed := range a.removedFuncs {
+			if used[removed] {
+				continue
+			}
+			if isSimilarName(removed, added) {
+				a.renamedFuncs = append(a.renamedFuncs, [2]string{removed, added})
+				used[removed] = true
+				break
+			}
+		}
+	}
+}
+
+func isSimilarName(a, b string) bool {
+	al := strings.ToLower(a)
+	bl := strings.ToLower(b)
+	if strings.Contains(al, bl) || strings.Contains(bl, al) {
+		return true
+	}
+	if len(al) > 3 && len(bl) > 3 && al[:3] == bl[:3] {
+		return true
+	}
+	return false
+}
+
 func extractFuncName(line, file string, added bool) string {
 	ext := strings.ToLower(filepath.Ext(file))
 	var patterns []*regexp.Regexp
@@ -332,6 +436,28 @@ func inferScope(a analysis) string {
 }
 
 func inferType(a analysis) string {
+	if a.branchHint != "" {
+		hint := strings.ToLower(a.branchHint)
+		if strings.HasPrefix(hint, "fix/") || strings.HasPrefix(hint, "bugfix/") || strings.HasPrefix(hint, "hotfix/") {
+			return "fix"
+		}
+		if strings.HasPrefix(hint, "feat/") || strings.HasPrefix(hint, "feature/") {
+			return "feat"
+		}
+		if strings.HasPrefix(hint, "docs/") {
+			return "docs"
+		}
+		if strings.HasPrefix(hint, "refactor/") || strings.HasPrefix(hint, "chore/") {
+			return "refactor"
+		}
+		if strings.HasPrefix(hint, "test/") {
+			return "test"
+		}
+	}
+
+	if a.isRenameOnly {
+		return "refactor"
+	}
 	if a.isDeleteOnly {
 		return "chore"
 	}
@@ -356,6 +482,9 @@ func inferType(a analysis) string {
 	if contains(a.patterns, "remove-debug-logs") && len(a.filesModified) <= 3 {
 		return "chore"
 	}
+	if len(a.renamedFuncs) > 0 && len(a.addedFuncs) == len(a.renamedFuncs) {
+		return "refactor"
+	}
 	if len(a.addedFuncs) > 0 && len(a.removedFuncs) == 0 {
 		return "feat"
 	}

branch.go

@@ -15,13 +15,11 @@ func runBranch() {
 
 	args := os.Args[2:]
 	if len(args) == 0 {
-		runBranchSwitch()
+		runBranchMenu()
 		return
 	}
 
 	switch args[0] {
-	case "switch", "sw":
-		runBranchSwitch()
 	case "create", "new":
 		runBranchCreate()
 	case "ls", "list":
@@ -30,11 +28,42 @@ func runBranch() {
 		runBranchDelete()
 	default:
 		fmt.Fprintf(os.Stderr, "  unknown branch command: %s\n", args[0])
-		fmt.Fprintf(os.Stderr, "  usage: commitdog branch [switch|create|ls|delete]\n")
+		fmt.Fprintf(os.Stderr, "  usage: commitdog branch [create|ls|delete]\n")
 		os.Exit(1)
 	}
 }
 
+func runBranchMenu() {
+	fmt.Println()
+	fmt.Println("  branch:")
+	fmt.Println()
+	fmt.Println("  1  switch")
+	fmt.Println("  2  create new")
+	fmt.Println("  3  delete")
+	fmt.Println()
+	fmt.Printf("  [1-3] pick, [q] quit › ")
+
+	for {
+		input := readLine()
+		switch input {
+		case "1":
+			runBranchSwitch()
+			return
+		case "2":
+			runBranchCreate()
+			return
+		case "3":
+			runBranchDelete()
+			return
+		case "q", "quit", "exit":
+			fmt.Println("  aborted.")
+			return
+		default:
+			fmt.Printf("  1, 2, 3, or q › ")
+		}
+	}
+}
+
 func runBranchSwitch() {
 	all, err := getAllBranches()
 	if err != nil {
@@ -147,23 +176,77 @@ func askBranchName(all []string, current string) string {
 
 func runBranchCreate() {
 	fmt.Println()
-	fmt.Printf("  new branch name › ")
 
-	name := ""
-	for {
-		input := strings.TrimSpace(readLine())
-		if input == "" {
-			fmt.Printf("  name cannot be empty › ")
-			continue
+	var suggestions []string
+	diff, err := getStagedDiff()
+	if err == nil && diff != "" {
+		a := analyzeDiffWithBranch(diff, getCurrentBranch())
+		suggestions = generateBranchNameSuggestions(a)
+	}
+
+	if len(suggestions) > 0 {
+		fmt.Println("  suggested branch names:")
+		fmt.Println()
+		for i, s := range suggestions {
+			fmt.Printf("  %d  %s\n", i+1, s)
 		}
-		if !isSafeGitRef(input) {
-			fmt.Printf("  invalid branch name (use letters, numbers, - _ /) › ")
-			continue
+		fmt.Println()
+		fmt.Printf("  [1-%d] pick, [e] enter name › ", len(suggestions))
+
+		input := readLine()
+		picked := false
+		name := ""
+		for i, s := range suggestions {
+			if input == fmt.Sprintf("%d", i+1) {
+				name = s
+				picked = true
+				break
+			}
 		}
-		name = input
-		break
+		if !picked {
+			fmt.Printf("  new branch name › ")
+			for {
+				var raw string
+				if input != "e" && input != "" {
+					raw = input
+					input = ""
+				} else {
+					raw = strings.TrimSpace(readLine())
+				}
+				if raw == "" {
+					fmt.Printf("  name cannot be empty › ")
+					continue
+				}
+				if !isSafeGitRef(raw) {
+					fmt.Printf("  invalid branch name (use letters, numbers, - _ /) › ")
+					continue
+				}
+				name = raw
+				break
+			}
+		}
+		doCreateBranch(name)
+	} else {
+		fmt.Printf("  new branch name › ")
+		name := ""
+		for {
+			input := strings.TrimSpace(readLine())
+			if input == "" {
+				fmt.Printf("  name cannot be empty › ")
+				continue
+			}
+			if !isSafeGitRef(input) {
+				fmt.Printf("  invalid branch name (use letters, numbers, - _ /) › ")
+				continue
+			}
+			name = input
+			break
+		}
+		doCreateBranch(name)
 	}
+}
 
+func doCreateBranch(name string) {
 	current := getCurrentBranch()
 	fmt.Printf("  base branch? [enter = %s] › ", current)
 	base := strings.TrimSpace(readLine())