localize

Author: bobbrow

Extension/src/LanguageServer/devcmd.ts

@@ -8,20 +8,41 @@ import { vcvars } from 'node-vcvarsall';
 import { vswhere } from 'node-vswhere';
 import * as path from 'path';
 import * as vscode from 'vscode';
+import * as nls from 'vscode-nls';
+import { isWindows } from '../constants';
 import { CppSettings } from './settings';
 
+nls.config({ messageFormat: nls.MessageFormat.bundle, bundleFormat: nls.BundleFormat.standalone })();
+const localize: nls.LocalizeFunc = nls.loadMessageBundle();
+
+const ERROR_NO_CONTEXT = localize('no.context.provided', 'No context provided');
+const NOT_WINDOWS = localize('not.windows', 'This command is only available on Windows');
+const ERROR_NO_VS_FOUND = localize('error.no.vs', 'A Visual Studio installation with the C++ compiler was not found');
+const ERROR_OPERATION_CANCELLED = localize('operation.cancelled', 'The operation was cancelled');
+const ERROR_NO_HOSTS_FOUND = localize('no.hosts', 'No hosts found');
+const CONFIGURING_DEV_ENV = localize('config.dev.env', 'Configuring Developer Environment...');
+const SELECT_VS_INSTALLATION = localize('select.vs.install', 'Select a Visual Studio installation');
+const ADVANCED_OPTIONS = localize('advanced.options', 'Advanced options...');
+const ADVANCED_OPTIONS_DESCRIPTION = localize('advanced.options.desc', 'Select a specific host/target architecture, toolset version, etc.');
+const SELECT_TOOLSET_VERSION = localize('select.toolset', 'Select a toolset version');
+const SELECT_HOST_TARGET_ARCH = localize('select.host.target', 'Select a host and target architecture');
+
 export function isEnvironmentOverrideApplied(context?: vscode.ExtensionContext) {
     return context?.environmentVariableCollection.get('VCToolsInstallDir') !== undefined;
 }
 
 export async function setEnvironment(context?: vscode.ExtensionContext) {
+    if (!isWindows) {
+        throw new Error(NOT_WINDOWS);
+    }
+
     if (!context) {
-        throw new Error('No context provided');
+        throw new Error(ERROR_NO_CONTEXT);
     }
 
     const vses = await getVSInstallations();
     if (!vses) {
-        throw new Error('A Visual Studio installation with the C++ compiler was not found');
+        throw new Error(ERROR_NO_VS_FOUND);
     }
 
     let vs = await chooseVSInstallation(vses);
@@ -34,11 +55,11 @@ export async function setEnvironment(context?: vscode.ExtensionContext) {
     const vars = await vscode.window.withProgress({
         cancellable: false,
         location: vscode.ProgressLocation.Notification,
-        title: 'Configuring Developer Environment...'
+        title: CONFIGURING_DEV_ENV
     }, () => vcvars.getVCVars(vs, options));
 
     if (!vars || !vars['INCLUDE']) {
-        throw new Error(`Something went wrong: ${JSON.stringify(vars)}`);
+        throw new Error(localize('something.wrong', 'Something went wrong: {0}', JSON.stringify(vars)));
     }
 
     const host = vars['VSCMD_ARG_HOST_ARCH'];
@@ -53,7 +74,7 @@ export async function setEnvironment(context?: vscode.ExtensionContext) {
     for (const key of Object.keys(vars)) {
         context.environmentVariableCollection.replace(key, vars[key].replace(`%${key}%`, '${env:' + key + '}'));
     }
-    context.environmentVariableCollection.description = (arch ? `${arch} ` : '') + 'Developer Command Prompt for ' + vs.displayName;
+    context.environmentVariableCollection.description = localize('dev.env.for', '{0} Developer Environment for {1}', arch, vs.displayName);
     context.environmentVariableCollection.persistent = settings.persistDevEnvironment;
 
     return true;
@@ -68,25 +89,25 @@ async function getVSInstallations() {
     });
 
     if (installations.length === 0) {
-        throw new Error('A Visual Studio installation with the C++ compiler was not found');
+        throw new Error(ERROR_NO_VS_FOUND);
     }
     return installations;
 }
 
 async function chooseVSInstallation(installations: vswhere.Installation[]): Promise<vswhere.Installation | undefined> {
     const items: vscode.QuickPickItem[] = installations.map(installation => <vscode.QuickPickItem>{
         label: installation.displayName,
-        description: `Default settings for ${installation.displayName}`
+        description: localize('default.settings', 'Default settings for {0}', installation.displayName)
     });
     items.push({
-        label: 'Advanced options...',
-        description: 'Select a specific host/target architecture, toolset version, etc.'
+        label: ADVANCED_OPTIONS,
+        description: ADVANCED_OPTIONS_DESCRIPTION
     });
     const selection = await vscode.window.showQuickPick(items, {
-        placeHolder: 'Select a Visual Studio installation'
+        placeHolder: SELECT_VS_INSTALLATION
     });
     if (!selection) {
-        throw new Error('The operation was cancelled');
+        throw new Error(ERROR_OPERATION_CANCELLED);
     }
 
     return installations.find(installation => installation.displayName === selection.label);
@@ -95,7 +116,7 @@ async function chooseVSInstallation(installations: vswhere.Installation[]): Prom
 async function getAdvancedConfiguration(vses: vswhere.Installation[]): Promise<Compiler> {
     const compiler = await chooseCompiler(vses);
     if (!compiler) {
-        throw new Error('The operation was cancelled');
+        throw new Error(ERROR_OPERATION_CANCELLED);
     }
     await setOptions(compiler);
     return compiler;
@@ -125,10 +146,10 @@ async function chooseCompiler(vses: vswhere.Installation[]): Promise<Compiler |
         description: compiler.vs.displayName
     });
     const selection = await vscode.window.showQuickPick(items, {
-        placeHolder: 'Select a toolset version'
+        placeHolder: SELECT_TOOLSET_VERSION
     });
     if (!selection) {
-        throw new Error('The operation was cancelled');
+        throw new Error(ERROR_OPERATION_CANCELLED);
     }
     return compilers.find(compiler => compiler.version === selection.label && compiler.vs.displayName === selection.description);
 }
@@ -139,13 +160,13 @@ async function setOptions(compiler: Compiler): Promise<void> {
     if (hostTargets.length > 1) {
         const items = hostTargets.map(ht => <vscode.QuickPickItem>{
             label: vcvars.getArchitecture(ht),
-            description: `host = ${ht.host}, target = ${ht.target}`
+            description: localize('host.target', 'host = {0}, target = {1}', ht.host, ht.target)
         });
         const selection = await vscode.window.showQuickPick(items, {
-            placeHolder: 'Select a host and target architecture'
+            placeHolder: SELECT_HOST_TARGET_ARCH
         });
         if (!selection) {
-            throw new Error('The operation was cancelled');
+            throw new Error(ERROR_OPERATION_CANCELLED);
         }
         compiler.options.arch = <vcvars.Architecture>selection.label;
     }
@@ -154,7 +175,7 @@ async function setOptions(compiler: Compiler): Promise<void> {
 async function getHostsAndTargets(vcPath: string): Promise<vcvars.HostTarget[]> {
     const hosts = await fs.readdir(vcPath);
     if (hosts.length === 0) {
-        throw new Error('No hosts found');
+        throw new Error(ERROR_NO_HOSTS_FOUND);
     }
     const hostTargets: vcvars.HostTarget[] = [];
     for (const host of hosts) {