Harmonize period usage in comments.

Only end titles and successive sentences with a period.

Author: RubenVerborgh

lib/N3Lexer.js

@@ -45,7 +45,7 @@ function N3Lexer(options) {
 
 N3Lexer.prototype = {
   // ## Regular expressions
-  // It's slightly faster to have these as properties than as in-scope variables.
+  // It's slightly faster to have these as properties than as in-scope variables
 
   _iri: /^<((?:[^ <>{}\\]|\\[uU])+)>[ \t]*/, // IRI with escape sequences; needs sanity check after unescaping
   _unescapedIri: /^<([^\x00-\x20<>\\"\{\}\|\^\`]*)>[ \t]*/, // IRI without escape sequences; no unescaping
@@ -69,12 +69,12 @@ N3Lexer.prototype = {
 
   // ## Private methods
 
-  // ### `_tokenizeToEnd` tokenizes as for as possible, emitting tokens through the callback.
+  // ### `_tokenizeToEnd` tokenizes as for as possible, emitting tokens through the callback
   _tokenizeToEnd: function (callback, inputFinished) {
-    // Continue parsing as far as possible; the loop will return eventually.
+    // Continue parsing as far as possible; the loop will return eventually
     var input = this._input, outputComments = this._comments;
     while (true) {
-      // Count and skip whitespace lines.
+      // Count and skip whitespace lines
       var whiteSpaceMatch, comment;
       while (whiteSpaceMatch = this._newline.exec(input)) {
         // Try to find a comment
@@ -84,13 +84,13 @@ N3Lexer.prototype = {
         input = input.substr(whiteSpaceMatch[0].length, input.length);
         this._line++;
       }
-      // Skip whitespace on current line.
+      // Skip whitespace on current line
       if (whiteSpaceMatch = this._whitespace.exec(input))
         input = input.substr(whiteSpaceMatch[0].length, input.length);
 
-      // Stop for now if we're at the end.
+      // Stop for now if we're at the end
       if (this._endOfFile.test(input)) {
-        // If the input is finished, emit EOF.
+        // If the input is finished, emit EOF
         if (inputFinished) {
           // Try to find a final comment
           if (outputComments && (comment = this._comment.exec(input)))
@@ -100,45 +100,45 @@ N3Lexer.prototype = {
         return this._input = input;
       }
 
-      // Look for specific token types based on the first character.
+      // Look for specific token types based on the first character
       var line = this._line, type = '', value = '', prefix = '',
           firstChar = input[0], match = null, matchLength = 0, unescaped, inconclusive = false;
       switch (firstChar) {
       case '^':
         // We need at least 3 tokens lookahead to distinguish ^^<IRI> and ^^pre:fixed
         if (input.length < 3)
           break;
-        // Try to match a type.
+        // Try to match a type
         else if (input[1] === '^') {
           this._prevTokenType = '^^';
-          // Move to type IRI or prefixed name.
+          // Move to type IRI or prefixed name
           input = input.substr(2);
           if (input[0] !== '<') {
             inconclusive = true;
             break;
           }
         }
-        // If no type, it must be a path expression.
+        // If no type, it must be a path expression
         else {
           if (this._n3Mode) {
             matchLength = 1;
             type = '^';
           }
           break;
         }
-        // Fall through in case the type is an IRI.
+        // Fall through in case the type is an IRI
       case '<':
-        // Try to find a full IRI without escape sequences.
+        // Try to find a full IRI without escape sequences
         if (match = this._unescapedIri.exec(input))
           type = 'IRI', value = match[1];
-        // Try to find a full IRI with escape sequences.
+        // 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;
         }
-        // Try to find a backwards implication arrow.
+        // Try to find a backwards implication arrow
         else if (this._n3Mode && input.length > 1 && input[1] === '=')
           type = 'inverse', matchLength = 2, value = 'http://www.w3.org/2000/10/swap/log#implies';
         break;
@@ -154,20 +154,20 @@ N3Lexer.prototype = {
 
       case '"':
       case "'":
-        // Try to find a non-empty double-quoted literal without escape sequences.
+        // Try to find a non-empty double-quoted literal without escape sequences
         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.
+        // 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, '"');
         }
-        // Try to find a literal wrapped in three pairs of single or double quotes.
+        // Try to find a literal wrapped in three pairs of single or double quotes
         else if (match = this._tripleQuotedString.exec(input)) {
           unescaped = match[1] || match[2];
-          // Count the newlines and advance line counter.
+          // Count the newlines and advance line counter
           this._line += unescaped.split(/\r\n|\r|\n/).length - 1;
           unescaped = this._unescape(unescaped);
           if (unescaped === null)
@@ -183,22 +183,22 @@ N3Lexer.prototype = {
         break;
 
       case '@':
-        // Try to find a language code.
+        // Try to find a language code
         if (this._prevTokenType === 'literal' && (match = this._langcode.exec(input)))
           type = 'langcode', value = match[1];
-        // Try to find a keyword.
+        // Try to find a keyword
         else if (match = this._keyword.exec(input))
           type = match[0];
         break;
 
       case '.':
-        // Try to find a dot as punctuation.
+        // Try to find a dot as punctuation
         if (input.length === 1 ? inputFinished : (input[1] < '0' || input[1] > '9')) {
           type = '.';
           matchLength = 1;
           break;
         }
-        // Fall through to numerical case (could be a decimal dot).
+        // Fall through to numerical case (could be a decimal dot)
 
       case '0':
       case '1':
@@ -212,7 +212,7 @@ N3Lexer.prototype = {
       case '9':
       case '+':
       case '-':
-        // Try to find a number.
+        // Try to find a number
         if (match = this._number.exec(input)) {
           type = 'literal';
           value = '"' + match[0] + '"^^http://www.w3.org/2001/XMLSchema#' +
@@ -226,7 +226,7 @@ N3Lexer.prototype = {
       case 'P':
       case 'G':
       case 'g':
-        // Try to find a SPARQL-style keyword.
+        // Try to find a SPARQL-style keyword
         if (match = this._sparqlKeyword.exec(input))
           type = match[0].toUpperCase();
         else
@@ -235,23 +235,23 @@ N3Lexer.prototype = {
 
       case 'f':
       case 't':
-        // Try to match a boolean.
+        // Try to match a 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.
+        // 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';
         else
           inconclusive = true;
         break;
 
       case '=':
-        // Try to find an implication arrow or equals sign.
+        // Try to find an implication arrow or equals sign
         if (this._n3Mode && input.length > 1) {
           type = 'abbreviation';
           if (input[1] !== '>')
@@ -281,9 +281,9 @@ N3Lexer.prototype = {
         inconclusive = true;
       }
 
-      // Some first characters do not allow an immediate decision, so inspect more.
+      // Some first characters do not allow an immediate decision, so inspect more
       if (inconclusive) {
-        // Try to find a prefix.
+        // Try to find a prefix
         if ((this._prevTokenType === '@prefix' || this._prevTokenType === 'PREFIX') &&
             (match = this._prefix.exec(input)))
           type = 'prefix', value = match[1] || '';
@@ -295,7 +295,7 @@ N3Lexer.prototype = {
           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.
+      // A type token is special: it can only be emitted after an IRI or prefixed name is read
       if (this._prevTokenType === '^^') {
         switch (type) {
         case 'prefixed': type = 'type';    break;
@@ -315,19 +315,19 @@ N3Lexer.prototype = {
           return this._input = input;
       }
 
-      // Emit the parsed token.
+      // Emit the parsed token
       callback(null, { line: line, type: type, value: value, prefix: prefix });
       this._prevTokenType = type;
 
-      // Advance to next part to tokenize.
+      // Advance to next part to tokenize
       input = input.substr(matchLength || match[0].length, input.length);
     }
 
     // Signals the syntax error through the callback
     function reportSyntaxError(self) { callback(self._syntaxError(/^\S*/.exec(input)[0])); }
   },
 
-  // ### `_unescape` replaces N3 escape codes by their corresponding characters.
+  // ### `_unescape` replaces N3 escape codes by their corresponding characters
   _unescape: function (item) {
     try {
       return item.replace(escapeSequence, function (sequence, unicode4, unicode8, escapedChar) {
@@ -369,7 +369,7 @@ N3Lexer.prototype = {
     var self = this;
     this._line = 1;
 
-    // If the input is a string, continuously emit tokens through the callback until the end.
+    // If the input is a string, continuously emit tokens through the callback until the end
     if (typeof input === 'string') {
       this._input = input;
       // If a callback was passed, asynchronously call it
@@ -383,7 +383,7 @@ N3Lexer.prototype = {
         return tokens;
       }
     }
-    // Otherwise, the input must be a stream.
+    // Otherwise, the input must be a stream
     else {
       this._input = '';
       if (typeof input.setEncoding === 'function')
@@ -405,6 +405,4 @@ N3Lexer.prototype = {
 };
 
 // ## Exports
-
-// Export the `N3Lexer` class as a whole.
 module.exports = N3Lexer;