n3 0.4.2 → 0.5.0

package/.eslintrc

@@ -0,0 +1,173 @@
+{
+  env: {
+    node: true,
+  },
+
+  rules: {
+    // Possible Errors
+    comma-dangle: [2, "always-multiline"],
+    no-cond-assign: 0,
+    no-console: 2,
+    no-constant-condition: 0,
+    no-debugger: 2,
+    no-dupe-args: 2,
+    no-dupe-keys: 2,
+    no-duplicate-case: 2,
+    no-empty: 2,
+    no-empty-character-class: 2,
+    no-ex-assign: 2,
+    no-extra-boolean-cast: 2,
+    no-extra-parens: 0,
+    no-extra-semi: 2,
+    no-func-assign: 2,
+    no-inner-declarations: 2,
+    no-invalid-regexp: 2,
+    no-irregular-whitespace: 2,
+    no-negated-in-lhs: 2,
+    no-obj-calls: 2,
+    no-regex-spaces: 2,
+    no-sparse-arrays: 2,
+    no-unreachable: 2,
+    use-isnan: 2,
+    valid-jsdoc: 0,
+    valid-typeof: 2,
+    no-unexpected-multiline: 2,
+
+    // Best Practices
+    accessor-pairs: 2,
+    block-scoped-var: 2,
+    complexity: 0,
+    consistent-return: 0,
+    curly: 0,
+    default-case: 0,
+    dot-notation: 2,
+    dot-location: [2, "property"],
+    eqeqeq: 2,
+    guard-for-in: 0,
+    no-alert: 2,
+    no-caller: 2,
+    no-div-regex: 2,
+    no-else-return: 0,
+    no-empty-label: 2,
+    no-eq-null: 2,
+    no-eval: 2,
+    no-extend-native: 2,
+    no-extra-bind: 2,
+    no-fallthrough: 0,
+    no-floating-decimal: 2,
+    no-implicit-coercion: 0,
+    no-implied-eval: 2,
+    no-invalid-this: 2,
+    no-iterator: 2,
+    no-labels: 2,
+    no-lone-blocks: 2,
+    no-loop-func: 2,
+    no-multi-spaces: 0,
+    no-multi-str: 2,
+    no-native-reassign: 2,
+    no-new-func: 2,
+    no-new-wrappers: 2,
+    no-new: 2,
+    no-octal-escape: 2,
+    no-octal: 2,
+    no-param-reassign: 0,
+    no-process-env: 2,
+    no-proto: 2,
+    no-redeclare: 2,
+    no-return-assign: 0,
+    no-script-url: 2,
+    no-self-compare: 2,
+    no-sequences: 0, // allow the comma operator
+    no-throw-literal: 2,
+    no-unused-expressions: 0,
+    no-useless-call: 2,
+    no-void: 2,
+    no-warning-comments: 2,
+    no-with: 2,
+    radix: 2,
+    vars-on-top: 0,
+    wrap-iife: 2,
+    yoda: 2,
+
+    // Strict Mode
+    strict: [2, "never"],
+
+    // Variables
+    init-declarations: 0,
+    no-catch-shadow: 2,
+    no-delete-var: 2,
+    no-label-var: 2,
+    no-shadow-restricted-names: 2,
+    no-shadow: 0,
+    no-undef-init: 2,
+    no-undef: 2,
+    no-undefined: 0,
+    no-unused-vars: 0,
+    no-use-before-define: [2, "nofunc"],
+
+    // Node.js
+    callback-return: 0,
+    handle-callback-err: 2,
+    no-mixed-requires: 2,
+    no-new-require: 2,
+    no-path-concat: 2,
+    no-process-exit: 2,
+    no-restricted-modules: 2,
+    no-sync: 2,
+
+    // Stylistic Issues
+    array-bracket-spacing: 0,
+    block-spacing: 2,
+    brace-style: [2, "stroustrup", { allowSingleLine: true }],
+    camelcase: 2,
+    comma-spacing: 2,
+    comma-style: 2,
+    computed-property-spacing: 2,
+    consistent-this: 0,
+    eol-last: 2,
+    func-names: 0,
+    func-style: [2, "declaration"],
+    id-length: 0,
+    id-match: 2,
+    indent: [2, 2, { VariableDeclarator: 2 }],
+    key-spacing: 0,
+    lines-around-comment: 2,
+    linebreak-style: 2,
+    max-nested-callbacks: [2, 1],
+    new-cap: 2,
+    new-parens: 2,
+    newline-after-var: 0,
+    no-array-constructor: 2,
+    no-continue: 2,
+    no-inline-comments: 0,
+    no-lonely-if: 2,
+    no-mixed-spaces-and-tabs: 2,
+    no-multiple-empty-lines: 0,
+    no-nested-ternary: 0,
+    no-new-object: 2,
+    no-spaced-func: 2,
+    no-ternary: 0,
+    no-trailing-spaces: 2,
+    no-underscore-dangle: 0,
+    no-unneeded-ternary: 2,
+    object-curly-spacing: [2, "always"],
+    one-var: 0,
+    operator-assignment: 2,
+    operator-linebreak: 2,
+    padded-blocks: [2, "never"],
+    quote-props: [2, "consistent-as-needed"],
+    quotes: [2, "single", "avoid-escape"],
+    semi-spacing: 2,
+    semi: 2,
+    sort-vars: 0,
+    space-after-keywords: 2,
+    space-before-blocks: 2,
+    space-before-function-paren: [2, {"anonymous": "always", "named": "never"}],
+    space-in-parens: 2,
+    space-infix-ops: 2,
+    space-return-throw-case: 2,
+    space-unary-ops: 2,
+    spaced-comment: 2,
+    wrap-regex: 0,
+  },
+}

