feat(isAlphanumeric): allow usage of options object

README.md

@@ -91,9 +91,9 @@ Validator                               | Description
 --------------------------------------- | --------------------------------------
 **contains(str, seed [, options ])**    | check if the string contains the seed.<br/><br/>`options` is an object that defaults to `{ ignoreCase: false, minOccurrences: 1 }`.<br />Options: <br/> `ignoreCase`: Ignore case when doing comparison, default false<br/>`minOccurences`: Minimum number of occurrences for the seed in the string. Defaults to 1.
 **equals(str, comparison)**             | check if the string matches the comparison.
-**isAfter(str [, date])**               | check if the string is a date that's after the specified date (defaults to now).
-**isAlpha(str [, locale, options])**    | check if the string contains only letters (a-zA-Z).<br/><br/>Locale is one of `['ar', 'ar-AE', 'ar-BH', 'ar-DZ', 'ar-EG', 'ar-IQ', 'ar-JO', 'ar-KW', 'ar-LB', 'ar-LY', 'ar-MA', 'ar-QA', 'ar-QM', 'ar-SA', 'ar-SD', 'ar-SY', 'ar-TN', 'ar-YE', 'bg-BG', 'bn', 'cs-CZ', 'da-DK', 'de-DE', 'el-GR', 'en-AU', 'en-GB', 'en-HK', 'en-IN', 'en-NZ', 'en-US', 'en-ZA', 'en-ZM', 'es-ES', 'fa-IR', 'fi-FI', 'fr-CA', 'fr-FR', 'he', 'hi-IN', 'hu-HU', 'it-IT', 'ko-KR', 'ja-JP', 'ku-IQ', 'nb-NO', 'nl-NL', 'nn-NO', 'pl-PL', 'pt-BR', 'pt-PT', 'ru-RU', 'si-LK', 'sl-SI', 'sk-SK', 'sr-RS', 'sr-RS@latin', 'sv-SE', 'tr-TR', 'uk-UA']`) and defaults to `en-US`. Locale list is `validator.isAlphaLocales`. options is an optional object that can be supplied with the following key(s): ignore which can either be a String or RegExp of characters to be ignored e.g. " -" will ignore spaces and -'s.
-**isAlphanumeric(str [, locale, options])**      | check if the string contains only letters and numbers (a-zA-Z0-9).<br/><br/>Locale is one of `['ar', 'ar-AE', 'ar-BH', 'ar-DZ', 'ar-EG', 'ar-IQ', 'ar-JO', 'ar-KW', 'ar-LB', 'ar-LY', 'ar-MA', 'ar-QA', 'ar-QM', 'ar-SA', 'ar-SD', 'ar-SY', 'ar-TN', 'ar-YE', 'bn', 'bg-BG', 'cs-CZ', 'da-DK', 'de-DE', 'el-GR', 'en-AU', 'en-GB', 'en-HK', 'en-IN', 'en-NZ', 'en-US', 'en-ZA', 'en-ZM', 'es-ES', 'fa-IR', 'fi-FI', 'fr-CA', 'fr-FR', 'he', 'hi-IN', 'hu-HU', 'it-IT', 'ko-KR', 'ja-JP','ku-IQ', 'nb-NO', 'nl-NL', 'nn-NO', 'pl-PL', 'pt-BR', 'pt-PT', 'ru-RU', 'si-LK', 'sl-SI', 'sk-SK', 'sr-RS', 'sr-RS@latin', 'sv-SE', 'tr-TR', 'uk-UA']`) and defaults to `en-US`. Locale list is `validator.isAlphanumericLocales`. options is an optional object that can be supplied with the following key(s): ignore which can either be a String or RegExp of characters to be ignored e.g. " -" will ignore spaces and -'s.
+**isAfter(str [, options])**            | check if the string is a date that's after the specified date.<br/><br/>`options` is an object that defaults to `{ date: new Date() }`.<br/>_Options:_<br/>`date`: Date to compare to. Defaults to `new Date()` (now).
+**isAlpha(str [, options])**    | check if the string contains only letters (a-zA-Z).<br/><br/>`options` is an object that defaults to `{ locale: 'en-US' }`.<br/><br/>**Options:**<br/>`locale`: The supported locale is one of `['ar', 'ar-AE', 'ar-BH', 'ar-DZ', 'ar-EG', 'ar-IQ', 'ar-JO', 'ar-KW', 'ar-LB', 'ar-LY', 'ar-MA', 'ar-QA', 'ar-QM', 'ar-SA', 'ar-SD', 'ar-SY', 'ar-TN', 'ar-YE', 'bg-BG', 'bn', 'cs-CZ', 'da-DK', 'de-DE', 'el-GR', 'en-AU', 'en-GB', 'en-HK', 'en-IN', 'en-NZ', 'en-US', 'en-ZA', 'en-ZM', 'es-ES', 'fa-IR', 'fi-FI', 'fr-CA', 'fr-FR', 'he', 'hi-IN', 'hu-HU', 'it-IT', 'ko-KR', 'ja-JP', 'ku-IQ', 'nb-NO', 'nl-NL', 'nn-NO', 'pl-PL', 'pt-BR', 'pt-PT', 'ru-RU', 'si-LK', 'sl-SI', 'sk-SK', 'sr-RS', 'sr-RS@latin', 'sv-SE', 'tr-TR', 'uk-UA']`) and defaults to `en-US`. The locale list is `validator.isAlphaLocales`.<br/><br/>`ignore`: (optional) A string or RegExp containing characters to ignore, e.g. `'- /' ` or `/[\s/-]/g` to ignore spaces and "-".
+**isAlphanumeric(str [, options])**     | check if the string contains only letters and numbers (a-zA-Z0-9).<br/><br/>`options` is an object that defaults to `{ locale: 'en-US' }`.<br/><br/>**Options:**<br/>`locale`: The supported locale is one of `['ar', 'ar-AE', 'ar-BH', 'ar-DZ', 'ar-EG', 'ar-IQ', 'ar-JO', 'ar-KW', 'ar-LB', 'ar-LY', 'ar-MA', 'ar-QA', 'ar-QM', 'ar-SA', 'ar-SD', 'ar-SY', 'ar-TN', 'ar-YE', 'bg-BG', 'bn', 'cs-CZ', 'da-DK', 'de-DE', 'el-GR', 'en-AU', 'en-GB', 'en-HK', 'en-IN', 'en-NZ', 'en-US', 'en-ZA', 'en-ZM', 'es-ES', 'fa-IR', 'fi-FI', 'fr-CA', 'fr-FR', 'he', 'hi-IN', 'hu-HU', 'it-IT', 'ko-KR', 'ja-JP', 'ku-IQ', 'nb-NO', 'nl-NL', 'nn-NO', 'pl-PL', 'pt-BR', 'pt-PT', 'ru-RU', 'si-LK', 'sl-SI', 'sk-SK', 'sr-RS', 'sr-RS@latin', 'sv-SE', 'tr-TR', 'uk-UA']`) and defaults to `en-US`. The locale list is `validator.isAlphanumericLocales`.<br/><br/>`ignore`: (optional) A string or RegExp containing characters to ignore, e.g. `'- /' ` or `/[\s/-]/g` to ignore spaces and "-".
 **isAscii(str)**                        | check if the string contains ASCII chars only.
 **isBase32(str [, options])**           | check if a string is base32 encoded. `options` is optional and defaults to `{crockford: false}`.<br/> When `crockford` is true it tests the given base32 encoded string using [Crockford's base32 alternative](http://www.crockford.com/base32.html).
 **isBase58(str)**                       | check if a string is base58 encoded.

package.json

@@ -66,7 +66,7 @@
     "build:node": "babel src -d .",
     "build": "run-p build:*",
     "pretest": "npm run build && npm run lint",
-    "test": "nyc --reporter=cobertura --reporter=text-summary mocha --require @babel/register --reporter dot"
+    "test": "nyc --reporter=cobertura --reporter=text-summary mocha --require @babel/register --reporter dot --recursive"
   },
   "engines": {
     "node": ">= 0.10"

src/lib/alpha.js

@@ -1,3 +1,5 @@
+import assertString from './util/assertString';
+
 export const alpha = {
   'en-US': /^[A-Z]+$/i,
   'az-AZ': /^[A-VXYZÇƏĞİıÖŞÜ]+$/i,
@@ -83,7 +85,7 @@ export const decimal = {
 };
 
 
-export const englishLocales = ['AU', 'GB', 'HK', 'IN', 'NZ', 'ZA', 'ZM'];
+const englishLocales = ['AU', 'GB', 'HK', 'IN', 'NZ', 'ZA', 'ZM'];
 
 for (let locale, i = 0; i < englishLocales.length; i++) {
   locale = `en-${englishLocales[i]}`;
@@ -93,7 +95,7 @@ for (let locale, i = 0; i < englishLocales.length; i++) {
 }
 
 // Source: http://www.localeplanet.com/java/
-export const arabicLocales = ['AE', 'BH', 'DZ', 'EG', 'IQ', 'JO', 'KW', 'LB', 'LY',
+const arabicLocales = ['AE', 'BH', 'DZ', 'EG', 'IQ', 'JO', 'KW', 'LB', 'LY',
   'MA', 'QM', 'QA', 'SA', 'SD', 'SY', 'TN', 'YE'];
 
 for (let locale, i = 0; i < arabicLocales.length; i++) {
@@ -103,15 +105,15 @@ for (let locale, i = 0; i < arabicLocales.length; i++) {
   decimal[locale] = decimal.ar;
 }
 
-export const farsiLocales = ['IR', 'AF'];
+const farsiLocales = ['IR', 'AF'];
 
 for (let locale, i = 0; i < farsiLocales.length; i++) {
   locale = `fa-${farsiLocales[i]}`;
   alphanumeric[locale] = alphanumeric.fa;
   decimal[locale] = decimal.ar;
 }
 
-export const bengaliLocales = ['BD', 'IN'];
+const bengaliLocales = ['BD', 'IN'];
 
 for (let locale, i = 0; i < bengaliLocales.length; i++) {
   locale = `bn-${bengaliLocales[i]}`;
@@ -121,8 +123,8 @@ for (let locale, i = 0; i < bengaliLocales.length; i++) {
 }
 
 // Source: https://en.wikipedia.org/wiki/Decimal_mark
-export const dotDecimal = ['ar-EG', 'ar-LB', 'ar-LY'];
-export const commaDecimal = [
+const dotDecimal = ['ar-EG', 'ar-LB', 'ar-LY'];
+const commaDecimal = [
   'bg-BG', 'cs-CZ', 'da-DK', 'de-DE', 'el-GR', 'en-ZM', 'es-ES', 'fr-CA', 'fr-FR',
   'id-ID', 'it-IT', 'ku-IQ', 'hi-IN', 'hu-HU', 'nb-NO', 'nn-NO', 'nl-NL', 'pl-PL', 'pt-PT',
   'ru-RU', 'si-LK', 'sl-SI', 'sr-RS@latin', 'sr-RS', 'sv-SE', 'tr-TR', 'uk-UA', 'vi-VN',
@@ -150,3 +152,49 @@ decimal['pl-Pl'] = decimal['pl-PL'];
 
 // see #1455
 alpha['fa-AF'] = alpha.fa;
+
+
+function removeIgnoredCharacters(str, ignoredCharacters) {
+  if (!ignoredCharacters) {
+    return str;
+  }
+
+  if (ignoredCharacters instanceof RegExp) {
+    return str.replace(ignoredCharacters, '');
+  }
+
+  if (typeof ignoredCharacters === 'string') {
+    return str.replace(new RegExp(`[${ignoredCharacters.replace(/[-[\]{}()*+?.,\\^$|#\\s]/g, '\\$&')}]`, 'g'), ''); // escape regex for 'ignoredCharacters'
+  }
+
+  throw new Error('"ignore" should be instance of a String or RegExp');
+}
+
+const ALPHA_TYPE_MAP = {
+  alpha,
+  alphanumeric,
+};
+
+function validate(typeKey) {
+  return (_str, ...args) => {
+    assertString(_str);
+
+    // For backwards compatibility:
+    // isAlpha | isAlphaNumeric(str [, locale, options])
+    // i.e. `options` could be used as argument for the legacy `locale`
+    const locale = (typeof args[0] === 'object' ? args[0].locale : args[0]) || 'en-US';
+    const ignore = (typeof args[0] === 'object' ? args[0].ignore : args[1]?.ignore);
+
+    const str = removeIgnoredCharacters(_str, ignore);
+    const alphaType = ALPHA_TYPE_MAP[typeKey];
+
+    if (alphaType[locale]) {
+      return alphaType[locale].test(str);
+    }
+
+    throw new Error(`Invalid "locale" '${locale}'`);
+  };
+}
+
+export const isAlpha = validate('alpha');
+export const isAlphanumeric = validate('alphanumeric');

src/lib/isAfter.js

@@ -1,8 +1,13 @@
 import assertString from './util/assertString';
 import toDate from './toDate';
 
-export default function isAfter(str, date = String(new Date())) {
+export default function isAfter(str, options) {
   assertString(str);
+
+  // accessing 'arguments' for backwards compatibility: isAfter(str [, date])
+  // eslint-disable-next-line prefer-rest-params
+  const date = (typeof options === 'object' ? options.date : arguments[1]) || Date().toString();
+
   const comparison = toDate(date);
   const original = toDate(str);
   return !!(original && comparison && original > comparison);

src/lib/isAlpha.js

@@ -1,26 +1,5 @@
-import assertString from './util/assertString';
-import { alpha } from './alpha';
+import { alpha, isAlpha } from './alpha';
 
-export default function isAlpha(_str, locale = 'en-US', options = {}) {
-  assertString(_str);
-
-  let str = _str;
-  const { ignore } = options;
-
-  if (ignore) {
-    if (ignore instanceof RegExp) {
-      str = str.replace(ignore, '');
-    } else if (typeof ignore === 'string') {
-      str = str.replace(new RegExp(`[${ignore.replace(/[-[\]{}()*+?.,\\^$|#\\s]/g, '\\$&')}]`, 'g'), ''); // escape regex for ignore
-    } else {
-      throw new Error('ignore should be instance of a String or RegExp');
-    }
-  }
-
-  if (locale in alpha) {
-    return alpha[locale].test(str);
-  }
-  throw new Error(`Invalid locale '${locale}'`);
-}
+export default isAlpha;
 
 export const locales = Object.keys(alpha);

src/lib/isAlphanumeric.js

@@ -1,26 +1,5 @@
-import assertString from './util/assertString';
-import { alphanumeric } from './alpha';
+import { alphanumeric, isAlphanumeric } from './alpha';
 
-export default function isAlphanumeric(_str, locale = 'en-US', options = {}) {
-  assertString(_str);
-
-  let str = _str;
-  const { ignore } = options;
-
-  if (ignore) {
-    if (ignore instanceof RegExp) {
-      str = str.replace(ignore, '');
-    } else if (typeof ignore === 'string') {
-      str = str.replace(new RegExp(`[${ignore.replace(/[-[\]{}()*+?.,\\^$|#\\s]/g, '\\$&')}]`, 'g'), ''); // escape regex for ignore
-    } else {
-      throw new Error('ignore should be instance of a String or RegExp');
-    }
-  }
-
-  if (locale in alphanumeric) {
-    return alphanumeric[locale].test(str);
-  }
-  throw new Error(`Invalid locale '${locale}'`);
-}
+export default isAlphanumeric;
 
 export const locales = Object.keys(alphanumeric);

test/testFunctions.js

@@ -0,0 +1,60 @@
+import assert from 'assert';
+import { format } from 'util';
+import validator from '../src/index';
+
+function test(options) {
+  const args = options.args || [];
+
+  args.unshift(null);
+
+  if (options.error) {
+    options.error.forEach((error) => {
+      args[0] = error;
+
+      try {
+        assert.throws(() => validator[options.validator](...args));
+      } catch (err) {
+        const warning = format(
+          'validator.%s(%s) passed but should error',
+          options.validator, args.join(', ')
+        );
+
+        throw new Error(warning);
+      }
+    });
+  }
+
+  if (options.valid) {
+    options.valid.forEach((valid) => {
+      args[0] = valid;
+
+      if (validator[options.validator](...args) !== true) {
+        const warning = format(
+          'validator.%s(%s) failed but should have passed',
+          options.validator, args.join(', ')
+        );
+
+        throw new Error(warning);
+      }
+    });
+  }
+
+  if (options.invalid) {
+    options.invalid.forEach((invalid) => {
+      args[0] = invalid;
+
+      if (validator[options.validator](...args) !== false) {
+        const warning = format(
+          'validator.%s(%s) passed but should have failed',
+          options.validator, args.join(', ')
+        );
+
+        throw new Error(warning);
+      }
+    });
+  }
+}
+
+export default {
+  test,
+};