Improve Language Negotiation logic to match the C++ implementation (#19)

Author: zbraniecki

fluent-langneg/src/index.js

@@ -16,7 +16,7 @@ function GetOption(options, property, type, values, fallback) {
     if (type === 'boolean') {
       value = new Boolean(value);
     } else if (type === 'string') {
-      value = value.toString();
+      value = String(value);
     }
 
     if (values !== undefined && values.indexOf(value) === -1) {
@@ -90,22 +90,27 @@ export default function negotiateLanguages(
   const strategy = GetOption(options, 'strategy', 'string',
     ['filtering', 'matching', 'lookup'], 'filtering');
 
-  if (strategy === 'lookup' && defaultLocale === undefined) {
+  if (strategy === 'lookup' && !defaultLocale) {
     throw new Error('defaultLocale cannot be undefined for strategy `lookup`');
   }
 
+  const resolvedReqLoc = Array.from(Object(requestedLocales)).map(loc => {
+    return String(loc);
+  });
+  const resolvedAvailLoc = Array.from(Object(availableLocales)).map(loc => {
+    return String(loc);
+  });
+
   const supportedLocales = filterMatches(
-    requestedLocales, availableLocales, strategy, likelySubtags
+    resolvedReqLoc,
+    resolvedAvailLoc, strategy, likelySubtags
   );
 
   if (strategy === 'lookup') {
     if (supportedLocales.length === 0) {
       supportedLocales.push(defaultLocale);
     }
-    return supportedLocales;
-  }
-
-  if (defaultLocale && !supportedLocales.includes(defaultLocale)) {
+  } else if (defaultLocale && !supportedLocales.includes(defaultLocale)) {
     supportedLocales.push(defaultLocale);
   }
   return supportedLocales;

fluent-langneg/src/locale.js

@@ -1,9 +1,11 @@
 /* eslint no-magic-numbers: 0 */
 
+import { getLikelySubtagsMin } from './subtags';
+
 const languageCodeRe = '([a-z]{2,3}|\\*)';
 const scriptCodeRe = '(?:-([a-z]{4}|\\*))';
 const regionCodeRe = '(?:-([a-z]{2}|\\*))';
-const variantCodeRe = '(?:-([a-z]+|\\*))';
+const variantCodeRe = '(?:-([a-z]{3}|\\*))';
 
 /**
  * Regular expression splitting locale id into four pieces:
@@ -33,7 +35,7 @@ export default class Locale {
    * properly parsed as `en-*-US-*`.
    */
   constructor(locale, range = false) {
-    const result = localeRe.exec(locale);
+    const result = localeRe.exec(locale.replace(/_/g, '-'));
     if (!result) {
       return;
     }
@@ -49,6 +51,7 @@ export default class Locale {
     this.script = script;
     this.region = region;
     this.variant = variant;
+    this.string = locale;
   }
 
   isEqual(locale) {
@@ -63,4 +66,23 @@ export default class Locale {
         this[part].toLowerCase() === locale[part].toLowerCase());
     });
   }
+
+  setVariantRange() {
+    this.variant = '*';
+  }
+
+  setRegionRange() {
+    this.region = '*';
+  }
+
+  addLikelySubtags() {
+    const newLocale = getLikelySubtagsMin(this.string.toLowerCase());
+
+    if (newLocale) {
+      localeParts.forEach(part => this[part] = newLocale[part]);
+      this.string = newLocale.string;
+      return true;
+    }
+    return false;
+  }
 }

fluent-langneg/src/matches.js

@@ -1,48 +1,8 @@
 /* eslint no-magic-numbers: 0 */
-/* eslint complexity: ["error", { "max": 22 }] */
+/* eslint complexity: ["error", { "max": 27 }] */
 
 import Locale from './locale';
-import { getLikelySubtagsMin } from './subtags';
 
-/**
- * Attempts to build a most likely maximum version of the locale id based
- * on it's minimal version.
- *
- * If possible it uses the lookup table above. If this one is missing,
- * it only attempts to place the language code in the region position.
- */
-function getLikelySubtagsLocale(loc, likelySubtags) {
-  if (likelySubtags) {
-    for (const key of Object.keys(likelySubtags)) {
-      if (key.toLowerCase() === loc.toLowerCase()) {
-        return new Locale(likelySubtags[key]);
-      }
-    }
-    return null;
-  }
-  return getLikelySubtagsMin(loc);
-}
-
-/**
- * Replaces the region position with a range to allow for matches
- * with the same language/script but from different region.
- */
-function regionRangeFor(locale) {
-  locale.region = '*';
-  return locale;
-}
-
-function variantRangeFor(locale) {
-  locale.variant = '*';
-  return locale;
-}
-
-function getOrParseLocaleRange(localeStr, cache) {
-  if (!cache.has(localeStr)) {
-    cache.set(localeStr, new Locale(localeStr, true));
-  }
-  return cache.get(localeStr);
-}
 /**
  * Negotiates the languages between the list of requested locales against
  * a list of available locales.
@@ -114,43 +74,57 @@ function getOrParseLocaleRange(localeStr, cache) {
  *    against `sr-Latn`.
  */
 export default function filterMatches(
-  requestedLocales, availableLocales, strategy, likelySubtags
+  requestedLocales, availableLocales, strategy
 ) {
   const supportedLocales = new Set();
 
-  const availableLocalesCache = new Map();
+  const availLocales =
+    new Set(availableLocales.map(locale => new Locale(locale, true)));
 
   outer:
   for (const reqLocStr of requestedLocales) {
-    if (strategy === 'lookup' && supportedLocales.size > 0) {
-      return Array.from(supportedLocales);
-    }
-
     const reqLocStrLC = reqLocStr.toLowerCase();
+    const requestedLocale = new Locale(reqLocStrLC);
+
+    if (requestedLocale.language === undefined) {
+      continue;
+    }
 
     // Attempt to make an exact match
     // Example: `en-US` === `en-US`
     for (const availableLocale of availableLocales) {
       if (reqLocStrLC === availableLocale.toLowerCase()) {
         supportedLocales.add(availableLocale);
-        if (strategy !== 'matching') {
+        for (const loc of availLocales) {
+          if (loc.isEqual(requestedLocale)) {
+            availLocales.delete(loc);
+            break;
+          }
+        }
+        if (strategy === 'lookup') {
+          return Array.from(supportedLocales);
+        } else if (strategy === 'matching') {
           continue outer;
+        } else {
+          break;
         }
       }
     }
 
-    const requestedLocale = new Locale(reqLocStrLC);
 
     // Attempt to match against the available range
     // This turns `en` into `en-*-*-*` and `en-US` into `en-*-US-*`
     // Example: ['en-US'] * ['en'] = ['en']
-    for (const availableLocale of availableLocales) {
-      if (requestedLocale.matches(
-        getOrParseLocaleRange(availableLocale, availableLocalesCache)
-      )) {
-        supportedLocales.add(availableLocale);
-        if (strategy !== 'matching') {
+    for (const availableLocale of availLocales) {
+      if (requestedLocale.matches(availableLocale)) {
+        supportedLocales.add(availableLocale.string);
+        availLocales.delete(availableLocale);
+        if (strategy === 'lookup') {
+          return Array.from(supportedLocales);
+        } else if (strategy === 'matching') {
           continue outer;
+        } else {
+          break;
         }
       }
     }
@@ -159,48 +133,54 @@ export default function filterMatches(
     // If data is available, it'll expand `en` into `en-Latn-US` and
     // `zh` into `zh-Hans-CN`.
     // Example: ['en'] * ['en-GB', 'en-US'] = ['en-US']
-    const maxRequestedLocale =
-      getLikelySubtagsLocale(reqLocStrLC, likelySubtags);
-
-    if (maxRequestedLocale) {
-      for (const availableLocale of availableLocales) {
-        if (maxRequestedLocale.matches(
-          getOrParseLocaleRange(availableLocale, availableLocalesCache)
-        )) {
-          supportedLocales.add(availableLocale);
-          if (strategy !== 'matching') {
+    if (requestedLocale.addLikelySubtags()) {
+      for (const availableLocale of availLocales) {
+        if (requestedLocale.matches(availableLocale)) {
+          supportedLocales.add(availableLocale.string);
+          availLocales.delete(availableLocale);
+          if (strategy === 'lookup') {
+            return Array.from(supportedLocales);
+          } else if (strategy === 'matching') {
             continue outer;
+          } else {
+            break;
           }
         }
       }
     }
 
     // Attempt to look up for a different variant for the same locale ID
     // Example: ['en-US-mac'] * ['en-US-win'] = ['en-US-win']
-    const variantRange = variantRangeFor(maxRequestedLocale || requestedLocale);
-
-    for (const availableLocale of availableLocales) {
-      if (variantRange.matches(
-        getOrParseLocaleRange(availableLocale, availableLocalesCache)
-      )) {
-        supportedLocales.add(availableLocale);
-        if (strategy !== 'matching') {
+    requestedLocale.setVariantRange();
+
+    for (const availableLocale of availLocales) {
+      if (requestedLocale.matches(availableLocale)) {
+        supportedLocales.add(availableLocale.string);
+        availLocales.delete(availableLocale);
+        if (strategy === 'lookup') {
+          return Array.from(supportedLocales);
+        } else if (strategy === 'matching') {
           continue outer;
+        } else {
+          break;
         }
       }
     }
 
     // Attempt to look up for a different region for the same locale ID
     // Example: ['en-US'] * ['en-AU'] = ['en-AU']
-    const regionRange = regionRangeFor(variantRange);
-
-    for (const availableLocale of availableLocales) {
-      if (regionRange.matches(
-        getOrParseLocaleRange(availableLocale, availableLocalesCache)
-      )) {
-        supportedLocales.add(availableLocale);
-        if (strategy !== 'matching') {
+    requestedLocale.setRegionRange();
+
+    for (const availableLocale of availLocales) {
+      if (requestedLocale.matches(availableLocale)) {
+        supportedLocales.add(availableLocale.string);
+        availLocales.delete(availableLocale);
+        if (strategy === 'lookup') {
+          return Array.from(supportedLocales);
+        } else if (strategy === 'matching') {
           continue outer;
+        } else {
+          break;
         }
       }
     }

fluent-langneg/src/subtags.js

@@ -56,6 +56,7 @@ export function getLikelySubtagsMin(loc) {
   const locale = new Locale(loc);
   if (regionMatchingLangs.includes(locale.language)) {
     locale.region = locale.language;
+    locale.string = `${locale.language}-${locale.region}`;
     return locale;
   }
   return null;