intl: Add more versions from ICU

doc/api/process.md

@@ -1643,8 +1643,10 @@ Will generate output similar to:
  ares: '1.10.0-DEV',
  modules: '43',
  icu: '55.1',
- openssl: '1.0.1k'
-}
+ openssl: '1.0.1k',
+ unicode: '8.0',
+ cldr: '29.0',
+ tz: '2016b' }
 ```
 
 ## Exit Codes

lib/internal/bootstrap_node.js

@@ -26,6 +26,8 @@
  // do this good and early, since it handles errors.
  setupProcessFatal();
 
+ setupProcessICUVersions();
+
  setupGlobalVariables();
  if (!process._noBrowserGlobals) {
  setupGlobalTimeouts();
@@ -304,6 +306,36 @@
  };
  }
 
+ function setupProcessICUVersions() {
+ const icu = process.binding('config').hasIntl ?
+ process.binding('icu') : undefined;
+ if (!icu) return; // no Intl/ICU: nothing to add here.
+ // With no argument, getVersion() returns a comma separated list
+ // of possible types.
+ const versionTypes = icu.getVersion().split(',');
+ versionTypes.forEach((name) => {
+ // Copied from module.js:addBuiltinLibsToObject
+ Object.defineProperty(process.versions, name, {
+ configurable: true,
+ enumerable: true,
+ get: () => {
+ // With an argument, getVersion(type) returns
+ // the actual version string.
+ const version = icu.getVersion(name);
+ // Replace the current getter with a new
+ // property.
+ delete process.versions[name];
+ Object.defineProperty(process.versions, name, {
+ value: version,
+ writable: false,
+ enumerable: true
+ });
+ return version;
+ }
+ });
+ });
+ }
+
  function tryGetCwd(path) {
  var threw = true;
  var cwd;

lib/util.js

@@ -1049,3 +1049,7 @@ exports._exceptionWithHostPort = function(err,
  }
  return ex;
 };
+
+// process.versions needs a custom function as some values are lazy-evaluated.
+process.versions[exports.inspect.custom] =
+ (depth) => exports.format(JSON.parse(JSON.stringify(process.versions)));

src/node.cc

@@ -3032,9 +3032,7 @@ void SetupProcessObject(Environment* env,
  FIXED_ONE_BYTE_STRING(env->isolate(), ARES_VERSION_STR));
 
 #if defined(NODE_HAVE_I18N_SUPPORT) && defined(U_ICU_VERSION)
- READONLY_PROPERTY(versions,
- "icu",
- OneByteString(env->isolate(), U_ICU_VERSION));
+ // ICU-related versions are now handled on the js side, see bootstrap_node.js
 
  if (icu_data_dir != nullptr) {
  // Did the user attempt (via env var or parameter) to set an ICU path?

src/node_i18n.cc

@@ -31,14 +31,18 @@
 #include "util-inl.h"
 #include "v8.h"
 
+#include <unicode/utypes.h>
 #include <unicode/putil.h>
 #include <unicode/uchar.h>
 #include <unicode/udata.h>
 #include <unicode/uidna.h>
-#include <unicode/utypes.h>
 #include <unicode/ucnv.h>
 #include <unicode/utf8.h>
 #include <unicode/utf16.h>
+#include <unicode/timezone.h>
+#include <unicode/ulocdata.h>
+#include <unicode/uvernum.h>
+#include <unicode/uversion.h>
 
 #ifdef NODE_HAVE_SMALL_ICU
 /* if this is defined, we have a 'secondary' entry point.
@@ -339,6 +343,67 @@ static void ICUErrorName(const FunctionCallbackInfo<Value>& args) {
  v8::NewStringType::kNormal).ToLocalChecked());
 }
 
+#define TYPE_ICU "icu"
+#define TYPE_UNICODE "unicode"
+#define TYPE_CLDR "cldr"
+#define TYPE_TZ "tz"
+
+/**
+ * This is the workhorse function that deals with the actual version info.
+ * Get an ICU version.
+ * @param type the type of version to get. One of VERSION_TYPES
+ * @param buf optional buffer for result
+ * @param status ICU error status. If failure, assume result is undefined.
+ * @return version number, or NULL. May or may not be buf.
+ */
+static const char* GetVersion(const char* type,
+ char buf[U_MAX_VERSION_STRING_LENGTH],
+ UErrorCode* status) {
+ if (!strcmp(type, TYPE_ICU)) {
+ return U_ICU_VERSION;
+ } else if (!strcmp(type, TYPE_UNICODE)) {
+ return U_UNICODE_VERSION;
+ } else if (!strcmp(type, TYPE_TZ)) {
+ return TimeZone::getTZDataVersion(*status);
+ } else if (!strcmp(type, TYPE_CLDR)) {
+ UVersionInfo versionArray;
+ ulocdata_getCLDRVersion(versionArray, status);
+ if (U_SUCCESS(*status)) {
+ u_versionToString(versionArray, buf);
+ return buf;
+ }
+ }
+ // Fall through - unknown type or error case
+ return nullptr;
+}
+
+static void GetVersion(const FunctionCallbackInfo<Value>& args) {
+ Environment* env = Environment::GetCurrent(args);
+ if ( args.Length() == 0 ) {
+ // With no args - return a comma-separated list of allowed values
+ args.GetReturnValue().Set(
+ String::NewFromUtf8(env->isolate(),
+ TYPE_ICU ","
+ TYPE_UNICODE ","
+ TYPE_CLDR ","
+ TYPE_TZ));
+ } else {
+ CHECK_GE(args.Length(), 1);
+ CHECK(args[0]->IsString());
+ Utf8Value val(env->isolate(), args[0]);
+ UErrorCode status = U_ZERO_ERROR;
+ char buf[U_MAX_VERSION_STRING_LENGTH] = ""; // Possible output buffer.
+ const char* versionString = GetVersion(*val, buf, &status);
+
+ if (U_SUCCESS(status) && versionString) {
+ // Success.
+ args.GetReturnValue().Set(
+ String::NewFromUtf8(env->isolate(),
+ versionString));
+ }
+ }
+}
+
 bool InitializeICUDirectory(const char* icu_data_path) {
  if (icu_data_path != nullptr) {
  flag_icu_data_dir = true;
@@ -558,6 +623,7 @@ void Init(Local<Object> target,
  env->SetMethod(target, "toUnicode", ToUnicode);
  env->SetMethod(target, "toASCII", ToASCII);
  env->SetMethod(target, "getStringWidth", GetStringWidth);
+ env->SetMethod(target, "getVersion", GetVersion);
 
  // One-shot converters
  env->SetMethod(target, "icuErrName", ICUErrorName);

test/parallel/test-process-versions.js

@@ -11,6 +11,9 @@ if (common.hasCrypto) {
 
 if (common.hasIntl) {
  expected_keys.push('icu');
+ expected_keys.push('cldr');
+ expected_keys.push('tz');
+ expected_keys.push('unicode');
 }
 
 expected_keys.sort();