From 7dfed2e6d1c91064a87b8824d121b98dba318e0a Mon Sep 17 00:00:00 2001 From: Ben Briggs Date: Thu, 3 Mar 2016 11:37:58 +0000 Subject: [PATCH] Rename each & remove methods. --- API.md | 32 ++++++++++----------- src/__tests__/container.js | 58 +++++++++++++++++++------------------- src/__tests__/parser.js | 2 +- src/selectors/container.js | 38 ++++++++++++------------- src/selectors/node.js | 6 ++-- 5 files changed, 68 insertions(+), 68 deletions(-) diff --git a/API.md b/API.md index f345449..7273189 100644 --- a/API.md +++ b/API.md @@ -227,13 +227,13 @@ Arguments: * `node`: The node to substitute the original with. -### `node.removeSelf()` +### `node.remove()` Removes the node from its parent node. ```js if (node.type === 'id') { - node.removeSelf(); + node.remove(); } ``` @@ -400,13 +400,13 @@ Arguments: * `callback (function)`: A function to call for each node, which receives `node` and `index` arguments. -### `container.eachInside(callback)` +### `container.walk(callback)` Like `container#each`, but will also iterate child nodes as long as they are `container` types. ```js -selectors.eachInside(function (selector, index) { +selectors.walk(function (selector, index) { // all nodes }); ``` @@ -419,20 +419,20 @@ Arguments: This iterator is safe to use whilst mutating `container.nodes`, like `container#each`. -### `container.eachInside` proxies +### `container.walk` proxies The container class provides proxy methods for iterating over types of nodes, so that it is easier to write modules that target specific selectors. Those methods are: -* `container.eachAttribute` -* `container.eachClass` -* `container.eachCombinator` -* `container.eachComment` -* `container.eachId` -* `container.eachPseudo` -* `container.eachTag` -* `container.eachUniversal` +* `container.walkAttributes` +* `container.walkClasses` +* `container.walkCombinators` +* `container.walkComments` +* `container.walkIds` +* `container.walkPseudos` +* `container.walkTags` +* `container.walkUniversals` ### `container.split(callback)` @@ -486,10 +486,10 @@ Arguments: * `old`: The existing node in the container. * `new`: The new node to add before/after the existing node. -### `container.remove(node)` +### `container.removeChild(node)` Remove the node from the container. Note that you can also use -`node.removeSelf()` if you would like to remove just a single node. +`node.remove()` if you would like to remove just a single node. ```js selector.length // => 2 @@ -532,5 +532,5 @@ It has no special functionality of its own. A pseudo selector extends a container node; if it has any parameters of its own (such as `h1:not(h2, h3)`), they will be its children. Note that the pseudo -`value` will always contain the colons preceeding the pseudo identifier. This +`value` will always contain the colons preceding the pseudo identifier. This is so that both `:before` and `::before` are properly represented in the AST. diff --git a/src/__tests__/container.js b/src/__tests__/container.js index 1e5e9e9..f4fbbe6 100644 --- a/src/__tests__/container.js +++ b/src/__tests__/container.js @@ -14,10 +14,10 @@ test('container#each', (t) => { t.same(str, 'h1h2'); }); -test('container#eachInside', (t) => { +test('container#walk', (t) => { let str = ''; parse('h1, h2:not(h3, h4)', (selectors) => { - selectors.eachInside((selector) => { + selectors.walk((selector) => { if (selector.type === 'tag') { str += selector.value; } @@ -26,87 +26,87 @@ test('container#eachInside', (t) => { t.same(str, 'h1h2h3h4'); }); -test('container#eachInside (safe iteration)', (t) => { +test('container#walk (safe iteration)', (t) => { let out = parse('[class] + *[href] *:not(*.green)', (selectors) => { - selectors.eachUniversal((selector) => { + selectors.walkUniversals((selector) => { let next = selector.next(); if (next && next.type !== 'combinator') { - selector.removeSelf(); + selector.remove(); } }); }); t.same(out, '[class] + [href] :not(.green)'); }); -test('container#eachAttribute', (t) => { +test('container#walkAttribute', (t) => { let out = parse('[href][class].class', (selectors) => { - selectors.eachAttribute((attr) => { + selectors.walkAttributes((attr) => { if (attr.attribute === 'class') { - attr.removeSelf(); + attr.remove(); } }); }); t.same(out, '[href].class'); }); -test('container#eachClass', (t) => { +test('container#walkClass', (t) => { let out = parse('.one, .two, .three:not(.four, .five)', (selectors) => { - selectors.eachClass((className) => { + selectors.walkClasses((className) => { className.value = className.value.slice(0, 1); }); }); t.same(out, '.o, .t, .t:not(.f, .f)'); }); -test('container#eachCombinator', (t) => { +test('container#walkCombinator', (t) => { let out = parse('h1 h2 h3 h4', (selectors) => { - selectors.eachCombinator((comment) => { - comment.removeSelf(); + selectors.walkCombinators((comment) => { + comment.remove(); }); }); t.same(out, 'h1h2h3h4'); }); -test('container#eachComment', (t) => { +test('container#walkComment', (t) => { let out = parse('.one/*test*/.two', (selectors) => { - selectors.eachComment((comment) => { - comment.removeSelf(); + selectors.walkComments((comment) => { + comment.remove(); }); }); t.same(out, '.one.two'); }); -test('container#eachId', (t) => { +test('container#walkId', (t) => { let out = parse('h1#one, h2#two', (selectors) => { - selectors.eachId((id) => { + selectors.walkIds((id) => { id.value = id.value.slice(0, 1); }); }); t.same(out, 'h1#o, h2#t'); }); -test('container#eachPseudo', (t) => { +test('container#walkPseudo', (t) => { let out = parse('a:before, a:after', (selectors) => { - selectors.eachPseudo((pseudo) => { + selectors.walkPseudos((pseudo) => { pseudo.value = pseudo.value.slice(0, 2); }); }); t.same(out, 'a:b, a:a'); }); -test('container#eachTag', (t) => { +test('container#walkTag', (t) => { let out = parse('1 2 3', (selectors) => { - selectors.eachTag((tag) => { + selectors.walkTags((tag) => { tag.value = 'h' + tag.value; }); }); t.same(out, 'h1 h2 h3'); }); -test('container#eachUniversal', (t) => { +test('container#walkUniversal', (t) => { let out = parse('*.class,*.class,*.class', (selectors) => { - selectors.eachUniversal((universal) => { - universal.removeSelf(); + selectors.walkUniversals((universal) => { + universal.remove(); }); }); t.same(out, '.class,.class,.class'); @@ -210,11 +210,11 @@ test('container#length', (t) => { }); }); -test('container#remove', (t) => { +test('container#removeChild', (t) => { let out = parse('h1.class h2.class h3.class', (selectors) => { - selectors.eachInside((selector) => { + selectors.walk((selector) => { if (selector.type === 'class') { - selector.parent.remove(selector); + selector.parent.removeChild(selector); } }); }); @@ -251,7 +251,7 @@ test('container#insertAfter', (t) => { test('container#insertAfter (during iteration)', (t) => { let out = parse('h1, h2, h3', (selectors) => { - selectors.eachTag(selector => { + selectors.walkTags(selector => { let attribute = parser.attribute({attribute: 'class'}); selector.parent.insertAfter(selector, attribute); }); diff --git a/src/__tests__/parser.js b/src/__tests__/parser.js index 9998406..956f6a1 100644 --- a/src/__tests__/parser.js +++ b/src/__tests__/parser.js @@ -61,7 +61,7 @@ test('no operation', (t) => { test('empty selector string', (t) => { t.notThrows(() => { return parser((selectors) => { - selectors.eachInside((selector) => { + selectors.walk((selector) => { selector.type = 'tag'; }); }).process('').result; diff --git a/src/selectors/container.js b/src/selectors/container.js index 90e73ba..a770657 100644 --- a/src/selectors/container.js +++ b/src/selectors/container.js @@ -43,7 +43,7 @@ export default class Container extends Node { return this.nodes.length; } - remove (child) { + removeChild (child) { child = this.index(child); this.at(child).parent = undefined; this.nodes.splice(child, 1); @@ -135,12 +135,12 @@ export default class Container extends Node { } } - eachInside (callback) { + walk (callback) { return this.each((node, i) => { let result = callback(node, i); if (result !== false && node.length) { - result = node.eachInside(callback); + result = node.walk(callback); } if (result === false) { @@ -149,64 +149,64 @@ export default class Container extends Node { }); } - eachAttribute (callback) { - return this.eachInside((selector) => { + walkAttributes (callback) { + return this.walk((selector) => { if (selector.type === 'attribute') { return callback.call(this, selector); } }); } - eachClass (callback) { - return this.eachInside((selector) => { + walkClasses (callback) { + return this.walk((selector) => { if (selector.type === 'class') { return callback.call(this, selector); } }); } - eachCombinator (callback) { - return this.eachInside((selector) => { + walkCombinators (callback) { + return this.walk((selector) => { if (selector.type === 'combinator') { return callback.call(this, selector); } }); } - eachComment (callback) { - return this.eachInside((selector) => { + walkComments (callback) { + return this.walk((selector) => { if (selector.type === 'comment') { return callback.call(this, selector); } }); } - eachId (callback) { - return this.eachInside((selector) => { + walkIds (callback) { + return this.walk((selector) => { if (selector.type === 'id') { return callback.call(this, selector); } }); } - eachPseudo (callback) { - return this.eachInside((selector) => { + walkPseudos (callback) { + return this.walk((selector) => { if (selector.type === 'pseudo') { return callback.call(this, selector); } }); } - eachTag (callback) { - return this.eachInside((selector) => { + walkTags (callback) { + return this.walk((selector) => { if (selector.type === 'tag') { return callback.call(this, selector); } }); } - eachUniversal (callback) { - return this.eachInside((selector) => { + walkUniversals (callback) { + return this.walk((selector) => { if (selector.type === 'universal') { return callback.call(this, selector); } diff --git a/src/selectors/node.js b/src/selectors/node.js index e5e8a48..4bd16ec 100644 --- a/src/selectors/node.js +++ b/src/selectors/node.js @@ -34,9 +34,9 @@ export default class { this.spaces = {before: '', after: ''}; } - removeSelf () { + remove () { if (this.parent) { - this.parent.remove(this); + this.parent.removeChild(this); } this.parent = undefined; return this; @@ -47,7 +47,7 @@ export default class { for (let index in arguments) { this.parent.insertBefore(this, arguments[index]); } - this.removeSelf(); + this.remove(); } return this; }