Always test if given a node

Fix inconsistent handling of sometimes throwing when not given a valid
node.  Now, this module always checks if given a valid node (object
with `type` set to a non-empty `string`), and returns `false` if not
given a valid node.

Author: wooorm

index.js

@@ -92,21 +92,21 @@ function is(test, node, index, parent, context) {
     throw new Error('Expected function, string, or object as test');
   }
 
-  if (!node || !node.type) {
-    throw new Error('Expected node');
-  }
-
   if (
     hasIndex &&
     (typeof index !== 'number' || index < 0 || index === Infinity)
   ) {
     throw new Error('Expected positive finite index or child node');
   }
 
-  if (hasParent && (!parent || !parent.type || !parent.children)) {
+  if (hasParent && (!is(null, parent) || !parent.children)) {
     throw new Error('Expected parent node');
   }
 
+  if (!node || !node.type || typeof node.type !== 'string') {
+    return false;
+  }
+
   if (hasParent !== hasIndex) {
     throw new Error('Expected both parent and index');
   }

readme.md

@@ -22,6 +22,8 @@ var parent = {type: 'paragraph', children: [node]};
 
 function test(node, n) { return n === 5 }
 
+is(); // false
+is(null, {children: []}); // false
 is(null, node); // true
 is('strong', node); // true
 is('emphasis', node); // false
@@ -42,19 +44,20 @@ is(test, node, 5, parent); // true
 ###### Parameters
 
 *   `test` ([`Function`][test], `string`, or `Node`, optional)
-    —  When not given, returns `true` for the first node.
+    —  When not given, checks if `node` is a [`Node`][node].
     When `string`, works like passing `function (node) {return
     node.type === test}`.
     When `object`, checks that all keys in `test` are in `node`,
     and that they have (strictly) equal values.
-*   `node` ([`Node`][node]) — Node to check;
+*   `node` ([`Node`][node]) — Node to check.  `false` is returned;
 *   `index` (`number`, optional) — Position of `node` in `parent`;
 *   `parent` (`Node`, optional) — Parent of `node`;
 *   `context` (`*`, optiona) — Context object to invoke `test` with.
 
 ###### Returns
 
-`boolean` — Whether `test` passed.
+`boolean` — Whether `test` passed _and_ `node` is a [`Node`][node] (object
+with `type` set to non-empty `string`).
 
 #### `function test(node[, index, parent])`
 

test.js

@@ -85,33 +85,27 @@ test('unist-util-is', function (t) {
     'should throw `parent` xor `index` are given (#2)'
   );
 
-  t.throws(
-    function () {
-      is();
-    },
-    /Expected node/,
-    'should fail without node'
-  );
-
-  t.equal(is(null, node), true, 'should return true without test');
+  t.notok(is(), 'should not fail without node');
+  t.ok(is(null, node), 'should check if given a node (#1)');
+  t.notok(is(null, {children: []}), 'should check if given a node (#2)');
 
-  t.equal(is('strong', node), true, 'should match types (#1)');
-  t.equal(is('emphasis', node), false, 'should match types (#2)');
+  t.ok(is('strong', node), 'should match types (#1)');
+  t.notok(is('emphasis', node), 'should match types (#2)');
 
-  t.equal(is(node, node), true, 'should match partially (#1)');
-  t.equal(is({type: 'strong'}, node), true, 'should match partially (#2)');
-  t.equal(is({type: 'paragraph'}, parent), true, 'should match partially (#3)');
-  t.equal(is({type: 'paragraph'}, node), false, 'should match partially (#4)');
+  t.ok(is(node, node), 'should match partially (#1)');
+  t.ok(is({type: 'strong'}, node), 'should match partially (#2)');
+  t.ok(is({type: 'paragraph'}, parent), 'should match partially (#3)');
+  t.notok(is({type: 'paragraph'}, node), 'should match partially (#4)');
 
   t.test('should accept a test', function (st) {
     /** Test. */
     function test(node, n) {
       return n === 5;
     }
 
-    st.equal(is(test, node), false);
-    st.equal(is(test, node, 0, parent), false);
-    st.equal(is(test, node, 5, parent), true);
+    t.notok(is(test, node));
+    t.notok(is(test, node, 0, parent));
+    st.ok(is(test, node, 5, parent));
 
     st.end();
   });