eyeling 1.5.26 → 1.5.28

package/eyeling.js

@@ -235,6 +235,12 @@ function lex(inputText) {
         i += 2;
         continue;
       }
+      // N3 predicate inversion: "<-" (swap subject/object for this predicate)
+      if (peek(1) === "-") {
+        tokens.push(new Token("OpPredInvert"));
+        i += 2;
+        continue;
+      }
       // Otherwise IRIREF <...>
       i++; // skip '<'
       const iriChars = [];
@@ -280,8 +286,41 @@ function lex(inputText) {
       continue;
     }
 
-    // String literal
+    // String literal: short "..." or long """..."""
     if (c === '"') {
+      // Long string literal """ ... """
+      if (peek(1) === '"' && peek(2) === '"') {
+        i += 3; // consume opening """
+        const sChars = [];
+        let closed = false;
+        while (i < n) {
+          // closing delimiter?
+          if (peek() === '"' && peek(1) === '"' && peek(2) === '"') {
+            i += 3; // consume closing """
+            closed = true;
+            break;
+          }
+          let cc = chars[i];
+          i++;
+          if (cc === "\\") {
+            // Preserve escapes verbatim (same behavior as short strings)
+            if (i < n) {
+              const esc = chars[i];
+              i++;
+              sChars.push("\\");
+              sChars.push(esc);
+            }
+            continue;
+          }
+          sChars.push(cc);
+        }
+        if (!closed) throw new Error('Unterminated long string literal """..."""');
+        const s = '"""' + sChars.join("") + '"""';
+        tokens.push(new Token("Literal", s));
+        continue;
+      }
+
+      // Short string literal " ... "
       i++; // consume opening "
       const sChars = [];
       while (i < n) {
@@ -790,9 +829,14 @@ class Parser {
     while (true) {
       // Verb (can also be 'a')
       let pred;
+      let invert = false;
       if (this.peek().typ === "Ident" && (this.peek().value || "") === "a") {
         this.next();
         pred = new Iri(RDF_NS + "type");
+      } else if (this.peek().typ === "OpPredInvert") {
+        this.next(); // consume "<-"
+        pred = this.parseTerm();
+        invert = true;
       } else {
         pred = this.parseTerm();
       }
@@ -805,7 +849,8 @@ class Parser {
       }
 
       for (const o of objs) {
-        this.pendingTriples.push(new Triple(subj, pred, o));
+        this.pendingTriples.push(invert ? new Triple(o, pred, subj)
+                                       : new Triple(subj, pred, o));
       }
 
       if (this.peek().typ === "Semicolon") {
@@ -873,14 +918,21 @@ class Parser {
     const out = [];
     while (true) {
       let verb;
+      let invert = false;
       if (this.peek().typ === "Ident" && (this.peek().value || "") === "a") {
         this.next();
         verb = new Iri(RDF_NS + "type");
+      } else if (this.peek().typ === "OpPredInvert") {
+        this.next(); // consume "<-"
+        verb = this.parseTerm(); // predicate expression
+        invert = true;
       } else {
         verb = this.parseTerm();
       }
       const objects = this.parseObjectList();
-      for (const o of objects) out.push(new Triple(subject, verb, o));
+      for (const o of objects) {
+        out.push(new Triple(invert ? o : subject, verb, invert ? subject : o));
+      }
 
       if (this.peek().typ === "Semicolon") {
         this.next();
@@ -1680,6 +1732,9 @@ function literalParts(lit) {
 }
 
 function stripQuotes(lex) {
+  if (lex.length >= 6 && lex.startsWith('"""') && lex.endsWith('"""')) {
+    return lex.slice(3, -3);
+  }
   if (lex.length >= 2 && lex[0] === '"' && lex[lex.length - 1] === '"') {
     return lex.slice(1, -1);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eyeling",
-  "version": "1.5.26",
+  "version": "1.5.28",
   "description": "A minimal Notation3 (N3) reasoner in JavaScript.",
   "main": "./index.js",
   "keywords": [

package/test/api.test.js

@@ -621,6 +621,35 @@ ${U('s')} ${U('p')} ${U('o')}. # another trailing comment
       mustOccurExactly(out, reD, 1, 'diamond subclass should not duplicate x type D');
     },
   },
+
+  {
+    name: '42 literals: language tags are accepted and preserved',
+    opt: { proofComments: false },
+    input: ` { ?s ${U('p')} ?o } => { ?s ${U('q')} ?o }. ${U('s')} ${U('p')} "colour"@en-GB.`,
+    expect: [new RegExp(`${EX}s>\\s+<${EX}q>\\s+"colour"@en-GB\\s*\\.`)],
+  },
+
+  {
+    name: '43 literals: long """...""" strings are accepted (with lang tag)',
+    opt: { proofComments: false },
+    input: ` { ?s ${U('p')} ?o } => { ?s ${U('q')} ?o }. ${U('s')} ${U('p')} """Hello
+world"""@en.`,
+    expect: [new RegExp(`${EX}s>\\s+<${EX}q>\\s+(?:"""Hello[\\s\\S]*?world"""@en|"Hello\\\\nworld"@en)\\s*\\.`)],
+  },
+
+  { name: '44 syntax: "<-" in predicate position swaps subject and object',
+    opt: { proofComments: false },
+    input: ` { ?s ${U('p')} ?o } => { ?s ${U('q')} ?o }.
+${U('a')} <-${U('p')} ${U('b')}.`,
+    expect: [new RegExp(`${EX}b>\\s+<${EX}q>\\s+<${EX}a>\\s*\\.`)],
+  },
+
+  { name: '45 syntax: "<-" works inside blank node property lists ([ ... ])',
+    opt: { proofComments: false },
+    input: ` ${U('s')} ${U('p')} [ <-${U('r')} ${U('o')} ].
+{ ${U('o')} ${U('r')} ?x } => { ?x ${U('q')} ${U('k')} }.`,
+    expect: [new RegExp(`_:b1\\s+<${EX}q>\\s+<${EX}k>\\s*\\.`)],
+  },
 ];
 
 let passed = 0;