add :root

Author: eush77

README.md

@@ -59,6 +59,19 @@ That's it!
   - [x] Begins with: `[value^="prefix"]`
   - [x] Containment: `[value*="substr"]`
   - [x] Ends with: `[value$="suffix"]`
+- [ ] Structural pseudo-classes: `paragraph:first-of-type`
+  - [x] `:root`
+  - [ ] `:nth-child(2n+1)`
+  - [ ] `:nth-last-child(2n+1)`
+  - [ ] `:nth-of-type(2n+1)`
+  - [ ] `:nth-last-of-type(2n+1)`
+  - [ ] `:first-child`
+  - [ ] `:last-child`
+  - [ ] `:first-of-type`
+  - [ ] `:last-of-type`
+  - [ ] `:only-child`
+  - [ ] `:only-of-type`
+  - [ ] `:empty`
 - [x] Negation pseudo-class: `*:not(paragraph)`
 
 ## API

lib/select.js

@@ -17,14 +17,14 @@ select.ruleSet = function (selector, ast) {
 };
 
 
-select.rule = function (selector, ast) {
+select.rule = function (selector, ast, parentNode) {
   var result = [];
 
   switch (selector.nestingOperator) {
     case null:
     case undefined:
     case '>':
-      walk(ast);
+      walk(ast, parentNode);
       break;
 
     case '+':
@@ -46,23 +46,23 @@ select.rule = function (selector, ast) {
   return result;
 
   function walk (node, parent) {
-    if (matches(selector, node)) {
+    if (matches(selector, node, parent == null)) {
       if (!selector.rule) {
         append(result, [node]);
       }
       else if (!selector.rule.nestingOperator ||
                selector.rule.nestingOperator == '>') {
         if (node.children) {
           node.children.forEach(function (childNode) {
-            append(result, select.rule(selector.rule, childNode));
+            append(result, select.rule(selector.rule, childNode, node));
           });
         }
       }
       else {
         if (parent) {
           append(result, select.rule(selector.rule, {
             children: parent.children.slice(parent.children.indexOf(node) + 1)
-          }));
+          }, parent));
         }
       }
     }
@@ -77,7 +77,7 @@ select.rule = function (selector, ast) {
 
 
 // True if node matches head of selector rule.
-function matches (rule, node) {
+function matches (rule, node, isRoot) {
   var match = true;
 
   // Match type.
@@ -127,6 +127,9 @@ function matches (rule, node) {
   // Match pseudo classes.
   match = match && (rule.pseudos || []).every(function (pseudo) {
     switch (pseudo.name) {
+      case 'root':
+        return isRoot;
+
       case 'not':
         return !matches(pseudo.value.rule, node);
 

test/test.js

@@ -16,7 +16,7 @@ test('edge cases', function (t) {
 
 test('type selector', function (t) {
   t.equal(select(ast, 'root').length, 1);
-  t.equal(select(ast, 'root')[0], ast);
+  t.deepEqual(select(ast, 'root'), [ast]);
   t.equal(select(ast, 'text').length, 39);
   t.equal(select(ast, 'text')[1], ast.children[1].children[0]);
   t.equal(select(ast, 'tableRow').length, 2);
@@ -127,6 +127,23 @@ test('attribute selectors', function (t) {
 });
 
 
+test('structural pseudo-classes', function (t) {
+  t.test(':root', function (t) {
+    t.deepEqual(select(ast, ':root'), [ast]);
+    t.deepEqual(select(ast, ':root:root'), [ast]);
+    t.deepEqual(select(ast, '* :root'), []);
+    t.deepEqual(select(ast, 'text:not(:root)'), select(ast, 'text'));
+    t.deepEqual(select(ast, ':root > list'), [
+      path(ast, [4]),
+      path(ast, [6])
+    ]);
+    t.end();
+  });
+
+  t.end();
+});
+
+
 test('negation pseudo-class', function (t) {
   t.deepEqual(select(ast, 'list:not([nonexistent])'), select(ast, 'list'));
   t.deepEqual(select(ast, 'list:not([start=null])'),