Get language translations partially loaded

Author: code-asher

packages/protocol/src/browser/client.ts

@@ -278,6 +278,7 @@ export class Client {
 					shell: init.getShell(),
 					extensionsDirectory: init.getExtensionsDirectory(),
 					builtInExtensionsDirectory: init.getBuiltinExtensionsDir(),
+					languageData: init.getLanguageData(),
 				};
 				this.initDataEmitter.emit(this._initData);
 				break;

packages/protocol/src/common/connection.ts

@@ -25,6 +25,7 @@ export interface InitData {
 	readonly shell: string;
 	readonly extensionsDirectory: string;
 	readonly builtInExtensionsDirectory: string;
+	readonly languageData: string;
 }
 
 export interface SharedProcessData {

packages/protocol/src/node/server.ts

@@ -9,13 +9,18 @@ import { ChildProcessModuleProxy, ForkProvider, FsModuleProxy, NetModuleProxy, N
 
 // tslint:disable no-any
 
+export interface LanguageConfiguration {
+	locale: string;
+}
+
 export interface ServerOptions {
 	readonly workingDirectory: string;
 	readonly dataDirectory: string;
 	readonly cacheDirectory: string;
 	readonly builtInExtensionsDirectory: string;
 	readonly extensionsDirectory: string;
 	readonly fork?: ForkProvider;
+	readonly getLanguageData?: () => Promise<LanguageConfiguration>;
 }
 
 interface ProxyData {
@@ -99,9 +104,25 @@ export class Server {
 		initMsg.setTmpDirectory(os.tmpdir());
 		initMsg.setOperatingSystem(platformToProto(os.platform()));
 		initMsg.setShell(os.userInfo().shell || global.process.env.SHELL || "");
-		const srvMsg = new ServerMessage();
-		srvMsg.setInit(initMsg);
-		connection.send(srvMsg.serializeBinary());
+
+		const getLanguageData = this.options.getLanguageData
+			|| ((): Promise<LanguageConfiguration> => Promise.resolve({
+				locale: "en",
+			}));
+
+		getLanguageData().then((languageData) => {
+			try {
+				initMsg.setLanguageData(JSON.stringify(languageData));
+			} catch (error) {
+				logger.error("Unable to send language config", field("error", error));
+			}
+
+			const srvMsg = new ServerMessage();
+			srvMsg.setInit(initMsg);
+			connection.send(srvMsg.serializeBinary());
+		}).catch((error) => {
+			logger.error(error.message, field("error", error));
+		});
 	}
 
 	/**

packages/protocol/src/proto/client.proto

@@ -42,4 +42,5 @@ message WorkingInit {
 	string shell = 6;
 	string builtin_extensions_dir = 7;
 	string extensions_directory = 8;
+	string language_data = 9;
 }

packages/protocol/src/proto/client_pb.d.ts

@@ -135,6 +135,9 @@ export class WorkingInit extends jspb.Message {
   getExtensionsDirectory(): string;
   setExtensionsDirectory(value: string): void;
 
+  getLanguageData(): string;
+  setLanguageData(value: string): void;
+
   serializeBinary(): Uint8Array;
   toObject(includeInstance?: boolean): WorkingInit.AsObject;
   static toObject(includeInstance: boolean, msg: WorkingInit): WorkingInit.AsObject;
@@ -155,6 +158,7 @@ export namespace WorkingInit {
     shell: string,
     builtinExtensionsDir: string,
     extensionsDirectory: string,
+    languageData: string,
   }
 
   export enum OperatingSystem {

packages/protocol/src/proto/client_pb.js

@@ -795,7 +795,8 @@ proto.WorkingInit.toObject = function(includeInstance, msg) {
     operatingSystem: jspb.Message.getFieldWithDefault(msg, 5, 0),
     shell: jspb.Message.getFieldWithDefault(msg, 6, ""),
     builtinExtensionsDir: jspb.Message.getFieldWithDefault(msg, 7, ""),
-    extensionsDirectory: jspb.Message.getFieldWithDefault(msg, 8, "")
+    extensionsDirectory: jspb.Message.getFieldWithDefault(msg, 8, ""),
+    languageData: jspb.Message.getFieldWithDefault(msg, 9, "")
   };
 
   if (includeInstance) {
@@ -864,6 +865,10 @@ proto.WorkingInit.deserializeBinaryFromReader = function(msg, reader) {
       var value = /** @type {string} */ (reader.readString());
       msg.setExtensionsDirectory(value);
       break;
+    case 9:
+      var value = /** @type {string} */ (reader.readString());
+      msg.setLanguageData(value);
+      break;
     default:
       reader.skipField();
       break;
@@ -949,6 +954,13 @@ proto.WorkingInit.serializeBinaryToWriter = function(message, writer) {
       f
     );
   }
+  f = message.getLanguageData();
+  if (f.length > 0) {
+    writer.writeString(
+      9,
+      f
+    );
+  }
 };
 
 
@@ -1081,4 +1093,19 @@ proto.WorkingInit.prototype.setExtensionsDirectory = function(value) {
 };
 
 
+/**
+ * optional string language_data = 9;
+ * @return {string}
+ */
+proto.WorkingInit.prototype.getLanguageData = function() {
+  return /** @type {string} */ (jspb.Message.getFieldWithDefault(this, 9, ""));
+};
+
+
+/** @param {string} value */
+proto.WorkingInit.prototype.setLanguageData = function(value) {
+  jspb.Message.setProto3StringField(this, 9, value);
+};
+
+
 goog.object.extend(exports, proto);

packages/server/src/cli.ts

@@ -1,5 +1,6 @@
 import { field, logger } from "@coder/logger";
 import { ServerMessage, SharedProcessActive } from "@coder/protocol/src/proto";
+import { LanguageConfiguration } from "@coder/protocol/src/node/server";
 import { withEnv } from "@coder/protocol";
 import { ChildProcess, fork, ForkOptions } from "child_process";
 import { randomFillSync } from "crypto";
@@ -11,6 +12,7 @@ import * as WebSocket from "ws";
 import { buildDir, cacheHome, dataHome, isCli, serveStatic } from "./constants";
 import { createApp } from "./server";
 import { forkModule, requireModule } from "./vscode/bootstrapFork";
+import { getNlsConfiguration } from "./vscode/language";
 import { SharedProcess, SharedProcessState } from "./vscode/sharedProcess";
 import opn = require("opn");
 
@@ -257,6 +259,7 @@ const bold = (text: string | number): string | number => {
 
 				return fork(modulePath, args, options);
 			},
+			getLanguageData: (): Promise<LanguageConfiguration> => getNlsConfiguration(dataDir, builtInExtensionsDir),
 		},
 		password,
 		httpsOptions: hasCustomHttps ? {

packages/server/src/vscode/language.ts

@@ -0,0 +1,70 @@
+import * as fs from "fs";
+import * as path from "path";
+import * as util from "util";
+import { logger } from "@coder/logger";
+import * as lp from "vs/base/node/languagePacks";
+
+// NOTE: This code was pulled from lib/vscode/src/main.js.
+
+const stripComments = (content: string): string => {
+	const regexp = /("(?:[^\\"]*(?:\\.)?)*")|('(?:[^\\']*(?:\\.)?)*')|(\/\*(?:\r?\n|.)*?\*\/)|(\/{2,}.*?(?:(?:\r?\n)|$))/g;
+
+	return content.replace(regexp, (match, _m1, _m2, m3, m4) => {
+		if (m3) { // Only one of m1, m2, m3, m4 matches.
+			return ""; // A block comment. Replace with nothing.
+		} else if (m4) { // A line comment. If it ends in \r?\n then keep it.
+			const length_1 = m4.length;
+			if (length_1 > 2 && m4[length_1 - 1] === "\n") {
+				return m4[length_1 - 2] === "\r" ? "\r\n" : "\n";
+			} else {
+				return "";
+			}
+		} else {
+			return match; // We match a string.
+		}
+	});
+};
+
+/**
+ * Get the locale from the locale file.
+ */
+const getUserDefinedLocale = async (userDataPath: string): Promise<string | undefined> => {
+	const localeConfig = path.join(userDataPath, "User/locale.json");
+
+	try {
+		const content = stripComments(await util.promisify(fs.readFile)(localeConfig, "utf8"));
+		const value = JSON.parse(content).locale;
+
+		return value && typeof value === "string" ? value.toLowerCase() : undefined;
+	} catch (e) {
+		return undefined;
+	}
+};
+
+export const getNlsConfiguration = (userDataPath: string, builtInDirectory: string): Promise<lp.NLSConfiguration> => {
+	const defaultConfig = { locale: "en", availableLanguages: {} };
+
+	return new Promise(async (resolve): Promise<void> => {
+		try {
+			const metaDataFile = require("path").join(builtInDirectory, "nls.metadata.json");
+			const locale = await getUserDefinedLocale(userDataPath);
+			if (!locale) {
+				logger.debug("No locale, using default");
+
+				return resolve(defaultConfig);
+			}
+
+			const config = (await lp.getNLSConfiguration(
+				process.env.VERSION || "development", userDataPath,
+				metaDataFile, locale,
+			)) || defaultConfig;
+
+			(config as lp.InternalNLSConfiguration)._languagePackSupport = true;
+			logger.debug(`Locale is ${locale}`, config);
+			resolve(config);
+		} catch (error) {
+			logger.error(error.message);
+			resolve(defaultConfig);
+		}
+	});
+};

