Refine cache in interpreter, and add more test cases

Author: teabyii

lib/Builder.js

@@ -621,6 +621,21 @@ class Builder {
         return this
     }
 
+    /**
+     * @return {Builder}
+     */
+    clone() {
+        const clone = new Builder()
+
+        // Copy deeply
+        clone._regEx = Array.from(this._regEx)
+        clone._modifiers = this._modifiers
+        clone._lastMethodType = this._lastMethodType
+        clone._group = this._group
+
+        return clone
+    }
+
     /**********************************************************/
     /*                   REGEX METHODS                        */
     /**********************************************************/

lib/Language/Helpers/buildQuery.js

@@ -38,7 +38,6 @@ function buildQuery(query, builder = new Builder()) {
             query.splice(i + 1, 1)
         }
 
-        // console.log(parameters)
         try {
             // Now, append that method to the builder object.
             method.setParameters(parameters).callMethodOn(builder)

lib/Language/Interpreter.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const Builder = require('../Builder')
 const Cache = require('./Helpers/Cache')
 const Literally = require('./Helpers/Literally')
 const parseParentheses = require('./Helpers/parseParentheses')
@@ -15,7 +16,7 @@ class Interpreter {
         const rawQuery = this.rawQuery = query.trim().replace(/\s*;$/, '')
 
         if (Cache.has(rawQuery)) {
-            this.builder = Cache.get(rawQuery)
+            this.builder = Cache.get(rawQuery).clone()
         } else {
             this.build()
         }

test/builder-test.js

@@ -76,6 +76,37 @@ describe('Builder Test', () => {
         assert.equal(matches[1], 'green')
     })
 
+    it('More Methods', () => {
+        const regex = new SRL()
+            .noWhitespace()
+            .literally('a')
+            .ifFollowedBy((builder) => {
+                return builder.noCharacter()
+            })
+            .tab()
+            .mustEnd()
+            .multiLine()
+            .get()
+        const target = `
+        ba\t
+        aaabbb
+        `
+        assert.ok(regex.test(target))
+
+        const regex2 = new SRL()
+            .startsWith()
+            .literally('a')
+            .newLine()
+            .whitespace()
+            .onceOrMore()
+            .literally('b')
+            .mustEnd()
+            .get()
+        const target2 = `a
+        b`
+        assert.ok(regex2.test(target2))
+    })
+
     it('Replace', () => {
         const regex = new SRL()
             .capture((query) => {
@@ -107,6 +138,17 @@ describe('Builder Test', () => {
         const matches = ',, '.match(regex)
         assert.equal(matches[1], ',,')
         assert.notEqual(matches[1], ',, ')
+
+        const regex2 = new SRL()
+            .literally(',')
+            .atLeast(1)
+            .lazy()
+            .get()
+
+        const matches2 = regex2.exec(',,,,,')
+        assert.equal(matches2[0], ',')
+        assert.notEqual(matches2[0], ',,,,,')
+
     })
 
     it('Global', () => {

test/cache-test.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const assert = require('assert')
+const Cache = require('../lib/Language/Helpers/Cache')
+const Interpreter = require('../lib/Language/Interpreter')
+
+describe('Cache', () => {
+    it('Basic', () => {
+        const re = {}
+        Cache.set('test', re)
+        assert.deepEqual(Cache.get('test'), re)
+    })
+
+    it('In interpreter', () => {
+        const RE = /(?:a)/
+        const query = new Interpreter('Literally "a"')
+        assert.deepEqual(query.get(), RE)
+
+        const query2 = new Interpreter('Literally "a"')
+        assert.notEqual(query2, RE)
+
+        assert(query !== query2)
+    })
+})

test/exceptions-test.js

@@ -0,0 +1,36 @@
+'use strict'
+
+const assert = require('assert')
+const SRL = require('../')
+
+const BuilderException = require('../lib/Exceptions/Builder')
+const ImplementationException = require('../lib/Exceptions/Implementation')
+
+describe('Builder Exceptions', () => {
+    it('Raw method', () => {
+        const regex = new SRL('Literally "a"')
+
+        assert.throws(() => {
+            regex.raw(')')
+        }, (error) => {
+            return error instanceof BuilderException &&
+                error.message === 'Adding raw would invalidate this regular expression. Reverted.'
+                && regex.test('a')
+        })
+    })
+
+
+})
+
+describe('Implementation Exception', () => {
+    it('Lazy Method', () => {
+        const regex = new SRL('Literally "a"')
+
+        assert.throws(() => {
+            regex.lazy()
+        }, (error) => {
+            return error instanceof ImplementationException &&
+                error.message === 'Cannot apply laziness at this point. Only applicable after quantifier.'
+        })
+    })
+})