preparing and cleaning libraries for release

Author: kevinchekovfeeney

dist/terminus-client.min.js

@@ -1,11 +1,12 @@
-'use strict';
 module.exports = {
 				 WOQLClient:require('./lib/woqlClient'),
                   ConnectionCapabilities:require('./lib/connectionCapabilities'),
                   ConnectionConfig:require('./lib/connectionConfig'),
                   IDParser:require('./lib/terminusIDParser'),
                   ErrorMessage:require('./lib/errorMessage'),
-                  FrameHelper:require('./lib/frameHelper'),
-                  ObjectFrame:require('./lib/objectFrame'),
+                  UTILS:require('./lib/utils'),
+                  TerminusDocument:require('./lib/document'),
                   WOQLResult:require('./lib/woqlResult'),
+                  WOQLRule:require('./lib/woqlRule'),
+                  FrameRule:require('./lib/frameRule'),
                   WOQL:require('./lib/woql')};

dist/terminus-client.min.js.map

@@ -0,0 +1 @@
+{}

index.js

@@ -3,6 +3,7 @@
  * @license Apache Version 2
  * @summary Functions for dispatching API requests via the axios library. 
  */
+
 const axios = require('axios');
 const UTILS = require('./utils.js');
 const CONST = require('./const.js');

lib/.eslintrc

@@ -1,3 +1,194 @@
+/**
+ * @file Javascript Terminus Document Classes
+ * @license Apache Version 2
+ * @summary Helper classes for accessing documents returned by the Terminus DB API programmatically
+ * 
+ * Usage: let doc = new TerminusDocument(client);
+ * 
+ * These set the objects document property and return promises:
+ *  
+ * doc.loadDocument(URL) //.then(() => console.log(this.document));
+ * doc.loadComplete(URL, CLS) // .then(() => console.log(this.document))
+ * doc.loadSchema(cls) //.then(() => console.log(this.document))
+ * 
+ * These just set the object's document property 
+ * doc.loadJSON(json_frames, cls) //console.log(this.document)
+ * doc.loadDataFrames(json_frames, cls)
+ * doc.loadClassFrames(json_frames, cls)
+ * 
+ */
+const WOQLClient = require('./woqlClient');
+const FrameHelper = require('./utils');
+
+
+/**
+ * 
+ * @param {WOQLClient} [client] - woql client object to reuse for loading the doucument
+ * @summary creates a Terminus Document Object for loading documents from the Terminus Document API
+ */
+function TerminusDocument(client){
+    this.client = client;
+    if(!this.client){
+        this.client = new WOQLClient();
+    }
+}
+
+TerminusDocument.prototype.db = function(dburl){
+    this.client.connectionConfig.setDB(dburl);
+    return this;
+}
+
+
+
+/**
+ *  @param {String} url - loads the document frame from the document API in frame form
+ *  @summary - loads the frame encapsulates more meta-data in the json and reduces the number of api calls we need to make
+ *  @returns {Promise}
+ */
+ TerminusDocument.prototype.loadDocument = function(url, encoding){
+     encoding = encoding || "terminus:frame";
+	 return this.client.getDocument(url, {"terminus:encoding": encoding})
+	.then((response) => (encoding == "terminus:frame" ? this.loadDataFrames(response) : this.loadJSON(response)));
+}
+
+TerminusDocument.prototype.loadSchema = function(cls, dbURL){
+	var ncls = FrameHelper.unshorten(cls);
+	return this.client.getClassFrame(dbURL, ncls)
+	.then((response) => this.loadSchemaFrames(response, ncls));
+}
+
+/**
+ *  @param {String} url - loads the document frame along with its class frame
+ *  @param {String} [cls] - optional class id of the document - if absent class frames will be loaded from the document class once it is loaded
+ *  @returns {Promise}
+ *  @summary - loads a document frame and it's class frame in unison
+ */
+
+TerminusDocument.prototype.loadComplete = function(url, cls){
+    if(cls){
+        return Promise.all([this.loadDocument(url), this.loadDocumentSchema(cls)]);        
+    }
+    else {
+	    return this.client.getDocument(url, {"terminus:encoding": "terminus:frame"})
+        .then((response) =>  this.loadDocumentSchema(this.document.cls));
+    }
+}
+
+TerminusDocument.prototype.loadJSON = function(json, type){
+    if(this.docid){
+        return this.loadDocument(this.docid);
+    }
+    else if(this.clsid){
+        return this.loadDocumentSchema(this.clsid);
+    }
+    console.error("Either docid or clid must be set before load is called")
+}
+
+TerminusDocument.prototype.loadDataFrames = function(dataframes, cls, classframes){
+	if(!cls){
+		if(this.document) cls = this.document.cls;
+		else {
+			if(dataframes && dataframes.length && dataframes[0] && dataframes[0].domain){
+				cls = dataframes[0].domain;
+			}
+		}
+	}
+	if(cls){
+		if(!this.document){
+			this.document = new TerminusClient.ObjectFrame(cls, dataframes, classframes);
+		}
+		else {
+			this.document.loadDataFrames(dataframes);
+		}
+	}
+	else {
+		console.log("Missing Class" + " " + "Failed to add dataframes due to missing class");
+	}
+}
+
+TerminusDocument.prototype.loadSchemaFrames = function(classframes, cls){
+	if(!cls){
+		if(classframes && classframes.length && classframes[0] && classframes[0].domain){
+			cls = classframes[0].domain;
+		}
+	}
+	if(cls){
+		if(!this.document){
+			this.document = new TerminusClient.ObjectFrame(cls);
+		}
+		if(classframes){
+			this.document.loadClassFrames(classframes);
+			if(!this.document.subjid){
+				this.document.newDoc = true;
+				this.document.fillFromSchema("_:");
+			}
+		}
+	}
+	else {
+		console.log("Missing Class", "Failed to add class frames due to missing both class and classframes");
+	}
+}
+
+TerminusDocument.prototype.render = function(){
+	if(!this.renderer && this.document){
+		if(this.config.renderer()){
+			this.renderer = this.config.renderer();
+		}
+		else {
+			this.applyRulesToDocument(this.document, this.config);
+			this.renderer = this.document;
+		}
+	}
+	if(this.renderer && this.renderer.render){
+		return this.renderer.render(this.document);
+	}
+	else if(typeof this.renderer == "function"){
+		var x = this.renderer(this.document);
+		return x;
+	}
+	else {
+		console.log("didna make it - no render function for document");
+	}
+}
+
+/*
+ * adds render and compare functions to object frames
+ */
+TerminusDocument.prototype.applyRulesToDocument = function(doc, config){
+	var self = this;
+	function onmatch(frame, rule){
+		if(typeof rule.render() != "undefined"){
+			frame.render = rule.render();
+		}
+		else {
+			if(rule.renderer()){
+				var renderer = self.loadRenderer(rule.renderer(), frame, rule.args);		
+			}
+			if(renderer && renderer.render){
+				frame.render = function(frame){
+					return renderer.render(frame);
+				}
+			}
+		}
+		if(rule.compare()){
+			frame.compare = rule.compare();
+		}
+		config.setFrameDisplayOptions(frame, rule);
+	}
+	if(doc.render){
+		function clearDisplay(frame, rule){
+			delete(frame['render']);
+			delete(frame['display_options']);
+			frame.compare = TerminusClient.ObjectFrame.prototype.compare;
+		}
+		var nconfig = TerminusClient.WOQL.document();
+		nconfig.all();
+		doc.filter(nconfig.rules, clearDisplay);
+	}
+	doc.filter(config.rules, onmatch);
+}
+
+
 /**
  * Represents a frame for programmatic access to object frame, anywhere within a document
  * Recursive data structure where this.children contains an indexed array of object frames
@@ -11,8 +202,6 @@
  * @param parent parent object
  * @returns
  */
