Output RDF/JS terms

.travis.yml

@@ -1,9 +1,10 @@
 language: node_js
 node_js:
- - "4"
  - "6"
  - "8"
  - "10"
+ - "12"
+ - "lts/*"
  - "node"
 
 before_script:

lib/SparqlGenerator.js

@@ -31,11 +31,12 @@ Generator.prototype.toQuery = function (q) {
   if (q.distinct)
     query += 'DISTINCT ';
 
-  if (q.variables)
+  if (q.variables){
     query += mapJoin(q.variables, undefined, function (variable) {
-      return isString(variable) ? this.toEntity(variable) :
-             '(' + this.toExpression(variable.expression) + ' AS ' + variable.variable + ')';
+      return isTerm(variable) ? this.toEntity(variable) :
+             '(' + this.toExpression(variable.expression) + ' AS ' + "?" + variable.variable.value + ')';
     }, this) + ' ';
+  }
   else if (q.template)
     query += this.group(q.template, true) + this._newline;
 
@@ -51,7 +52,7 @@ Generator.prototype.toQuery = function (q) {
   if (q.group)
     query += 'GROUP BY ' + mapJoin(q.group, undefined, function (it) {
       var result = isString(it.expression) ? it.expression : '(' + this.toExpression(it.expression) + ')';
-      return it.variable ? '(' + result + ' AS ' + it.variable + ')' : result;
+      return it.variable ? '(' + result + ' AS ' + "?" + it.variable.value + ')' : result;
     }, this) + this._newline;
   if (q.having)
     query += 'HAVING (' + mapJoin(q.having, undefined, this.toExpression, this) + ')' + this._newline;
@@ -156,7 +157,7 @@ Generator.prototype.filter = function (filter) {
 };
 
 Generator.prototype.bind = function (bind) {
-  return 'BIND(' + this.toExpression(bind.expression) + ' AS ' + bind.variable + ')';
+  return 'BIND(' + this.toExpression(bind.expression) + ' AS ' + "?" + bind.variable.value + ')';
 };
 
 Generator.prototype.optional = function (optional) {
@@ -201,14 +202,14 @@ Generator.prototype.service = function (service) {
 
 // Converts the parsed expression object into a SPARQL expression
 Generator.prototype.toExpression = function (expr) {
-  if (isString(expr))
+  if (isTerm(expr)) {
     return this.toEntity(expr);
-
+  }
   switch (expr.type.toLowerCase()) {
     case 'aggregate':
       return expr.aggregation.toUpperCase() +
              '(' + (expr.distinct ? 'DISTINCT ' : '') + this.toExpression(expr.expression) +
-             (expr.separator ? '; SEPARATOR = ' + this.toEntity('"' + expr.separator + '"') : '') + ')';
+             (expr.separator ? '; SEPARATOR = ' + '"' + expr.separator.replace(escape, escapeReplacer) + '"' : '') + ')';
     case 'functioncall':
       return this.toEntity(expr.function) + '(' + mapJoin(expr.args, ', ', this.toExpression, this) + ')';
     case 'operation':
@@ -227,9 +228,9 @@ Generator.prototype.toExpression = function (expr) {
       case '-':
       case '*':
       case '/':
-          return (isString(args[0]) ? this.toEntity(args[0]) : '(' + this.toExpression(args[0]) + ')') +
+          return (isTerm(args[0]) ? this.toEntity(args[0]) : '(' + this.toExpression(args[0]) + ')') +
                  ' ' + operator + ' ' +
-                 (isString(args[1]) ? this.toEntity(args[1]) : '(' + this.toExpression(args[1]) + ')');
+                 (isTerm(args[1]) ? this.toEntity(args[1]) : '(' + this.toExpression(args[1]) + ')');
       // Unary operators
       case '!':
         return '!(' + this.toExpression(args[0]) + ')';
@@ -255,30 +256,31 @@ Generator.prototype.toExpression = function (expr) {
 
 // Converts the parsed entity (or property path) into a SPARQL entity
 Generator.prototype.toEntity = function (value) {
-  // regular entity
-  if (isString(value)) {
-    switch (value[0]) {
+  if (isTerm(value)) {
+    switch (value.termType) {
     // variable, * selector, or blank node
-    case '?':
-    case '$':
-    case '*':
-    case '_':
-      return value;
+    case "Wildcard":
+      return "*";
+    case 'Variable':
+      return "?" + value.value;
+    case "BlankNode":
+      return '_:' + value.value;
     // literal
-    case '"':
-      var match = value.match(/^"([^]*)"(?:(@.+)|\^\^(.+))?$/) || {},
-          lexical = match[1] || '', language = match[2] || '', datatype = match[3];
-      value = '"' + lexical.replace(escape, escapeReplacer) + '"' + language;
-      if (datatype) {
-        if (datatype === XSD_INTEGER && /^\d+$/.test(lexical))
+    case "Literal":
+      var lexical = value.value || '', language = value.language || '', datatype = value.datatype;
+      value = '"' + lexical.replace(escape, escapeReplacer) + '"';
+      if (language){
+        value += '@' + language;
+      } else if (datatype) {
+        if (datatype.value === XSD_INTEGER && /^\d+$/.test(lexical))
           // Add space to avoid confusion with decimals in broken parsers
           return lexical + ' ';
-        value += '^^' + this.encodeIRI(datatype);
+        value += '^^' + this.encodeIRI(datatype.value);
       }
       return value;
     // IRI
     default:
-      return this.encodeIRI(value);
+      return this.encodeIRI(value.value);
     }
   }
   // property path
@@ -358,6 +360,9 @@ Generator.prototype.indent = function(text) { return text.replace(/^/gm, this._i
 // Checks whether the object is a string
 function isString(object) { return typeof object === 'string'; }
 
+// Checks whether the object is a Term
+function isTerm(object) { return object.termType !== undefined; }
+
 // Maps the array with the given function, and joins the results using the separator
 function mapJoin(array, sep, func, self) {
   return array.map(func, self).join(isString(sep) ? sep : ' ');

lib/Wildcard.js

@@ -0,0 +1,28 @@
+var Term = require('n3').DataFactory.internal.Term;
+
+// Wildcard constructor
+class Wildcard extends Term {
+  constructor() {
+    super('');
+    return WILDCARD || this;
+  }
+
+  get termType() {
+    return 'Wildcard';
+  }
+
+  equals(other) {
+    return other && (this.termType === other.termType);
+  }
+}
+
+Object.defineProperty(Wildcard.prototype, 'value', {
+  enumerable: true,
+  value: '*',
+});
+
+
+// Wildcard singleton
+var WILDCARD = new Wildcard();
+
+module.exports.Wildcard = Wildcard;