golint, go vet

main.go

@@ -13,7 +13,7 @@ import (
 )
 
 // doJob is main function
-func doJob(remove, trim, duplicate, sorting, calculate bool, min, max int, src_file, new_file string) error {
+func doJob(remove, trim, duplicate, sorting, calculate bool, min, max int, srcFile, newFile string) error {
 
 	// Check operations
 	if !remove && !trim && !duplicate && !sorting && !calculate {
@@ -22,31 +22,31 @@ func doJob(remove, trim, duplicate, sorting, calculate bool, min, max int, src_f
 
 	// Cleaning
 	if (remove || trim) && (!duplicate && !sorting && !calculate) {
-		if err := o.DoClean(remove, trim, min, max, src_file, new_file); err != nil {
+		if err := o.DoClean(remove, trim, min, max, srcFile, newFile); err != nil {
 			return err
 		}
 		return nil
 	}
 
 	//Duplicate search
 	if duplicate && (!remove && !trim && !sorting && !calculate) {
-		if err := o.DoDuplicate(src_file, new_file); err != nil {
+		if err := o.DoDuplicate(srcFile, newFile); err != nil {
 			return err
 		}
 		return nil
 	}
 
 	// Sorting
 	if sorting && (!remove && !trim && !duplicate && !calculate) {
-		if err := o.DoSorting(src_file, new_file); err != nil {
+		if err := o.DoSorting(srcFile, newFile); err != nil {
 			return err
 		}
 		return nil
 	}
 
 	// calculate
 	if calculate && (!remove && !trim && !duplicate && !sorting) {
-		if err := o.DoCalculate(src_file); err != nil {
+		if err := o.DoCalculate(srcFile); err != nil {
 			return err
 		}
 		return nil
@@ -66,18 +66,18 @@ func splitFileName(file string) (string, string) {
 func main() {
 
 	// variables
-	var remove bool = false
-	var trim bool = false
-	var duplicate bool = false
-	var sorting bool = false
-	var calculate bool = false
-	var min int = 8
-	var max int = 63
-	var src_file string = "Dict.dic"
-	var new_file string = "Dict_cleaned.dic"
-	var auto bool = false
-	var file_ext = ".dic"
-	var version = "0.2.6"
+	remove := false
+	trim := false
+	duplicate := false
+	sorting := false
+	calculate := false
+	min := 8
+	max := 63
+	srcFile := "Dict.dic"
+	newFile := "Dict_cleaned.dic"
+	auto := false
+	fileExt := ".dic"
+	version := "0.2.6"
 
 	// args
 	for k, arg := range os.Args {
@@ -113,38 +113,38 @@ func main() {
 		case "-src":
 			err := s.CheckArgs(len(os.Args), k)
 			s.CheckError(err)
-			src_file = os.Args[k+1]
+			srcFile = os.Args[k+1]
 		case "-new":
 			err := s.CheckArgs(len(os.Args), k)
 			s.CheckError(err)
-			new_file = os.Args[k+1]
+			newFile = os.Args[k+1]
 		case "-a":
 			auto = true
 		case "-ext":
 			err := s.CheckArgs(len(os.Args), k)
 			s.CheckError(err)
-			file_ext = "." + os.Args[k+1]
+			fileExt = "." + os.Args[k+1]
 		}
 	}
 
 	// start time
 	start := time.Now()
 
 	if auto {
-		files_list, err := s.SearchFilesInDir(file_ext, "./")
+		filesList, err := s.SearchFilesInDir(fileExt, "./")
 		s.CheckError(err)
 		fmt.Println()
-		fmt.Println(len(files_list), "files found.")
+		fmt.Println(len(filesList), "files found.")
 		fmt.Println()
-		for _, src_file := range files_list {
-			name, ext := splitFileName(src_file)
-			new_file := name + "_cleaned" + ext
-			err = doJob(remove, trim, duplicate, sorting, calculate, min, max, src_file, new_file)
+		for _, srcFile := range filesList {
+			name, ext := splitFileName(srcFile)
+			newFile := name + "_cleaned" + ext
+			err = doJob(remove, trim, duplicate, sorting, calculate, min, max, srcFile, newFile)
 			s.CheckError(err)
 		}
 	} else {
 		fmt.Println()
-		err := doJob(remove, trim, duplicate, sorting, calculate, min, max, src_file, new_file)
+		err := doJob(remove, trim, duplicate, sorting, calculate, min, max, srcFile, newFile)
 		s.CheckError(err)
 	}
 

operations/calculate.go

@@ -7,14 +7,14 @@ import (
 )
 
 // DoCalculate calculate lines in source file
-func DoCalculate(src_file string) error {
+func DoCalculate(srcFile string) error {
 
-	total, err := s.CalculateLines(src_file)
+	total, err := s.CalculateLines(srcFile)
 	if err != nil {
 		return err
 	}
 
-	fmt.Printf("|%-40s|%20d|\n", src_file, total)
+	fmt.Printf("|%-40s|%20d|\n", srcFile, total)
 
 	return nil
 }

operations/duplicate_search.go

@@ -12,24 +12,24 @@ import (
 )
 
 // DoDuplicate search duplicates in source file and write uniq to new file
-func DoDuplicate(src_file, new_file string) error {
+func DoDuplicate(srcFile, newFile string) error {
 
 	m := map[uint64]bool{}
 
-	var added int64 = 0
+	var added int64
 
-	total, err := s.CalculateLines(src_file)
+	total, err := s.CalculateLines(srcFile)
 	if err != nil {
 		return err
 	}
 
-	in, err := os.Open(src_file)
+	in, err := os.Open(srcFile)
 	if err != nil {
 		return err
 	}
 	defer in.Close()
 
-	out, err := os.Create(new_file)
+	out, err := os.Create(newFile)
 	if err != nil {
 		return err
 	}
@@ -50,11 +50,11 @@ func DoDuplicate(src_file, new_file string) error {
 
 	for scanner.Scan() {
 		line := scanner.Text()
-		line_hash := s.GetHashFvn64(line)
+		lineHash := s.GetHashFvn64(line)
 
-		if _, seen := m[line_hash]; !seen {
+		if _, seen := m[lineHash]; !seen {
 			fmt.Fprintln(writer, line)
-			m[line_hash] = true
+			m[lineHash] = true
 			added++
 		}
 		bar.Increment()
@@ -66,12 +66,13 @@ func DoDuplicate(src_file, new_file string) error {
 		return err
 	}
 
-	fmt.Println("\nResult:", src_file)
+	fmt.Println("\nResult:", srcFile)
 	fmt.Println("-------------------------------------------")
 	fmt.Printf("|%-20s|%20d|\n", "Total", total)
 	fmt.Printf("|%-20s|%20d|\n", "Removed", (total - added))
 	fmt.Printf("|%-20s|%20d|\n", "Result", added)
-	fmt.Println("-------------------------------------------\n")
+	fmt.Println("-------------------------------------------")
+	fmt.Println()
 
 	return scanner.Err()
 }

operations/remove_trim.go

@@ -3,8 +3,9 @@ package operations
 import (
 	"bufio"
 	"fmt"
-	"github.com/cheggaaa/pb"
 	"os"
+
+	"github.com/cheggaaa/pb"
 	//"time"
 
 	s "github.com/gkiryaziev/go-wordlist-cleaner/service"
@@ -29,22 +30,22 @@ func isSize(min, max int, line string) bool {
 }
 
 // DoClean clean a string
-func DoClean(remove, trim bool, min, max int, src_file, new_file string) error {
+func DoClean(remove, trim bool, min, max int, srcFile, newFile string) error {
 
-	var added int64 = 0
+	var added int64
 
-	total, err := s.CalculateLines(src_file)
+	total, err := s.CalculateLines(srcFile)
 	if err != nil {
 		return err
 	}
 
-	in, err := os.Open(src_file)
+	in, err := os.Open(srcFile)
 	if err != nil {
 		return err
 	}
 	defer in.Close()
 
-	out, err := os.Create(new_file)
+	out, err := os.Create(newFile)
 	if err != nil {
 		return err
 	}
@@ -95,12 +96,13 @@ func DoClean(remove, trim bool, min, max int, src_file, new_file string) error {
 		return err
 	}
 
-	fmt.Println("\nResult:", src_file)
+	fmt.Println("\nResult:", srcFile)
 	fmt.Println("-------------------------------------------")
 	fmt.Printf("|%-20s|%20d|\n", "Total", total)
 	fmt.Printf("|%-20s|%20d|\n", "Removed", (total - added))
 	fmt.Printf("|%-20s|%20d|\n", "Result", added)
-	fmt.Println("-------------------------------------------\n")
+	fmt.Println("-------------------------------------------")
+	fmt.Println()
 
 	return scanner.Err()
 }

operations/sorting.go

@@ -8,16 +8,16 @@ import (
 )
 
 // DoSorting read source file, sort it alphabetically and write to new file
-func DoSorting(src_file, new_file string) error {
+func DoSorting(srcFile, newFile string) error {
 
-	total, err := s.CalculateLines(src_file)
+	total, err := s.CalculateLines(srcFile)
 	if err != nil {
 		return err
 	}
 
 	// read file
 	fmt.Println("\nReading...")
-	source, err := s.ReadLine(src_file)
+	source, err := s.ReadLine(srcFile)
 	if err != nil {
 		return err
 	}
@@ -28,12 +28,12 @@ func DoSorting(src_file, new_file string) error {
 
 	// write file
 	fmt.Println("Saving...")
-	err = s.WriteLine(source, new_file)
+	err = s.WriteLine(source, newFile)
 	if err != nil {
 		return err
 	}
 
-	fmt.Println("\nResult:", src_file)
+	fmt.Println("\nResult:", srcFile)
 	fmt.Println("-------------------------------------------")
 	fmt.Printf("|%-20s|%20d|\n", "Total", total)
 	fmt.Println("-------------------------------------------")

service/calculate_hash.go

@@ -11,7 +11,7 @@ func GetHashFvn(s string) uint32 {
 	return h.Sum32()
 }
 
-// GetHashFvn return uint64 fnv hash
+// GetHashFvn64 return uint64 fnv hash
 func GetHashFvn64(s string) uint64 {
 	h := fnv.New64a()
 	h.Write([]byte(s))

service/calculate_lines.go

@@ -15,7 +15,7 @@ func CalculateLines(path string) (int64, error) {
 	defer file.Close()
 
 	buf := make([]byte, 8192)
-	var count int64 = 0
+	var count int64
 	lineSep := []byte{'\n'}
 
 	for {

service/check_all.go

@@ -22,16 +22,15 @@ func CheckFile(file string) error {
 	if err == nil {
 		if f.IsDir() {
 			return errors.New("Directory with name " + file + " is exists.")
-		} else {
-			return errors.New("File with name " + file + " is exists.")
 		}
+		return errors.New("File with name " + file + " is exists.")
 	}
 	return nil
 }
 
 // CheckArgs check key value
-func CheckArgs(args_length, arg_index int) error {
-	if args_length == (arg_index + 1) {
+func CheckArgs(argsLength, argIndex int) error {
+	if argsLength == (argIndex + 1) {
 		return errors.New("Not specified key value.")
 	}
 	return nil

service/search_files.go

@@ -7,23 +7,23 @@ import (
 )
 
 // SearchFilesInDir return list of files in directory by extension
-func SearchFilesInDir(file_ext, path string) ([]string, error) {
-	var files_list []string
+func SearchFilesInDir(fileExt, path string) ([]string, error) {
+	var filesList []string
 
 	files, err := ioutil.ReadDir(path)
 	if err != nil {
 		return nil, err
 	}
 
 	for _, f := range files {
-		if filepath.Ext(f.Name()) == file_ext {
-			files_list = append(files_list, f.Name())
+		if filepath.Ext(f.Name()) == fileExt {
+			filesList = append(filesList, f.Name())
 		}
 	}
 
-	if len(files_list) <= 0 {
+	if len(filesList) <= 0 {
 		return nil, errors.New("No files found.")
 	}
 
-	return files_list, nil
+	return filesList, nil
 }