From e44a7e37b6c7b5961adaffc62b9042b8d442938e Mon Sep 17 00:00:00 2001
From: mensonge <mensonge@b3834d28-1941-0410-a4f8-b48e95affb8f>
Date: Thu, 13 Nov 2008 09:49:11 +0000
Subject: New feature: basic Ajax suggestion for tags and implementation of
 Dojo toolkit

git-svn-id: https://semanticscuttle.svn.sourceforge.net/svnroot/semanticscuttle/trunk@151 b3834d28-1941-0410-a4f8-b48e95affb8f
---
 includes/js/dojox/jsonPath/query.js | 163 ++++++++++++++++++++++++++++++++++++
 1 file changed, 163 insertions(+)
 create mode 100644 includes/js/dojox/jsonPath/query.js

(limited to 'includes/js/dojox/jsonPath/query.js')

diff --git a/includes/js/dojox/jsonPath/query.js b/includes/js/dojox/jsonPath/query.js
new file mode 100644
index 0000000..4e24309
--- /dev/null
+++ b/includes/js/dojox/jsonPath/query.js
@@ -0,0 +1,163 @@
+if(!dojo._hasResource["dojox.jsonPath.query"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.
+dojo._hasResource["dojox.jsonPath.query"] = true;
+dojo.provide("dojox.jsonPath.query");
+
+dojox.jsonPath.query = function(/*Object*/obj, /*String*/expr, /*Object*/arg){
+	// summaRy
+	// 	Perform jsonPath query `expr` on javascript object or json string `obj`
+	//	obj - object || json string to perform query on
+	//	expr - jsonPath expression (string) to be evaluated
+	//	arg - {}special arugments.  
+	//		resultType: "VALUE"||"BOTH"||"PATH"} (defaults to value)
+	//		evalType: "RESULT"||"ITEM"} (defaults to ?)
+
+	var re = dojox.jsonPath._regularExpressions;
+	if (!arg){arg={};}
+
+	var strs = [];
+	function _str(i){ return strs[i];}
+	var acc;
+	if (arg.resultType == "PATH" && arg.evalType == "RESULT") throw Error("RESULT based evaluation not supported with PATH based results");
+	var P = {
+		resultType: arg.resultType || "VALUE",
+		normalize: function(expr){
+			var subx = [];
+			expr = expr.replace(/'([^']|'')*'/g, function(t){return "_str("+(strs.push(eval(t))-1)+")";});
+			var ll = -1;
+			while(ll!=subx.length){
+				ll=subx.length;//TODO: Do expression syntax checking
+				expr = expr.replace(/(\??\([^\(\)]*\))/g, function($0){return "#"+(subx.push($0)-1);});
+			}
+			expr = expr.replace(/[\['](#[0-9]+)[\]']/g,'[$1]')
+						  .replace(/'?\.'?|\['?/g, ";")
+						  .replace(/;;;|;;/g, ";..;")
+						  .replace(/;$|'?\]|'$/g, "");
+			ll = -1;
+			while(ll!=expr){
+				ll=expr;
+					 expr = expr.replace(/#([0-9]+)/g, function($0,$1){return subx[$1];});
+			}
+			return expr.split(";");
+		},
+		asPaths: function(paths){
+			for (var j=0;j<paths.length;j++){
+			var p = "$";
+			var x= paths[j];
+			for (var i=1,n=x.length; i<n; i++)
+				p += /^[0-9*]+$/.test(x[i]) ? ("["+x[i]+"]") : ("['"+x[i]+"']");
+			paths[j]=p;
+		  }
+			return paths;
+		},
+		exec: function(locs, val, rb){
+			var path = ['$'];
+			var result=rb?val:[val];
+			var paths=[path];
+			function add(v, p,def){
+			  if (v && v.hasOwnProperty(p) && P.resultType != "VALUE") paths.push(path.concat([p]));
+				if (def) 
+				  result = v[p];
+			  else if (v && v.hasOwnProperty(p))  
+					result.push(v[p]);
+			}
+			function desc(v){
+				result.push(v);
+				paths.push(path);
+				P.walk(v,function(i){
+					if (typeof v[i] ==='object')  {
+						var oldPath = path;
+						path = path.concat(i);
+						desc(v[i]);
+						path = oldPath;
+					}
+				});
+			}
+			function slice(loc, val){
+				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)
+						add(val,i);
+				}
+			}
+			function repStr(str){
+				var i=loc.match(/^_str\(([0-9]+)\)$/);
+				return i?strs[i[1]]:str;
+			}
+			function oper(val){
+				if (/^\(.*?\)$/.test(loc)) // [(expr)]
+					add(val, P.eval(loc, val),rb);
+				else if (loc === "*"){
+					P.walk(val, rb && val instanceof Array ? // if it is result based, there is no point to just return the same array
+					function(i){P.walk(val[i],function(j){ add(val[i],j); })} :
+					function(i){ add(val,i); });
+				}
+				else if (loc === "..") 
+					desc(val);
+				else if (/,/.test(loc)){ // [name1,name2,...]
+					for (var s=loc.split(/'?,'?/),i=0,n=s.length; i<n; i++)
+						add(val,repStr(s[i])); 
+				}
+				else if (/^\?\(.*?\)$/.test(loc)) // [?(expr)]
+					P.walk(val, function(i){ if (P.eval(loc.replace(/^\?\((.*?)\)$/,"$1"),val[i])) add(val,i); });
+				else if (/^(-?[0-9]*):(-?[0-9]*):?([0-9]*)$/.test(loc)) // [start:end:step]  python slice syntax
+					slice(loc, val);
+				else {
+					loc=repStr(loc);
+					if (rb && val instanceof Array && !/^[0-9*]+$/.test(loc)) 
+						P.walk(val, function(i){ add(val[i], loc)});
+					else 
+						add(val,loc,rb);		
+				}
+
+			}
+			while (locs.length){
+				var loc = locs.shift();
+				if ((val = result) === null || val===undefined) return val;
+				result = [];
+				var valPaths = paths;
+				paths = [];
+				if (rb) 
+					oper(val)
+				else
+					P.walk(val,function(i){path=valPaths[i]||path;oper(val[i])});
+			}
+			if (P.resultType == "BOTH"){
+				paths = P.asPaths(paths);
+				var newResult = [];
+				for (var i =0;i <paths.length;i++)
+					newResult.push({path:paths[i],value:result[i]});
+				return newResult;
+			}
+			return P.resultType == "PATH" ? P.asPaths(paths):result;
+		},
+		walk: function(val, f){
+			if (val instanceof Array){
+				for (var i=0,n=val.length; i<n; i++)
+					if (i in val)
+						f(i);
+			}
+			else if (typeof val === "object"){
+				for (var m in val)
+					if (val.hasOwnProperty(m))
+						f(m);
+			}
+		},
+		eval: function(x, _v){
+			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){
+		return P.exec(P.normalize(expr).slice(1), obj, arg.evalType == "RESULT");
+	}	
+
+	return false;
+
+}; 
+
+}
-- 
cgit v1.2.3