added test and fixed hasPrefix/hasSuffix bug in simplifySet, bump patch

Author: bfulton

package.json

@@ -1,6 +1,6 @@
 {
   "name": "regex-trigram",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "JavaScript port of portions of Google Code Search",
   "author": "Bright Fulton",
   "main": "lib/regex.js",

src/regex-query.js

@@ -22,7 +22,6 @@ var analyze = function(re) {
   //println("analyze", re.String())
   //defer func() { println("->", ret.String()) }()
   var info = new RegexInfo({});
-  var i;
   switch (re.type) {
     case "NO_MATCH":
       return RegexInfo.noMatch();
@@ -690,7 +689,7 @@ RegexInfo.prototype.simplifySet = function(s) {
   // doesn't help at all to know that  "abc" is also a possible
   // prefix, so delete "abc".
   w = 0;
-  var f = s == this.suffix ? hasSuffix : hasPrefix;
+  var f = isEqualTo(s, this.suffix) ? hasSuffix : hasPrefix;
   for (i = 0; i < t.length; i++) {
     str = t[i];
     if (w === 0 || !f(str, t[w - 1])) {
@@ -703,11 +702,11 @@ RegexInfo.prototype.simplifySet = function(s) {
 };
 
 var hasPrefix = function(str, prefix) {
-  return str.slice(0, prefix.length) == str;
+  return str.slice(0, prefix.length) == prefix;
 };
 
 var hasSuffix = function(str, suffix) {
-  return str.slice(-suffix.length) == str;
+  return str.slice(-suffix.length) == suffix;
 };
 
 var suffixComparator = function(a, b) {
@@ -762,8 +761,7 @@ var cross = function(s, t, isSuffix) {
       p.push(ss + t[j]);
     }
   }
-  var ret = clean(p, isSuffix);
-  return ret;
+  return clean(p, isSuffix);
 };
 
 // isSubsetOf returns true if all strings in s are also in t.
@@ -781,3 +779,18 @@ var isSubsetOf = function(s, t) {
   }
   return true;
 };
+
+var isEqualTo = function(s, t) {
+  if (s.length != t.length) {
+    return false;
+  }
+  if (s == t) {
+    return true;
+  }
+  for (var i = 0; i < s.length; i++) {
+    if (s[i] != t[i]) {
+      return false;
+    }
+  }
+  return true;
+};

test/regex-peg_test.js

@@ -155,6 +155,42 @@ module.exports = {
         ]
       });
       test.done();
+    },
+
+    "/([0-9]+) ?sec/": function(test) {
+      var tree = peg.parse("([0-9]+) ?sec");
+      test.deepEqual(tree, {
+        type: 'concat',
+        value: [
+          { type: 'repetition',
+            quantifier: '+',
+            value: {
+              type: 'char_class',
+              value: '0-9'
+            }
+          },
+          { type: 'concat',
+            value: [
+              { type: 'repetition',
+                quantifier: '?',
+                value: { type: 'literal', value: ' ' }
+              },
+              { type: 'concat',
+                value: [
+                  { type: 'literal', value: 's' },
+                  { type: 'concat',
+                    value: [
+                      { type: 'literal', value: 'e' },
+                      { type: 'literal', value: 'c' }
+                    ]
+                  }
+                ]
+              }
+            ]
+          }
+        ]
+      });
+      test.done();
     }
   }
 };

test/regex-trigram_test.js

@@ -135,6 +135,37 @@ module.exports = {
           ]
       });
       test.done();
+    },
+
+    "/([0-9]+) ?sec/": function(test) {
+      var re = regex.parse("([0-9]+) ?sec");
+      var q = regex.query(re);
+      test.deepEqual(q, {
+        op: 'AND',
+        trigram: [ 'sec' ],
+        sub:
+          [
+            { op: 'OR',
+              trigram: [ '1se', '2se', '3se', '4se', '5se', '6se', '7se', '8se', '9se' ],
+              sub: [
+                { op: 'AND',
+                  trigram: [ ' se' ],
+                  sub: [
+                    { op: 'OR',
+                      trigram: [ '0 s', '1 s', '2 s', '3 s', '4 s', '5 s', '6 s', '7 s', '8 s', '9 s' ],
+                      sub: []
+                    }
+                  ]
+                },
+                { op: 'AND',
+                  trigram: [ '0se' ],
+                  sub: []
+                }
+              ]
+            }
+          ]
+      });
+      test.done();
     }
   }
 };