Adds support for several RegEx character classes

* Comment in character classes to be added

* Add carriage return placeholder comment

* Add helper methods and builder hashes for additonal RegEx character classes

* Add all new character classes, clean up comments

* Remove A and z character classes which are not supperted in JavaScript, add tests for new characters and improved helper methods

* Modify test rules

* Gitignore package lock and remove test package

* Remove nested git file

* Move rules back into place

* Remove git submodule

* change file encoding of new test rules

* Amend rules files for word and no word

* Change allowed type of word boundaries

* Add mapper functions for word and nonword boundaries

* Fix all new test rules, verify working

* Hard delete package-lock

* Restore .gitmodules for test

* Update package.json

* Move rules files to submodule repo

* remove duplicate rules files

* Remove only rules file duplicates

* Reactivate submodule

* Add vertical tab as supported JavaScript regex character, and remove my comments from methodMatch

* Add support for text input of backslash

* Amend vertical tab in mbuilder and methodMatch

Author: corsonknowles

.gitignore

@@ -1,3 +1,4 @@
 node_modules
 coverage
 .vscode
+package-lock.json

lib/Builder.js

@@ -39,16 +39,31 @@ const simpleMapper = {
         'type': METHOD_TYPE_CHARACTER,
         'allowed': METHOD_TYPES_ALLOWED_FOR_CHARACTERS
     },
+    'backslash': {
+        'add': '\\',
+        'type': METHOD_TYPE_CHARACTER,
+        'allowed': METHOD_TYPES_ALLOWED_FOR_CHARACTERS
+    },
     'tab': {
         'add': '\\t',
         'type': METHOD_TYPE_CHARACTER,
         'allowed': METHOD_TYPES_ALLOWED_FOR_CHARACTERS
     },
+    'verticalTab': {
+        'add': '\\v',
+        'type': METHOD_TYPE_CHARACTER,
+        'allowed': METHOD_TYPES_ALLOWED_FOR_CHARACTERS
+    },
     'newLine': {
         'add': '\\n',
         'type': METHOD_TYPE_CHARACTER,
         'allowed': METHOD_TYPES_ALLOWED_FOR_CHARACTERS
     },
