run lint:fix

lib/reconstruct.ts

@@ -8,7 +8,7 @@ const simplifications: [sets.SetFunc, string][] = [
   [sets.notInts, '\\D'],
   [sets.whitespace, '\\s'],
   [sets.notWhitespace, '\\S'],
-  [sets.anyChar, '.']
+  [sets.anyChar, '.'],
 ];
 
 const reduceStack = (stack: Token[]): string => stack.map(reconstruct).join('');
@@ -27,17 +27,18 @@ export const reconstruct = (token: Tokens): string => {
   switch (token.type) {
     case types.ROOT:
       return createAlternate(token);
-    case types.CHAR:
+    case types.CHAR: {
       const c = String.fromCharCode(token.value);
-      return (/[[\]^.\/|?*+()]/.test(c) ? '\\' : '') + c;
+      return (/[[\]^./|?*+()]/.test(c) ? '\\' : '') + c;
+    }
     case types.POSITION:
       if (token.value === '^' || token.value === '$') {
         return token.value;
       } else {
-        return '\\' + token.value;
+        return `\\${token.value}`;
       }
     case types.REFERENCE:
-      return '\\' + token.value;
+      return `\\${token.value}`;
     case types.SET:
       for (const [set, simplification] of simplifications) {
         if (JSON.stringify(set()) === JSON.stringify(token)) {
@@ -50,10 +51,10 @@ export const reconstruct = (token: Tokens): string => {
     case types.GROUP:
       // Check token.remember
       return `(${token.remember ? '' : '?'}${token.followedBy ? '=' :
-          token.notFollowedBy ? '!' :
-            (token.remember ? '' : ':')
-        }${createAlternate(token)})`
-    case types.REPETITION:
+        token.notFollowedBy ? '!' :
+          token.remember ? '' : ':'
+      }${createAlternate(token)})`;
+    case types.REPETITION: {
       const { min, max } = token;
       let endWith;
       if (min === 0 && max === 1) {
@@ -63,10 +64,11 @@ export const reconstruct = (token: Tokens): string => {
       } else if (min === 0 && max === Infinity) {
         endWith = '*';
       } else {
-        endWith = max === Infinity ? `{${min},}`
-          : `{${min}${min === max ? `` : `,${max}`}}`;
+        endWith = max === Infinity ? `{${min},}` :
+          `{${min}${min === max ? `` : `,${max}`}}`;
       }
       return `${reconstruct(token.value)}${endWith}`;
+    }
     default:
       throw new Error(`Invalid token type ${token}`);
   }

test/reconstruct-test.js

@@ -2,36 +2,35 @@ const vows = require('vows');
 const assert = require('assert');
 const ret = require('../dist');
 const { tokenToString } = require('typescript');
-const reconstruct = require('../dist/reconstruct').reconstruct
-const types = require('../dist/types').types
+const reconstruct = require('../dist/reconstruct').reconstruct;
+const types = require('../dist/types').types;
 
-const inverseTestFactory = (regexp) => {
-  return {
-    topic: ret(regexp),
+const inverseTestFactory = regexp => ({
+  topic: ret(regexp),
 
-    [`Checking ${regexp} reconstructs`]: (t) => {
-      const reconstructed = reconstruct(t) // May need to do some sort of sanitisation here
-      assert.isString(reconstructed);
-      assert.deepStrictEqual(reconstructed, regexp.replace(/\[\^0\-9\]/g, '\\D')
-                                                  .replace(/\[0\-9\]/g, '\\d')
-                                                  .replace(/\[\^\_a\-zA\-Z0\-9\]/g, '\\W')
-                                                  .replace(/\[\_a\-zA\-Z0\-9\]/g, '\\w')
-      )
-    }
-  }
-}
+  [`Checking ${regexp} reconstructs`]: t => {
+    // May need to do some sort of sanitisation here
+    const reconstructed = reconstruct(t);
+    assert.isString(reconstructed);
+    assert.deepStrictEqual(reconstructed, regexp.replace(/\[\^0-9\]/g, '\\D')
+      .replace(/\[0-9\]/g, '\\d')
+      .replace(/\[\^_a-zA-Z0-9\]/g, '\\W')
+      .replace(/\[_a-zA-Z0-9\]/g, '\\w'),
+    );
+  },
+});
 
-/*! fromentries. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
+/* ! fromentries. MIT License. Feross Aboukhadijeh <https://feross.org/opensource> */
 function fromEntries(iterable) {
   return [...iterable].reduce((obj, [key, val]) => {
-    obj[key] = val
-    return obj
-  }, {})
+    obj[key] = val;
+    return obj;
+  }, {});
 }
 
 const multiInverseTestFactory = regexps => fromEntries(
-  regexps.map(regexp => [regexp, inverseTestFactory(regexp)])
-)
+  regexps.map(regexp => [regexp, inverseTestFactory(regexp)]),
+);
 
 vows.describe('Regexp Reconstruction')
   .addBatch({
@@ -45,7 +44,7 @@ vows.describe('Regexp Reconstruction')
       '\\/\\/',
       '\\W',
       '\\D',
-      '\\w\\W\\d\\D\\s\\S.'
+      '\\w\\W\\d\\D\\s\\S.',
     ]),
     'testing start and finish flags (using inverse of Ret)': multiInverseTestFactory([
       '$',
@@ -57,7 +56,7 @@ vows.describe('Regexp Reconstruction')
       '$\\/\\/^',
       '$\\W^',
       '$\\D^',
-      '$\\w\\W\\d\\D\\s\\S.^'
+      '$\\w\\W\\d\\D\\s\\S.^',
     ]),
     'all main regexp expressions': {
       'No special characters': inverseTestFactory('walnuts'),
@@ -67,7 +66,7 @@ vows.describe('Regexp Reconstruction')
       'Custom Sets': multiInverseTestFactory([
         '[$!a-z123] thing [^0-9]',
         '[^\\.]',
-        '[^test]'
+        '[^test]',
       ]),
       'Whitespace characters': inverseTestFactory('[\t\r\n\u2028\u2029 ]'),
       'Two sets in a row with dash in between': inverseTestFactory('[01]-[ab]'),
@@ -76,12 +75,12 @@ vows.describe('Regexp Reconstruction')
         '(foo|bar|za)',
         '(foo|bar|za)|(^fe|fi|fo|fum)',
       ]),
-      'Group': {
+      Group: {
         'with no special characters': inverseTestFactory('hey (there)'),
         'that is not remembered': inverseTestFactory('(?:loner)'),
         'matched previous clause if not followed by this': inverseTestFactory('what(?!ever)'),
         'matched next clause': inverseTestFactory('hello(?= there)'),
-        'with subgroup': inverseTestFactory('a(b(c|(?:d))fg) @_@')
+        'with subgroup': inverseTestFactory('a(b(c|(?:d))fg) @_@'),
       },
       'Custom repetition with': {
         'exact amount': inverseTestFactory('(?:pika){2}'),
@@ -102,41 +101,42 @@ vows.describe('Regexp Reconstruction')
         // ]),
         'Unicode Characters': multiInverseTestFactory([
           //  '[A\\xA9\\u2603]|\\uD834\\uDF06',
-          //  '[\\0-@\\{-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]'
+          //  '[\\0-@\\{-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|
+          //   [\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF]'
         ]),
-        'Reference': inverseTestFactory('<(\\w+)>\\w*<\\1>'),
-        'Simplifications': multiInverseTestFactory([
+        Reference: inverseTestFactory('<(\\w+)>\\w*<\\1>'),
+        Simplifications: multiInverseTestFactory([
           '[_a-zA-Z0-9]',
           '[0-9]',
           '[^_a-zA-Z0-9]',
           '[^0-9]',
-          ]),
+        ]),
         'Set simplification tests': {
-          'INTS': {
-            'topic': [{ type: types.RANGE, from: 48, to: 57 }],   
-            'Set simplification works': (set) => {
-              assert.deepStrictEqual(reconstruct({ type: types.SET, set, not: false }), '\\d')
+          INTS: {
+            topic: [{ type: types.RANGE, from: 48, to: 57 }],
+            'Set simplification works': set => {
+              assert.deepStrictEqual(reconstruct({ type: types.SET, set, not: false }), '\\d');
             },
-            'Negative set simplification works': (set) => {
-              assert.deepStrictEqual(reconstruct({ type: types.SET, set, not: true }), '\\D')
+            'Negative set simplification works': set => {
+              assert.deepStrictEqual(reconstruct({ type: types.SET, set, not: true }), '\\D');
             },
           },
-          'WORDS': {
-            'topic': [
+          WORDS: {
+            topic: [
               { type: types.CHAR, value: 95 },
               { type: types.RANGE, from: 97, to: 122 },
               { type: types.RANGE, from: 65, to: 90 },
-              { type: types.RANGE , from: 48, to: 57 }
+              { type: types.RANGE, from: 48, to: 57 },
             ],
-            'Set simplification works': (set) => {
-              assert.deepStrictEqual(reconstruct({ type: types.SET, set, not: false }), '\\w')
+            'Set simplification works': set => {
+              assert.deepStrictEqual(reconstruct({ type: types.SET, set, not: false }), '\\w');
             },
-            'Negative set simplification works': (set) => {
-              assert.deepStrictEqual(reconstruct({ type: types.SET, set, not: true }), '\\W')
+            'Negative set simplification works': set => {
+              assert.deepStrictEqual(reconstruct({ type: types.SET, set, not: true }), '\\W');
             },
           },
-          'WHITESPACE': {
-            'topic': [
+          WHITESPACE: {
+            topic: [
               { type: types.CHAR, value: 9 },
               { type: types.CHAR, value: 10 },
               { type: types.CHAR, value: 11 },
@@ -151,50 +151,50 @@ vows.describe('Regexp Reconstruction')
               { type: types.CHAR, value: 8239 },
               { type: types.CHAR, value: 8287 },
               { type: types.CHAR, value: 12288 },
-              { type: types.CHAR, value: 65279 }
-            ], 
-            'Set simplification works': (set) => {
-              assert.deepStrictEqual(reconstruct({ type: types.SET, set, not: false }), '\\s')
+              { type: types.CHAR, value: 65279 },
+            ],
+            'Set simplification works': set => {
+              assert.deepStrictEqual(reconstruct({ type: types.SET, set, not: false }), '\\s');
             },
-            'Negative set simplification works': (set) => {
-              assert.deepStrictEqual(reconstruct({ type: types.SET, set, not: true }), '\\S')
+            'Negative set simplification works': set => {
+              assert.deepStrictEqual(reconstruct({ type: types.SET, set, not: true }), '\\S');
             },
           },
-          'NOTANYCHAR': {
-            'topic': [
+          NOTANYCHAR: {
+            topic: [
               { type: types.CHAR, value: 10 },
               { type: types.CHAR, value: 13 },
               { type: types.CHAR, value: 8232 },
               { type: types.CHAR, value: 8233 },
-            ],    
-            'Set simplification works': (set) => {
-              assert.deepStrictEqual(reconstruct({ type: types.SET, set, not: true }), '.')
+            ],
+            'Set simplification works': set => {
+              assert.deepStrictEqual(reconstruct({ type: types.SET, set, not: true }), '.');
             },
           },
         },
       },
       'Reconstruct error test (bad root)': {
-        'topic': () => {
+        topic: () => {
           try {
-            reconstruct({ type : ret.types.ROOT });
+            return reconstruct({ type: ret.types.ROOT });
           } catch (e) {
             return e;
           }
         },
-        'throws error emessage': (err) => {
+        'throws error emessage': err => {
           assert.isObject(err);
           assert.include(err.message, 'options or stack must be Root or Group token');
         },
       },
       'Reconstruct error test (invalid token)': {
-        'topic': () => {
+        topic: () => {
           try {
-            reconstruct({});
+            return reconstruct({});
           } catch (e) {
             return e;
           }
         },
-        'throws error emessage': (err) => {
+        'throws error emessage': err => {
           assert.isObject(err);
           assert.include(err.message, 'Invalid token type');
         },