Allow ignoreCase flag if all RegExps use it

Author: tjvr

moo.js

@@ -41,8 +41,6 @@
       return '(?:' + reEscape(obj) + ')'
 
     } else if (isRegExp(obj)) {
-      // TODO: consider /u support
-      if (obj.ignoreCase) throw new Error('RegExp /i flag not allowed')
       if (obj.global) throw new Error('RegExp /g flag is implied')
       if (obj.sticky) throw new Error('RegExp /y flag is implied')
       if (obj.multiline) throw new Error('RegExp /m flag is implied')
@@ -154,6 +152,7 @@
     var fast = Object.create(null)
     var fastAllowed = true
     var unicodeFlag = null
+    var ignoreCaseFlag = null
     var groups = []
     var parts = []
 
@@ -210,7 +209,7 @@
 
       groups.push(options)
 
-      // Check unicode flag is used everywhere or nowhere
+      // Check unicode and ignoreCase flags are used everywhere or nowhere
       for (var j = 0; j < match.length; j++) {
         var obj = match[j]
         if (!isRegExp(obj)) {
@@ -222,6 +221,12 @@
         } else if (unicodeFlag !== obj.unicode) {
           throw new Error("If one rule is /u then all must be")
         }
+
+        if (ignoreCaseFlag === null) {
+          ignoreCaseFlag = obj.ignoreCase
+        } else if (ignoreCaseFlag !== obj.ignoreCase) {
+          throw new Error("If one rule is /i then all must be")
+        }
       }
 
       // convert to RegExp
@@ -257,6 +262,7 @@
     var suffix = hasSticky || fallbackRule ? '' : '|'
 
     if (unicodeFlag === true) flags += "u"
+    if (ignoreCaseFlag === true) flags += "i"
     var combined = new RegExp(reUnion(parts) + suffix, flags)
     return {regexp: combined, groups: groups, fast: fast, error: errorRule || defaultErrorRule}
   }

test/test.js

@@ -28,10 +28,9 @@ describe('compiler', () => {
     expect(lex4.next()).toMatchObject({type: 'err', text: 'nope!'})
   })
 
-  test("warns for /g, /y, /i, /m", () => {
+  test("warns for /g, /y, /m", () => {
     expect(() => compile({ word: /foo/ })).not.toThrow()
     expect(() => compile({ word: /foo/g })).toThrow('implied')
-    expect(() => compile({ word: /foo/i })).toThrow('not allowed')
     expect(() => compile({ word: /foo/y })).toThrow('implied')
     expect(() => compile({ word: /foo/m })).toThrow('implied')
   })
@@ -1211,3 +1210,22 @@ describe("unicode flag", () => {
   })
 
 })
+
+
+describe('ignoreCase flag', () => {
+
+  test("allows all rules to be /i", () => {
+    expect(() => compile({ a: /foo/i, b: /bar/i, c: "quxx" })).not.toThrow()
+    expect(() => compile({ a: /foo/i, b: /bar/, c: "quxx" })).toThrow("If one rule is /i then all must be")
+    expect(() => compile({ a: /foo/, b: /bar/i, c: "quxx" })).toThrow("If one rule is /i then all must be")
+  })
+
+  test("supports ignoreCase", () => {
+    const lexer = compile({ a: /foo/i, b: /bar/i, c: "quxx" })
+    lexer.reset("FoObArQuXx")
+    expect(lexer.next()).toMatchObject({value: "FoO"})
+    expect(lexer.next()).toMatchObject({value: "bAr"})
+    expect(lexer.next()).toMatchObject({value: "QuXx"})
+  })
+
+})