add :nth-last-of-type, :last-of-type, :only-of-type

Close #3.

Author: eush77

lib/ast-walkers.js

@@ -15,6 +15,10 @@ var walkers = exports;
 //         if true, `props` will have an integer `typeIndex` field which
 //         represents a node index among all its sibling of the same type
 //
+//   - [typeCount]: boolean=false
+//         if true, `props` will have an integer `typeCount` field which
+//         is equal to number of siblings sharing the same type with this node
+//
 
 
 walkers.topScan = function (node, nodeIndex, parent, opts) {
@@ -24,27 +28,22 @@ walkers.topScan = function (node, nodeIndex, parent, opts) {
     throw Error('topScan is supposed to be called from the root node');
   }
 
-  if (!opts.typeIndex) {
+  if (!opts.typeIndex && !opts.typeCount) {
     opts.iterator(node, nodeIndex, parent);
   }
   walkers.descendant.apply(this, arguments);
 };
 
 
 walkers.descendant = function (node, nodeIndex, parent, opts) {
-  if (!node.children || !node.children.length) {
-    return;
-  }
+  var iterator = opts.iterator;
 
-  if (opts.typeIndex) {
-    var typeIndex = TypeIndex();
-  }
+  opts.iterator = function (node, nodeIndex, parent) {
+    iterator.apply(this, arguments);
+    walkers.child(node, nodeIndex, node, opts);
+  };
 
-  node.children.forEach(function (child, childIndex) {
-    opts.iterator(child, childIndex, node,
-                  opts.typeIndex ? { typeIndex: typeIndex(child) } : undefined);
-    walkers.descendant(child, childIndex, node, opts);
-  });
+  return walkers.child(node, nodeIndex, parent, opts);
 };
 
 
@@ -53,14 +52,9 @@ walkers.child = function (node, nodeIndex, parent, opts) {
     return;
   }
 
-  if (opts.typeIndex) {
-    var typeIndex = TypeIndex();
-  }
-
-  node.children.forEach(function (child, childIndex) {
-    opts.iterator(child, childIndex, node,
-                  opts.typeIndex ? { typeIndex: typeIndex(child) } : undefined);
-  });
+  walkIterator(node, opts)
+    .each()
+    .finally();
 };
 
 
@@ -69,20 +63,11 @@ walkers.adjacentSibling = function (node, nodeIndex, parent, opts) {
     return;
   }
 
-  if (opts.typeIndex) {
-    var typeIndex = TypeIndex();
-
-    // Prefill type indexes with preceding nodes.
-    for (var prevIndex = 0; prevIndex <= nodeIndex; ++prevIndex) {
-      typeIndex(parent.children[prevIndex]);
-    }
-  }
-
-  if (++nodeIndex < parent.children.length) {
-    node = parent.children[nodeIndex];
-    opts.iterator(node, nodeIndex, parent,
-                  opts.typeIndex ? { typeIndex: typeIndex(node) } : undefined);
-  }
+  walkIterator(parent, opts)
+    .prefillTypeIndex(0, ++nodeIndex)
+    .each(nodeIndex, ++nodeIndex)
+    .prefillTypeIndex(nodeIndex)
+    .finally();
 };
 
 
@@ -91,18 +76,75 @@ walkers.generalSibling = function (node, nodeIndex, parent, opts) {
     return;
   }
 
-  if (opts.typeIndex) {
-    var typeIndex = TypeIndex();
+  walkIterator(parent, opts)
+    .prefillTypeIndex(0, ++nodeIndex)
+    .each(nodeIndex)
+    .finally();
+};
 
-    // Prefill type indexes with preceding nodes.
-    for (var prevIndex = 0; prevIndex <= nodeIndex; ++prevIndex) {
-      typeIndex(parent.children[prevIndex]);
-    }
-  }
 
