implement loose option. fixes #15

Author: shellscape

lib/errors/ParserError.js

@@ -0,0 +1,19 @@
+'use strict';
+
+class ParserError extends Error {
+  constructor(message) {
+    super(message);
+
+    this.name = this.constructor.name;
+    this.message = message || 'An error ocurred while parsing.';
+
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, this.constructor);
+    }
+    else {
+      this.stack = (new Error(message)).stack;
+    }
+  }
+}
+
+module.exports = ParserError;

lib/index.js

@@ -13,8 +13,8 @@ const Str = require('./string');
 const Value = require('./value');
 const Word = require('./word');
 
-let parser = function (source) {
-  return new Parser(source);
+let parser = function (source, options) {
+  return new Parser(source, options);
 };
 
 parser.atword = function (opts) {

lib/parser.js

@@ -19,14 +19,18 @@ const tokenize = require('./tokenize');
 const flatten = require('flatten');
 const indexesOf = require('indexes-of');
 const uniq = require('uniq');
+const ParserError = require('./errors/ParserError');
 
 function sortAscending (list) {
   return list.sort((a, b) => a - b);
 }
 
 module.exports = class Parser {
-  constructor (input) {
+  constructor (input, options) {
+    const defaults = { loose: false };
+
     this.input = input;
+    this.options = Object.assign({}, defaults, options);
     this.position = 0;
     // we'll use this to keep track of the paren balance
     this.unbalanced = 0;
@@ -37,7 +41,8 @@ module.exports = class Parser {
     this.root.append(value);
 
     this.current = value;
-    this.tokens = tokenize(input);
+    this.tokens = tokenize(input, this.options);
+    // console.log(this.tokens);
   }
 
   parse () {
@@ -106,8 +111,8 @@ module.exports = class Parser {
     this.position++;
   }
 
-  error (message) {
-    throw new Error(message); // eslint-disable-line new-cap
+  error (message, token) {
+    throw new ParserError(message + ` at line: ${token[2]}, column ${token[3]}`);
   }
 
   loop () {
@@ -129,7 +134,30 @@ module.exports = class Parser {
 
   operator () {
 
-    let node = new Operator({
+    // if a +|- operator is followed by a non-word character (. is allowed) and
+    // is preceded by a non-word character. (5+5)
+    let char = this.currToken[1],
+      node;
+
+    if (char === '+' || char === '-') {
+      if (this.position > 0) {
+        if (!this.options.loose) {
+          if (this.prevToken[0] !== 'space') {
+            this.error('Syntax Error', this.currToken);
+          }
+          else if (this.nextToken[0] !== 'space') {
+            this.error('Syntax Error', this.currToken);
+          }
+        }
+      }
+
+      if ((!this.current.nodes.length || (this.current.last && this.current.last.type === 'operator')) && this.nextToken[0] === 'word') {
+        return this.word();
+      }
+    }
+
+
+    node = new Operator({
       value: this.currToken[1],
       source: {
         start: {
@@ -205,7 +233,7 @@ module.exports = class Parser {
     }
 
     if (unbalanced) {
-      this.error('Expected closing parenthesis.');
+      this.error('Expected closing parenthesis', token);
     }
 
     // ok, all parens are balanced. continue on
@@ -300,7 +328,7 @@ module.exports = class Parser {
     this.current.unbalanced --;
 
     if (this.current.unbalanced < 0) {
-      this.error('Expected opening parenthesis.');
+      this.error('Expected opening parenthesis', token);
     }
 
     if (!this.current.unbalanced && this.cache) {
@@ -450,10 +478,6 @@ module.exports = class Parser {
     return this.splitWord();
   }
 
-  missingParenthesis () {
-    return this.error('Expected opening parenthesis.');
-  }
-
   newNode (node) {
     if (this.spaces) {
       node.raws.before += this.spaces;

lib/tokenize.js

@@ -24,7 +24,10 @@ const wordEndNum = /[ \n\t\r\(\)\*:;@!&'"\-\+\|~>,\[\]\\]|\//g;
 const util = require('util');
 const TokenizeError = require('./errors/TokenizeError');
 
-module.exports = function tokenize (input) {
+module.exports = function tokenize (input, options) {
+
+  options = options || {};
+
   let tokens = [],
     css = input.valueOf(),
     length = css.length,
@@ -37,7 +40,7 @@ module.exports = function tokenize (input) {
 
   function unclosed (what) {
     let message = util.format('Unclosed %s at line: %d, column: %d, token: %d', what, line, pos - offset, pos);
-    throw new Error(message);
+    throw new TokenizeError(message);
   }
 
   function tokenizeError () {
@@ -208,28 +211,14 @@ module.exports = function tokenize (input) {
           break;
         }
 
-        // if a +|- operator is followed by a non-word character (. is allowed) and
-        // is preceded by a non-word character. (5+5)
-        if (pos > 0 && (code === plus || code === minus)) {
-          if (prevChar.charCodeAt(0) !== space) {
-            tokenizeError();
-          }
-          else if (nextChar.charCodeAt(0) !== space) {
-            tokenizeError();
-          }
-        }
-
-        /* eslint no-fallthrough: 0 */
-        if (!/[a-z0-9\.]/gi.test(nextChar)) {
-          tokens.push(['operator', css.slice(pos, next),
-            line, pos  - offset,
-            line, next - offset,
-            pos
-          ]);
+        tokens.push(['operator', css.slice(pos, next),
+          line, pos  - offset,
+          line, next - offset,
+          pos
+        ]);
 
-          pos = next - 1;
-          break;
-        }
+        pos = next - 1;
+        break;
 
       default:
         if (code === slash && css.charCodeAt(pos + 1) === asterisk) {

test/number.js

@@ -2,7 +2,7 @@
 
 const expect = require('chai').expect;
 const Parser = require('../lib/parser');
-const TokenizeError = require('../lib/errors/TokenizeError');
+const ParserError = require('../lib/errors/ParserError');
 
 describe('Parser → Number', () => {
 
@@ -72,7 +72,7 @@ describe('Parser → Number', () => {
       }
 
       if (fixture.expected.throw) {
-        expect(parse).to.throw(TokenizeError);
+        expect(parse).to.throw(ParserError);
       }
       else {
         parse();
@@ -91,3 +91,49 @@ describe('Parser → Number', () => {
   });
 
 });
+
+describe('Parser → Number : Loose', () => {
+
+  let fixtures = [
+    {
+      test: '-2',
+      expected: { value: '-2', unit: '', length: 1 }
+    },
+    {
+      test: '  -2',
+      expected: { value: '-2', unit: '', length: 1 }
+    },
+    {
+      test: '+-2.',
+      expected: { value: '-2.', unit: '', length: 2 }
+    },
+    {
+      test: '5+ 5',
+      expected: { value: '5', unit: '', length: 3 }
+    },
+    {
+      test: '1+ 5 + +5',
+      expected: { value: '+5', unit: '', length: 5 }
+    },
+    {
+      test: '5+5',
+      expected: { value: '5', unit: '', length: 3 }
+    },
+    {
+      test: '5+-+-+-+5',
+      expected: { value: '+5', unit: '', length: 8 }
+    }
+  ];
+
+  fixtures.forEach((fixture) => {
+    it('should ' + (fixture.expected.throw ? 'not ' : '')  + 'parse ' + fixture.test, () => {
+      let ast = new Parser(fixture.test, { loose: true }).parse(),
+        node = ast.first.last;
+
+      expect(ast.first.nodes.length).to.equal(fixture.expected.length);
+      expect(node.value).to.equal(fixture.expected.value);
+      expect(node.unit).to.equal(fixture.expected.unit);
+    });
+  });
+
+});