dev/js/src/vc.js - KorAP/Kalamar - Gitiles

 /**
  * Create virtual collections with a visual user interface.
  * This resembles the collection type objects of a KoralQuery
  * "collection" object.
  *
  * KoralQuery v0.3 is expected.
  *
  * @author Nils Diewald
  */
 /*
  * This replaces a previous version written by Mengfei Zhou
  */

 /*
   TODO: Disable "and" or "or" in case it's followed
         by an unspecified document
   TODO: Add "and"-method to root to add further constraints based on match-
         input (like clicking on a pubDate timestamp in a match)
   TODO: Implement "persistence"-Option,
         injecting the current creation date stamp
   TODO: Implement vec-Type for document-id vectors
         like docID in [1,2,3,4 ...]

   Error codes:
   701: "JSON-LD group has no @type attribute"
   704: "Operation needs operand list"
   802: "Match type is not supported by value type"
   804: "Unknown value type"
   805: "Value is invalid"
   806: "Value is not a valid date string"
   807: "Value is not a valid regular expression"
   810: "Unknown document group operation" (like 711)
   811: "Document group expects operation" (like 703)
   812: "Operand not supported in document group" (like 744)
   813: "Collection type is not supported" (like 713)
   814: "Unknown rewrite operation"
   815: "Rewrite expects source"

   Localization strings:
   KorAP.Locale = {
     EMPTY : '...',
     AND : 'and',
     OR : 'or',
     DELETE : 'x'
   }
   and various field names with the prefix 'VC_'
 */

 define([
   'vc/unspecified',
   'vc/doc',
   'vc/docgroup',
   'vc/menu',
   'vc/statistic',
   'datepicker',
   'util',
 ], function (unspecDocClass, docClass, docGroupClass, menuClass, statClass, dpClass) {
   "use strict";

   KorAP._validUnspecMatchRE = new RegExp("^(?:eq|ne|contains(?:not)?|excludes)$");
   KorAP._validStringMatchRE = new RegExp("^(?:eq|ne)$");
   KorAP._validTextMatchRE = KorAP._validUnspecMatchRE;
   KorAP._validTextOnlyMatchRE = new RegExp("^(?:contains(?:not)?|excludes)$");
   KorAP._overrideStyles     = false;
   // KorAP._validDateMatchRE is defined in datepicker.js!

   const loc = KorAP.Locale;

   KorAP._vcKeyMenu = undefined;
   KorAP._vcDatePicker = dpClass.create();

 	// Create match menus ....
 	KorAP._vcMatchopMenu = {
 	  'string' : menuClass.create([
 	    ['eq', null],
 	    ['ne', null]
 	  ]),
 	  'text' : menuClass.create([
 	    ['eq', null],         // Requires exact match
 	    ['ne', null],
 	    ['contains', null],   // Requires token sequence match
 	    ['containsnot', null]
 	  ]),
 	  'date' : menuClass.create([
 	    ['eq', null],
       ['ne', null],
 	    ['geq', null],
 	    ['leq', null]
 	  ]),
 	  'regex' : menuClass.create([
 	    ['eq', null],
 	    ['ne', null]
 	  ])
 	};

   /**
    * Virtual Collection
    */
   return {

     /**
      * The JSON-LD type of the virtual collection
      */
     ldType : function () {
       return null;
     },

     // Initialize virtual collection
     _init : function (keyList) {

       // Inject localized css styles
       if (!KorAP._overrideStyles) {
 	      var sheet = KorAP.newStyleSheet();

 	      // Add css rule for OR operations
 	      sheet.insertRule(
 	        '.vc .docGroup[data-operation=or] > .doc::before,' +
 	          '.vc .docGroup[data-operation=or] > .docGroup::before ' +
 	          '{ content: "' + loc.OR + '" }',
 	        0
 	      );

 	      // Add css rule for AND operations
 	      sheet.insertRule(
 	        '.vc .docGroup[data-operation=and] > .doc::before,' +
 	          '.vc .docGroup[data-operation=and] > .docGroup::before ' +
 	          '{ content: "' + loc.AND + '" }',
 	        1
 	      );

 	      KorAP._overrideStyles = true;
       };

 	    // Create key menu
       KorAP._vcKeyMenu = menuClass.create(keyList);
       KorAP._vcKeyMenu.limit(6);

       return this;
     },

     /**
      * Create a new virtual collection.
      */
     create : function (keyList) {
       var obj = Object.create(this)._init(keyList);
       obj._root = unspecDocClass.create(obj);
       return obj;
     },


     /**
      * Create and render a new virtual collection
      * based on a KoralQuery collection document
      */
     fromJson : function (json) {
       if (json !== undefined) {
 	      // Parse root document
 	      if (json['@type'] == 'koral:doc') {
 	        this._root = docClass.create(this, json);
 	      }
 	      // parse root group
 	      else if (json['@type'] == 'koral:docGroup') {
 	        this._root = docGroupClass.create(this, json);
 	      }
 	      // Unknown collection type
 	      else {
 	        KorAP.log(813, "Collection type is not supported");
 	        return;
 	      };
       }

       else {
 	      // Add unspecified object
 	      this._root = unspecDocClass.create(this);
       };

       // Init element and update
       this.update();

       return this;
     },


     // Check if the virtual corpus contains a rewrite
     // This is a class method
     checkRewrite : function (json) {

       // There is a rewrite attribute
       if (json['rewrites'] !== undefined) {
         return true;
       }

       // There is a group to check for rewrites
       else if (json['@type'] === 'koral:docGroup') {
         var ops = json['operands'];
         if (ops === undefined)
           return false;

         for (var i in ops) {

           // "this" is the class
           if (this.checkRewrite(ops[i])) {
             return true;
           };
         };
       };
       return false;
     },

     /**
      * Clean the virtual document to uspecified doc.
      */
     clean : function () {
       if (this._root.ldType() !== "non") {
 	      this._root.destroy();
 	      this.root(unspecDocClass.create(this));
       };
       return this;
     },


     /**
      * Get or set the root object of the
      * virtual collection.
      */
     root : function (obj) {
       if (arguments.length === 1) {
 	      var e = this.element();

 	      if (e.firstChild !== null) {
 	        if (e.firstChild !== obj.element()) {
 	          e.replaceChild(obj.element(), e.firstChild);
 	        };
 	      }

 	      // Append root element
 	      else {
 	        e.appendChild(obj.element());
 	      };

 	      // Update parent child relations
 	      this._root = obj;
 	      obj.parent(this);

 	      this.update();
       };
       return this._root;
     },


     /**
      * Get the element associated with the virtual collection
      */
     element : function () {
       if (this._element !== undefined) {
 	      return this._element;
       };

       this._element = document.createElement('div');
       this._element.setAttribute('class', 'vc');

       // Initialize root
       this._element.appendChild(this._root.element());

       return this._element;
     },


     /**
      * Update the whole object based on the underlying
      * data structure
      */
     update : function () {
       this._root.update();
       return this;
     },

     /**
      * Make the vc persistant by injecting the current timestamp
      * as a creation date limit criterion.
      */
     makePersistant : function () {
       // this.root().wrapOnRoot('and');
       var todayStr = KorAP._vcDatePicker.today();
       var doc = docClass.create();
       var root = this.root();

       if (root.ldType() === 'docGroup' &&
 	        root.operation === 'and') {
 	      root.append(cond);
       }
       else {
 	      root.wrapOnRoot('and');
 	      root.append(doc);
       };

       doc.key("creationDate");
       doc.type("date");
       doc.matchop("leq");
       doc.value(todayStr);

 /*
  {
 	"@type" : "koral:doc",
 	"key" : "creationDate",
 	"type" : "type:date",
 	"match" : "match:leq",
 	"value" : todayStr
       }
       this.root().append(cond);
 */
       this.update();
     },

     /**
      * Get the generated json string
      */
     toJson : function () {
       return this._root.toJson();
     },


     /**
      * Get the generated query string
      */
     toQuery : function () {
       return this._root.toQuery();
     },


     /**
     * Get associated corpus statistic,
     * create corpus statistic if it is unassigned
    	*/
    	statistic : function(){
    		if(this.corpStat == undefined){
    			this.corpStat = statClass.create();
    		}
    		return this.corpStat;
    	}

   };
 });
	/**
	* Create virtual collections with a visual user interface.
	* This resembles the collection type objects of a KoralQuery
	* "collection" object.
	*
	* KoralQuery v0.3 is expected.
	*
	* @author Nils Diewald
	*/
	/*
	* This replaces a previous version written by Mengfei Zhou
	*/

	/*
	TODO: Disable "and" or "or" in case it's followed
	by an unspecified document
	TODO: Add "and"-method to root to add further constraints based on match-
	input (like clicking on a pubDate timestamp in a match)
	TODO: Implement "persistence"-Option,
	injecting the current creation date stamp
	TODO: Implement vec-Type for document-id vectors
	like docID in [1,2,3,4 ...]

	Error codes:
	701: "JSON-LD group has no @type attribute"
	704: "Operation needs operand list"
	802: "Match type is not supported by value type"
	804: "Unknown value type"
	805: "Value is invalid"
	806: "Value is not a valid date string"
	807: "Value is not a valid regular expression"
	810: "Unknown document group operation" (like 711)
	811: "Document group expects operation" (like 703)
	812: "Operand not supported in document group" (like 744)
	813: "Collection type is not supported" (like 713)
	814: "Unknown rewrite operation"
	815: "Rewrite expects source"

	Localization strings:
	KorAP.Locale = {
	EMPTY : '...',
	AND : 'and',
	OR : 'or',
	DELETE : 'x'
	}
	and various field names with the prefix 'VC_'
	*/

	define([
	'vc/unspecified',
	'vc/doc',
	'vc/docgroup',
	'vc/menu',
	'vc/statistic',
	'datepicker',
	'util',
	], function (unspecDocClass, docClass, docGroupClass, menuClass, statClass, dpClass) {
	"use strict";

	KorAP._validUnspecMatchRE = new RegExp("^(?:eq\|ne\|contains(?:not)?\|excludes)$");
	KorAP._validStringMatchRE = new RegExp("^(?:eq\|ne)$");
	KorAP._validTextMatchRE = KorAP._validUnspecMatchRE;
	KorAP._validTextOnlyMatchRE = new RegExp("^(?:contains(?:not)?\|excludes)$");
	KorAP._overrideStyles = false;
	// KorAP._validDateMatchRE is defined in datepicker.js!

	const loc = KorAP.Locale;

	KorAP._vcKeyMenu = undefined;
	KorAP._vcDatePicker = dpClass.create();

	// Create match menus ....
	KorAP._vcMatchopMenu = {
	'string' : menuClass.create([
	['eq', null],
	['ne', null]
	]),
	'text' : menuClass.create([
	['eq', null], // Requires exact match
	['ne', null],
	['contains', null], // Requires token sequence match
	['containsnot', null]
	]),
	'date' : menuClass.create([
	['eq', null],
	['ne', null],
	['geq', null],
	['leq', null]
	]),
	'regex' : menuClass.create([
	['eq', null],
	['ne', null]
	])
	};

	/**
	* Virtual Collection
	*/
	return {

	/**
	* The JSON-LD type of the virtual collection
	*/
	ldType : function () {
	return null;
	},

	// Initialize virtual collection
	_init : function (keyList) {

	// Inject localized css styles
	if (!KorAP._overrideStyles) {
	var sheet = KorAP.newStyleSheet();

	// Add css rule for OR operations
	sheet.insertRule(
	'.vc .docGroup[data-operation=or] > .doc::before,' +
	'.vc .docGroup[data-operation=or] > .docGroup::before ' +
	'{ content: "' + loc.OR + '" }',
	0
	);

	// Add css rule for AND operations
	sheet.insertRule(
	'.vc .docGroup[data-operation=and] > .doc::before,' +
	'.vc .docGroup[data-operation=and] > .docGroup::before ' +
	'{ content: "' + loc.AND + '" }',
	1
	);

	KorAP._overrideStyles = true;
	};

	// Create key menu
	KorAP._vcKeyMenu = menuClass.create(keyList);
	KorAP._vcKeyMenu.limit(6);

	return this;
	},

	/**
	* Create a new virtual collection.
	*/
	create : function (keyList) {
	var obj = Object.create(this)._init(keyList);
	obj._root = unspecDocClass.create(obj);
	return obj;
	},


	/**
	* Create and render a new virtual collection
	* based on a KoralQuery collection document
	*/
	fromJson : function (json) {
	if (json !== undefined) {
	// Parse root document
	if (json['@type'] == 'koral:doc') {
	this._root = docClass.create(this, json);
	}
	// parse root group
	else if (json['@type'] == 'koral:docGroup') {
	this._root = docGroupClass.create(this, json);
	}
	// Unknown collection type
	else {
	KorAP.log(813, "Collection type is not supported");
	return;
	};
	}

	else {
	// Add unspecified object
	this._root = unspecDocClass.create(this);
	};

	// Init element and update
	this.update();

	return this;
	},


	// Check if the virtual corpus contains a rewrite
	// This is a class method
	checkRewrite : function (json) {

	// There is a rewrite attribute
	if (json['rewrites'] !== undefined) {
	return true;
	}

	// There is a group to check for rewrites
	else if (json['@type'] === 'koral:docGroup') {
	var ops = json['operands'];
	if (ops === undefined)
	return false;

	for (var i in ops) {

	// "this" is the class
	if (this.checkRewrite(ops[i])) {
	return true;
	};
	};
	};
	return false;
	},

	/**
	* Clean the virtual document to uspecified doc.
	*/
	clean : function () {
	if (this._root.ldType() !== "non") {
	this._root.destroy();
	this.root(unspecDocClass.create(this));
	};
	return this;
	},


	/**
	* Get or set the root object of the
	* virtual collection.
	*/
	root : function (obj) {
	if (arguments.length === 1) {
	var e = this.element();

	if (e.firstChild !== null) {
	if (e.firstChild !== obj.element()) {
	e.replaceChild(obj.element(), e.firstChild);
	};
	}

	// Append root element
	else {
	e.appendChild(obj.element());
	};

	// Update parent child relations
	this._root = obj;
	obj.parent(this);

	this.update();
	};
	return this._root;
	},


	/**
	* Get the element associated with the virtual collection
	*/
	element : function () {
	if (this._element !== undefined) {
	return this._element;
	};

	this._element = document.createElement('div');
	this._element.setAttribute('class', 'vc');

	// Initialize root
	this._element.appendChild(this._root.element());

	return this._element;
	},


	/**
	* Update the whole object based on the underlying
	* data structure
	*/
	update : function () {
	this._root.update();
	return this;
	},

	/**
	* Make the vc persistant by injecting the current timestamp
	* as a creation date limit criterion.
	*/
	makePersistant : function () {
	// this.root().wrapOnRoot('and');
	var todayStr = KorAP._vcDatePicker.today();
	var doc = docClass.create();
	var root = this.root();

	if (root.ldType() === 'docGroup' &&
	root.operation === 'and') {
	root.append(cond);
	}
	else {
	root.wrapOnRoot('and');
	root.append(doc);
	};

	doc.key("creationDate");
	doc.type("date");
	doc.matchop("leq");
	doc.value(todayStr);

	/*
	{
	"@type" : "koral:doc",
	"key" : "creationDate",
	"type" : "type:date",
	"match" : "match:leq",
	"value" : todayStr
	}
	this.root().append(cond);
	*/
	this.update();
	},

	/**
	* Get the generated json string
	*/
	toJson : function () {
	return this._root.toJson();
	},


	/**
	* Get the generated query string
	*/
	toQuery : function () {
	return this._root.toQuery();
	},


	/**
	* Get associated corpus statistic,
	* create corpus statistic if it is unassigned
	*/
	statistic : function(){
	if(this.corpStat == undefined){
	this.corpStat = statClass.create();
	}
	return this.corpStat;
	}

	};
	});