JSONPath-Plus · erithmetic · Oct 6, 2011 · Oct 7, 2011 · Oct 7, 2011 · Oct 7, 2011
diff --git a/lib/environment.js b/lib/environment.js
@@ -0,0 +1,117 @@
+var Expression = require('./expression');
+
+var Environment = module.exports = function(jsonObject, expression, options) {
+  this.jsonObject = jsonObject;
+  this.expression = this.normalize(expression);
+  this.options = options;
+  this.result = [];
+};
+
+Environment.prototype.execute = function() {
+  this.trace(this.expression, this.jsonObject, "$");
+  return this.result.length ? this.result : false;
+};
+
+Environment.prototype.normalize = function(expression) {
+  var subx = [];
+  var ret = expression.replace(/[\['](\??\(.*?\))[\]']/g, function($0,$1) {
+    return "[#"+(subx.push($1)-1)+"]";
+  }).
+    replace(/'?\.'?|\['?/g, ";").
+    replace(/;;;|;;/g, ";..;").
+    replace(/;$|'?\]|'$/g, "").
+    replace(/#([0-9]+)/g, function(str, digits){ return subx[digits]; });
+  return ret.replace(/^\$;/,"");
+};
+
+Environment.prototype.asPath = function(path) {
+   var x = path.split(";"), p = "$";
+   for (var i=1,n=x.length; i<n; i++)
+      p += /^[0-9*]+$/.test(x[i]) ? ("["+x[i]+"]") : ("['"+x[i]+"']");
+   return p;
+};
+
+Environment.prototype.store = function(path, value) {
+  if (path) {
+    var storageValue = this.options.resultType == "PATH" ? this.asPath(path) : value;
+    this.result.push(storageValue);
+  }
+};
+
+Environment.prototype.trace = function(expression, object, path) {
+   var self = this;
+   if (expression) {
+      var segments = expression.split(";")
+      var segment = segments.shift();
+      var newExpression = segments.join(";");
+      if (object && object.hasOwnProperty(segment))
+         this.trace(newExpression, object[segment], path + ";" + segment);
+      else if (segment === "*") {
+        this.walk(object, function(property) {
+          self.trace(property + ";" + newExpression, object, path);
+        });
+      }
+      else if (segment === "..") {
+         this.trace(newExpression, object, path);
+         this.walk(object, function(property) {
+           typeof object[property] === "object" &&
+             self.trace("..;" + newExpression, object[property], path + ";" + property);
+         });
+      }
+      else if (/,/.test(segment)) { // [name1,name2,...]
+        var s = segment.split(/'?,'?/);
+         for (var i=0,n=s.length; i<n; i++)
+            this.trace(s[i]+";"+newExpression, object, path);
+      }
+      else if (/^\(.*?\)$/.test(segment)) { // [(newExpression)]
+        var name = path.substr(path.lastIndexOf(";")+1);
+        var extendedExpression = this.match(segment, object, name) + ";" + newExpression;
+        this.trace(extendedExpression, object, path);
+      }
+      else if (/^\?\(.*?\)$/.test(segment)) { // [?(newExpression)]
+         this.walk(object, function(property) {
+           var newerExpression = segment.replace(/^\?\((.*?)\)$/,"$1");
+           if (self.match(newerExpression, object[property]))
+             self.trace(property + ";" + newExpression, object, path);
+         });
+      }
+      else if (/^(-?[0-9]*):(-?[0-9]*):?([0-9]*)$/.test(segment)) // [start:end:step]  phyton slice syntax
+         this.slice(segment, newExpression, object, path);
+   } else {
+      this.store(path, object);
+   }
+};
+
+Environment.prototype.walk = function(object, callback) {
+   if (object instanceof Array) {
+     for (var index = 0, n = object.length; index < n; index++)
+       if(index in object)
+         callback(index);
+   }
+   else if (typeof object === "object") {
+      for (var property in object)
+         if (object.hasOwnProperty(property))
+            callback(property);
+   }
+};
+
+Environment.prototype.slice = function(segment, expression, object, path) {
+   if (object instanceof Array) {
+      var len=object.length, start=0, end=len, step=1;
+      segment.replace(/^(-?[0-9]*):(-?[0-9]*):?(-?[0-9]*)$/g, function($0,$1,$2,$3) {
+        start=parseInt($1||start);
+        end=parseInt($2||end);
+        step=parseInt($3||step);
+      });
+      start = (start < 0) ? Math.max(0,start+len) : Math.min(len,start);
+      end   = (end < 0)   ? Math.max(0,end+len)   : Math.min(len,end);
+      for (var i=start; i<end; i+=step)
+         this.trace(i+";"+expression, object, path);
+   }
+};
+
+Environment.prototype.match = function(expression, object, _vname) {
+  if(!object) return object;
+
+  return Expression.execute(expression, object);
+};
diff --git a/lib/expression.js b/lib/expression.js
@@ -0,0 +1,72 @@
+var Expression = module.exports = {
+  execute: function(expression, object) {
+    if(/[>=<]/.test(expression))
+      return this.operate(object, expression, '>=<');
+    else if(/[-+*\/]/.test(expression))
+      return this.operate(object, expression, '-+*/');
+    else if(/\./.test(expression))
+      return this.getProperty(expression, object);
+    else
+      throw new SyntaxError("jsonPath: invalid query syntax: " + expression);
+  },
+
+  getProperty: function(expression, object) {
+    var parts = expression.match(/\.([^\s]+)/);
+    var properties = parts[1].split('.');
+
+    for(var i = 0, n = properties.length; i < n; i++) {
+      var rhs;
+      try {
+        rhs = JSON.parse('"' + properties[i] + '"');
+      }
+      catch(e) {
+        throw new SyntaxError("jsonPath: invalid property name: " + properties[1]);
+      }
+      if(object.hasOwnProperty(rhs))
+        object = object[rhs];
+      else
+        return false;
+    }
+
+    return object;
+  },
+
+  getValue: function(expression) {
+    try {
+      return JSON.parse(expression);
+    }
+    catch(e) {
+      throw new SyntaxError("jsonPath: invalid right-hand-side value: " + expression);
+    }
+  },
+
+  operate: function(object, expression, operators) {
+    var regex = new RegExp("([^\(\)" + operators + "]+)([" + operators + "]+)([^\(\)]+)");
+    var parts = expression.match(regex);
+    var lhs = this.getProperty(parts[1], object);
+    var rhs = this.getValue(parts[3]);
+
+    switch(parts[2]) {
+    case '==':
+      return lhs == rhs;
+    case '>=':
+      return lhs >= rhs;
+    case '<=':
+      return lhs <= rhs;
+    case '>':
+      return lhs > rhs;
+    case '<':
+      return lhs < rhs;
+    case '-':
+      return lhs - rhs;
+    case '+':
+      return lhs + rhs;
+    case '*':
+      return lhs * rhs;
+    case '/':
+      return lhs / rhs;
+    default:
+      throw new SyntaxError("jsonPath: invalid query syntax: " + expression);
+    }
+  },
+};
diff --git a/lib/jsonpath.js b/lib/jsonpath.js
@@ -1,96 +1,25 @@
-/* JSONPath 0.8.0 - XPath for JSON
- *
- * Copyright (c) 2007 Stefan Goessner (goessner.net)
- * Licensed under the MIT (MIT-LICENSE.txt) licence.
- */
-
-exports.eval = jsonPath;
-var cache = {};
-function jsonPath(obj, expr, arg) {
-   var P = {
-      resultType: arg && arg.resultType || "VALUE",
-      result: [],
-      normalize: function(expr) {
-         if(cache[expr]) {
-            return cache[expr];
-         }
-
-         var subx = [];
-         ret = expr.replace(/[\['](\??\(.*?\))[\]']/g, function($0,$1){return "[#"+(subx.push($1)-1)+"]";})
-                    .replace(/'?\.'?|\['?/g, ";")
-                    .replace(/;;;|;;/g, ";..;")
-                    .replace(/;$|'?\]|'$/g, "")
-                    .replace(/#([0-9]+)/g, function($0,$1){return subx[$1];});
-         cache[expr] = ret;
-         return ret;
-      },
-      asPath: function(path) {
-         var x = path.split(";"), p = "$";
-         for (var i=1,n=x.length; i<n; i++)
-            p += /^[0-9*]+$/.test(x[i]) ? ("["+x[i]+"]") : ("['"+x[i]+"']");
-         return p;
-      },
-      store: function(p, v) {
-         if (p) P.result[P.result.length] = P.resultType == "PATH" ? P.asPath(p) : v;
-         return !!p;
-      },
-      trace: function(expr, val, path) {
-         if (expr) {
-            var x = expr.split(";"), loc = x.shift();
-            x = x.join(";");
-            if (val && val.hasOwnProperty(loc))
-               P.trace(x, val[loc], path + ";" + loc);
-            else if (loc === "*")
-               P.walk(loc, x, val, path, function(m,l,x,v,p) { P.trace(m+";"+x,v,p); });
-            else if (loc === "..") {
-               P.trace(x, val, path);
-               P.walk(loc, x, val, path, function(m,l,x,v,p) { typeof v[m] === "object" && P.trace("..;"+x,v[m],p+";"+m); });
-            }
-            else if (/,/.test(loc)) { // [name1,name2,...]
-               for (var s=loc.split(/'?,'?/),i=0,n=s.length; i<n; i++)
-                  P.trace(s[i]+";"+x, val, path);
-            }
-            else if (/^\(.*?\)$/.test(loc)) // [(expr)]
-               P.trace(P.eval(loc, val, path.substr(path.lastIndexOf(";")+1))+";"+x, val, path);
-            else if (/^\?\(.*?\)$/.test(loc)) // [?(expr)]
-               P.walk(loc, x, val, path, function(m,l,x,v,p) { if (P.eval(l.replace(/^\?\((.*?)\)$/,"$1"),v[m],m)) P.trace(m+";"+x,v,p); });
-            else if (/^(-?[0-9]*):(-?[0-9]*):?([0-9]*)$/.test(loc)) // [start:end:step]  phyton slice syntax
-               P.slice(loc, x, val, path);
-         }
-         else
-            P.store(path, val);
-      },
-      walk: function(loc, expr, val, path, f) {
-         if (val instanceof Array) {
-            for (var i=0,n=val.length; i<n; i++)
-               if (i in val)
-                  f(i,loc,expr,val,path);
-         }
-         else if (typeof val === "object") {
-            for (var m in val)
-               if (val.hasOwnProperty(m))
-                  f(m,loc,expr,val,path);
-         }
-      },
-      slice: function(loc, expr, val, path) {
-         if (val instanceof Array) {
-            var len=val.length, start=0, end=len, step=1;
-            loc.replace(/^(-?[0-9]*):(-?[0-9]*):?(-?[0-9]*)$/g, function($0,$1,$2,$3){start=parseInt($1||start);end=parseInt($2||end);step=parseInt($3||step);});
-            start = (start < 0) ? Math.max(0,start+len) : Math.min(len,start);
-            end   = (end < 0)   ? Math.max(0,end+len)   : Math.min(len,end);
-            for (var i=start; i<end; i+=step)
-               P.trace(i+";"+expr, val, path);
-         }
-      },
-      eval: function(x, _v, _vname) {
-         try { return $ && _v && eval(x.replace(/@/g, "_v")); }
-         catch(e) { throw new SyntaxError("jsonPath: " + e.message + ": " + x.replace(/@/g, "_v").replace(/\^/g, "_a")); }
-      }
-   };
-
-   var $ = obj;
-   if (expr && obj && (P.resultType == "VALUE" || P.resultType == "PATH")) {
-      P.trace(P.normalize(expr).replace(/^\$;/,""), obj, "$");
-      return P.result.length ? P.result : false;
-   }
-} 
+/* JSONPath 0.8.0 - XPath for JSON
+ *
+ * Copyright (c) 2007 Stefan Goessner (goessner.net)
+ * Licensed under the MIT (MIT-LICENSE.txt) licence.
+ */
+
+var Environment = require('./environment');
+
+var JSONPath = module.exports = {
+  eval: function jsonPath(jsonObject, expression, options) {
+    if(!jsonObject)
+      throw 'You must provide a JSON object';
+    if(!expression)
+      throw 'An expression is required';
+    if(!options)
+      options = {};
+    if(!options.resultType)
+      options.resultType = 'VALUE';
+    if(options.resultType != "VALUE" && options.resultType != "PATH")
+      throw 'Invalid options, resultType must be "VALUE" or "PATH"';
+
+    var env = new Environment(jsonObject, expression, options);
+    return env.execute();
+  }
+};
diff --git a/package.json b/package.json
@@ -1,19 +1,20 @@
 {
   "author": "Stefan Goessner",
-  "name": "JSONPath",
+  "name": "dkastner-JSONPath",
   "description": "A JS implementation of JSONPath",
   "contributors": [ 
     { "name": "Stefan Goessner", "email": "subbu@subbu.org" },
-    { "name": "Mike Brevoort", "email": "mike@brevoort.com" }
+    { "name": "Mike Brevoort", "email": "mike@brevoort.com" },
+    { "name": "Derek Kastner", "email": "dkastner@gmail.com" }
   ],  
-  "version": "0.8.2",
+  "version": "0.9.2",
   "repository": {
     "type": "git",
-    "url": "git://github.com/s3u/JSONPath.git"
+    "url": "git://github.com/dkastner/JSONPath.git"
   },
   "main" : "./lib/jsonpath",
   "dependencies": {},
   "devDependencies": {
-    "nodeunit": "latest"
+    "vows": "latest"
   }
 }
diff --git a/test/environment-test.js b/test/environment-test.js
@@ -0,0 +1,17 @@
+var assert = require('assert'),
+    vows = require('vows'),
+    Environment = require("../lib/environment");
+
+vows.describe('Environment').addBatch({
+  '#match': {
+    topic: new Environment({}, '', {}),
+
+    'returns null if there is nothing to match against': function(env) {
+      assert.isNull(env.match('something', null));
+    },
+    'matches the expression against the current object': function(env) {
+      var obj = { isbn: 'abc123' };
+      assert.equal(env.match('@.isbn', obj), 'abc123');
+    }
+  }
+}).export(module);