Add partial property tests

This removes the identity test (by passing one node), but adds a new
test (when given an object), which tests that all keys in `test` are
in the comparator `node`, and that they have strictly equal values.

Closes GH-1.

Author: wooorm

index.js

@@ -43,15 +43,23 @@ function typeFactory(test) {
 }
 
 /**
- * Utility to convert a node into a function which checks
- * a given node for strict equality.
+ * Utility assert each property in `test` is represented
+ * in `node`, and each values are strictly equal.
  *
- * @param {Node} test - Node to test.
+ * @param {Object} test - Spec.
  * @return {is~test} - Tester.
  */
-function nodeFactory(test) {
+function matchesFactory(test) {
     return function (node) {
-        return node === test;
+        var key;
+
+        for (key in test) {
+            if (node[key] !== test[key]) {
+                return false;
+            }
+        }
+
+        return true;
     }
 }
 
@@ -102,12 +110,12 @@ function is(test, node, index, parent, context) {
 
     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 === 'object') {
+        test = matchesFactory(test);
     } else if (typeof test !== 'function') {
-        throw new Error('Expected function, string, or node as test');
+        throw new Error('Expected function, string, or object as test');
     }
 
     if (!node || !node.type) {

readme.md

@@ -39,7 +39,8 @@ is('strong', node); // true
 is('emphasis', node); // false
 
 is(node, node) // true
-is(node, {type: 'strong'}) // false
+is({type: 'paragraph'}, parent) // true
+is({type: 'strong'}, parent) // false
 
 is(test, node); // false
 is(test, node, 4, parent); // false
@@ -58,11 +59,11 @@ Utility to check if a node passes a test.
     `Node`, optional)
     — When not given, return is return `true`.
 
-    Passing a `string` is equal to passing
+    Passing a `string` is like passing
     `function (node) {return node.type === test}`.
 
-    Passing a `node` is equal to passing
-    `function (node) {return node === test}`.
+    Passing an `object` checks that all keys in `test` are in `node`,
+    and that they have (strictly) equal values.
 
 *   `node` (`Node`)
     — [Node](https://github.com/wooorm/unist#unist-nodes) to test;

test.js

@@ -41,7 +41,7 @@ describe('unist-util-is', function () {
     it('should throw when `test` is invalid', function () {
         throws(function () {
             is(false);
-        }, /Expected function, string, or node as test/);
+        }, /Expected function, string, or object as test/);
     });
 
     it('should throw when `index` is invalid', function () {
@@ -95,11 +95,15 @@ describe('unist-util-is', function () {
         equal(is('emphasis', node), false);
     });
 
-    it('should match nodes', function () {
+    it('should match partially', function () {
         equal(is(node, node), true);
-        equal(is(node, {
+        equal(is({
             'type': 'strong'
-        }), false);
+        }, node), true);
+
+        equal(is({
+            'type': 'paragraph'
+        }, parent), true);
     });
 
     it('should accept a test', function () {