fix char_class, typo in andOr

* brute force character classes
* fix undefined op typo
* test case to cover both

Author: bfulton

src/regex-query.js

@@ -118,34 +118,19 @@ var analyze = function(re) {
     case "char_class":
       info.match = RegexQuery.ALL;
 
-      // Special case.
-      if (re.value.length === 0) {
-        return RegexInfo.noMatch();
-      }
+      var classExpansion = expandCharClass(re.value);
 
       // Special case.
-      if (re.value.length == 1) {
-        info.exact = [ re.value ];
-        break;
+      if (classExpansion.length === 0) {
+        return RegexInfo.noMatch();
       }
 
-      var n = 0;
-      for (i = 0; i < re.value.length; i += 2) {
-        n += re.value.charCodeAt(i + 1) - re.value.charCodeAt(i);
-      }
       // If the class is too large, it's okay to overestimate.
-      if (n > 100) {
+      if (classExpansion.length > 100) {
         return RegexInfo.anyChar();
       }
 
-      info.exact = [];
-      for (i = 0; i < re.value.length; i += 2) {
-        var lo = re.value.charCodeAt(i);
-        var hi = re.value.charCodeAt(i + 1);
-        for (var rr = lo; rr <= hi; rr++) {
-          info.exact.push(String.fromCharCode(rr));
-        }
-      }
+      info.exact = classExpansion;
       break;
 
     default:
@@ -155,6 +140,21 @@ var analyze = function(re) {
   return info;
 };
 
+var expandCharClass = function(charClass) {
+  var pattern = new RegExp("[" + charClass + "]");
+  var expansion = [];
+  for (var code = 0; code < 0xFFFF; code++) {
+    var char = String.fromCharCode(code);
+    if (expansion.indexOf(char) != -1) {
+      continue;
+    }
+    if (pattern.test(char)) {
+      expansion.push(char);
+    }
+  }
+  return expansion;
+};
+
 // fold is the usual higher-order function.
 var fold = function(f, sub, zero) {
   var info;
@@ -387,7 +387,7 @@ RegexQuery.prototype.andOr = function(other, op) {
     // Add in factored trigrams.
     var otherOp = op == "AND" ? "OR" : "AND";
     var t = new RegexQuery(otherOp, common);
-    return t.andOr(s, t.Op);
+    return t.andOr(s, t.op);
   }
 
   // Otherwise just create the op.

test/regex-peg_test.js

@@ -136,6 +136,25 @@ module.exports = {
         ]
       });
       test.done();
+    },
+
+    "/[aA]bc[dD]/": function(test) {
+      var tree = peg.parse("[aA]bc[dD]");
+      test.deepEqual(tree, {
+        type: "concat",
+        value: [
+          { type: "char_class", value: "aA" },
+          { type: "concat", value: [
+            { type: "literal", value: "b" },
+            { type: "concat",
+              value: [
+                { type: "literal", value: "c" },
+                { type: "char_class", value: "dD" }
+            ] }
+          ] }
+        ]
+      });
+      test.done();
     }
   }
 };

test/regex-trigram_test.js

@@ -105,6 +105,36 @@ module.exports = {
         sub: []
       });
       test.done();
+    },
+
+    "/[aA]bc[dD]/": function(test) {
+      var re = regex.parse("[aA]bc[dD]");
+      var q = regex.query(re);
+      test.deepEqual(q, {
+        op: 'OR',
+        trigram: [],
+        sub:
+          [
+            { op: 'AND',
+              trigram: [ 'Abc' ],
+              sub: [
+                { op: 'OR',
+                  trigram: [ 'bcD', 'bcd' ],
+                  sub: []
+                }
+              ]
+            },
+            { op: 'AND',
+              trigram: [ 'abc', 'bcD' ],
+              sub: []
+            },
+            { op: 'AND',
+              trigram: [ 'abc', 'bcd' ],
+              sub: []
+            }
+          ]
+      });
+      test.done();
     }
   }
 };