packages/vscode/src/client.ts

@@ -22,6 +22,7 @@ class VSClient extends IdeClient {
 			paths._paths.initialize(data, sharedData);
 			product.initialize(data);
 			process.env.SHELL = data.shell;
+			process.env.VSCODE_NLS_CONFIG = data.languageData;
 			// At this point everything should be filled, including `os`. `os` also
 			// relies on `initData` but it listens first so it initialize before this
 			// callback, meaning we are safe to include everything from VS Code now.

packages/vscode/src/fill/platform.ts

@@ -1,11 +1,64 @@
+import * as fs from "fs";
 import * as os from "os";
+import * as path from "path";
+import * as util from "util";
 import * as platform from "vs/base/common/platform";
 import * as browser from "vs/base/browser/browser";
+import * as nls from "vs/nls";
+import * as lp from "vs/base/node/languagePacks";
 
 // tslint:disable no-any to override const
 
-// Use en instead of en-US since that's vscode default and it uses
-// that to determine whether to output aliases which will be redundant.
+interface IBundledStrings {
+	[moduleId: string]: string[];
+}
+
+const rawNlsConfig = process.env.VSCODE_NLS_CONFIG;
+if (rawNlsConfig) {
+	const nlsConfig = JSON.parse(rawNlsConfig) as lp.InternalNLSConfiguration;
+	const resolved = nlsConfig.availableLanguages["*"];
+	(platform as any).locale = nlsConfig.locale;
+	(platform as any).language = resolved ? resolved : "en";
+	(platform as any).translationsConfigFile = nlsConfig._translationsConfigFile;
+
+	// TODO: Each time this is imported, VS Code's loader creates a different
+	// module with an array of all the translations for that file. We don't use
+	// their loader (we're using Webpack) so we need to figure out a good way to
+	// handle that.
+	if (nlsConfig._resolvedLanguagePackCoreLocation) {
+		const bundles = Object.create(null);
+		(nls as any).load("nls", undefined, (mod: any) => {
+			Object.keys(mod).forEach((k) => (nls as any)[k] = mod[k]);
+		}, {
+			"vs/nls": {
+				...nlsConfig,
+				// Taken from lib/vscode/src/bootstrap.js.
+				loadBundle: async (
+					bundle: string, language: string,
+					cb: (error?: Error, messages?: string[] | IBundledStrings) => void,
+				): Promise<void> => {
+					let result = bundles[bundle];
+					if (result) {
+						return cb(undefined, result);
+					}
+
+					const bundleFile = path.join(nlsConfig._resolvedLanguagePackCoreLocation, bundle.replace(/\//g, "!") + ".nls.json");
+
+					try {
+						const content = await util.promisify(fs.readFile)(bundleFile, "utf8");
+						bundles[bundle] = JSON.parse(content);
+						cb(undefined, bundles[bundle]);
+					} catch (error) {
+						cb(error, undefined);
+					}
+				},
+			},
+		});
+	}
+}
+
+// Anything other than "en" will cause English aliases to display, which ends up
+// just displaying a lot of redundant text when the locale is en-US.
 if (platform.locale === "en-US") {
 	(platform as any).locale = "en";
 }
@@ -20,8 +73,12 @@ if (platform.language === "en-US") {
 (platform as any).isLinux = os.platform() === "linux";
 (platform as any).isWindows = os.platform() === "win32";
 (platform as any).isMacintosh = os.platform() === "darwin";
-(platform as any).platform = os.platform() === "linux" ? platform.Platform.Linux : os.platform() === "win32" ? platform.Platform.Windows : platform.Platform.Mac;
+(platform as any).platform = os.platform() === "linux"
+	? platform.Platform.Linux : os.platform() === "win32"
+	? platform.Platform.Windows : platform.Platform.Mac;
 
 // This is used for keybindings, and in one place to choose between \r\n and \n
 // (which we change to use platform.isWindows instead).
-(platform as any).OS = (browser.isMacintosh ? platform.OperatingSystem.Macintosh : (browser.isWindows ? platform.OperatingSystem.Windows : platform.OperatingSystem.Linux));
+(platform as any).OS = browser.isMacintosh
+	? platform.OperatingSystem.Macintosh : browser.isWindows
+	? platform.OperatingSystem.Windows : platform.OperatingSystem.Linux;