fixed some tests for woql

Author: kevinchekovfeeney

lib/framePattern.js

@@ -1,8 +1,9 @@
+const FrameHelper = require('./frameHelper');
 /**
  * A frame pattern can have the following variables
  * renderer : object, property, data, * - matches a specific part of the frame
  * label : matches the label of a property
- * frame_type: object, data, document, oneOf
+ * frame_type: object, data, document, id, oneOf
  * subject: id of the subject
  * subjectClass: class of the subject
  * range: type of a property (applies to property and data)
@@ -209,7 +210,7 @@ FramePattern.prototype.checkLabel = function (rtype, frame) {
 };
 
 FramePattern.prototype.IDsMatch = function (ida, idb) {
-	return TerminusClient.FrameHelper.compareIDs(ida, idb);
+	return FrameHelper.compareIDs(ida, idb);
 };
 
 FramePattern.prototype.classIDsMatch = function (ida, idb) {
@@ -314,6 +315,41 @@ FrameRule.prototype.unpack = function(arr, nonstring){
 	return str;
 }
 
+FrameRule.prototype.unpackFeatures = function(feats){
+	let extensions = {};
+	var fstr = "";
+	for(var i = 0; i<feats.length; i++){
+		if(typeof feats[i] == "string"){
+			fstr += '"' + feats[i] + '"';
+		}
+		else if(typeof feats[i] == "object"){
+			var fid = Object.keys(feats[i])[0];
+			fstr += '"' +  fid + '"';
+			for(var prop in feats[i][fid]){
+				extensions[prop] = feats[i][fid][prop];
+			}
+		}
+		if(i < feats.length - 1){
+			fstr += ", "
+		}
+	}
+	for(var k = 0; k < Object.keys(extensions).length; k++){
+		var ext = Object.keys(extensions)[k];
+		var val = extensions[ext];
+		fstr += ")." + ext + "(";
+		if(typeof val == "function"){
+			fstr += val;
+		}
+		else if(typeof val == "string"){
+			fstr += '"' + val + '"';
+		}
+		else if(typeof val == "object"){
+			fstr += JSON.stringify(val);
+		}
+	}
+	return fstr;
+}
+
 FrameRule.prototype.prettyPrint = function(type){
 	//starts with obj. ...
 	if(this.scope() == "*"){
@@ -355,7 +391,13 @@ FrameRule.prototype.prettyPrint = function(type){
 		str += ".parent(" + this.parent.prettyPrint() + ")";
 	}
 	if(typeof this.depth() != "undefined"){
-		str += ".depth('" + this.depth() + "')";
+		var d = this.depth();
+		if(typeof d == "string"){
+			str += ".depth('" + this.depth() + "')";
+		}
+		else {
+			str += ".depth(" + this.depth() + ")";
+		}
 	}
 	if(typeof this.index() != "undefined"){
 		str += ".index(" + this.unpack(this.index(), true) + ")";
@@ -367,7 +409,7 @@ FrameRule.prototype.prettyPrint = function(type){
 		str += ".renderer('" + this.renderer() + "')";
 	}
 	if(typeof this.render() != "undefined"){
-		str += ".render(" + this.render() + ")";
+		str += ".render(" + this.render + ")";
 	}
 	if(typeof this.compare() != "undefined"){
 		str += ".compare(" + this.compare() + ")";
@@ -390,28 +432,26 @@ FrameRule.prototype.prettyPrint = function(type){
 	if(typeof this.header() != "undefined"){
 		str += ".header(" + this.header() + ")";
 	}
-	if(typeof this.features() != "undefined"){
-		str += ".features(" + this.unpack(this.features()) + ")";
+	if(typeof this.style() != "undefined"){
+		str += ".style(\"" + this.style() + "\")";
 	}
-	if(typeof this.headerFeatures() != "undefined"){
-		str += ".headerFeatures(" + this.unpack(this.headerFeatures()) + ")";
+	if(typeof this.headerStyle() != "undefined"){
+		str += ".headerStyle(\"" + this.headerStyle() + "\")";
+	}
+	if(typeof this.args() != "undefined"){
+		str += ".args(" + JSON.stringify(this.args()) + ")";
 	}
 	if(typeof this.showEmpty() != "undefined"){
 		str += ".showEmpty(" + this.show_empty() + ")";
 	}
 	if(typeof this.dataviewer() != "undefined"){
-		str += ".dataviewer('" + this.dataviewer() + "')";
+		str += ".dataviewer(\"" + this.dataviewer() + "\")";
 	}
-	if(typeof this.args() != "undefined"){
-		str += ".args(" + JSON.stringify(this.args()) + ")";
+	if(typeof this.features() != "undefined"){
+		str += ".features(" + this.unpackFeatures(this.features()) + ")";
 	}
-	if(typeof this.featureRenderers() != "undefined"){
-		str += ".featureRenderers({";
-		for(var f in this.featureRenderers()){
-			str += JSON.stringify(f) + ":" + this.rule.feature_renderers[f] + ",";
-		}
-		str = str.substring(0, str.length-1);
-		str += "})";
+	if(typeof this.headerFeatures() != "undefined"){
+		str += ".headerFeatures(" + this.unpackFeatures(this.headerFeatures()) + ")";
 	}
 	return str;
 }
@@ -424,7 +464,7 @@ FrameRule.prototype.scope = function(scope){
 
 FrameRule.prototype.frameType = function(...frametype){
 	if(typeof frametype == "undefined" || frametype.length == 0) return this.rule.pattern.frametype;
-	this.rule.pattern.frametype = frame_type;
+	this.rule.pattern.frametype = frametype;
 	return this;
 };
 
@@ -509,57 +549,172 @@ FrameRule.prototype.status = function(...status){
 	return this;
 };
 
-FrameRule.prototype.renderer = function(rend){
-	if(!rend) return this.rule.renderer;
-	this.rule.renderer = rend;
-	return this;
-}
+/**
+ * The below correspond to rule actions - what happens when a pattern matches
+ */
 
