feat: add log:isImpliedBy feature flag (#500)

* feat: add log:isImpliedBy feature flag

* chore(docs): document isImpliedBy

* chore: add comma

* chore: rename parserIsImpledBy -> parserIsImpliedBy

* chore: improve log:isImpliedBy docs

Author: jeswr

README.md

@@ -159,6 +159,13 @@ prefix or, if set to an empty string, completely disable prefixing:
 const parser = new N3.Parser({ blankNodePrefix: '' });
 ```
 
+The parser can output a backwards chaining rule such as `_:q <= _:p.` in two ways:
+- as `_:p log:implies _:q.` (default)
+- as `_:q log:isImpliedBy _:p.` (when the `isImpliedBy` flag is set to `true`)
+```JavaScript
+const parser = new N3.Parser({ isImpliedBy: true });
+```
+
 ### From an RDF stream to quads
 
 `N3.Parser` can parse [Node.js streams](http://nodejs.org/api/stream.html) as they grow,

src/IRIs.js

@@ -26,5 +26,6 @@ export default {
   },
   log: {
     implies: `${SWAP}log#implies`,
+    isImpliedBy: `${SWAP}log#isImpliedBy`,
   },
 };

src/N3Lexer.js

@@ -54,6 +54,9 @@ export default class N3Lexer {
     this._endOfFile = /^(?:#[^\n\r]*)?$/;
     options = options || {};
 
+    // Whether the log:isImpliedBy predicate is supported
+    this._isImpliedBy = options.isImpliedBy;
+
     // In line mode (N-Triples or N-Quads), only simple features may be parsed
     if (this._lineMode = !!options.lineMode) {
       this._n3Mode = false;
@@ -152,8 +155,11 @@ export default class N3Lexer {
         else if (input.length > 1 && input[1] === '<')
           type = '<<', matchLength = 2;
         // Try to find a backwards implication arrow
-        else if (this._n3Mode && input.length > 1 && input[1] === '=')
-          type = 'inverse', matchLength = 2, value = '>';
+        else if (this._n3Mode && input.length > 1 && input[1] === '=') {
+          matchLength = 2;
+          if (this._isImpliedBy) type = 'abbreviation', value = '<';
+          else type = 'inverse', value = '>';
+        }
         break;
 
       case '>':

src/N3Parser.js

@@ -27,14 +27,16 @@ export default class N3Parser {
       this._readPredicateOrNamedGraph = this._readPredicate;
     // Support triples in other graphs
     this._supportsQuads = !(isTurtle || isTriG || isNTriples || isN3);
+    // Whether the log:isImpliedBy predicate is supported
+    this._isImpliedBy = options.isImpliedBy;
     // Support nesting of triples
     this._supportsRDFStar = format === '' || /star|\*$/.test(format);
     // Disable relative IRIs in N-Triples or N-Quads mode
     if (isLineMode)
       this._resolveRelativeIRI = iri => { return null; };
     this._blankNodePrefix = typeof options.blankNodePrefix !== 'string' ? '' :
                               options.blankNodePrefix.replace(/^(?!_:)/, '_:');
-    this._lexer = options.lexer || new N3Lexer({ lineMode: isLineMode, n3: isN3 });
+    this._lexer = options.lexer || new N3Lexer({ lineMode: isLineMode, n3: isN3, isImpliedBy: this._isImpliedBy });
     // Disable explicit quantifiers by default
     this._explicitQuantifiers = !!options.explicitQuantifiers;
   }
@@ -1096,6 +1098,7 @@ function initDataFactory(parser, factory) {
     'a': factory.namedNode(namespaces.rdf.type),
     '=': factory.namedNode(namespaces.owl.sameAs),
     '>': factory.namedNode(namespaces.log.implies),
+    '<': factory.namedNode(namespaces.log.isImpliedBy),
   };
   parser.QUANTIFIERS_GRAPH = factory.namedNode('urn:n3:quantifiers');
 }

test/N3Parser-test.js

@@ -1983,6 +1983,7 @@ describe('Parser', () => {
 
   describe('A Parser instance for the N3 format', () => {
     function parser() { return new Parser({ baseIRI: BASE_IRI, format: 'N3' }); }
+    function parserIsImpliedBy() { return new Parser({ baseIRI: BASE_IRI, format: 'N3', isImpliedBy: true }); }
 
     it(
       'should parse a single triple',
@@ -2046,6 +2047,12 @@ describe('Parser', () => {
                   ['b', 'http://www.w3.org/2000/10/swap/log#implies', 'a']),
     );
 
+    it(
+      'should parse a simple left implication',
+      shouldParse(parserIsImpliedBy, '<a> <= <b>.',
+                  ['a', 'http://www.w3.org/2000/10/swap/log#isImpliedBy', 'b']),
+    );
+
     it(
       'should parse a right implication between one-triple graphs',
       shouldParse(parser, '{ ?a ?b <c>. } => { <d> <e> ?a }.',
@@ -2054,6 +2061,14 @@ describe('Parser', () => {
                   ['d',  'e',  '?a', '_:b1']),
     );
 
+    it(
+      'should parse a right implication between one-triple graphs',
+      shouldParse(parserIsImpliedBy, '{ ?a ?b <c>. } => { <d> <e> ?a }.',
+                  ['_:b0', 'http://www.w3.org/2000/10/swap/log#implies', '_:b1'],
+                  ['?a', '?b', 'c',  '_:b0'],
+                  ['d',  'e',  '?a', '_:b1']),
+    );
+
     it(
       'should parse a right implication between two-triple graphs',
       shouldParse(parser, '{ ?a ?b <c>. <d> <e> <f>. } => { <d> <e> ?a, <f> }.',
@@ -2072,6 +2087,14 @@ describe('Parser', () => {
                   ['d',  'e',  '?a', '_:b1']),
     );
 
+    it(
+      'should parse a left implication between one-triple graphs',
+      shouldParse(parserIsImpliedBy, '{ ?a ?b <c>. } <= { <d> <e> ?a }.',
+                  ['_:b0', 'http://www.w3.org/2000/10/swap/log#isImpliedBy', '_:b1'],
+                  ['?a', '?b', 'c',  '_:b0'],
+                  ['d',  'e',  '?a', '_:b1']),
+    );
+
     it(
       'should parse a left implication between two-triple graphs',
       shouldParse(parser, '{ ?a ?b <c>. <d> <e> <f>. } <= { <d> <e> ?a, <f> }.',