-const FrameHelper = require('./frameHelper');
-const FramePattern = require('./framePattern');
 
 function ObjectFrame(cls, dataframes, classframes, parent, parentframe) {
 	// the class of the frame - mandatory
@@ -168,7 +357,7 @@ ObjectFrame.prototype.clear = function () {
  */
 ObjectFrame.prototype.filter = function (rules, onmatch, options) {
 	const cascading = (options && options.ignore_failure ? true : false);
-	var hits = FramePattern.FramePatternMatcher.testRules(rules, this, onmatch);
+	//var hits = FramePattern.FramePatternMatcher.testRules(rules, this, onmatch);
 	//if(hits.length || cascading){
 		for (const prop of Object.keys(this.properties)) {
 			this.properties[prop].filter(rules, onmatch, options);
@@ -650,7 +839,7 @@ PropertyFrame.prototype.createEmpty = function(){
 
 PropertyFrame.prototype.filter = function (rules, onmatch, options) {
 	const cascading = (options && options.ignore_failure ? true : false);
-	var hits = FramePattern.FramePatternMatcher.testRules(rules, this, onmatch);
+	//var hits = FramePattern.FramePatternMatcher.testRules(rules, this, onmatch);
 	//if(hits.length || cascading){
 		for (var i = 0; i<this.values.length; i++){
 			this.values[i].filter(rules, onmatch, options);
@@ -760,7 +949,7 @@ DataFrame.prototype.load = function (frame) {
 };
 
 DataFrame.prototype.filter = function (rules, onmatch) {
-	FramePattern.FramePatternMatcher.testRules(rules, this, onmatch);
+	//FramePattern.FramePatternMatcher.testRules(rules, this, onmatch);
 	return this;
 };
 
@@ -1166,4 +1355,4 @@ Restriction.prototype.loadRestriction = function (restriction) {
 	}
 };
 
-module.exports = ObjectFrame;
+module.exports = TerminusDocument;