+/**
+ * These onces can apply to features - if the rule includes an earlier features or header_features call, subsequent render, style, hidden and args apply to it
+ */
 FrameRule.prototype.render = function(func){
-	if(func){
+	if(!func) return this.rule.render;
+	var hf = this.headerFeatures(); 
+	var f = this.features(); 
+	if(hf && hf.length){
+		var feats = this.applyFeatureProperty(hf, "render", func);
+		this.headerFeatures(...feats);
+	}
+	else if(f && f.length){
+		var feats = this.applyFeatureProperty(f, "render", func);
+		this.features(...feats);
+	}
+	else {
 		this.rule.render = func;
-		return this;
 	}
-	return func;
+	return this;
+}
+
+FrameRule.prototype.style = function(style){
+	if(typeof style == "undefined") return this.rule.style;
+	var hf = this.headerFeatures(); 
+	var f = this.features(); 
+	if(hf && hf.length){
+		var feats = this.applyFeatureProperty(hf, "style", style);
+		this.headerFeatures(...feats);
+	}
+	else if(f && f.length){
+		var feats = this.applyFeatureProperty(f, "style", style);
+		this.features(...feats);
+	}
+	else {
+		this.rule.style = style;
+	}
+	return this;
+};
+
+/**
+ * The frame or feature will be hidden or unhidden (boolean)
+ */
+FrameRule.prototype.hidden = function(m){
+	if(typeof m == "undefined") return this.rule.hidden;
+	var hf = this.headerFeatures(); 
+	var f = this.features(); 
+	if(hf && hf.length){
+		var feats = this.applyFeatureProperty(hf, "hidden", m);
+		this.headerFeatures(...feats);
+	}
+	else if(f && f.length){
+		var feats = this.applyFeatureProperty(f, "hidden", m);
+		this.features(...feats);
+	}
+	else {
+		this.rule.hidden = m;
+	}
+	return this;
 }
 
+/**
+ * Specifies arguments to a renderer 
+ */
 FrameRule.prototype.args = function(json){
 	if(!json) return this.rule.args;
-	this.rule.args = json;
+	var hf = this.headerFeatures(); 
+	var f = this.features(); 
+	if(hf && hf.length){
+		var feats = this.applyFeatureProperty(hf, "args", json);
+		this.headerFeatures(...feats);
+	}
+	else if(f && f.length){
+		var feats = this.applyFeatureProperty(f, "args", json);
+		this.features(...feats);
+	}
+	else {
+		this.rule.args = json;
+	}
+	return this;
+}
+
+/**
+ * Adds a property to a feature array
+ */
+FrameRule.prototype.applyFeatureProperty = function(feats, prop, val){
+	var nfeats = [];
+	for(var i = 0; i<feats.length; i++){
+		if(typeof feats[i] == "string"){
+			var nfeat = {};
+			nfeat[feats[i]] = {};
+			nfeat[feats[i]][prop] = val;
+			nfeats.push(nfeat);
+		}
+		else if(typeof feats[i] == "object"){
+			let fkey = Object.keys(feats[i])[0];
+			if(fkey){
+				var nfeat = feats[i];
+				nfeat[fkey][prop] = val;
+				nfeats.push(nfeat);
+			}
+		}
+	}
+	return nfeats;
+}
+	
+
+
+/**
+ * These apply to regular frames
+ */
+FrameRule.prototype.renderer = function(rend){
+	if(!rend) return this.rule.renderer;
+	this.rule.renderer = rend;
+	return this;
+}
+
+FrameRule.prototype.headerStyle = function(hstyle){
+	if(!hstyle) return this.rule.header_style;
+	this.rule.header_style = hstyle;
 	return this;
 }
 
+/**
+ * Function which specifies the ordering of values in a frame
+ */
 FrameRule.prototype.compare = function(func){
 	if(!func) return this.rule.compare;
 	this.rule.compare = func;
 	return this;
 }
 
+/**
+ * Edit / view mode
+ */
 FrameRule.prototype.mode = function(m){
 	if(!m) return this.rule.mode;
 	this.rule.mode = m;
 	return this;
 }
 
+/**
+ * Specifies whether a frame should be presented in collapsed form or not
+ */
 FrameRule.prototype.collapse = function(m){
 	if(!m) return this.rule.collapse;
 	this.rule.collapse = m;
 	return this;
 }
 
-
-FrameRule.prototype.hidden = function(m){
-	if(!m) return this.rule.hidden;
-	this.rule.hidden = m;
-	return this;
-}
+/**
+ * Specifies whether a frame should include a view selector
+ */
 
 FrameRule.prototype.view = function(m){
 	if(!m) return this.rule.view;
 	this.rule.view = m;
 	return this;
 }
 
+/**
+ * Should actions which are disabled in the given context be displayed?
+ */
 FrameRule.prototype.showDisabledButtons = function(m){
 	if(!m) return this.rule.show_disabled_buttons;
 	this.rule.show_disabled_buttons = m;
@@ -584,12 +739,6 @@ FrameRule.prototype.header = function(m){
 	return this;
 }
 
-FrameRule.prototype.featureRenderers = function(m){
-	if(!m) return this.rule.feature_renderers;
-	this.rule.feature_renderers = m;
-	return this;
-}
-
 FrameRule.prototype.showEmpty = function(m){
 	if(!m) return this.rule.show_empty;
 	this.rule.show_empty = m;