+    'carriageReturn': {
+        'add': '\\r',
+        'type': METHOD_TYPE_CHARACTER,
+        'allowed': METHOD_TYPES_ALLOWED_FOR_CHARACTERS
+    },
     'whitespace': {
         'add': '\\s',
         'type': METHOD_TYPE_CHARACTER,
@@ -68,7 +83,18 @@ const simpleMapper = {
         'add': '\\W',
         'type': METHOD_TYPE_CHARACTER,
         'allowed': METHOD_TYPES_ALLOWED_FOR_CHARACTERS
+    },
+    'word': {
+        'add': '\\b',
+        'type': METHOD_TYPE_CHARACTER,
+        'allowed': METHOD_TYPE_BEGIN
+    },
+    'nonWord': {
+        'add': '\\B',
+        'type': METHOD_TYPE_CHARACTER,
+        'allowed': METHOD_TYPE_BEGIN
     }
+
 }
 
 class Builder {
@@ -140,6 +166,21 @@ class Builder {
         return this.add(`[${result}]`)
     }
 
+    /**
+     * Literally match a character that is not one of these characters.
+     *
+     * @param  {string} chars
+     * @return {Builder}
+     */
+    noneOf(chars) {
+        this._validateAndAddMethodType(METHOD_TYPE_CHARACTER, METHOD_TYPES_ALLOWED_FOR_CHARACTERS)
+
+        let result = chars.split('').map((character) => this.escape(character)).join('')
+        result = result.replace('-', '\\-').replace(']', '\\]')
+
+        return this.add(`[^${result}]`)
+    }
+
     /**
      * Literally match all of these characters in that order.
      *
@@ -166,6 +207,17 @@ class Builder {
         return this.add(`[${min}-${max}]`)
     }
 
+    /**
+     * Match any non-digit character (in given span). Default will be any character not between 0 and 9.
+     *
+     * @return {Builder}
+     */
+    noDigit() {
+        this._validateAndAddMethodType(METHOD_TYPE_CHARACTER, METHOD_TYPES_ALLOWED_FOR_CHARACTERS)
+
+        return this.add(`[^0-9]`)
+    }
+
     /**
      * Match any uppercase letter (between A to Z).
      *
@@ -194,10 +246,10 @@ class Builder {
     /**********************************************************/
 
     /**
-     * Match any of these condition.
+     * Match any of these conditions.
      *
      * @param  {Closure|Builder|string} conditions Anonymous function with its Builder as first parameter.
-     * @return {Builer}
+     * @return {Builder}
      */
     anyOf(conditions) {
         this._validateAndAddMethodType(METHOD_TYPE_GROUP, METHOD_TYPES_ALLOWED_FOR_CHARACTERS)
@@ -423,10 +475,18 @@ class Builder {
         return this._addFromMapper('any')
     }
 
+    backslash() {
+        return this._addFromMapper('backslash')
+    }
+
     tab() {
         return this._addFromMapper('tab')
     }
 
+    verticalTab() {
+        return this._addFromMapper('verticalTab')
+    }
+
     newLine() {
         return this._addFromMapper('newLine')
     }
@@ -447,6 +507,14 @@ class Builder {
         return this._addFromMapper('noCharacter')
     }
 
+    word() {
+        return this._addFromMapper('word')
+    }
+
+    nonWord() {
+        return this._addFromMapper('nonWord')
+    }
+
     /**********************************************************/
     /*                   INTERNAL METHODS                     */
     /**********************************************************/

lib/Language/Helpers/methodMatch.js

@@ -13,29 +13,41 @@ const SyntaxException = require('../../Exceptions/Syntax')
 // Unimplemented: all lazy, single line, unicode, first match
 const mapper = {
     'any character': { 'class': SimpleMethod, 'method': 'anyCharacter' },
+    'backslash': { 'class': SimpleMethod, 'method': 'backslash' },
     'no character': { 'class': SimpleMethod, 'method': 'noCharacter' },
     'multi line': { 'class': SimpleMethod, 'method': 'multiLine' },
     'case insensitive': { 'class': SimpleMethod, 'method': 'caseInsensitive' },
     'starts with': { 'class': SimpleMethod, 'method': 'startsWith' },
+    'start with': { 'class': SimpleMethod, 'method': 'startsWith' },
     'begin with': { 'class': SimpleMethod, 'method': 'startsWith' },
+    'begins with': { 'class': SimpleMethod, 'method': 'startsWith' },
     'must end': { 'class': SimpleMethod, 'method': 'mustEnd' },
     'once or more': { 'class': SimpleMethod, 'method': 'onceOrMore' },
     'never or more': { 'class': SimpleMethod, 'method': 'neverOrMore' },
     'new line': { 'class': SimpleMethod, 'method': 'newLine' },
     'whitespace': { 'class': SimpleMethod, 'method': 'whitespace' },
     'no whitespace': { 'class': SimpleMethod, 'method': 'noWhitespace' },
     'anything': { 'class': SimpleMethod, 'method': 'any' },
-    'tab': { 'class': SimpleMethod, 'method': 'atb' },
+    'tab': { 'class': SimpleMethod, 'method': 'tab' },
+    'vertical tab': { 'class': SimpleMethod, 'method': 'verticalTab' },
     'digit': { 'class': SimpleMethod, 'method': 'digit' },
+    'no digit': { 'class': SimpleMethod, 'method': 'noDigit' },
+    'nondigit': { 'class': SimpleMethod, 'method': 'noDigit' },
     'number': { 'class': SimpleMethod, 'method': 'digit' },
     'letter': { 'class': SimpleMethod, 'method': 'letter' },
     'uppercase': { 'class': SimpleMethod, 'method': 'uppercaseLetter' },
     'once': { 'class': SimpleMethod, 'method': 'once' },
     'twice': { 'class': SimpleMethod, 'method': 'twice' },
+    'word': { 'class': SimpleMethod, 'method': 'word' },
+    'no word': { 'class': SimpleMethod, 'method': 'nonWord' },
+    'nonword': { 'class': SimpleMethod, 'method': 'nonWord' },
+    'carriage return': { 'class': SimpleMethod, 'method': 'carriageReturn' },
+    'carriagereturn': { 'class': SimpleMethod, 'method': 'carriageReturn' },
 
     'literally': { 'class': DefaultMethod, 'method': 'literally' },
     'either of': { 'class': DefaultMethod, 'method': 'anyOf' },
     'any of': { 'class': DefaultMethod, 'method': 'anyOf' },
+    'none of': { 'class': DefaultMethod, 'method': 'noneOf' },
     'if followed by': { 'class': DefaultMethod, 'method': 'ifFollowedBy' },
     'if not followed by': { 'class': DefaultMethod, 'method': 'ifNotFollowedBy' },
     'optional': { 'class': DefaultMethod, 'method': 'optional' },