package/.travis.yml

@@ -1,10 +1,7 @@
 language: node_js
 node_js:
- - "0.10"
-
-branches:
-  except:
-    - browser
-    - earl
+ - "4"
+ - "6"
+ - "node"
 
 sudo: false

package/README.md

@@ -6,13 +6,13 @@ It offers:
 - [**Parsing**](#parsing) triples/quads from
   [Turtle](http://www.w3.org/TR/turtle/),
   [TriG](http://www.w3.org/TR/trig/),
-  [N-Triples](http://www.w3.org/TR/ntriples/)
-  and [N-Quads](http://www.w3.org/TR/nquads/).
+  [N-Triples](http://www.w3.org/TR/n-triples/)
+  and [N-Quads](http://www.w3.org/TR/n-quads/).
 - [**Writing**](#Writing) triples/quads to
   [Turtle](http://www.w3.org/TR/turtle/),
   [TriG](http://www.w3.org/TR/trig/),
-  [N-Triples](http://www.w3.org/TR/ntriples/)
-  and [N-Quads](http://www.w3.org/TR/nquads/).
+  [N-Triples](http://www.w3.org/TR/n-triples/)
+  and [N-Quads](http://www.w3.org/TR/n-quads/).
 - **Storage** of triples/quads in memory
 
 Parsing and writing is:
@@ -199,7 +199,7 @@ A dedicated `prefix` event signals every prefix with `prefix` and `iri` argument
 Write triples through `addTriple`.
 
 ``` js
-var writer = N3.Writer({ prefixes: { 'c': 'http://example.org/cartoons#' } });
+var writer = N3.Writer({ prefixes: { c: 'http://example.org/cartoons#' } });
 writer.addTriple('http://example.org/cartoons#Tom',
                  'http://www.w3.org/1999/02/22-rdf-syntax-ns#type',
                  'http://example.org/cartoons#Cat');
@@ -225,7 +225,7 @@ var writer2 = N3.Writer({ format: 'application/trig' });
 `N3.Writer` can also write triples to a Node.js stream.
 
 ``` js
-var writer = N3.Writer(process.stdout, { prefixes: { 'c': 'http://example.org/cartoons#' } });
+var writer = N3.Writer(process.stdout, { prefixes: { c: 'http://example.org/cartoons#' } });
 writer.addTriple('http://example.org/cartoons#Tom',
                  'http://www.w3.org/1999/02/22-rdf-syntax-ns#type',
                  'http://example.org/cartoons#Cat');
@@ -244,12 +244,47 @@ writer.end();
 ``` js
 var streamParser = new N3.StreamParser(),
     inputStream = fs.createReadStream('cartoons.ttl'),
-    streamWriter = new N3.StreamWriter({ 'c': 'http://example.org/cartoons#' });
+    streamWriter = new N3.StreamWriter({ prefixes: { c: 'http://example.org/cartoons#' } });
 inputStream.pipe(streamParser);
 streamParser.pipe(streamWriter);
 streamWriter.pipe(process.stdout);
 ```
 
+### Blank nodes and lists
+You might want to use the `[…]` and list `(…)` notations of Turtle and TriG.
+However, a streaming writer cannot create these automatically:
+the shorthand notations are only possible if blank nodes or list heads are not used later on,
+which can only be determined conclusively at the end of the stream.
+
+The `blank` and `list` functions allow you to create them manually instead:
+```js
+var writer = N3.Writer({ prefixes: { c: 'http://example.org/cartoons#',
+                                     foaf: 'http://xmlns.com/foaf/0.1/' } });
+writer.addTriple(writer.blank('http://xmlns.com/foaf/0.1/givenName', '"Tom"@en'),
+                 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type',
+                 'http://example.org/cartoons#Cat');
+writer.addTriple('http://example.org/cartoons#Jerry',
+                 'http://xmlns.com/foaf/0.1/knows',
+                 writer.blank([{
+                   predicate: 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type',
+                   object: 'http://example.org/cartoons#Cat'
+                 },{
+                   predicate: 'http://xmlns.com/foaf/0.1/givenName',
+                   object: '"Tom"@en',
+                 }]));
+writer.addTriple('http://example.org/cartoons#Mammy',
+                 'http://example.org/cartoons#hasPets',
+                 writer.list([
+                   'http://example.org/cartoons#Tom',
+                   'http://example.org/cartoons#Jerry'
+                 ]));
+writer.end(function (error, result) { console.log(result); });
+```
+
+Be careful to use the output of `blank` and `list`
+**only once** and **only as argument to `addTriple`** of the same writer,
+as return values of these functions are unspecified.
+
 ## Storing
 
 `N3.Store` allows you to store triples in memory and find them fast.
@@ -318,7 +353,7 @@ N3Util.isLiteral('_:b1'); // false
 
 **Prefixed names** can be tested and expanded:
 ``` js
-var prefixes = { 'rdfs': 'http://www.w3.org/2000/01/rdf-schema#' };
+var prefixes = { rdfs: 'http://www.w3.org/2000/01/rdf-schema#' };
 N3Util.isPrefixedName('rdfs:label'); // true;
 N3Util.expandPrefixedName('rdfs:label', prefixes); // http://www.w3.org/2000/01/rdf-schema#label
 ```

package/lib/N3Lexer.js

@@ -27,7 +27,7 @@ function N3Lexer(options) {
     this._tokenize = this.tokenize;
     this.tokenize = function (input, callback) {
       this._tokenize(input, function (error, token) {
-        if (!error && /IRI|prefixed|literal|langcode|type|\.|eof/.test(token.type))
+        if (!error && /^(?:IRI|prefixed|literal|langcode|type|\.|eof)$/.test(token.type))
           callback && callback(error, token);
         else
           callback && callback(error || self._syntaxError(token.type, callback = null));
@@ -100,17 +100,14 @@ N3Lexer.prototype = {
 
       case '<':
         // Try to find a full IRI without escape sequences.
-        if (match = this._unescapedIri.exec(input)) {
-          type = 'IRI';
-          value = match[1];
-        }
+        if (match = this._unescapedIri.exec(input))
+          type = 'IRI', value = match[1];
         // Try to find a full IRI with escape sequences.
         else if (match = this._iri.exec(input)) {
           unescaped = this._unescape(match[1]);
           if (unescaped === null || illegalIriChars.test(unescaped))
             return reportSyntaxError(this);
-          type = 'IRI';
-          value = unescaped;
+          type = 'IRI', value = unescaped;
         }
         break;
 
@@ -119,27 +116,21 @@ N3Lexer.prototype = {
         // we always need a non-dot character before deciding it is a prefixed name.
         // Therefore, try inserting a space if we're at the end of the input.
         if ((match = this._blank.exec(input)) ||
-            inputFinished && (match = this._blank.exec(input + ' '))) {
-          type = 'prefixed';
-          prefix = '_';
-          value = match[1];
-        }
+            inputFinished && (match = this._blank.exec(input + ' ')))
+          type = 'prefixed', prefix = '_', value = match[1];
         break;
 
       case '"':
       case "'":
         // Try to find a non-empty double-quoted literal without escape sequences.
-        if (match = this._unescapedString.exec(input)) {
-          type = 'literal';
-          value = match[0];
-        }
+        if (match = this._unescapedString.exec(input))
+          type = 'literal', value = match[0];
         // Try to find any other literal wrapped in a pair of single or double quotes.
         else if (match = this._singleQuotedString.exec(input)) {
           unescaped = this._unescape(match[0]);
           if (unescaped === null)
             return reportSyntaxError(this);
-          type = 'literal';
-          value = unescaped.replace(/^'|'$/g, '"');
+          type = 'literal', value = unescaped.replace(/^'|'$/g, '"');
         }
         // Try to find a literal wrapped in three pairs of single or double quotes.
         else if (match = this._tripleQuotedString.exec(input)) {
@@ -149,21 +140,17 @@ N3Lexer.prototype = {
           unescaped = this._unescape(unescaped);
           if (unescaped === null)
             return reportSyntaxError(this);
-          type = 'literal';
-          value = unescaped.replace(/^'|'$/g, '"');
+          type = 'literal', value = unescaped.replace(/^'|'$/g, '"');
         }
         break;
 
       case '@':
         // Try to find a language code.
-        if (this._prevTokenType === 'literal' && (match = this._langcode.exec(input))) {
-          type = 'langcode';
-          value = match[1];
-        }
+        if (this._prevTokenType === 'literal' && (match = this._langcode.exec(input)))
+          type = 'langcode', value = match[1];
         // Try to find a keyword.
-        else if (match = this._keyword.exec(input)) {
+        else if (match = this._keyword.exec(input))
           type = match[0];
-        }
         break;
 
       case '.':
@@ -211,20 +198,16 @@ N3Lexer.prototype = {
       case 'f':
       case 't':
         // Try to match a boolean.
-        if (match = this._boolean.exec(input)) {
-          type = 'literal';
-          value = '"' + match[0] + '"^^http://www.w3.org/2001/XMLSchema#boolean';
-        }
+        if (match = this._boolean.exec(input))
+          type = 'literal', value = '"' + match[0] + '"^^http://www.w3.org/2001/XMLSchema#boolean';
         else
           inconclusive = true;
         break;
 
       case 'a':
         // Try to find an abbreviated predicate.
-        if (match = this._shortPredicates.exec(input)) {
-          type = 'abbreviation';
-          value = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
-        }
+        if (match = this._shortPredicates.exec(input))
+          type = 'abbreviation', value = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
         else
           inconclusive = true;
         break;
@@ -250,19 +233,14 @@ N3Lexer.prototype = {
       if (inconclusive) {
         // Try to find a prefix.
         if ((this._prevTokenType === '@prefix' || this._prevTokenType === 'PREFIX') &&
-            (match = this._prefix.exec(input))) {
-          type = 'prefix';
-          value = match[1] || '';
-        }
+            (match = this._prefix.exec(input)))
+          type = 'prefix', value = match[1] || '';
         // Try to find a prefixed name. Since it can contain (but not end with) a dot,
         // we always need a non-dot character before deciding it is a prefixed name.
         // Therefore, try inserting a space if we're at the end of the input.
         else if ((match = this._prefixed.exec(input)) ||
-                 inputFinished && (match = this._prefixed.exec(input + ' '))) {
-          type = 'prefixed';
-          prefix = match[1] || '';
-          value = this._unescape(match[2]);
-        }
+                 inputFinished && (match = this._prefixed.exec(input + ' ')))
+          type = 'prefixed', prefix = match[1] || '', value = this._unescape(match[2]);
       }
 
       // A type token is special: it can only be emitted after an IRI or prefixed name is read.
@@ -369,9 +347,8 @@ N3Lexer.prototype = {
 
     // Parses until the end
     function end() {
-      if (self._input !== null) {
+      if (self._input !== null)
         self._tokenizeToEnd(callback, true);
-      }
     }
   },
 };