-  while (++nodeIndex < parent.children.length) {
-    node = parent.children[nodeIndex];
-    opts.iterator(node, nodeIndex, parent,
-                  opts.typeIndex ? { typeIndex: typeIndex(node) } : undefined);
-  }
-};
+// Handles typeIndex and typeCount properties for every walker.
+function walkIterator (parent, opts) {
+  var hasTypeIndex = opts.typeIndex || opts.typeCount;
+  var typeIndex = hasTypeIndex ? TypeIndex() : Function.prototype;
+  var nodeThunks = [];
+
+  var rangeDefaults = function (iter) {
+    return function (start, end) {
+      if (start == null || start < 0) {
+        start = 0;
+      }
+      if (end == null || end > parent.children.length) {
+        end = parent.children.length;
+      }
+      return iter.call(this, start, end);
+    };
+  };
+
+  return {
+    prefillTypeIndex: rangeDefaults(function (start, end) {
+      if (hasTypeIndex) {
+        for (var nodeIndex = start; nodeIndex < end; ++nodeIndex) {
+          typeIndex(parent.children[nodeIndex]);
+        }
+      }
+      return this;
+    }),
+
+    each: rangeDefaults(function each (start, end) {
+      if (start >= end) {
+        return this;
+      }
+
+      var nodeIndex = start;
+      var node = parent.children[nodeIndex];
+      var props = {};
+      var nodeTypeIndex = typeIndex(node);
+
+      if (opts.typeIndex) {
+        props.typeIndex = nodeTypeIndex;
+      }
+
+      if (opts.typeCount) {
+        nodeThunks.push(function () {
+          props.typeCount = typeIndex.count(node);
+          pushNode();
+        });
+      }
+      else {
+        pushNode();
+      }
+
+      return each.call(this, start + 1, end);
+
+      function pushNode () {
+        opts.iterator(node, nodeIndex, parent, props);
+      }
+    }),
+
+    finally: function () {
+      nodeThunks.forEach(Function.call.bind(Function.call));
+      return this;
+    }
+  };
+}

lib/match-node.js

