feat(helpers): add fromRegExp method

src/modules/helpers/index.ts

@@ -165,29 +165,137 @@ export class HelpersModule {
    * Supported patterns:
    * - `.{times}` => Repeat the character exactly `times` times.
    * - `.{min,max}` => Repeat the character `min` to `max` times.
-   * - `[min-max]` => Generate a number between min and max (inclusive).
+   * - `[x-y]` => Randomly get a character between `x` and `y` (inclusive).
+   * - `[x-y]{times}` => Randomly get a character between `x` and `y` (inclusive) and repeat it `times` times.
+   * - `[x-y]{min,max}` => Randomly get a character between `x` and `y` (inclusive) and repeat it `min` to `max` times.
+   * - `[^...]` => Randomly get a character that is not in the given range. (e.g. `[^0-9]` will get a random non-numeric character)
+   * - `[-...]` => Include dashes in the range. Must be placed after the negate character `^` and before any character sets if used . (e.g. `[^-0-9]` will not get any numeric characters or dashes)
    *
    * @param string The template string to to parse.
    *
    * @example
    * faker.helpers.regexpStyleStringParse() // ''
    * faker.helpers.regexpStyleStringParse('#{5}') // '#####'
    * faker.helpers.regexpStyleStringParse('#{2,9}') // '#######'
-   * faker.helpers.regexpStyleStringParse('[500-15000]') // '8375'
+   * faker.helpers.regexpStyleStringParse('[1-7]') // '5'
    * faker.helpers.regexpStyleStringParse('#{3}test[1-5]') // '###test3'
+   * faker.helpers.regexpStyleStringParse('[0-9a-dmno]') // '5' | 'c' | 'o'
+   * faker.helpers.regexpStyleStringParse('[^a-zA-Z0-8]') // '9'
+   * faker.helpers.regexpStyleStringParse('[a-d0-6]{2,8}') // 'a0' | 'd6' | 'a0dc45b0'
+   * faker.helpers.regexpStyleStringParse('[-a-z]{5}') // 'a-zab'
    *
    * @since 5.0.0
    */
   regexpStyleStringParse(string: string = ''): string {
-    // Deal with range repeat `{min,max}`
     const RANGE_REP_REG = /(.)\{(\d+)\,(\d+)\}/;
     const REP_REG = /(.)\{(\d+)\}/;
-    const RANGE_REG = /\[(\d+)\-(\d+)\]/;
+    const RANGE_ALPHANUMEMRIC_REG =
+      /\[(\^|)(-|)(.+)\](?:\{(\d+)(?:\,(\d+)|)\}|)/;
+
     let min: number;
     let max: number;
     let tmp: number;
     let repetitions: number;
-    let token = string.match(RANGE_REP_REG);
+
+    // Deal with character classes with quantifiers `[a-z0-9]{min[, max]}`
+    let token = string.match(RANGE_ALPHANUMEMRIC_REG);
+    const SINGLE_RANGE_REG = /(\d-\d|\w-\w|\d|\w)/;
+    while (token != null) {
+      const isNegated = token[1] === '^';
+      const includesDash: boolean = token[2] === '-';
+      const quantifierMin: string = token[4];
+      const quantifierMax: string = token[5];
+
+      const rangeCodes: number[] = [];
+
+      if (isNegated) {
+        // 0-9
+        for (let i = 48; i <= 57; i++) {
+          rangeCodes.push(i);
+        }
+        // a-z
+        for (let i = 65; i <= 90; i++) {
+          rangeCodes.push(i);
+        }
+        // A-Z
+        for (let i = 97; i <= 122; i++) {
+          rangeCodes.push(i);
+        }
+      }
+
+      if (!quantifierMin) {
+        repetitions = 1;
+      } else {
+        repetitions = parseInt(quantifierMin);
+      }
+
+      let ranges = token[3];
+      let range = ranges.match(SINGLE_RANGE_REG);
+
+      if (includesDash) {
+        // 45 is the ascii code for '-'
+        if (isNegated) {
+          rangeCodes.splice(rangeCodes.indexOf(45), 1);
+        } else {
+          rangeCodes.push(45);
+        }
+      }
+
+      while (range != null) {
+        if (range[0].indexOf('-') === -1) {
+          if (isNegated) {
+            rangeCodes.splice(rangeCodes.indexOf(range[0].charCodeAt(0)), 1);
+          } else {
+            rangeCodes.push(range[0].charCodeAt(0));
+          }
+        } else {
+          const rangeMinMax = range[0].split('-').map((x) => x.charCodeAt(0));
+          min = rangeMinMax[0];
+          max = rangeMinMax[1];
+          // switch min and max
+          if (min > max) {
+            tmp = min;
+            min = max;
+            max = tmp;
+          }
+          for (let i = min; i <= max; i++) {
+            if (isNegated) {
+              rangeCodes.splice(rangeCodes.indexOf(i), 1);
+            } else {
+              rangeCodes.push(i);
+            }
+          }
+        }
+
+        ranges = ranges.substring(range[0].length);
+        range = ranges.match(SINGLE_RANGE_REG);
+      }
+
+      if (quantifierMax) {
+        repetitions = this.faker.datatype.number({
+          min: parseInt(quantifierMin),
+          max: parseInt(quantifierMax),
+        });
+      }
+
+      const generatedString = Array.from(Array(repetitions)).reduce(
+        (acc: string) =>
+          acc +
+          String.fromCharCode(
+            rangeCodes[this.faker.datatype.number(rangeCodes.length - 1)]
+          ),
+        ''
+      );
+
+      string =
+        string.slice(0, token.index) +
+        generatedString +
+        string.slice(token.index + token[0].length);
+      token = string.match(RANGE_ALPHANUMEMRIC_REG);
+    }
+
+    // Deal with quantifier ranges `{min,max}`
+    token = string.match(RANGE_REP_REG);
     while (token != null) {
       min = parseInt(token[2]);
       max = parseInt(token[3]);
@@ -214,25 +322,7 @@ export class HelpersModule {
         string.slice(token.index + token[0].length);
       token = string.match(REP_REG);
     }
-    // Deal with range `[min-max]` (only works with numbers for now)
-    //TODO: implement for letters e.g. [0-9a-zA-Z] etc.
 
-    token = string.match(RANGE_REG);
-    while (token != null) {
-      min = parseInt(token[1]); // This time we are not capturing the char before `[]`
-      max = parseInt(token[2]);
-      // switch min and max
-      if (min > max) {
-        tmp = max;
-        max = min;
-        min = tmp;
-      }
-      string =
-        string.slice(0, token.index) +
-        this.faker.datatype.number({ min: min, max: max }).toString() +
-        string.slice(token.index + token[0].length);
-      token = string.match(RANGE_REG);
-    }
     return string;
   }
 

test/__snapshots__/helpers.spec.ts.snap

@@ -45,12 +45,22 @@ exports[`helpers > 42 > objectKey > simple 1`] = `"b"`;
 
 exports[`helpers > 42 > objectValue > simple 1`] = `2`;
 
+exports[`helpers > 42 > regexpStyleStringParse > character class 1`] = `"Hello !#####test685"`;
+
+exports[`helpers > 42 > regexpStyleStringParse > dash 1`] = `"!#####test774"`;
+
+exports[`helpers > 42 > regexpStyleStringParse > negate 1`] = `"!#####testjpF"`;
+
+exports[`helpers > 42 > regexpStyleStringParse > negate and dash 1`] = `"!#####testioF"`;
+
 exports[`helpers > 42 > regexpStyleStringParse > noArgs 1`] = `""`;
 
 exports[`helpers > 42 > regexpStyleStringParse > only symbols 1`] = `"###test2"`;
 
 exports[`helpers > 42 > regexpStyleStringParse > some string 1`] = `"Hello !###test2"`;
 
+exports[`helpers > 42 > regexpStyleStringParse > swap range if start is greater than end 1`] = `"j"`;
+
 exports[`helpers > 42 > replaceCreditCardSymbols > noArgs 1`] = `"6453-3791-7755-1410-0489"`;
 
 exports[`helpers > 42 > replaceCreditCardSymbols > only symbols 1`] = `"7917-6-7563-4"`;
@@ -193,12 +203,22 @@ exports[`helpers > 1211 > objectKey > simple 1`] = `"c"`;
 
 exports[`helpers > 1211 > objectValue > simple 1`] = `3`;
 
+exports[`helpers > 1211 > regexpStyleStringParse > character class 1`] = `"Hello !###testf86538"`;
+
+exports[`helpers > 1211 > regexpStyleStringParse > dash 1`] = `"!###testf67538"`;
+
+exports[`helpers > 1211 > regexpStyleStringParse > negate 1`] = `"!###testPniHDq"`;
+
+exports[`helpers > 1211 > regexpStyleStringParse > negate and dash 1`] = `"!###testPmiHDp"`;
+
 exports[`helpers > 1211 > regexpStyleStringParse > noArgs 1`] = `""`;
 
 exports[`helpers > 1211 > regexpStyleStringParse > only symbols 1`] = `"###test5"`;
 
 exports[`helpers > 1211 > regexpStyleStringParse > some string 1`] = `"Hello !###test5"`;
 
+exports[`helpers > 1211 > regexpStyleStringParse > swap range if start is greater than end 1`] = `"y"`;
+
 exports[`helpers > 1211 > replaceCreditCardSymbols > noArgs 1`] = `"6453-9487-2190-6162-7434"`;
 
 exports[`helpers > 1211 > replaceCreditCardSymbols > only symbols 1`] = `"4872-9-1927-1"`;
@@ -331,12 +351,22 @@ exports[`helpers > 1337 > objectKey > simple 1`] = `"a"`;
 
 exports[`helpers > 1337 > objectValue > simple 1`] = `1`;
 
+exports[`helpers > 1337 > regexpStyleStringParse > character class 1`] = `"Hello !###test145"`;
+
+exports[`helpers > 1337 > regexpStyleStringParse > dash 1`] = `"!###test135"`;
+
+exports[`helpers > 1337 > regexpStyleStringParse > negate 1`] = `"!###testTEG"`;
+
+exports[`helpers > 1337 > regexpStyleStringParse > negate and dash 1`] = `"!###testTEG"`;
+
 exports[`helpers > 1337 > regexpStyleStringParse > noArgs 1`] = `""`;
 
 exports[`helpers > 1337 > regexpStyleStringParse > only symbols 1`] = `"###test2"`;
 
 exports[`helpers > 1337 > regexpStyleStringParse > some string 1`] = `"Hello !###test2"`;
 
+exports[`helpers > 1337 > regexpStyleStringParse > swap range if start is greater than end 1`] = `"g"`;
+
 exports[`helpers > 1337 > replaceCreditCardSymbols > noArgs 1`] = `"6453-2512-2540-3255-2399"`;
 
 exports[`helpers > 1337 > replaceCreditCardSymbols > only symbols 1`] = `"5122-5-5424-8"`;

test/helpers.spec.ts

@@ -44,7 +44,12 @@ describe('helpers', () => {
     t.describe('regexpStyleStringParse', (t) => {
       t.it('noArgs')
         .it('only symbols', '#{3}test[1-5]')
-        .it('some string', 'Hello !#{3}test[1-5]');
+        .it('some string', 'Hello !#{3}test[1-5]')
+        .it('character class', 'Hello !#{3,5}test[1-5a-g]{10}[5-8]{2,6}')
+        .it('dash', '!#{3,5}test[-1-5a-g]{10}[-5-8]{2,6}')
+        .it('negate', '!#{3,5}test[^1-5a-g]{10}[^-5-8]{2,6}')
+        .it('negate and dash', '!#{3,5}test[^-1-5a-g]{10}[^-5-8]{2,6}')
+        .it('swap range if start is greater than end', '[z-a]');
     });
 
     t.describe('mustache', (t) => {