feat: merge

cmd/ls_lint/BUILD.bazel

@@ -10,6 +10,7 @@ go_library(
     deps = [
         "//internal/config",
         "//internal/debug",
+        "//internal/flag",
         "//internal/linter",
         "//internal/rule",
         "@in_gopkg_yaml_v3//:yaml_v3",

cmd/ls_lint/main.go

@@ -5,12 +5,15 @@ import (
 	"fmt"
 	"github.com/loeffel-io/ls-lint/v2/internal/config"
 	"github.com/loeffel-io/ls-lint/v2/internal/debug"
+	_flag "github.com/loeffel-io/ls-lint/v2/internal/flag"
 	"github.com/loeffel-io/ls-lint/v2/internal/linter"
 	"github.com/loeffel-io/ls-lint/v2/internal/rule"
 	"gopkg.in/yaml.v3"
 	"log"
+	"maps"
 	"os"
 	"runtime"
+	"slices"
 	"strings"
 )
 
@@ -21,12 +24,14 @@ func main() {
 	var exitCode = 0
 	var writer = os.Stdout
 	var flags = flag.NewFlagSet(os.Args[0], flag.ExitOnError)
-	var flagConfig = flags.String("config", ".ls-lint.yml", "ls-lint config file path")
 	var flagWorkdir = flags.String("workdir", ".", "change working directory before executing the given subcommand")
 	var flagWarn = flags.Bool("warn", false, "write lint errors to stdout instead of stderr (exit 0)")
 	var flagDebug = flags.Bool("debug", false, "write debug informations to stdout")
 	var flagVersion = flags.Bool("version", false, "prints version information for ls-lint")
 
+	var flagConfig _flag.Config
+	flags.Var(&flagConfig, "config", "ls-lint config file paths")
+
 	if err = flags.Parse(os.Args[1:]); err != nil {
 		log.Fatal(err)
 	}
@@ -37,17 +42,30 @@ func main() {
 	}
 
 	var filesystem = os.DirFS(*flagWorkdir)
-	var lslintConfig = config.NewConfig(nil, nil)
-	var configBytes []byte
 
-	// read file
-	if configBytes, err = os.ReadFile(*flagConfig); err != nil {
-		log.Fatal(err)
+	if len(flagConfig) == 0 {
+		flagConfig = _flag.Config{".ls-lint.yaml"}
 	}
 
-	// to yaml
-	if err = yaml.Unmarshal(configBytes, lslintConfig); err != nil {
-		log.Fatal(err)
+	var lslintConfig = config.NewConfig(make(config.Ls), make([]string, 0))
+	for _, c := range flagConfig {
+		var tmpLslintConfig = config.NewConfig(nil, nil)
+		var tmpConfigBytes []byte
+
+		// read file
+		if tmpConfigBytes, err = os.ReadFile(c); err != nil {
+			log.Fatal(err)
+		}
+
+		// to yaml
+		if err = yaml.Unmarshal(tmpConfigBytes, tmpLslintConfig); err != nil {
+			log.Fatal(err)
+		}
+
+		maps.Copy(lslintConfig.GetLs(), tmpLslintConfig.GetLs())
+		lslintConfig.Ignore = append(lslintConfig.Ignore, tmpLslintConfig.GetIgnore()...)
+		slices.Sort(lslintConfig.Ignore)
+		lslintConfig.Ignore = slices.Compact(lslintConfig.Ignore)
 	}
 
 	// linter
@@ -59,7 +77,7 @@ func main() {
 	)
 
 	// runner
-	if err = lslintLinter.Run(filesystem, *flagDebug, false); err != nil {
+	if err = lslintLinter.Run(filesystem, *flagDebug); err != nil {
 		log.Fatal(err)
 	}
 

internal/debug/statistic.go

@@ -16,6 +16,7 @@ type Statistic struct {
 
 func NewStatistic() *Statistic {
 	return &Statistic{
+		Start:   time.Now(),
 		RWMutex: new(sync.RWMutex),
 	}
 }

internal/flag/BUILD.bazel

@@ -0,0 +1,8 @@
+load("@io_bazel_rules_go//go:def.bzl", "go_library")
+
+go_library(
+    name = "flag",
+    srcs = ["config.go"],
+    importpath = "github.com/loeffel-io/ls-lint/v2/internal/flag",
+    visibility = ["//:__subpackages__"],
+)

internal/flag/config.go

@@ -0,0 +1,14 @@
+package flag
+
+import "strings"
+
+type Config []string
+
+func (config *Config) String() string {
+	return strings.Join(*config, ",")
+}
+
+func (config *Config) Set(value string) error {
+	*config = append(*config, value)
+	return nil
+}

internal/glob/glob.go

@@ -35,7 +35,10 @@ func Index[IndexValue bool | map[string][]rule.Rule](filesystem fs.FS, index map
 				continue
 			}
 
-			index[match] = value
+			if _, ok := index[match]; !ok {
+				index[match] = value
+			}
+
 			delete(index, key)
 		}
 	}

internal/linter/linter.go

@@ -8,10 +8,10 @@ import (
 	"github.com/loeffel-io/ls-lint/v2/internal/rule"
 	"golang.org/x/sync/errgroup"
 	"io/fs"
-	"log"
 	"path/filepath"
 	"strings"
 	"sync"
+	"time"
 )
 
 const (
@@ -164,7 +164,7 @@ func (linter *Linter) validateFile(index config.RuleIndex, path string) error {
 	return nil
 }
 
-func (linter *Linter) Run(filesystem fs.FS, debug bool, statistics bool) (err error) {
+func (linter *Linter) Run(filesystem fs.FS, debug bool) (err error) {
 	var index config.RuleIndex
 	var ignoreIndex = linter.config.GetIgnoreIndex()
 
@@ -183,26 +183,66 @@ func (linter *Linter) Run(filesystem fs.FS, debug bool, statistics bool) (err er
 		return err
 	}
 
+	if debug {
+		fmt.Printf("=============================\nls index\n-----------------------------\n")
+		for path, pathIndex := range index {
+			switch path == "" {
+			case true:
+				fmt.Printf(".:")
+			case false:
+				fmt.Printf("%s:", path)
+			}
+
+			for extension, rules := range pathIndex {
+				var tmpRules = make([]string, 0)
+				for _, tmpRule := range rules {
+					if len(tmpRule.GetParameters()) > 0 {
+						tmpRules = append(tmpRules, fmt.Sprintf("%s:%s", tmpRule.GetName(), strings.Join(tmpRule.GetParameters(), ",")))
+						continue
+					}
+
+					tmpRules = append(tmpRules, tmpRule.GetName())
+				}
+
+				fmt.Printf(" %s: %s", extension, strings.Join(tmpRules, ", "))
+			}
+			fmt.Printf("\n")
+		}
+
+		fmt.Printf("-----------------------------\nignore index\n-----------------------------\n")
+		for path := range ignoreIndex {
+			fmt.Printf("%s\n", path)
+		}
+
+		fmt.Printf("-----------------------------\nlint\n-----------------------------\n")
+	}
+
+	if debug {
+		defer func() {
+			fmt.Printf("-----------------------------\nstatistics\n-----------------------------\n")
+			fmt.Printf("time: %d ms\n", time.Since(linter.GetStatistics().Start).Milliseconds())
+			fmt.Printf("files: %d\n", linter.GetStatistics().Files)
+			fmt.Printf("file skips: %d\n", linter.GetStatistics().FileSkips)
+			fmt.Printf("dirs: %d\n", linter.GetStatistics().Dirs)
+			fmt.Printf("dir skips: %d\n", linter.GetStatistics().DirSkips)
+			fmt.Printf("=============================\n")
+		}()
+	}
+
 	return fs.WalkDir(filesystem, linter.root, func(path string, info fs.DirEntry, err error) error {
 		if linter.config.ShouldIgnore(ignoreIndex, path) {
 			if info.IsDir() {
 				if debug {
-					log.Printf("skip dir: %s", path)
-				}
-
-				if statistics {
-					defer linter.GetStatistics().AddDirSkip()
+					fmt.Printf("skip dir: %s\n", path)
+					linter.GetStatistics().AddDirSkip()
 				}
 
 				return fs.SkipDir
 			}
 
 			if debug {
-				log.Printf("skip file: %s", path)
-			}
-
-			if statistics {
-				defer linter.GetStatistics().AddFileSkip()
+				fmt.Printf("skip file: %s\n", path)
+				linter.GetStatistics().AddFileSkip()
 			}
 
 			return nil
@@ -214,22 +254,16 @@ func (linter *Linter) Run(filesystem fs.FS, debug bool, statistics bool) (err er
 
 		if info.IsDir() {
 			if debug {
-				log.Printf("lint dir: %s", path)
-			}
-
-			if statistics {
-				defer linter.GetStatistics().AddDir()
+				fmt.Printf("lint dir: %s\n", path)
+				linter.GetStatistics().AddDir()
 			}
 
 			return linter.validateDir(index, path)
 		}
 
 		if debug {
-			log.Printf("lint file: %s", path)
-		}
-
-		if statistics {
-			defer linter.GetStatistics().AddFile()
+			fmt.Printf("lint file: %s\n", path)
+			linter.GetStatistics().AddFile()
 		}
 
 		return linter.validateFile(index, path)

internal/linter/linter_test.go

@@ -292,7 +292,7 @@ func TestLinterRun(t *testing.T) {
 	for _, test := range tests {
 		fmt.Printf("Run test %d (%s)\n", i, test.description)
 
-		var err = test.linter.Run(test.filesystem, true, true)
+		var err = test.linter.Run(test.filesystem, true)
 
 		if !errors.Is(err, test.expectedErr) {
 			t.Errorf("Test %d (%s) failed with unmatched error value - %v", i, test.description, err)

internal/rule/camelcase.go

@@ -28,6 +28,10 @@ func (rule *CamelCase) SetParameters(params []string) error {
 	return nil
 }
 
+func (rule *CamelCase) GetParameters() []string {
+	return nil
+}
+
 // Validate checks if string is camel case
 // false if rune is no letter and no digit
 func (rule *CamelCase) Validate(value string) (bool, error) {

internal/rule/kebabcase.go

@@ -28,6 +28,10 @@ func (rule *KebabCase) SetParameters(params []string) error {
 	return nil
 }
 
+func (rule *KebabCase) GetParameters() []string {
+	return nil
+}
+
 // Validate checks if string is kebab case
 // false if rune is no lowercase letter, digit or -
 func (rule *KebabCase) Validate(value string) (bool, error) {

internal/rule/lowercase.go

@@ -28,6 +28,10 @@ func (rule *Lowercase) SetParameters(params []string) error {
 	return nil
 }
 
+func (rule *Lowercase) GetParameters() []string {
+	return nil
+}
+
 // Validate checks if every letter is lower
 func (rule *Lowercase) Validate(value string) (bool, error) {
 	for _, c := range value {

internal/rule/pascalcase.go

@@ -28,6 +28,10 @@ func (rule *PascalCase) SetParameters(params []string) error {
 	return nil
 }
 
+func (rule *PascalCase) GetParameters() []string {
+	return nil
+}
+
 // Validate checks if string is pascal case
 // false if rune is no letter and no digit
 // false if first rune is not upper

internal/rule/pointcase.go

@@ -28,6 +28,10 @@ func (rule *PointCase) SetParameters(params []string) error {
 	return nil
 }
 
+func (rule *PointCase) GetParameters() []string {
+	return nil
+}
+
 // Validate checks if string is "point case"
 // false if rune is no lowercase letter, digit or .
 func (rule *PointCase) Validate(value string) (bool, error) {

internal/rule/regex.go

@@ -43,6 +43,10 @@ func (rule *Regex) SetParameters(params []string) error {
 	return nil
 }
 
+func (rule *Regex) GetParameters() []string {
+	return []string{rule.RegexPattern}
+}
+
 // Validate checks if full string matches regex
 func (rule *Regex) Validate(value string) (bool, error) {
 	return regexp.MatchString(fmt.Sprintf("^%s$", rule.getRegexPattern()), value)

internal/rule/rule.go

@@ -39,6 +39,7 @@ type Rule interface {
 	Init() Rule
 	GetName() string
 	SetParameters(params []string) error
+	GetParameters() []string
 	Validate(value string) (bool, error)
 	GetErrorMessage() string
 }

internal/rule/screamingsnakecase.go

@@ -28,6 +28,10 @@ func (rule *ScreamingSnakeCase) SetParameters(params []string) error {
 	return nil
 }
 
+func (rule *ScreamingSnakeCase) GetParameters() []string {
+	return nil
+}
+
 // Validate checks if string is screaming sneak case
 // false if rune is no uppercase letter, digit or _
 func (rule *ScreamingSnakeCase) Validate(value string) (bool, error) {

internal/rule/snakecase.go

@@ -28,6 +28,10 @@ func (rule *SnakeCase) SetParameters(params []string) error {
 	return nil
 }
 
+func (rule *SnakeCase) GetParameters() []string {
+	return nil
+}
+
 // Validate checks if string is sneak case
 // false if rune is no lowercase letter, digit or _
 func (rule *SnakeCase) Validate(value string) (bool, error) {

repositories.bzl

@@ -7,6 +7,7 @@ def go_repositories():
         sum = "h1:HTuxyug8GyFbRkrffIpzNCSK4luc0TY3wzXvzIZhEXc=",
         version = "v4.6.0",
     )
+
     go_repository(
         name = "in_gopkg_check_v1",
         importpath = "gopkg.in/check.v1",
@@ -19,6 +20,7 @@ def go_repositories():
         sum = "h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=",
         version = "v3.0.1",
     )
+
     go_repository(
         name = "org_golang_x_sync",
         importpath = "golang.org/x/sync",