@@ -73,6 +73,9 @@ function matchPseudos (rule, node, nodeIndex, parent, props) {
       case 'nth-of-type':
         return parent && pseudo.value(props.typeIndex);
 
+      case 'nth-last-of-type':
+        return parent && pseudo.value(props.typeCount - 1 - props.typeIndex);
+
       case 'first-child':
         return parent && nodeIndex == 0;
 
@@ -82,9 +85,15 @@ function matchPseudos (rule, node, nodeIndex, parent, props) {
       case 'first-of-type':
         return parent && props.typeIndex == 0;
 
+      case 'last-of-type':
+        return parent && props.typeIndex == props.typeCount - 1;
+
       case 'only-child':
         return parent && parent.children.length == 1;
 
+      case 'only-of-type':
+        return parent && props.typeCount == 1;
+
       case 'empty':
         return node.children && !node.children.length;
 

lib/select.js

@@ -57,14 +57,18 @@ select.rule = function (rule, ast) {
 
 
 function searchOpts (opts, rule) {
-  if (rule.pseudos && rule.pseudos.some(function (pseudo) {
-    return (pseudo.name == 'nth-of-type' ||
-            pseudo.name == 'nth-last-of-type' ||
-            pseudo.name == 'first-of-type' ||
-            pseudo.name == 'last-of-type');
-  })) {
-    opts.typeIndex = true;
-  }
+  rule.pseudos && rule.pseudos.forEach(function (pseudo) {
+    switch (pseudo.name) {
+      case 'nth-last-of-type':
+      case 'last-of-type':
+      case 'only-of-type':
+        opts.typeCount = true;
+
+      case 'nth-of-type':
+      case 'first-of-type':
+        opts.typeIndex = true;
+    }
+  });
 
   return opts;
 }

lib/type-index.js

@@ -4,7 +4,7 @@
 module.exports = function TypeIndex () {
   var typeLists = Object.create(null);
 
-  return function (node) {
+  var index = function (node) {
     var type = node.type;
 
     if (!typeLists[type]) {
@@ -13,4 +13,11 @@ module.exports = function TypeIndex () {
 
     return typeLists[type].push(node) - 1;
   };
+
+  index.count = function (node) {
+    var typeList = typeLists[node.type];
+    return typeList ? typeList.length : 0;
+  };
+
+  return index;
 };

test/select.js

@@ -208,6 +208,31 @@ test('structural pseudo-classes', function (t) {
     t.end();
   });
 
+  t.test(':nth-last-of-type', function (t) {
+    t.deepEqual(select(ast, ':root > :nth-last-of-type(n+3)'), [
+      path(ast, [0]),
+      path(ast, [1]),
+      path(ast, [3]),
+      path(ast, [5]),
+      path(ast, [7]),
+      path(ast, [8]),
+      path(ast, [13])
+    ]);
+    t.deepEqual(select(ast, ':root > :nth-last-of-type(even)'), [
+      path(ast, [1]),
+      path(ast, [4]),
+      path(ast, [5]),
+      path(ast, [11]),
+      path(ast, [12]),
+      path(ast, [14])
+    ]);
+    t.deepEqual(select(ast, 'list + :nth-last-of-type(n+3)'), [
+      path(ast, [5]),
+      path(ast, [7])
+    ]);
+    t.end();
+  });
+
   t.test(':first-child', function (t) {
     t.deepEqual(select(ast, ':first-child'), select(ast, ':nth-child(1)'));
     t.deepEqual(select(ast, ':root:first-child'), []);
@@ -251,6 +276,29 @@ test('structural pseudo-classes', function (t) {
     t.end();
   });
 
+  t.test(':last-of-type', function (t) {
+    t.deepEqual(select(ast, ':last-of-type'),
+                select(ast, ':nth-last-of-type(1)'));
+    t.deepEqual(select(ast, ':root:last-of-type'), []);
+    t.deepEqual(select(ast, ':root > :last-of-type'), [
+      path(ast, [2]),
+      path(ast, [6]),
+      path(ast, [9]),
+      path(ast, [10]),
+      path(ast, [15]),
+      path(ast, [16]),
+      path(ast, [17]),
+      path(ast, [18])
+    ]);
+    t.deepEqual(select(ast, 'table ~ :last-of-type'), [
+      path(ast, [15]),
+      path(ast, [16]),
+      path(ast, [17]),
+      path(ast, [18])
+    ]);
+    t.end();
+  });
+
   t.test(':only-child', function (t) {
     t.deepEqual(select(ast, ':only-child'),
                 select(ast, ':first-child:last-child'));
@@ -262,6 +310,18 @@ test('structural pseudo-classes', function (t) {
     t.end();
   });
 
+  t.test(':only-of-type', function (t) {
+    t.deepEqual(select(ast, ':only-of-type'),
+                select(ast, ':first-of-type:last-of-type'));
+    t.deepEqual(select(ast, ':root > :only-of-type'), [
+      path(ast, [2]),
+      path(ast, [9]),
+      path(ast, [10]),
+      path(ast, [18])
+    ]);
+    t.end();
+  });
+
   t.test(':empty', function (t) {
     t.deepEqual(select(ast, ':root:empty'), []);
     t.deepEqual(select(ast, 'text:empty'), []);

test/type-index.js

@@ -8,15 +8,20 @@ var test = require('tape');
 test('TypeIndex', function (t) {
   var typeIndex = TypeIndex();
 
+  t.equal(typeIndex.count({ type: 'foo' }), 0);
   t.equal(typeIndex({ type: 'foo' }), 0);
+  t.equal(typeIndex.count({ type: 'foo' }), 1);
   t.equal(typeIndex({ type: 'bar' }), 0);
   t.equal(typeIndex({ type: 'foo' }), 1);
   t.equal(typeIndex({ type: 'foo' }), 2);
   t.equal(typeIndex({ type: 'bar' }), 1);
   t.equal(typeIndex({ type: 'baz' }), 0);
+  t.equal(typeIndex.count({ type: 'foo' }), 3);
 
   typeIndex = TypeIndex();
+  t.equal(typeIndex.count({ type: 'foo' }), 0);
   t.equal(typeIndex({ type: 'foo' }), 0);
+  t.equal(typeIndex.count({ type: 'foo' }), 1);
 
   t.end();
 });