Merge pull request #16 from telerik/default-currency

Determine default currency based on chronological order

Author: danielkaradachki

src/cldr/currency.js

@@ -1,16 +1,19 @@
 import { cldr, getLocaleInfo } from './info';
-import localeTerritory from './territory';
 import { errors } from '../errors';
+import localeTerritory from './territory';
+import parseRangeDate from './parse-range-date';
 
 const {
     NoCurrency,
     NoCurrencyDisplay,
     NoSupplementalCurrency,
-    NoCurrencyRegion
+    NoCurrencyRegion,
+    NoValidCurrency
 } = errors;
 
 const DEFAULT_CURRENCY_FRACTIONS = 2;
 const SYMBOL = "symbol";
+const INVALID_CURRENCY_CODE = 'XXX';
 
 function getCurrencyInfo(locale, currency) {
     const info = getLocaleInfo(locale);
@@ -32,6 +35,38 @@ function lengthComparer(a, b) {
     return b.length - a.length;
 }
 
+function regionCurrency(regionCurrencies) {
+    let latestValidUntil, latestValidUntilRange;
+    let latestStillValid, latestStillValidDate;
+
+    for (let idx = 0; idx < regionCurrencies.length; idx++) {
+        const currency = regionCurrencies[idx];
+        const code = Object.keys(currency)[0];
+        const info = currency[code];
+        if (code !== INVALID_CURRENCY_CODE && info._tender !== 'false' && info._from) {
+            if (!info._to) {
+                const stillValidDate = parseRangeDate(info._from);
+                if (!latestStillValidDate || latestStillValidDate < stillValidDate) {
+                    latestStillValid = code;
+                    latestStillValidDate = stillValidDate;
+                }
+            } else if (!latestStillValid) {
+                const validFrom = parseRangeDate(info._from);
+                const validTo = parseRangeDate(info._to);
+                if (!latestValidUntilRange || latestValidUntilRange.to < validTo || latestValidUntilRange.from < validFrom) {
+                    latestValidUntil = code;
+                    latestValidUntilRange = {
+                        from: validFrom,
+                        to: validTo
+                    };
+                }
+            }
+        }
+    }
+
+    return latestStillValid || latestValidUntil;
+}
+
 export function currencyDisplays(locale, currency) {
     const currencyInfo = getCurrencyInfo(locale, currency);
     if (!currencyInfo.displays) {
@@ -92,19 +127,29 @@ export function territoryCurrencyCode(territory) {
     }
 
     const regionCurrencies = currencyData.region[territory];
+
     if (!regionCurrencies) {
-        throw NoCurrencyRegion.error();
+        throw NoCurrencyRegion.error(territory);
     }
-    const currencyCode = Object.keys(regionCurrencies[regionCurrencies.length - 1])[0];
+
+    const currencyCode = regionCurrency(regionCurrencies);
 
     return currencyCode;
 }
 
-export function localeCurrency(locale) {
+export function localeCurrency(locale, throwIfNoValid) {
     const info = getLocaleInfo(locale);
     const numbers = info.numbers;
+
     if (!numbers.localeCurrency) {
-        numbers.localeCurrency = territoryCurrencyCode(localeTerritory(info));
+        const currency = territoryCurrencyCode(localeTerritory(info));
+
+        if (!currency && throwIfNoValid) {
+            throw NoValidCurrency.error(info.name);
+        }
+
+        numbers.localeCurrency = currency;
     }
+
     return numbers.localeCurrency;
 }

src/cldr/parse-range-date.js

@@ -0,0 +1,8 @@
+export default function(value) {
+    const parts = value.split('-');
+    const year = parseInt(parts[0], 10);
+    const month = parseInt(parts[1], 10) - 1;
+    const day = parseInt(parts[2], 10);
+
+    return new Date(year, month, day);
+}

src/error-details.js

@@ -9,5 +9,6 @@ export default {
     "NoCurrencyDisplay": "Cannot determine currency display information. Please load the locale currencies data. The default culture does not include the all currencies data.",
     "NoGMTInfo": "Cannot determine locale GMT format. Please load the locale timeZoneNames data.",
     "NoWeekData": "Cannot determine locale first day of week. Please load the supplemental weekData.",
-    "NoFirstDay": "Cannot determine locale first day of week. Please load the supplemental weekData. The default culture includes only the 'en-US' first day info."
+    "NoFirstDay": "Cannot determine locale first day of week. Please load the supplemental weekData. The default culture includes only the 'en-US' first day info.",
+    "NoValidCurrency": "Cannot determine a default currency for the {0} locale. Please specify explicitly the currency with the format options."
 };

src/numbers/format-currency-symbol.js

@@ -2,7 +2,7 @@ import { currencyDisplay, localeCurrency } from '../cldr';
 
 export default function formatCurrencySymbol(info, options = {}) {
     if (!options.currency) {
-        options.currency = localeCurrency(info);
+        options.currency = localeCurrency(info, true);
     }
 
     const display = currencyDisplay(info, options);

src/numbers/parse-number.js

@@ -4,29 +4,31 @@ const exponentRegExp = /[eE][\-+]?[0-9]+/;
 const nonBreakingSpaceRegExp = /\u00A0/g;
 
 function cleanCurrencyNumber(value, info, format) {
-    const currency = format.currency || localeCurrency(info);
-    const displays = currencyDisplays(info, currency);
     let isCurrency = format.style === "currency";
     let number = value;
     let negative;
 
+    const currency = format.currency || localeCurrency(info, isCurrency);
 
-    for (let idx = 0; idx < displays.length; idx++) {
-        let display = displays[idx];
-        if (number.includes(display)) {
-            number = number.replace(display, "");
-            isCurrency = true;
-            break;
+    if (currency) {
+        const displays = currencyDisplays(info, currency);
+        for (let idx = 0; idx < displays.length; idx++) {
+            let display = displays[idx];
+            if (number.includes(display)) {
+                number = number.replace(display, "");
+                isCurrency = true;
+                break;
+            }
         }
-    }
 
-    if (isCurrency) {
-        const patterns = info.numbers.currency.patterns;
-        if (patterns.length > 1) {
-            const parts = (patterns[1] || "").replace("$", "").split("n");
-            if (number.indexOf(parts[0]) > -1 && number.indexOf(parts[1]) > -1) {
-                number = number.replace(parts[0], "").replace(parts[1], "");
-                negative = true;
+        if (isCurrency) {
+            const patterns = info.numbers.currency.patterns;
+            if (patterns.length > 1) {
+                const parts = (patterns[1] || "").replace("$", "").split("n");
+                if (number.indexOf(parts[0]) > -1 && number.indexOf(parts[1]) > -1) {
+                    number = number.replace(parts[0], "").replace(parts[1], "");
+                    negative = true;
+                }
             }
         }
     }

test/cldr.js

@@ -277,10 +277,104 @@ describe('firstDay', () => {
 });
 
 describe('localeCurrency', () => {
+
+    cldr.currencyTest = {
+        identity: {
+            territory: "currencyTest"
+        },
+        numbers: {}
+    };
+
+    afterEach(() => {
+        delete cldr.currencyTest.numbers.localeCurrency;
+    });
+
     it('should return default currency code for locale', () => {
         expect(localeCurrency('en')).toEqual('USD');
         expect(localeCurrency('bg')).toEqual('BGN');
     });
+
+    it('throws error if second parameter is true and there is no valid currency for the locale', () => {
+        cldr.supplemental.currencyData.region.currencyTest = [{ XXX: {} }];
+
+        expect(() => {
+            localeCurrency('currencyTest', true);
+        }).toThrowError(/NoValidCurrency/);
+    });
+
+    it('returns still valid currency', () => {
+        cldr.supplemental.currencyData.region.currencyTest = [
+          {
+            "Foo": {
+              "_from": "1915-01-01"
+            }
+          }, {
+            "Bar": {
+              "_from": "1872-08-26",
+              "_to": "2002-05-15"
+            }
+          }
+        ];
+
+        expect(localeCurrency('currencyTest')).toEqual('Foo');
+    });
+
+    it('returns latest still valid currency', () => {
+        cldr.supplemental.currencyData.region.currencyTest = [
+          {
+            "Foo": {
+              "_from": "1915-01-01"
+            }
+          }, {
+            "Bar": {
+              "_from": "1872-08-26"
+            }
+          }
+        ];
+
+        expect(localeCurrency('currencyTest')).toEqual('Foo');
+    });
+
+    it('returns latest valid until currency', () => {
+        cldr.supplemental.currencyData.region.currencyTest = [
+          {
+            "Foo": {
+              "_from": "1994-01-24",
+              "_to": "2002-05-15"
+            }
+          }, {
+            "Bar": {
+              "_from": "2003-02-04",
+              "_to": "2006-06-03"
+            }
+          }, {
+            "Baz": {
+              "_from": "2002-05-15",
+              "_to": "2006-06-03"
+            }
+          }
+        ];
+
+        expect(localeCurrency('currencyTest')).toEqual('Bar');
+    });
+
+    it('ignores currencies with _tender equal to false', () => {
+        cldr.supplemental.currencyData.region.currencyTest = [
+          {
+            "Foo": {
+              "_from": "1915-01-01",
+              "_tender": "false"
+            }
+          }, {
+            "Bar": {
+              "_from": "1872-08-26"
+            }
+          }
+        ];
+
+        expect(localeCurrency('currencyTest')).toEqual('Bar');
+    });
+
 });
 
 describe('currencyDisplay', () => {

test/numbers.js

@@ -1,4 +1,4 @@
-import { load } from '../src/cldr';
+import { load, cldr } from '../src/cldr';
 import { formatNumber, parseNumber } from '../src/numbers';
 
 const likelySubtags = require("cldr-data/supplemental/likelySubtags.json");
@@ -7,7 +7,7 @@ const currencies = require("cldr-data/main/bg/currencies.json");
 const currencyData = require("cldr-data/supplemental/currencyData.json");
 
 // CUSTOM region is used in tests below
-currencyData.supplemental.currencyData.region.CUSTOM = [{}];
+currencyData.supplemental.currencyData.region.CUSTOM = [{ XXX: {} }];
 
 load(likelySubtags, currencyData, numbers, currencies);
 
@@ -16,7 +16,8 @@ function loadCustom(options) {
       "main": {
         "custom": {
           "identity": {
-            "language": "custom"
+            "language": "custom",
+            "territory": "CUSTOM"
           },
           "numbers": {
             "symbols-numberSystem-latn": {
@@ -50,6 +51,30 @@ describe('formatNumber', () => {
         expect(formatNumber(Infinity)).toBe(Infinity);
         expect(formatNumber("foo")).toEqual("foo");
     });
+
+
+    describe('errors', () => {
+        currencyData.supplemental.currencyData.region.CUSTOM = [{ XXX: {} }];
+        loadCustom({ currencies: { USD: { symbol: "$" } } });
+
+        it('throws error if the default locale currency cannot be determined', () => {
+            expect(() => {
+                formatNumber(10, 'c', 'custom');
+            }).toThrowError(/NoValidCurrency/);
+        });
+
+        it('does not throw error if default locale currency cannot be determined but the currency is specified', () => {
+            expect(() => {
+                formatNumber(10, { style: 'currency', currency: 'USD' }, 'custom');
+            }).not.toThrow();
+        });
+
+        it('does not throw error if default locale currency cannot be determined but the format does not require it', () => {
+            expect(() => {
+                formatNumber(10, 'n', 'custom');
+            }).not.toThrow();
+        });
+    });
 });
 
 describe('standard scientific formatting', () => {
@@ -570,4 +595,26 @@ describe('parseNumber', () => {
         expect(parseNumber("1,23432e+5", "bg")).toEqual(123432);
     });
 
-});
+    describe('errors', () => {
+        currencyData.supplemental.currencyData.region.CUSTOM = [{ XXX: {} }];
+        loadCustom({ currencies: { USD: { symbol: "$" } } });
+
+        it('throws error if the default locale currency cannot be determined', () => {
+            expect(() => {
+                parseNumber("10", 'custom', { style: "currency" });
+            }).toThrowError(/NoValidCurrency/);
+        });
+
+        it('does not throw error if default locale currency cannot be determined but the currency is specified', () => {
+            expect(() => {
+                parseNumber("10", 'custom', { style: "currency", currency: 'USD' });
+            }).not.toThrow();
+        });
+
+        it('does not throw error if default locale currency cannot be determined but the format does not require it', () => {
+            expect(() => {
+                parseNumber("10", 'custom', "n");
+            }).not.toThrow();
+        });
+    });
+});