feat: unicode-range node (#46)

Author: evilebottnawi

API.md

@@ -17,6 +17,7 @@ not documented here are subject to change at any point.*
   * [`parser.string([props])`](#parserstringprops)
   * [`parser.value([props])`](#parservalueprops)
   * [`parser.word([props])`](#parserwordprops)
+  * [`parser.unicodeRange([props])`](#parserunicoderangeprops)
 - [Node types](#node-types)
   * [`node.type`](#nodetype)
   * [`node.parent`](#nodeparent)
@@ -214,13 +215,26 @@ not documented here are subject to change at any point.*
 
   * `props (object)`: The new node's properties.
 
+### `parser.unicodeRange([props])`
+
+  Creates a new unicode range Node.
+
+  ```js
+  parser.unicodeRange({ value: 'U+26' });
+  // → U+26
+  ```
+
+  Arguments:
+
+  * `props (object)`: The new node's properties.
+  
 ## Node types
 
 ### `node.type`
 
   A string representation of the node type. It can be one of the following;
   `atword`, `colon`, `comma`, `comment`, `func`, `number`, `operator`,
-  `paren`, `string`, `value`, `word`.
+  `paren`, `string`, `unicoderange`, `value`, `word`.
 
   ```js
   parser.word({ value: '#fff' }).type;
@@ -493,9 +507,9 @@ methods are:
 * `container.walkOperators`
 * `container.walkParenthesis`
 * `container.walkStringNodes`
+* `container.walkUnicodeRanges`
 * `container.walkWords`
 
-
 ### `container.prepend(node)` & `container.append(node)`
 
 Add a node to the start/end of the container. Note that doing so will set

lib/index.js

@@ -10,6 +10,7 @@ const Num = require('./number');
 const Operator = require('./operator');
 const Paren = require('./paren');
 const Str = require('./string');
+const UnicodeRange = require('./unicode-range');
 const Value = require('./value');
 const Word = require('./word');
 
@@ -65,4 +66,8 @@ parser.word = function (opts) {
   return new Word(opts);
 };
 
+parser.unicodeRange = function (opts) {
+  return new UnicodeRange(opts);
+};
+
 module.exports = parser;

lib/parser.js

@@ -13,6 +13,7 @@ const Operator = require('./operator');
 const Paren = require('./paren');
 const Str = require('./string');
 const Word = require('./word');
+const UnicodeRange = require('./unicode-range');
 
 const tokenize = require('./tokenize');
 
@@ -236,6 +237,9 @@ module.exports = class Parser {
       case 'string':
         this.string();
         break;
+      case 'unicoderange':
+        this.unicodeRange();
+        break;
       default:
         this.word();
         break;
@@ -379,6 +383,27 @@ module.exports = class Parser {
     }
   }
 
+  unicodeRange () {
+    let token = this.currToken;
+
+    this.newNode(new UnicodeRange({
+      value: token[1],
+      source: {
+        start: {
+          line: token[2],
+          column: token[3]
+        },
+        end: {
+          line: token[4],
+          column: token[5]
+        }
+      },
+      sourceIndex: token[6]
+    }));
+
+    this.position ++;
+  }
+
   splitWord () {
     let nextToken = this.nextToken,
       word = this.currToken[1],

lib/tokenize.js

@@ -25,10 +25,13 @@ const lowerE = 'e'.charCodeAt(0);
 const upperE = 'E'.charCodeAt(0);
 const digit0 = '0'.charCodeAt(0);
 const digit9 = '9'.charCodeAt(0);
+const lowerU = 'u'.charCodeAt(0);
+const upperU = 'U'.charCodeAt(0);
 const atEnd = /[ \n\t\r\{\(\)'"\\;,/]/g;
 const wordEnd = /[ \n\t\r\(\)\{\}\*:;@!&'"\+\|~>,\[\]\\]|\/(?=\*)/g;
 const wordEndNum = /[ \n\t\r\(\)\{\}\*:;@!&'"\-\+\|~>,\[\]\\]|\//g;
 const alphaNum = /^[a-z0-9]/i;
+const unicodeRange = /^[a-f0-9?\-]/i;
 
 const util = require('util');
 const TokenizeError = require('./errors/TokenizeError');
@@ -287,6 +290,21 @@ module.exports = function tokenize (input, options) {
 
           pos = next - 1;
         }
+        else if ((code === lowerU || code === upperU) && css.charCodeAt(pos + 1) === plus) {
+          next = pos + 2;
+
+          do {
+            next += 1;
+            code = css.charCodeAt(next);
+          } while (next < length && unicodeRange.test(css.slice(next, next + 1)));
+
+          tokens.push(['unicoderange', css.slice(pos, next),
+            line, pos  - offset,
+            line, next - offset,
+            pos
+          ]);
+          pos = next - 1;
+        }
         // catch a regular slash, that isn't a comment
         else if (code === slash) {
           next = pos + 1;

lib/unicode-range.js

@@ -0,0 +1,15 @@
+'use strict';
+
+const Container = require('./container');
+const Node = require('./node');
+
+class UnicodeRange extends Node {
+  constructor (opts) {
+    super(opts);
+    this.type = 'unicode-range';
+  }
+}
+
+Container.registerWalker(UnicodeRange);
+
+module.exports = UnicodeRange;

test/unicode-range.js

@@ -0,0 +1,67 @@
+'use strict';
+
+const chai = require('chai');
+const shallowDeepEqual = require('chai-shallow-deep-equal');
+const Parser = require('../lib/parser');
+
+let expect = chai.expect;
+
+describe('Parser → Unicode range', () => {
+
+  chai.use(shallowDeepEqual);
+
+  let fixtures = [
+    {
+      it: 'should parse single codepoint',
+      test: 'U+26',
+      expected: [
+        { type: 'unicode-range', value: 'U+26' },
+      ]
+    },
+    {
+      it: 'should parse other single codepoint',
+      test: 'U+0-7F',
+      expected: [
+        { type: 'unicode-range', value: 'U+0-7F' },
+      ]
+    },
+    {
+      it: 'should parse codepoint range',
+      test: 'U+0025-00FF',
+      expected: [
+        { type: 'unicode-range', value: 'U+0025-00FF' },
+      ]
+    },
+    {
+      it: 'should parse wildcard range',
+      test: 'U+4??',
+      expected: [
+        { type: 'unicode-range', value: 'U+4??' },
+      ]
+    },
+    {
+      it: 'should parse multiple values',
+      test: 'U+0025-00FF, U+4??',
+      expected: [
+        { type: 'unicode-range', value: 'U+0025-00FF' },
+        { type: 'comma', value: ',', raws: { before: '', after: '' } },
+        { type: 'unicode-range', value: 'U+4??', raws: { before: ' ', after: '' } },
+      ]
+    }
+  ];
+
+  fixtures.forEach((fixture) => {
+    it(fixture.it, () => {
+      let ast = new Parser(fixture.test).parse();
+
+      ast.first.walk((node, index) => {
+        let expected = fixture.expected[index];
+
+        if (expected) {
+          expect(node).to.shallowDeepEqual(expected);
+        }
+      });
+    });
+  });
+
+});