feat: add cli package (#126)

Author: kunitsudev

.github/workflows/label-checker.yml

@@ -46,7 +46,7 @@ jobs:
           # Add labels based on PR title
           GH_PR_TITLE=$(gh pr view --json title --jq .title)
           gh label list --json name --jq ".[].name" | while read -r LINE; do
-            grep -Eo "^${LINE:?}" <<<"${GH_PR_TITLE:?}" || true # NOTE: Ignore the return value of grep because we just want to output the string
+            awk -F: "/^${LINE-}(\([^\)]+\))?:/ {print \$1}" <<<"${GH_PR_TITLE:?}" | grep -Eo "^${LINE:?}" || true # NOTE: Ignore the return value of grep because we just want to output the string
           done | xargs -t -I{} gh pr edit --add-label {}
 
           # If any of the labels are present, exit with success

.gitignore

@@ -9,7 +9,7 @@ Thumbs.db
 /.tmp/
 
 # codecov
-coverage.txt
+coverage.txt*
 coverage.html
 
 # env

.test.env

@@ -0,0 +1,2 @@
+# UTIL_GO_CLI_TRACE=true
+UTIL_GO_CLI_DEBUG=true

Makefile

@@ -57,12 +57,15 @@ lint: githooks ## Run secretlint, go mod tidy, golangci-lint
 .PHONY: test
 test: githooks ## Run go test and display coverage
 	@[ -x "${DOTLOCAL_DIR}/bin/godotnev" ] || GOBIN="${DOTLOCAL_DIR}/bin" go install github.com/joho/godotenv/cmd/godotenv@latest
+
 	# Unit testing
-	godotenv -f .test.env go test -v -race -p=4 -parallel=8 -timeout=300s -cover -coverprofile=./coverage.txt ./... && go tool cover -func=./coverage.txt
+	godotenv -f .test.env go test -v -race -p=4 -parallel=8 -timeout=300s -cover -coverprofile=./coverage.txt.tmp ./... ; grep -Ev "\.deprecated\.go" ./coverage.txt.tmp > ./coverage.txt ; go tool cover -func=./coverage.txt
+
 	# Unit testing (with external modules)
-	cd grpc && godotenv -f .test.env go test -v -race -p=4 -parallel=8 -timeout=300s -cover -coverprofile=./coverage.txt ./... && go tool cover -func=./coverage.txt
+	cd grpc ; godotenv -f .test.env go test -v -race -p=4 -parallel=8 -timeout=300s -cover -coverprofile=./coverage.txt.tmp ./... ; grep -Ev "\.deprecated\.go" ./coverage.txt.tmp > ./coverage.txt ; go tool cover -func=./coverage.txt
+
 	# Integration testing
-	cd integrationtest && godotenv -f .test.env go test -v -race -p=4 -parallel=8 -timeout=300s -cover -coverprofile=./coverage.txt ./... && go tool cover -func=./coverage.txt
+	cd integrationtest ; godotenv -f .test.env go test -v -race -p=4 -parallel=8 -timeout=300s -cover -coverprofile=./coverage.txt.tmp ./... ; grep -Ev "\.deprecated\.go" ./coverage.txt.tmp > ./coverage.txt ; go tool cover -func=./coverage.txt
 
 .PHONY: bench
 bench: ## Run benchmarks

exp/cli/check_commands.go

@@ -0,0 +1,33 @@
+package cliz
+
+import errorz "github.com/kunitsucom/util.go/errors"
+
+func (cmd *Command) checkSubCommands() error {
+	if err := cmd.checkDuplicateSubCommands(); err != nil {
+		return errorz.Errorf("%s: %w", cmd.Name, err)
+	}
+
+	return nil
+}
+
+func (cmd *Command) checkDuplicateSubCommands() error {
+	names := make(map[string]bool)
+
+	for _, cmd := range cmd.SubCommands {
+		name := cmd.Name
+
+		TraceLog.Printf("checkDuplicateSubCommands: %s", name)
+
+		if name != "" && names[name] {
+			return errorz.Errorf("sub command: %s: %w", name, ErrDuplicateSubCommand)
+		}
+		names[name] = true
+	}
+
+	for _, subcmd := range cmd.SubCommands {
+		if err := subcmd.checkDuplicateSubCommands(); err != nil {
+			return errorz.Errorf("%w", err)
+		}
+	}
+	return nil
+}

exp/cli/check_commands_test.go

@@ -0,0 +1,50 @@
+package cliz
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestCommand_checkCommands(t *testing.T) {
+	t.Parallel()
+	t.Run("success,", func(t *testing.T) {
+		t.Parallel()
+		c := &Command{
+			Name: "main-cli",
+			SubCommands: []*Command{
+				{
+					Name: "sub-cmd",
+				},
+			},
+		}
+
+		if err := c.checkSubCommands(); err != nil {
+			t.Fatalf("❌: %+v", err)
+		}
+	})
+
+	t.Run("failure,", func(t *testing.T) {
+		t.Parallel()
+
+		c := &Command{
+			Name: "main-cli",
+			SubCommands: []*Command{
+				{
+					Name: "sub-cmd",
+					SubCommands: []*Command{
+						{
+							Name: "sub-sub-cmd",
+						},
+						{
+							Name: "sub-sub-cmd",
+						},
+					},
+				},
+			},
+		}
+
+		if err := c.checkSubCommands(); !errors.Is(err, ErrDuplicateSubCommand) {
+			t.Fatalf("❌: err != ErrDuplicateSubCommand: %+v", err)
+		}
+	})
+}

exp/cli/check_options.go

@@ -0,0 +1,51 @@
+package cliz
+
+import errorz "github.com/kunitsucom/util.go/errors"
+
+func (cmd *Command) checkOptions() error {
+	// NOTE: duplicate check
+	if err := cmd.checkDuplicateOptions(make(map[string]bool)); err != nil {
+		return errorz.Errorf("%s: %w", cmd.Name, err)
+	}
+
+	return nil
+}
+
+//nolint:cyclop
+func (cmd *Command) checkDuplicateOptions(envs map[string]bool) error {
+	names := make(map[string]bool)
+	shorts := make(map[string]bool)
+
+	for _, opt := range cmd.Options {
+		if name := opt.GetName(); name != "" {
+			TraceLog.Printf("checkDuplicateOptions: %s: option: %s", cmd.Name, name)
+			if names[name] {
+				err := ErrDuplicateOptionName
+				return errorz.Errorf("option: %s%s: %w", longOptionPrefix, name, err)
+			}
+			names[name] = true
+		}
+
+		if short := opt.GetShort(); short != "" {
+			if shorts[short] {
+				return errorz.Errorf("short option: %s%s: %w", shortOptionPrefix, short, ErrDuplicateOptionName)
+			}
+			shorts[short] = true
+		}
+
+		if env := opt.GetEnvironment(); env != "" {
+			if envs[env] {
+				return errorz.Errorf("environment: %s: %w", env, ErrDuplicateOptionName)
+			}
+			envs[env] = true
+		}
+	}
+
+	for _, subcmd := range cmd.SubCommands {
+		if err := subcmd.checkDuplicateOptions(envs); err != nil {
+			return errorz.Errorf("%s: %w", subcmd.Name, err)
+		}
+	}
+
+	return nil
+}

exp/cli/check_options_test.go

@@ -0,0 +1,108 @@
+package cliz
+
+import (
+	"errors"
+	"testing"
+)
+
+func TestCommand_checkOptions(t *testing.T) {
+	t.Parallel()
+	t.Run("success,", func(t *testing.T) {
+		t.Parallel()
+		c := &Command{
+			Name: "main-cli",
+			SubCommands: []*Command{
+				{
+					Name: "sub-cmd",
+					Options: []Option{
+						&StringOption{
+							Name: "foo",
+						},
+					},
+				},
+			},
+		}
+
+		if err := c.checkOptions(); err != nil {
+			t.Fatalf("❌: %+v", err)
+		}
+	})
+
+	t.Run("failure,ErrDuplicateOptionName,name", func(t *testing.T) {
+		t.Parallel()
+		c := &Command{
+			Name: "main-cli",
+			SubCommands: []*Command{
+				{
+					Name: "sub-cmd",
+					Options: []Option{
+						&StringOption{
+							Name: "foo",
+						},
+						&StringOption{
+							Name: "foo",
+						},
+					},
+				},
+			},
+		}
+
+		if err := c.checkOptions(); !errors.Is(err, ErrDuplicateOptionName) {
+			t.Fatalf("❌: err != ErrDuplicateOptionName: %+v", err)
+		}
+	})
+
+	t.Run("failure,ErrDuplicateOptionName,short", func(t *testing.T) {
+		t.Parallel()
+		c := &Command{
+			Name: "main-cli",
+			SubCommands: []*Command{
+				{
+					Name: "sub-cmd",
+					Options: []Option{
+						&StringOption{
+							Short: "f",
+						},
+						&StringOption{
+							Short: "f",
+						},
+					},
+				},
+			},
+		}
+
+		{
+			err := c.checkOptions()
+			if !errors.Is(err, ErrDuplicateOptionName) {
+				t.Fatalf("❌: err != ErrDuplicateOptionName: %+v", err)
+			}
+		}
+	})
+
+	t.Run("failure,ErrDuplicateOptionName,environment", func(t *testing.T) {
+		t.Parallel()
+		c := &Command{
+			Name: "main-cli",
+			SubCommands: []*Command{
+				{
+					Name: "sub-cmd",
+					Options: []Option{
+						&StringOption{
+							Environment: "FOO",
+						},
+						&StringOption{
+							Environment: "FOO",
+						},
+					},
+				},
+			},
+		}
+
+		{
+			err := c.checkOptions()
+			if !errors.Is(err, ErrDuplicateOptionName) {
+				t.Fatalf("❌: err != ErrDuplicateOptionName: %+v", err)
+			}
+		}
+	})
+}