Wrap pending user visible content with localizer routines (#325)

This commit surrounds user visible content with localization
routines and fixes #298

Author: apoorvdeshmukh

cmd/modern/root.go

@@ -9,6 +9,7 @@ import (
 	"github.com/microsoft/go-sqlcmd/cmd/modern/root"
 	"github.com/microsoft/go-sqlcmd/internal/cmdparser"
 	"github.com/microsoft/go-sqlcmd/internal/config"
+	"github.com/microsoft/go-sqlcmd/internal/localizer"
 )
 
 // Root type implements the very top-level command for sqlcmd (which contains
@@ -36,18 +37,19 @@ func (c *Root) DefineCommand(...cmdparser.CommandOptions) {
 	steps = append(steps, "sqlcmd delete")
 
 	examples := []cmdparser.ExampleOptions{
-		{Description: "Install/Create, Query, Uninstall SQL Server",
+		{Description: localizer.Sprintf("Install/Create, Query, Uninstall SQL Server"),
 			Steps: steps},
-		{Description: "View configuration information and connection strings",
+		{Description: localizer.Sprintf("View configuration information and connection strings"),
 			Steps: []string{"sqlcmd config view", "sqlcmd config cs"}},
 	}
 
+	const feedbackUrl = "https://github.com/microsoft/go-sqlcmd/issues/new"
 	commandOptions := cmdparser.CommandOptions{
 		Use: "sqlcmd",
-		Short: `sqlcmd: Install/Create/Query SQL Server, Azure SQL, and Tools
+		Short: localizer.Sprintf(`sqlcmd: Install/Create/Query SQL Server, Azure SQL, and Tools
 
 Feedback:
-  https://github.com/microsoft/go-sqlcmd/issues/new`,
+  %s`, feedbackUrl),
 		SubCommands: c.SubCommands(),
 		Examples:    examples,
 	}
@@ -102,7 +104,7 @@ func (c *Root) addGlobalFlags() {
 		Bool:      &unused,
 		Name:      "?",
 		Shorthand: "?",
-		Usage:     "help for backwards compatibility flags (-S, -U, -E etc.)",
+		Usage:     localizer.Sprintf("help for backwards compatibility flags (-S, -U, -E etc.)"),
 	})
 
 	// BUG(stuartpa): - This is a temporary flag until we have migrated
@@ -111,14 +113,14 @@ func (c *Root) addGlobalFlags() {
 	c.AddFlag(cmdparser.FlagOptions{
 		Bool:  &unused,
 		Name:  "version",
-		Usage: "print version of sqlcmd",
+		Usage: localizer.Sprintf("print version of sqlcmd"),
 	})
 
 	c.AddFlag(cmdparser.FlagOptions{
 		String:        &c.configFilename,
 		DefaultString: config.DefaultFileName(),
 		Name:          "sqlconfig",
-		Usage:         "configuration file",
+		Usage:         localizer.Sprintf("configuration file"),
 	})
 
 	/* BUG(stuartpa): - At the moment this is a top level flag, but it doesn't
@@ -136,6 +138,6 @@ func (c *Root) addGlobalFlags() {
 		Int:        (*int)(&c.loggingLevel),
 		DefaultInt: 2,
 		Name:       "verbosity",
-		Usage:      "log level, error=0, warn=1, info=2, debug=3, trace=4",
+		Usage:      localizer.Sprintf("log level, error=0, warn=1, info=2, debug=3, trace=4"),
 	})
 }

cmd/modern/root/config.go

@@ -5,8 +5,10 @@ package root
 
 import (
 	"fmt"
+
 	"github.com/microsoft/go-sqlcmd/cmd/modern/root/config"
 	"github.com/microsoft/go-sqlcmd/internal/cmdparser"
+	"github.com/microsoft/go-sqlcmd/internal/localizer"
 	"github.com/microsoft/go-sqlcmd/internal/pal"
 )
 
@@ -20,11 +22,11 @@ type Config struct {
 func (c *Config) DefineCommand(...cmdparser.CommandOptions) {
 	options := cmdparser.CommandOptions{
 		Use:         "config",
-		Short:       `Modify sqlconfig files using subcommands like "sqlcmd config use-context mssql"`,
+		Short:       localizer.Sprintf(`Modify sqlconfig files using subcommands like "%s"`, localizer.UseContextCommand),
 		SubCommands: c.SubCommands(),
 		Examples: []cmdparser.ExampleOptions{
 			{
-				Description: "Add context for existing endpoint and user (use SQLCMD_PASSWORD or SQLCMDPASSWORD)",
+				Description: localizer.Sprintf("Add context for existing endpoint and user (use %s or %s)", localizer.PasswordEnvVar, localizer.PasswordEnvVar2),
 				Steps: []string{
 					fmt.Sprintf("%s SQLCMD_PASSWORD=<placeholderpassword>", pal.CreateEnvVarKeyword()),
 					"sqlcmd config add-user --name sa1434 --username sa",

cmd/modern/root/config/add-context.go

@@ -9,6 +9,7 @@ import (
 	"github.com/microsoft/go-sqlcmd/cmd/modern/sqlconfig"
 	"github.com/microsoft/go-sqlcmd/internal/cmdparser"
 	"github.com/microsoft/go-sqlcmd/internal/config"
+	"github.com/microsoft/go-sqlcmd/internal/localizer"
 )
 
 // AddContext implements the `sqlcmd config add-context` command
@@ -23,10 +24,10 @@ type AddContext struct {
 func (c *AddContext) DefineCommand(...cmdparser.CommandOptions) {
 	options := cmdparser.CommandOptions{
 		Use:   "add-context",
-		Short: "Add a context",
+		Short: localizer.Sprintf("Add a context"),
 		Examples: []cmdparser.ExampleOptions{
 			{
-				Description: "Add a context for a local instance of SQL Server on port 1433 using trusted authentication",
+				Description: localizer.Sprintf("Add a context for a local instance of SQL Server on port 1433 using trusted authentication"),
 				Steps: []string{
 					"sqlcmd config add-endpoint --name localhost-1433",
 					"sqlcmd config add-context --name mssql --endpoint localhost-1433"}},
@@ -39,17 +40,17 @@ func (c *AddContext) DefineCommand(...cmdparser.CommandOptions) {
 		String:        &c.name,
 		Name:          "name",
 		DefaultString: "context",
-		Usage:         "Display name for the context"})
+		Usage:         localizer.Sprintf("Display name for the context")})
 
 	c.AddFlag(cmdparser.FlagOptions{
 		String: &c.endpointName,
 		Name:   "endpoint",
-		Usage:  "Name of endpoint this context will use"})
+		Usage:  localizer.Sprintf("Name of endpoint this context will use")})
 
 	c.AddFlag(cmdparser.FlagOptions{
 		String: &c.userName,
 		Name:   "user",
-		Usage:  "Name of user this context will use"})
+		Usage:  localizer.Sprintf("Name of user this context will use")})
 }
 
 // run adds a context to the configuration and sets it as the current context. The
@@ -69,27 +70,27 @@ func (c *AddContext) run() {
 
 	if c.endpointName == "" || !config.EndpointExists(c.endpointName) {
 		output.FatalfWithHintExamples([][]string{
-			{"View existing endpoints to choose from", "sqlcmd config get-endpoints"},
-			{"Add a new local endpoint", "sqlcmd create"},
-			{"Add an already existing endpoint", "sqlcmd config add-endpoint --address localhost --port 1433"}},
-			"Endpoint required to add context.  Endpoint '%v' does not exist.  Use --endpoint flag", c.endpointName)
+			{localizer.Sprintf("View existing endpoints to choose from"), "sqlcmd config get-endpoints"},
+			{localizer.Sprintf("Add a new local endpoint"), "sqlcmd create"},
+			{localizer.Sprintf("Add an already existing endpoint"), "sqlcmd config add-endpoint --address localhost --port 1433"}},
+			localizer.Sprintf("Endpoint required to add context.  Endpoint '%v' does not exist.  Use %s flag", c.endpointName, localizer.EndpointFlag))
 	}
 
 	if c.userName != "" {
 		if !config.UserNameExists(c.userName) {
 			output.FatalfWithHintExamples([][]string{
-				{"View list of users", "sqlcmd config get-users"},
-				{"Add the user", fmt.Sprintf("sqlcmd config add-user --name %v", c.userName)},
-				{"Add an endpoint", "sqlcmd create"}},
-				"User '%v' does not exist", c.userName)
+				{localizer.Sprintf("View list of users"), "sqlcmd config get-users"},
+				{localizer.Sprintf("Add the user"), fmt.Sprintf("sqlcmd config add-user --name %v", c.userName)},
+				{localizer.Sprintf("Add an endpoint"), "sqlcmd create"}},
+				localizer.Sprintf("User '%v' does not exist", c.userName))
 		}
 	}
 
 	context.Name = config.AddContext(context)
 	config.SetCurrentContextName(context.Name)
 	output.InfofWithHintExamples([][]string{
-		{"Open in Azure Data Studio", "sqlcmd open ads"},
-		{"To start interactive query session", "sqlcmd query"},
-		{"To run a query", "sqlcmd query \"SELECT @@version\""},
-	}, "Current Context '%v'", context.Name)
+		{localizer.Sprintf("Open in Azure Data Studio"), "sqlcmd open ads"},
+		{localizer.Sprintf("To start interactive query session"), "sqlcmd query"},
+		{localizer.Sprintf("To run a query"), "sqlcmd query \"SELECT @@version\""},
+	}, localizer.Sprintf("Current Context '%v'", context.Name))
 }

cmd/modern/root/config/add-endpoint.go

@@ -5,10 +5,12 @@ package config
 
 import (
 	"fmt"
+
 	"github.com/microsoft/go-sqlcmd/cmd/modern/sqlconfig"
 
 	"github.com/microsoft/go-sqlcmd/internal/cmdparser"
 	"github.com/microsoft/go-sqlcmd/internal/config"
+	"github.com/microsoft/go-sqlcmd/internal/localizer"
 )
 
 // AddEndpoint implements the `sqlcmd config add-endpoint` command
@@ -23,10 +25,10 @@ type AddEndpoint struct {
 func (c *AddEndpoint) DefineCommand(...cmdparser.CommandOptions) {
 	options := cmdparser.CommandOptions{
 		Use:   "add-endpoint",
-		Short: "Add an endpoint",
+		Short: localizer.Sprintf("Add an endpoint"),
 		Examples: []cmdparser.ExampleOptions{
 			{
-				Description: "Add a default endpoint",
+				Description: localizer.Sprintf("Add a default endpoint"),
 				Steps:       []string{"sqlcmd config add-endpoint --name my-endpoint --address localhost --port 1433"},
 			},
 		},
@@ -38,21 +40,21 @@ func (c *AddEndpoint) DefineCommand(...cmdparser.CommandOptions) {
 		String:        &c.name,
 		Name:          "name",
 		DefaultString: "endpoint",
-		Usage:         "Display name for the endpoint",
+		Usage:         localizer.Sprintf("Display name for the endpoint"),
 	})
 
 	c.AddFlag(cmdparser.FlagOptions{
 		String:        &c.address,
 		Name:          "address",
 		DefaultString: "localhost",
-		Usage:         "The network address to connect to, e.g. 127.0.0.1 etc.",
+		Usage:         localizer.Sprintf("The network address to connect to, e.g. 127.0.0.1 etc."),
 	})
 
 	c.AddFlag(cmdparser.FlagOptions{
 		Int:        &c.port,
 		Name:       "port",
 		DefaultInt: 1433,
-		Usage:      "The network port to connect to, e.g. 1433 etc.",
+		Usage:      localizer.Sprintf("The network port to connect to, e.g. 1433 etc."),
 	})
 }
 
@@ -73,11 +75,11 @@ func (c *AddEndpoint) run() {
 
 	uniqueEndpointName := config.AddEndpoint(endpoint)
 	output.InfofWithHintExamples([][]string{
-		{"Add a context for this endpoint", fmt.Sprintf("sqlcmd config add-context --endpoint %v", uniqueEndpointName)},
-		{"View endpoint names", "sqlcmd config get-endpoints"},
-		{"View endpoint details", fmt.Sprintf("sqlcmd config get-endpoints %v", uniqueEndpointName)},
-		{"View all endpoints details", "sqlcmd config get-endpoints --detailed"},
-		{"Delete this endpoint", fmt.Sprintf("sqlcmd config delete-endpoint %v", uniqueEndpointName)},
+		{localizer.Sprintf("Add a context for this endpoint"), fmt.Sprintf("sqlcmd config add-context --endpoint %v", uniqueEndpointName)},
+		{localizer.Sprintf("View endpoint names"), "sqlcmd config get-endpoints"},
+		{localizer.Sprintf("View endpoint details"), fmt.Sprintf("sqlcmd config get-endpoints %v", uniqueEndpointName)},
+		{localizer.Sprintf("View all endpoints details"), "sqlcmd config get-endpoints --detailed"},
+		{localizer.Sprintf("Delete this endpoint"), fmt.Sprintf("sqlcmd config delete-endpoint %v", uniqueEndpointName)},
 	},
-		"Endpoint '%v' added (address: '%v', port: '%v')", uniqueEndpointName, c.address, c.port)
+		localizer.Sprintf("Endpoint '%v' added (address: '%v', port: '%v')", uniqueEndpointName, c.address, c.port))
 }

cmd/modern/root/config/add-user.go

@@ -5,11 +5,13 @@ package config
 
 import (
 	"fmt"
-	"github.com/microsoft/go-sqlcmd/cmd/modern/sqlconfig"
-	"github.com/microsoft/go-sqlcmd/internal/pal"
 	"os"
 	"runtime"
 
+	"github.com/microsoft/go-sqlcmd/cmd/modern/sqlconfig"
+	"github.com/microsoft/go-sqlcmd/internal/localizer"
+	"github.com/microsoft/go-sqlcmd/internal/pal"
+
 	"github.com/microsoft/go-sqlcmd/internal/cmdparser"
 	"github.com/microsoft/go-sqlcmd/internal/config"
 	"github.com/microsoft/go-sqlcmd/internal/secret"
@@ -28,15 +30,15 @@ type AddUser struct {
 func (c *AddUser) DefineCommand(...cmdparser.CommandOptions) {
 	examples := []cmdparser.ExampleOptions{
 		{
-			Description: "Add a user (using the SQLCMD_PASSWORD environment variable)",
+			Description: localizer.Sprintf("Add a user (using the SQLCMD_PASSWORD environment variable)"),
 			Steps: []string{
 				fmt.Sprintf(`%s SQLCMD_PASSWORD=<placeholderpassword>`, pal.CreateEnvVarKeyword()),
 				"sqlcmd config add-user --name my-user --username user1 --password-encryption none",
 				fmt.Sprintf(`%s SQLCMD_PASSWORD=`, pal.CreateEnvVarKeyword()),
 			},
 		},
 		{
-			Description: "Add a user (using the SQLCMDPASSWORD environment variable)",
+			Description: localizer.Sprintf("Add a user (using the SQLCMDPASSWORD environment variable)"),
 			Steps: []string{
 				fmt.Sprintf(`%s SQLCMDPASSWORD=<placeholderpassword>`, pal.CreateEnvVarKeyword()),
 				"sqlcmd config add-user --name my-user --username user1 --password-encryption none",
@@ -47,7 +49,7 @@ func (c *AddUser) DefineCommand(...cmdparser.CommandOptions) {
 
 	if runtime.GOOS == "windows" {
 		examples = append(examples, cmdparser.ExampleOptions{
-			Description: "Add a user using Windows Data Protection API to encrypt password in sqlconfig",
+			Description: localizer.Sprintf("Add a user using Windows Data Protection API to encrypt password in sqlconfig"),
 			Steps: []string{
 				fmt.Sprintf(`%s SQLCMD_PASSWORD=<placeholderpassword>`, pal.CreateEnvVarKeyword()),
 				"sqlcmd config add-user --name my-user --username user1 --password-encryption dpapi",
@@ -58,7 +60,7 @@ func (c *AddUser) DefineCommand(...cmdparser.CommandOptions) {
 
 	options := cmdparser.CommandOptions{
 		Use:      "add-user",
-		Short:    "Add a user",
+		Short:    localizer.Sprintf("Add a user"),
 		Examples: examples,
 		Run:      c.run}
 
@@ -68,27 +70,26 @@ func (c *AddUser) DefineCommand(...cmdparser.CommandOptions) {
 		String:        &c.name,
 		Name:          "name",
 		DefaultString: "user",
-		Usage:         "Display name for the user (this is not the username)",
+		Usage:         localizer.Sprintf("Display name for the user (this is not the username)"),
 	})
 
 	c.AddFlag(cmdparser.FlagOptions{
 		String:        &c.authType,
 		Name:          "auth-type",
 		DefaultString: "basic",
-		Usage:         "Authentication type this user will use (basic | other)",
+		Usage:         localizer.Sprintf("Authentication type this user will use (basic | other)"),
 	})
 
 	c.AddFlag(cmdparser.FlagOptions{
 		String: &c.username,
 		Name:   "username",
-		Usage:  "The username (provide password in SQLCMD_PASSWORD or SQLCMDPASSWORD environment variable)",
+		Usage:  localizer.Sprintf("The username (provide password in %s or %s environment variable)", localizer.PasswordEnvVar, localizer.PasswordEnvVar2),
 	})
 
 	c.AddFlag(cmdparser.FlagOptions{
 		String: &c.passwordEncryption,
 		Name:   "password-encryption",
-		Usage: fmt.Sprintf("Password encryption method (%s) in sqlconfig file",
-			secret.EncryptionMethodsForUsage()),
+		Usage:  localizer.Sprintf("Password encryption method (%s) in sqlconfig file", secret.EncryptionMethodsForUsage()),
 	})
 }
 
@@ -105,21 +106,21 @@ func (c *AddUser) run() {
 
 	if c.authType != "basic" &&
 		c.authType != "other" {
-		output.FatalfWithHints([]string{"Authentication type must be 'basic' or 'other'"},
-			"Authentication type '' is not valid %v'", c.authType)
+		output.FatalfWithHints([]string{localizer.Sprintf("Authentication type must be '%s' or '%s'", localizer.ModernAuthTypeBasic, localizer.ModernAuthTypeOther)},
+			localizer.Sprintf("Authentication type '' is not valid %v'", c.authType))
 	}
 
 	if c.authType != "basic" && c.passwordEncryption != "" {
 		output.FatalWithHints([]string{
-			"Remove the --password-encryption flag",
-			"Pass in the --auth-type basic"},
-			"The --password-encryption flag can only be used when authentication type is 'basic'")
+			localizer.Sprintf("Remove the %s flag", localizer.PasswordEncryptFlag),
+			localizer.Sprintf("Pass in the %s %s", localizer.AuthTypeFlag, localizer.ModernAuthTypeBasic)},
+			localizer.Sprintf("The %s flag can only be used when authentication type is '%s'", localizer.PasswordEncryptFlag, localizer.ModernAuthTypeBasic))
 	}
 
 	if c.authType == "basic" && c.passwordEncryption == "" {
 		output.FatalWithHints([]string{
-			"Add the --password-encryption flag"},
-			"The --password-encryption flag must be set when authentication type is 'basic'")
+			localizer.Sprintf("Add the %s flag", localizer.PasswordEncryptFlag)},
+			localizer.Sprintf("The %s flag must be set when authentication type is '%s'", localizer.PasswordEncryptFlag, localizer.ModernAuthTypeBasic))
 	}
 
 	user := sqlconfig.User{
@@ -130,29 +131,29 @@ func (c *AddUser) run() {
 	if c.authType == "basic" {
 		if os.Getenv("SQLCMD_PASSWORD") == "" && os.Getenv("SQLCMDPASSWORD") == "" {
 			output.FatalWithHints([]string{
-				"Provide password in the SQLCMD_PASSWORD (or SQLCMDPASSWORD) environment variable"},
-				"Authentication Type 'basic' requires a password")
+				localizer.Sprintf("Provide password in the %s (or %s) environment variable", localizer.PasswordEnvVar, localizer.PasswordEnvVar2)},
+				localizer.Sprintf("Authentication Type '%s' requires a password", localizer.ModernAuthTypeBasic))
 		}
 
 		if c.username == "" {
 			output.FatalfWithHintExamples([][]string{
-				{"Provide a username with the --username flag",
+				{localizer.Sprintf("Provide a username with the %s flag"),
 					"sqlcmd config add-user --username sa"},
 			},
-				"Username not provided")
+				localizer.Sprintf("Username not provided"))
 		}
 
 		if !secret.IsValidEncryptionMethod(c.passwordEncryption) {
 			output.FatalfWithHints([]string{
-				fmt.Sprintf("Provide a valid encryption method (%s) with the --password-encryption flag", secret.EncryptionMethodsForUsage())},
-				"Encryption method '%v' is not valid", c.passwordEncryption)
+				localizer.Sprintf("Provide a valid encryption method (%s) with the %s flag", secret.EncryptionMethodsForUsage(), localizer.PasswordEncryptFlag)},
+				localizer.Sprintf("Encryption method '%v' is not valid", c.passwordEncryption))
 		}
 
 		if os.Getenv("SQLCMD_PASSWORD") != "" &&
 			os.Getenv("SQLCMDPASSWORD") != "" {
 			output.FatalWithHints([]string{
-				"Unset one of the environment variables SQLCMD_PASSWORD or SQLCMDPASSWORD"},
-				"Both environment variables SQLCMD_PASSWORD and SQLCMDPASSWORD are set. ")
+				localizer.Sprintf("Unset one of the environment variables %s or %s", localizer.PasswordEnvVar, localizer.PasswordEnvVar2)},
+				localizer.Sprintf("Both environment variables %s and %s are set. ", localizer.PasswordEnvVar, localizer.PasswordEnvVar2))
 		}
 
 		password := os.Getenv("SQLCMD_PASSWORD")
@@ -167,5 +168,5 @@ func (c *AddUser) run() {
 	}
 
 	uniqueUserName := config.AddUser(user)
-	output.Infof("User '%v' added", uniqueUserName)
+	output.Infof(localizer.Sprintf("User '%v' added", uniqueUserName))
 }