feat: Iniital commit with pre-commit integrated

main.go

@@ -10,15 +10,18 @@ import (
 	"regexp"
 )
 
-const CHANNEL_BUFFERING = 10
+// ChannelBuffering is the size of file processing results queue
+const ChannelBuffering = 10
 
+// FileMatchData contains grep results
 type FileMatchData struct {
 	Path        string
 	LineIndexes []int
 	Lines       []string
 }
 
-func ProcessSingleFile(re_pattern regexp.Regexp, path string, out chan FileMatchData) error {
+// ProcessSingleFile processes file and send it Result to channel
+func ProcessSingleFile(rePattern regexp.Regexp, path string, out chan FileMatchData) {
 	file, err := os.Open(path)
 	if err != nil {
 		log.Fatal(err)
@@ -28,45 +31,44 @@ func ProcessSingleFile(re_pattern regexp.Regexp, path string, out chan FileMatch
 	res := FileMatchData{Path: path, LineIndexes: make([]int, 0), Lines: make([]string, 0)}
 	scanner := bufio.NewScanner(file)
 	// optionally, resize scanner's capacity for lines over 64K, see next example
-	cur_line_ind := 1
+	curLineInd := 1
 	for scanner.Scan() {
-		line_text := scanner.Text()
-		if re_pattern.FindString(line_text) != "" {
-			res.LineIndexes = append(res.LineIndexes, cur_line_ind)
-			res.Lines = append(res.Lines, line_text)
+		lineText := scanner.Text()
+		if rePattern.FindString(lineText) != "" {
+			res.LineIndexes = append(res.LineIndexes, curLineInd)
+			res.Lines = append(res.Lines, lineText)
 		}
-		cur_line_ind++
+		curLineInd++
 	}
 
 	if err := scanner.Err(); err != nil {
-		log.Fatal(err)
+		fmt.Printf("Error %v with file %v\n", err, path)
 	}
 	out <- res
-	return nil
 }
 
 func main() {
-	path_pattern := "git/hook"
-	re_path_pattern, err := regexp.Compile(path_pattern)
+	pathPattern := "git/hook"
+	rePathPattern, err := regexp.Compile(pathPattern)
 	if err != nil {
-		fmt.Printf("Unable to compile path pattern Regexp: %v\n", path_pattern)
+		fmt.Printf("Unable to compile path pattern Regexp: %v\n", pathPattern)
 		return
 	}
 
-	text_pattern := "the commit"
-	re_text_pattern, err := regexp.Compile(text_pattern)
+	textPattern := "the commit"
+	reTextPattern, err := regexp.Compile(textPattern)
 	if err != nil {
-		fmt.Printf("Unable to compile text pattern Regexp: %v\n", text_pattern)
+		fmt.Printf("Unable to compile text pattern Regexp: %v\n", textPattern)
 		return
 	}
-	processed_channel := make(chan FileMatchData, CHANNEL_BUFFERING)
-	total_files := 0
+	processedChannel := make(chan FileMatchData, ChannelBuffering)
+	totalFiles := 0
 	err = filepath.Walk(".", func(path string, info fs.FileInfo, err error) error {
 		if err != nil {
 			fmt.Printf("prevent panic by handling failure accessing a path %q: %v\n", path, err)
 			return err
 		}
-		if re_path_pattern.FindString(path) == "" {
+		if rePathPattern.FindString(path) == "" {
 			return nil
 		}
 		// if info.IsDir() && info.Name() == subDirToSkip {
@@ -76,25 +78,25 @@ func main() {
 		if info.IsDir() {
 			return nil
 		}
-		go ProcessSingleFile(*re_text_pattern, path, processed_channel)
-		total_files++
+		go ProcessSingleFile(*reTextPattern, path, processedChannel)
+		totalFiles++
 
 		return nil
 	})
-	for ; total_files > 0; total_files-- {
-		cur_processed := <-processed_channel
-		if len(cur_processed.Lines) == 0 {
+	for ; totalFiles > 0; totalFiles-- {
+		curProcessed := <-processedChannel
+		if len(curProcessed.Lines) == 0 {
 			continue
 		}
-		fmt.Printf("%s:\n", cur_processed.Path)
-		for i := 0; i < len(cur_processed.Lines); i++ {
-			fmt.Printf("%d:%s\n", cur_processed.LineIndexes[i], cur_processed.Lines[i])
+		fmt.Printf("%s:\n", curProcessed.Path)
+		for i := 0; i < len(curProcessed.Lines); i++ {
+			fmt.Printf("%d:%s\n", curProcessed.LineIndexes[i], curProcessed.Lines[i])
 		}
 		fmt.Print("\n")
 	}
 
 	if err != nil {
-		fmt.Printf("error walking the path %q: %v\n", path_pattern, err)
+		fmt.Printf("error walking the path %q: %v\n", pathPattern, err)
 		return
 	}
 }