Kong to Cobra Migration (#208)

Author: JyotikaGargg

.vscode/launch.json

@@ -24,7 +24,7 @@
             "request": "launch",
             "mode" : "auto",
             "program": "${workspaceFolder}/cmd/modern",
-            "args" : ["-Q", "EXIT(select net_transport from sys.dm_exec_connections)"],
+            "args" : ["-Q", "EXIT(select net_transport from sys.dm_exec_connections)"],    
         },
         {
             "name" : "Run file query",

.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+    "go.lintTool": "golangci-lint",
+    "go.lintOnSave": "workspace"
+}

cmd/sqlcmd/sqlcmd.go

@@ -10,30 +10,14 @@ import (
 	"strings"
 	"testing"
 
-	"github.com/alecthomas/kong"
 	"github.com/microsoft/go-mssqldb/azuread"
 	"github.com/microsoft/go-sqlcmd/pkg/sqlcmd"
+	"github.com/spf13/cobra"
 	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/require"
 )
 
 const oneRowAffected = "(1 row affected)"
 
-func newKong(t *testing.T, cli interface{}, options ...kong.Option) *kong.Kong {
-	t.Helper()
-	options = append([]kong.Option{
-		kong.Name("test"),
-		kong.NoDefaultHelp(),
-		kong.Exit(func(int) {
-			t.Helper()
-			assert.Fail(t, "unexpected exit()")
-		}),
-	}, options...)
-	parser, err := kong.New(cli, options...)
-	require.NoError(t, err)
-	return parser
-}
-
 func TestValidCommandLineToArgsConversion(t *testing.T) {
 	type cmdLineTest struct {
 		commandLine []string
@@ -90,15 +74,34 @@ func TestValidCommandLineToArgsConversion(t *testing.T) {
 		{[]string{"--version"}, func(args SQLCmdArguments) bool {
 			return args.Version
 		}},
+		{[]string{}, func(args SQLCmdArguments) bool {
+			return args.ScreenWidth == nil
+		}},
+		{[]string{"-w", "10"}, func(args SQLCmdArguments) bool {
+			return args.ScreenWidth != nil && *args.ScreenWidth == 10
+		}},
 		{[]string{"-s", "|", "-w", "10", "-W"}, func(args SQLCmdArguments) bool {
 			return args.TrimSpaces && args.ColumnSeparator == "|" && *args.ScreenWidth == 10
 		}},
 	}
 
 	for _, test := range commands {
 		arguments := &SQLCmdArguments{}
-		parser := newKong(t, arguments)
-		_, err := parser.Parse(test.commandLine)
+		cmd := &cobra.Command{
+			Use:   "testCommand",
+			Short: "A brief description of my command",
+			Long:  "A long description of my command",
+			PreRunE: func(cmd *cobra.Command, argss []string) error {
+				SetScreenWidthFlag(arguments, cmd)
+				return arguments.Validate()
+			},
+			Run: func(cmd *cobra.Command, argss []string) {
+				// Command logic goes here
+			},
+		}
+		setFlags(cmd, arguments)
+		cmd.SetArgs(test.commandLine)
+		err := cmd.Execute()
 		msg := ""
 		if err != nil {
 			msg = err.Error()
@@ -116,19 +119,61 @@ func TestInvalidCommandLine(t *testing.T) {
 	}
 
 	commands := []cmdLineTest{
-		{[]string{"-E", "-U", "someuser"}, "--use-trusted-connection and --user-name can't be used together"},
-		// the test prefix is a kong artifact https://github.com/alecthomas/kong/issues/221
-		{[]string{"-a", "100"}, "test: '-a 100': Packet size has to be a number between 512 and 32767."},
+		// Issue:341  https://github.com/microsoft/go-sqlcmd/issues/341
+		//{[]string{"-E", "-U", "someuser"}, "--use-trusted-connection and --user-name can't be used together"},
 		{[]string{"-F", "what"}, "--format must be one of \"horiz\",\"horizontal\",\"vert\",\"vertical\" but got \"what\""},
-		{[]string{"-r", "5"}, `--errors-to-stderr must be one of "-1","0","1" but got '\x05'`},
-		{[]string{"-h-4"}, "test: '-h -4': header value must be either -1 or a value between 1 and 2147483647"},
-		{[]string{"-w", "6"}, "test: '-w 6': value must be greater than 8 and less than 65536."},
+		{[]string{"-r", "5"}, `--errors-to-stderr must be one of "-1","0","1" but got "5"`},
 	}
 
 	for _, test := range commands {
 		arguments := &SQLCmdArguments{}
-		parser := newKong(t, arguments)
-		_, err := parser.Parse(test.commandLine)
+		cmd := &cobra.Command{
+			Use:   "testCommand",
+			Short: "A brief description of my command",
+			Long:  "A long description of my command",
+			PreRunE: func(cmd *cobra.Command, argss []string) error {
+				return normalizeFlags(cmd)
+			},
+			Run: func(cmd *cobra.Command, argss []string) {
+			},
+		}
+		setFlags(cmd, arguments)
+		cmd.SetArgs(test.commandLine)
+		err := cmd.Execute()
+		assert.EqualError(t, err, test.errorMessage, "Command line:%v", test.commandLine)
+	}
+}
+
+func TestValidateFlags(t *testing.T) {
+	type cmdLineTest struct {
+		commandLine  []string
+		errorMessage string
+	}
+
+	commands := []cmdLineTest{
+		{[]string{"-a", "100"}, "'-a 100': Packet size has to be a number between 512 and 32767."},
+		{[]string{"-h-4"}, "'-h -4': header value must be either -1 or a value between 1 and 2147483647"},
+		{[]string{"-w", "6"}, "'-w 6': value must be greater than 8 and less than 65536."},
+	}
+
+	for _, test := range commands {
+		arguments := &SQLCmdArguments{}
+		//var screenWidth *int
+		cmd := &cobra.Command{
+			Use:   "testCommand",
+			Short: "A brief description of my command",
+			Long:  "A long description of my command",
+			PreRunE: func(cmd *cobra.Command, argss []string) error {
+				SetScreenWidthFlag(arguments, cmd)
+				return arguments.Validate()
+			},
+			Run: func(cmd *cobra.Command, argss []string) {
+			},
+		}
+
+		setFlags(cmd, arguments)
+		cmd.SetArgs(test.commandLine)
+		err := cmd.Execute()
 		assert.EqualError(t, err, test.errorMessage, "Command line:%v", test.commandLine)
 	}
 }

cmd/sqlcmd/sqlcmd_test.go

@@ -1 +1 @@
-select 100
+select 100

cmd/sqlcmd/testdata/select100.sql

@@ -4,7 +4,6 @@ go 1.18
 
 require (
 	github.com/alecthomas/chroma/v2 v2.5.0
-	github.com/alecthomas/kong v0.6.2-0.20220922001058-c62bf25854a0
 	github.com/billgraziano/dpapi v0.4.0
 	github.com/docker/distribution v2.8.2+incompatible
 	github.com/docker/docker v20.10.24+incompatible
@@ -16,6 +15,7 @@ require (
 	github.com/peterh/liner v1.2.2
 	github.com/pkg/errors v0.9.1
 	github.com/spf13/cobra v1.6.1
+	github.com/spf13/pflag v1.0.5
 	github.com/spf13/viper v1.14.0
 	github.com/stretchr/testify v1.8.1
 	golang.org/x/sys v0.5.0
@@ -65,7 +65,6 @@ require (
 	github.com/spf13/afero v1.9.2 // indirect
 	github.com/spf13/cast v1.5.0 // indirect
 	github.com/spf13/jwalterweatherman v1.1.0 // indirect
-	github.com/spf13/pflag v1.0.5 // indirect
 	github.com/subosito/gotenv v1.4.1 // indirect
 	golang.org/x/crypto v0.0.0-20220622213112-05595931fe9d // indirect
 	golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4 // indirect

go.mod

@@ -53,8 +53,6 @@ github.com/Microsoft/go-winio v0.6.0/go.mod h1:cTAf44im0RAYeL23bpB+fzCyDH2MJiz2B
 github.com/alecthomas/assert/v2 v2.2.1 h1:XivOgYcduV98QCahG8T5XTezV5bylXe+lBxLG2K2ink=
 github.com/alecthomas/chroma/v2 v2.5.0 h1:CQCdj1BiBV17sD4Bd32b/Bzuiq/EqoNTrnIhyQAZ+Rk=
 github.com/alecthomas/chroma/v2 v2.5.0/go.mod h1:yrkMI9807G1ROx13fhe1v6PN2DDeaR73L3d+1nmYQtw=
-github.com/alecthomas/kong v0.6.2-0.20220922001058-c62bf25854a0 h1:HQ3WlFsqBcr4qsiHtfA7UdFSrChglOcQa8q/tbXJFBI=
-github.com/alecthomas/kong v0.6.2-0.20220922001058-c62bf25854a0/go.mod h1:n1iCIO2xS46oE8ZfYCNDqdR0b0wZNrXAIAqro/2132U=
 github.com/alecthomas/repr v0.2.0 h1:HAzS41CIzNW5syS8Mf9UwXhNH1J9aix/BvDRf1Ml2Yk=
 github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
 github.com/alecthomas/template v0.0.0-20190718012654-fb15b899a751/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=

go.sum

@@ -21,7 +21,6 @@ var ImportsAnalyzer = &analysis.Analyzer{
 }
 
 var AllowedImports = map[string][]string{
-	`"github.com/alecthomas/kong`:      {`cmd/sqlcmd`, `pkg/sqlcmd`},
 	`"github.com/golang-sql/sqlexp`:    {`pkg/sqlcmd`},
 	`"github.com/google/uuid`:          {},
 	`"github.com/peterh/liner`:         {`pkg/console`},

pkg/sqlcmd-linter/imports.go

@@ -4,14 +4,14 @@
 package sqlcmd
 
 import (
+	"flag"
 	"fmt"
 	"os"
 	"regexp"
 	"sort"
 	"strconv"
 	"strings"
 
-	"github.com/alecthomas/kong"
 	"github.com/microsoft/go-sqlcmd/internal/color"
 	"golang.org/x/text/encoding/unicode"
 	"golang.org/x/text/transform"
@@ -398,41 +398,33 @@ func listCommand(s *Sqlcmd, args []string, line uint) (err error) {
 	return
 }
 
-type connectData struct {
-	Server               string `arg:""`
-	Database             string `short:"D"`
-	Username             string `short:"U"`
-	Password             string `short:"P"`
-	LoginTimeout         string `short:"l"`
-	AuthenticationMethod string `short:"G"`
-}
-
 func connectCommand(s *Sqlcmd, args []string, line uint) error {
-
 	if len(args) == 0 {
 		return InvalidCommandError("CONNECT", line)
 	}
-	cmdLine := strings.TrimSpace(args[0])
-	if cmdLine == "" {
-		return InvalidCommandError("CONNECT", line)
-	}
-	arguments := &connectData{}
-	parser, err := kong.New(arguments)
-	if err != nil {
-		return InvalidCommandError("CONNECT", line)
-	}
 
-	// Fields removes extra whitespace.
-	// Note :connect doesn't support passwords with spaces
-	if _, err = parser.Parse(strings.Fields(cmdLine)); err != nil {
+	commandArgs := strings.Fields(args[0])
+
+	// Parse flags
+	flags := flag.NewFlagSet("connect", flag.ContinueOnError)
+	database := flags.String("D", "", "database name")
+	username := flags.String("U", "", "user name")
+	password := flags.String("P", "", "password")
+	loginTimeout := flags.String("l", "", "login timeout")
+	authenticationMethod := flags.String("G", "", "authentication method")
+
+	err := flags.Parse(commandArgs[1:])
+	//err := flags.Parse(args[1:])
+	if err != nil {
 		return InvalidCommandError("CONNECT", line)
 	}
 
 	connect := *s.Connect
-	connect.UserName, _ = resolveArgumentVariables(s, []rune(arguments.Username), false)
-	connect.Password, _ = resolveArgumentVariables(s, []rune(arguments.Password), false)
-	connect.ServerName, _ = resolveArgumentVariables(s, []rune(arguments.Server), false)
-	timeout, _ := resolveArgumentVariables(s, []rune(arguments.LoginTimeout), false)
+	connect.UserName, _ = resolveArgumentVariables(s, []rune(*username), false)
+	connect.Password, _ = resolveArgumentVariables(s, []rune(*password), false)
+	connect.Database, _ = resolveArgumentVariables(s, []rune(*database), false)
+
+	timeout, _ := resolveArgumentVariables(s, []rune(*loginTimeout), false)
 	if timeout != "" {
 		if timeoutSeconds, err := strconv.ParseInt(timeout, 10, 32); err == nil {
 			if timeoutSeconds < 0 {
@@ -441,9 +433,17 @@ func connectCommand(s *Sqlcmd, args []string, line uint) error {
 			connect.LoginTimeoutSeconds = int(timeoutSeconds)
 		}
 	}
-	connect.AuthenticationMethod = arguments.AuthenticationMethod
+
+	connect.AuthenticationMethod = *authenticationMethod
+
+	// Set server name as the first positional argument
+	if len(commandArgs) > 0 {
+		connect.ServerName, _ = resolveArgumentVariables(s, []rune(commandArgs[0]), false)
+	}
+
 	// If no user name is provided we switch to integrated auth
 	_ = s.ConnectDb(&connect, s.lineIo == nil)
+
 	// ConnectDb prints connection errors already, and failure to connect is not fatal even with -b option
 	return nil
 }