Refactor to externalise assertions

Author: wooorm

component.json

@@ -16,6 +16,9 @@
     "util",
     "utility"
   ],
+  "dependencies": {
+    "wooorm/unist-util-is": "^1.0.0"
+  },
   "repository": "wooorm/unist-util-find-after",
   "scripts": [
     "index.js"

index.js

@@ -10,50 +10,11 @@
 
 /* eslint-env commonjs */
 
-/**
- * Test.
- *
- * @typedef {Function} findAfter~test
- * @param {Node} node - Node to test.
- * @param {number} index - Position of `node` in `parent`.
- * @param {Node} parent - Parent of `node`.
- * @return {boolean?} - Whether this iteration passes.
- */
-
-/**
- * Utility to return true for the first node.
- *
- * @type {findAfter~test}
- */
-function first() {
-    return true;
-}
-
-/**
- * Utility to convert a string into a function which checks
- * a given node’s type for said string.
- *
- * @param {string} test - Node type to test.
- * @return {findAfter~test} - Tester.
+/*
+ * Dependencies.
  */
-function typeFactory(test) {
-    return function (node) {
-        return Boolean(node && node.type === test);
-    }
-}
 
-/**
- * Utility to convert a node into a function which checks
- * a given node for strict equality.
- *
- * @param {Node} test - Node to test.
- * @return {findAfter~test} - Tester.
- */
-function nodeFactory(test) {
-    return function (node) {
-        return Boolean(node && node === test);
-    }
-}
+var is = require('unist-util-is');
 
 /**
  * Find a node after `index` in `parent` which passes
@@ -62,7 +23,7 @@ function nodeFactory(test) {
  * @param {Node} parent - Parent to search in.
  * @param {number|Node} index - (Position of) node to
  *   search after.
- * @param {string|Node|findAfter~test} test - Tester.
+ * @param {*} test - See `wooorm/unist-util-is`.
  * @return {Node?} - A child node of `parent` which passes
  *   `test`.
  */
@@ -86,20 +47,10 @@ function findAfter(parent, index, test) {
         throw new Error('Expected positive finite index or child node');
     }
 
-    if (typeof test === 'string') {
-        test = typeFactory(test);
-    } else if (test && test.type) {
-        test = nodeFactory(test);
-    } else if (test === null || test === undefined) {
-        test = first;
-    } else if (typeof test !== 'function') {
-        throw new Error('Expected function, string, or node as test');
-    }
-
     while (++index < length) {
         child = children[index];
 
-        if (test(child, index, parent)) {
+        if (is(test, child, index, parent)) {
             return child;
         }
     }

package.json

@@ -16,6 +16,9 @@
     "util",
     "utility"
   ],
+  "dependencies": {
+    "unist-util-is": "^1.0.0"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/wooorm/unist-util-find-after.git"

readme.md

@@ -72,31 +72,11 @@ given).
 
 *   `index` (`number`) — Position of child to search after;
 
-*   `test` ([`Function`](#function-testnode-index-parent), `string`, or
-    `Node`, optional)
-    — Invoked for each following child of `parent` after `node` or `position`.
-    When `test` returns truthy for the first time on a `child`, that `child` is
-    returned.
-
-    Passing a `string` is equal to passing
-    `function (node) {return node.type === test}`.
-
-    Passing a `node` is equal to passing
-    `function (node) {return node === test}`, useful when checking if `test`
-    comes after `index` or `node` in `parent`.
+*   `test` (`Function`, `string`, or `Node`; optional)
+    — See [`is()`](https://github.com/wooorm/unist-util-is#istest-node-index-parent-context).
 
 **Returns**: `node?`, when found. Child node of `parent` which passes `test`.
 
-### function test(node, index, parent)
-
-**Parameters**:
-
-*   `node` (`Node`) — Node to test;
-*   `index` (`number`) — Position of `node` in `parent`.
-*   `parent` (`Node`) — Parent of `node`.
-
-**Returns**: `boolean?`, whether this iteration passes.
-
 ## License
 
 [MIT](LICENSE) © [Titus Wormer](http://wooorm.com)

test.js

@@ -80,14 +80,22 @@ describe('unist-util-find-after', function () {
         assert.throws(function () {
             findAfter({
                 'type': 'foo',
-                'children': []
+                'children': [{
+                    'type': 'bar'
+                }, {
+                    'type': 'baz'
+                }]
             }, 0, false);
         }, /Expected function, string, or node as test/);
 
         assert.throws(function () {
             findAfter({
                 'type': 'foo',
-                'children': []
+                'children': [{
+                    'type': 'bar'
+                }, {
+                    'type': 'baz'
+                }]
             }, 0, true);
         }, /Expected function, string, or node as test/);
     });

unist-util-find-after.js

@@ -11,20 +11,87 @@
 
 /* eslint-env commonjs */
 
+/*
+ * Dependencies.
+ */
+
+var is = require('unist-util-is');
+
+/**
+ * Find a node after `index` in `parent` which passes
+ * `test`.
+ *
+ * @param {Node} parent - Parent to search in.
+ * @param {number|Node} index - (Position of) node to
+ *   search after.
+ * @param {*} test - See `wooorm/unist-util-is`.
+ * @return {Node?} - A child node of `parent` which passes
+ *   `test`.
+ */
+function findAfter(parent, index, test) {
+    var children;
+    var child;
+    var length;
+
+    if (!parent || !parent.type || !parent.children) {
+        throw new Error('Expected parent node');
+    }
+
+    children = parent.children;
+    length = children.length;
+
+    if (index && index.type) {
+        index = children.indexOf(index);
+    }
+
+    if (isNaN(index) || index < 0 || index === Infinity) {
+        throw new Error('Expected positive finite index or child node');
+    }
+
+    while (++index < length) {
+        child = children[index];
+
+        if (is(test, child, index, parent)) {
+            return child;
+        }
+    }
+
+    return null;
+}
+
+/*
+ * Expose.
+ */
+
+module.exports = findAfter;
+
+},{"unist-util-is":2}],2:[function(require,module,exports){
+/**
+ * @author Titus Wormer
+ * @copyright 2015 Titus Wormer
+ * @license MIT
+ * @module unist:util:is
+ * @fileoverview Utility to check if a node passes a test.
+ */
+
+'use strict';
+
+/* eslint-env commonjs */
+
 /**
  * Test.
  *
- * @typedef {Function} findAfter~test
+ * @typedef {Function} is~test
  * @param {Node} node - Node to test.
  * @param {number} index - Position of `node` in `parent`.
  * @param {Node} parent - Parent of `node`.
  * @return {boolean?} - Whether this iteration passes.
  */
 
 /**
- * Utility to return true for the first node.
+ * Utility to return true.
  *
- * @type {findAfter~test}
+ * @type {is~test}
  */
 function first() {
     return true;
@@ -35,7 +102,7 @@ function first() {
  * a given node’s type for said string.
  *
  * @param {string} test - Node type to test.
- * @return {findAfter~test} - Tester.
+ * @return {is~test} - Tester.
  */
 function typeFactory(test) {
     return function (node) {
@@ -48,44 +115,58 @@ function typeFactory(test) {
  * a given node for strict equality.
  *
  * @param {Node} test - Node to test.
- * @return {findAfter~test} - Tester.
+ * @return {is~test} - Tester.
  */
 function nodeFactory(test) {
     return function (node) {
-        return Boolean(node && node === test);
+        return node === test;
     }
 }
 
 /**
- * Find a node after `index` in `parent` which passes
- * `test`.
+ * Assert if `test` passes for `node`.
+ * When a `parent` node is known the `index` of node
  *
- * @param {Node} parent - Parent to search in.
- * @param {number|Node} index - (Position of) node to
- *   search after.
- * @param {string|Node|findAfter~test} test - Tester.
- * @return {Node?} - A child node of `parent` which passes
- *   `test`.
+ * @example
+ *   is(null, {type: 'strong'}); // true
+ *
+ * @example
+ *   is('strong', {type: 'strong'}); // true
+ *   is('emphasis', {type: 'strong'}); // false
+ *
+ * @example
+ *   var node = {type: 'strong'};
+ *   is(node, node) // true
+ *   is(node, {type: 'strong'}) // false
+ *
+ * @example
+ *   var node = {type: 'strong'};
+ *   var parent = {type: 'paragraph', children: [node]};
+ *   function test(node, n) {return n === 5};
+ *   is(test, {type: 'strong'}); // false
+ *   is(test, {type: 'strong'}, 4, parent); // false
+ *   is(test, {type: 'strong'}, 5, parent); // true
+ *
+ * @example
+ *   var node = {type: 'strong'};
+ *   var parent = {type: 'paragraph', children: [node]};
+ *   is('strong'); // throws
+ *   is('strong', node, 0) // throws
+ *   is('strong', node, null, parent) // throws
+ *   is('strong', node, 0, {type: 'paragraph'}) // throws
+ *   is('strong', node, -1, parent) // throws
+ *   is('strong', node, Infinity, parent) // throws
+ *
+ * @param {(string|Node|is~test)?} test - Tester.
+ * @param {Node} node - Node to test.
+ * @param {number?} [index] - Position of `node` in `parent`.
+ * @param {Node?} [parent] - Parent of `node`.
+ * @param {*} [context] - Context to invoke `test` with.
+ * @return {boolean} - Whether `test` passes.
  */
-function findAfter(parent, index, test) {
-    var children;
-    var child;
-    var length;
-
-    if (!parent || !parent.type || !parent.children) {
-        throw new Error('Expected parent node');
-    }
-
-    children = parent.children;
-    length = children.length;
-
-    if (index && index.type) {
-        index = children.indexOf(index);
-    }
-
-    if (isNaN(index) || index < 0 || index === Infinity) {
-        throw new Error('Expected positive finite index or child node');
-    }
+function is(test, node, index, parent, context) {
+    var hasParent = parent !== null && parent !== undefined;
+    var hasIndex = index !== null && index !== undefined;
 
     if (typeof test === 'string') {
         test = typeFactory(test);
@@ -97,22 +178,33 @@ function findAfter(parent, index, test) {
         throw new Error('Expected function, string, or node as test');
     }
 
-    while (++index < length) {
-        child = children[index];
+    if (!node || !node.type) {
+        throw new Error('Expected node');
+    }
 
-        if (test(child, index, parent)) {
-            return child;
-        }
+    if (
+        hasIndex &&
+        (typeof index !== 'number' || index < 0 || index === Infinity)
+    ) {
+        throw new Error('Expected positive finite index or child node');
     }
 
-    return null;
+    if (hasParent && (!parent || !parent.type || !parent.children)) {
+        throw new Error('Expected parent node');
+    }
+
+    if (hasParent !== hasIndex) {
+        throw new Error('Expected both parent and index');
+    }
+
+    return Boolean(test.call(context, node, index, parent));
 }
 
 /*
  * Expose.
  */
 
-module.exports = findAfter;
+module.exports = is;
 
 },{}]},{},[1])(1)
 });