| "use strict"; |
| |
| var _ava = _interopRequireDefault(require("ava")); |
| |
| var _index = _interopRequireDefault(require("../index")); |
| |
| function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } |
| |
| // Node creation |
| var nodeTypes = [['attribute', '[href]', { |
| attribute: 'href' |
| }], ['className', '.classy', { |
| value: 'classy' |
| }], ['combinator', ' >> ', { |
| value: '>>', |
| spaces: { |
| before: ' ', |
| after: ' ' |
| } |
| }], ['comment', '/* comment */', { |
| value: '/* comment */' |
| }], ['id', '#test', { |
| value: 'test' |
| }], ['nesting', '&'], ['pseudo', '::before', { |
| value: '::before' |
| }], ['string', '"wow"', { |
| value: '"wow"' |
| }], ['tag', 'button', { |
| value: 'button' |
| }], ['universal', '*']]; |
| nodeTypes.forEach(function (type) { |
| (0, _ava.default)("parser#" + type[0], function (t) { |
| var node = _index.default[type[0]](type[2] || {}); |
| |
| t.deepEqual(String(node), type[1]); |
| }); |
| }); |
| (0, _ava.default)('string constants', function (t) { |
| t.truthy(_index.default.TAG); |
| t.truthy(_index.default.STRING); |
| t.truthy(_index.default.SELECTOR); |
| t.truthy(_index.default.ROOT); |
| t.truthy(_index.default.PSEUDO); |
| t.truthy(_index.default.NESTING); |
| t.truthy(_index.default.ID); |
| t.truthy(_index.default.COMMENT); |
| t.truthy(_index.default.COMBINATOR); |
| t.truthy(_index.default.CLASS); |
| t.truthy(_index.default.ATTRIBUTE); |
| t.truthy(_index.default.UNIVERSAL); |
| }); |
| (0, _ava.default)('construct a whole tree', function (t) { |
| var root = _index.default.root(); |
| |
| var selector = _index.default.selector(); |
| |
| selector.append(_index.default.id({ |
| value: 'tree' |
| })); |
| root.append(selector); |
| t.deepEqual(String(root), '#tree'); |
| }); |
| (0, _ava.default)('no operation', function (t) { |
| t.notThrows(function () { |
| return (0, _index.default)().processSync('h1 h2 h3'); |
| }); |
| }); |
| (0, _ava.default)('empty selector string', function (t) { |
| t.notThrows(function () { |
| return (0, _index.default)(function (selectors) { |
| selectors.walk(function (selector) { |
| selector.type = 'tag'; |
| }); |
| }).processSync(''); |
| }); |
| }); |
| (0, _ava.default)('async parser', function (t) { |
| return (0, _index.default)(function (selectors) { |
| return new Promise(function (res) { |
| setTimeout(function () { |
| selectors.first.nodes[0].value = 'bar'; |
| res(); |
| }, 1); |
| }); |
| }).process('foo').then(function (result) { |
| t.deepEqual(result, 'bar'); |
| }); |
| }); |
| (0, _ava.default)('parse errors with the async parser', function (t) { |
| return (0, _index.default)(function (selectors) { |
| return new Promise(function (res) { |
| setTimeout(function () { |
| selectors.first.nodes[0].value = 'bar'; |
| res(); |
| }, 1); |
| }); |
| }).process('a b: c').catch(function (err) { |
| return t.truthy(err); |
| }); |
| }); |
| (0, _ava.default)('parse errors within the async processor', function (t) { |
| return (0, _index.default)(function (selectors) { |
| return new Promise(function (res, rej) { |
| setTimeout(function () { |
| rej(selectors.error("async error")); |
| }, 1); |
| }); |
| }).process('.foo').catch(function (err) { |
| return t.truthy(err); |
| }); |
| }); |
| (0, _ava.default)('parse errors within the async processor before the promise returns', function (t) { |
| return (0, _index.default)(function (selectors) { |
| throw selectors.error("async error"); |
| }).process('.foo').catch(function (err) { |
| return t.truthy(err); |
| }); |
| }); |
| (0, _ava.default)('returning a promise to the sync processor fails', function (t) { |
| t.throws(function () { |
| return (0, _index.default)(function () { |
| return new Promise(function (res) { |
| setTimeout(function () { |
| res(); |
| }, 1); |
| }); |
| }).processSync('.foo'); |
| }); |
| }); |
| (0, _ava.default)('Passing a rule works async', function (t) { |
| var rule = { |
| selector: '.foo' |
| }; |
| return (0, _index.default)(function (root) { |
| return new Promise(function (res) { |
| setTimeout(function () { |
| root.walkClasses(function (node) { |
| node.value = "bar"; |
| }); |
| res(); |
| }, 1); |
| }); |
| }).process(rule).then(function (newSel) { |
| t.deepEqual(newSel, ".bar"); |
| t.deepEqual(rule.selector, ".bar"); |
| }); |
| }); |
| (0, _ava.default)('Passing a rule with mutation disabled works async', function (t) { |
| var rule = { |
| selector: '.foo' |
| }; |
| return (0, _index.default)(function (root) { |
| return new Promise(function (res) { |
| setTimeout(function () { |
| root.walkClasses(function (node) { |
| node.value = "bar"; |
| }); |
| res(); |
| }, 1); |
| }); |
| }).process(rule, { |
| updateSelector: false |
| }).then(function (newSel) { |
| t.deepEqual(newSel, ".bar"); |
| t.deepEqual(rule.selector, ".foo"); |
| }); |
| }); |
| (0, _ava.default)('Passing a rule with mutation works sync', function (t) { |
| var rule = { |
| selector: '.foo' |
| }; |
| var newSel = (0, _index.default)(function (root) { |
| root.walkClasses(function (node) { |
| node.value = "bar"; |
| }); |
| }).processSync(rule, { |
| updateSelector: true |
| }); |
| t.deepEqual(newSel, ".bar"); |
| t.deepEqual(rule.selector, ".bar"); |
| }); |
| (0, _ava.default)('Transform a selector synchronously', function (t) { |
| var rule = { |
| selector: '.foo' |
| }; |
| var count = (0, _index.default)(function (root) { |
| var classCount = 0; |
| root.walkClasses(function (node) { |
| classCount++; |
| node.value = "bar"; |
| }); |
| return classCount; |
| }).transformSync(rule, { |
| updateSelector: true |
| }); |
| t.deepEqual(count, 1); |
| t.deepEqual(rule.selector, ".bar"); |
| }); |
| (0, _ava.default)('Transform a selector asynchronously', function (t) { |
| var rule = { |
| selector: '.foo' |
| }; |
| return (0, _index.default)(function (root) { |
| return new Promise(function (res) { |
| setTimeout(function () { |
| var classCount = 0; |
| root.walkClasses(function (node) { |
| classCount++; |
| node.value = "bar"; |
| }); |
| res(classCount); |
| }, 1); |
| }); |
| }).transform(rule, { |
| updateSelector: true |
| }).then(function (count) { |
| t.deepEqual(count, 1); |
| t.deepEqual(rule.selector, ".bar"); |
| }); |
| }); |
| (0, _ava.default)('get AST of a selector synchronously', function (t) { |
| var rule = { |
| selector: '.foo' |
| }; |
| var ast = (0, _index.default)(function (root) { |
| var classCount = 0; |
| root.walkClasses(function (node) { |
| classCount++; |
| node.value = "bar"; |
| }); |
| return classCount; |
| }).astSync(rule, { |
| updateSelector: true |
| }); |
| t.deepEqual(ast.nodes[0].nodes[0].value, "bar"); |
| t.deepEqual(rule.selector, ".bar"); |
| }); |
| (0, _ava.default)('get AST a selector asynchronously', function (t) { |
| var rule = { |
| selector: '.foo' |
| }; |
| return (0, _index.default)(function (root) { |
| return new Promise(function (res) { |
| setTimeout(function () { |
| var classCount = 0; |
| root.walkClasses(function (node) { |
| classCount++; |
| node.value = "bar"; |
| }); |
| res(classCount); |
| }, 1); |
| }); |
| }).ast(rule, { |
| updateSelector: true |
| }).then(function (ast) { |
| t.deepEqual(ast.nodes[0].nodes[0].value, "bar"); |
| t.deepEqual(rule.selector, ".bar"); |
| }); |
| }); |