Add rules test

Author: teabyii

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "test/rules"]
+	path = test/rules
+	url = https://github.com/SimpleRegex/Test-Rules

lib/Builder.js

@@ -4,7 +4,7 @@ const SyntaxException = require('./Exceptions/Syntax')
 const BuilderException = require('./Exceptions/Builder')
 const ImplementationException = require('./Exceptions/Implementation')
 
-const NON_LITERAL_CHARACTERS = '[\\^$.|?*+()'
+const NON_LITERAL_CHARACTERS = '[\\^$.|?*+()/'
 const METHOD_TYPE_BEGIN = 0b00001
 const METHOD_TYPE_CHARACTER = 0b00010
 const METHOD_TYPE_GROUP = 0b00100
@@ -247,7 +247,7 @@ class Builder {
     ifNotFollowedBy(conditions) {
         this._validateAndAddMethodType(METHOD_TYPE_GROUP, METHOD_TYPES_ALLOWED_FOR_CHARACTERS)
 
-        return this._addClosure(new Builder()._extends('(?!=%s)'), conditions)
+        return this._addClosure(new Builder()._extends('(?!%s)'), conditions)
     }
 
     /**
@@ -347,12 +347,13 @@ class Builder {
         const chars = '+*}?'
         const raw = this.getRawRegex()
         const last = raw.substr(-1)
+        const lastMethodType = this._lastMethodType
         this._lastMethodType = METHOD_TYPE_QUANTIFIER
 
-
         if (!chars.includes(last)) {
             if (last === ')' && chars.includes(raw.substr(-2, 1))) {
-                return this.add('?')
+                const target = lastMethodType === METHOD_TYPE_GROUP ? this._revertLast().slice(0, -1) + '?)' : '?'
+                return this.add(target)
             }
 
             throw new ImplementationException('Cannot apply laziness at this point. Only applicable after quantifier.')
@@ -539,6 +540,8 @@ class Builder {
      * @return {Builder}
      */
     _addUniqueModifier(modifier) {
+        this._result = null
+
         if (!this._modifiers.includes(modifier)) {
             this._modifiers += modifier
         }

test/rules

@@ -0,0 +1,157 @@
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const assert = require('assert')
+const SRL = require('../')
+
+function testRules() {
+    const rulesDir = path.resolve(__dirname, './rules')
+    const files = fs.readdirSync(rulesDir)
+
+    files.forEach((file) => {
+        // Ignore
+        if (path.extname(file) !== '.rule') {
+            return
+        }
+
+        const lines = fs.readFileSync(path.join(rulesDir, file), { encoding: 'utf-8' }).split('\n')
+        runAssertions(buildData(lines))
+    })
+}
+
+function applySpecialChars(target) {
+    return target.replace('\\n', '\n').replace('\\t', '\t')
+}
+
+function getExpression(srl, query) {
+    return `\n\nSupplied SRL Query: ${srl}\nGenerated Expression: ${query.getRawRegex()}\n\n`
+}
+
+function buildData(lines) {
+    const data = {
+        srl: null,
+        matches: [],
+        no_matches: [],
+        captures: {}
+    }
+    let inCapture = false
+    let captures = null // Remember captures' name and index.
+
+    lines.forEach((line) => {
+        if (line === '' || line.startsWith('#')) {
+            return
+        }
+
+        if (inCapture && !line.startsWith('-')) {
+            inCapture = false
+        }
+
+        if (line.startsWith('srl: ')) {
+            captures = []
+
+            data.srl = line.substr(5).replace(/as\s+"([^"]+)"/g, (s, c) => {
+                captures.push(c)
+                return ''
+            })
+        } else if (line.startsWith('match: "')) {
+            data.matches.push(applySpecialChars(line.slice(8, -1)))
+        } else if (line.startsWith('no match: "')) {
+            data.no_matches.push(applySpecialChars(line.slice(11, -1)))
+        } else if (
+            line.startsWith('capture for "') &&
+            line.substr(-2, 2) === '":'
+        ) {
+            inCapture = line.slice(13, -2)
+            data['captures'][inCapture] = []
+        } else if (
+            inCapture &&
+            line.startsWith('-')
+        ) {
+            const split = line.substr(1).split(': ')
+            const index = captures.indexOf(split[1].trim())
+            let target = data['captures'][inCapture][Number(split[0])]
+
+            if (!target) {
+                target = data['captures'][inCapture][Number(split[0])] = []
+            }
+
+            if (index !== -1) {
+                target[index] = applySpecialChars(split[2].slice(1, -1))
+            } else {
+                target.push(applySpecialChars(split[2].slice(1, -1)))
+            }
+        }
+    })
+
+    return data
+}
+
+function runAssertions(data) {
+    assert(data.srl, 'SRL for rule is empty. Invalid rule.')
+
+    let query, assertionMade = false
+
+    try {
+        query = new SRL(data.srl)
+    } catch (e) {
+        assert(false, `Parser error: ${e.message}\n\nSupplied SRL Query: ${data.srl}\n\n`)
+    }
+
+    data.matches.forEach((match) => {
+        assert(
+            query.test(match),
+            `Failed asserting that this query matches '${match}'.${getExpression(data.srl, query)}`
+        )
+        assertionMade = true
+    })
+
+    data.no_matches.forEach((noMatch) => {
+        assert(
+            !query.test(noMatch),
+            `Failed asserting that this query does not match '${noMatch}'.${getExpression(data.srl, query)}`
+        )
+        assertionMade = true
+    })
+
+    Object.keys(data.captures).forEach((test) => {
+        const expected = data.captures[test]
+        const matches = []
+        const regex = query.all()
+
+        try {
+            let result = null
+            while (result = regex.exec(test)) {
+                matches.push(result.map((item) => item === undefined ? '' : item).slice(1))
+
+                if (regex.lastIndex === test.length - 1) {
+                    break
+                }
+            }
+        } catch (e) {
+            assert(false, `Parser error: ${e.message}${getExpression(data.srl, query)}`)
+        }
+
+        assert.equal(
+            expected.length,
+            matches.length,
+            `Invalid match count for test ${test}.${getExpression(data.srl, query)}`
+        )
+
+        matches.forEach((capture, index) => {
+            assert.deepEqual(
+                expected[index],
+                capture,
+                `The capture group did not return the expected results for test ${test}.${getExpression(data.srl, query)}`
+            )
+        })
+
+        assertionMade = true
+    })
+
+    assert(assertionMade, `No assertion. Invalid rule. ${getExpression(data.srl, query)}`)
+}
+
+describe('Rules', () => {
+    testRules()
+})