add type and function predicates

Use unist-util-is for testing a node.

BREAKING CHANGE: `opts` argument position is changed to better suit
the function form of the predicate argument.

Author: eush77

README.md

@@ -77,12 +77,15 @@ remove(ast, ast)
 
 ## API
 
-### `remove(ast, nodes, [opts])`
+### `remove(ast, [opts], predicate)`
 
 - `ast` — [Unist] tree.
-- `nodes` — [Unist] node or array of nodes.
+- `predicate` — one of:
+    - [Unist] node or array of nodes,
+    - node type (string),
+    - function invoked with arguments `(node, index?, parent?)`.
 
-Removes `nodes` from `ast`. Returns a modified [Unist] tree.
+Iterates over `ast` in preorder traversal and removes all nodes matching `predicate` from `ast`. Returns a modified [Unist] tree.
 
 ##### `opts.cascade`
 

index.js

@@ -1,18 +1,23 @@
 'use strict';
 
+var is = require('unist-util-is');
 
-module.exports = function (ast, nodes, opts) {
-  if (!Array.isArray(nodes)) {
-    nodes = [nodes];
+
+module.exports = function (ast, opts, predicate) {
+  if (arguments.length == 2) {
+    predicate = opts;
+    opts = {};
   }
 
-  opts = opts || {};
+  if (Array.isArray(predicate)) {
+    predicate = arrayPredicate(predicate);
+  }
   opts.cascade = opts.cascade || opts.cascade === undefined;
 
   // Check and remove nodes recursively in preorder.
   // For each composite node, modify its children array in-place.
-  return (function preorder (node) {
-    if (nodes.indexOf(node) >= 0) {
+  return (function preorder (node, nodeIndex, parent) {
+    if (is(predicate, node, nodeIndex, parent)) {
       return null;
     }
     if (!node.children) {
@@ -24,7 +29,7 @@ module.exports = function (ast, nodes, opts) {
     var length = 0;
 
     for (var index = 0; index < node.children.length; ++index) {
-      var child = preorder(node.children[index]);
+      var child = preorder(node.children[index], index, node);
 
       if (child) {
         node.children[length++] = child;
@@ -38,5 +43,12 @@ module.exports = function (ast, nodes, opts) {
 
     node.children.length = length;
     return node;
-  }(ast));
+  }(ast, null, null));
 };
+
+
+function arrayPredicate (nodes) {
+  return function (node) {
+    return nodes.indexOf(node) >= 0;
+  };
+}

package.json

@@ -28,7 +28,9 @@
     "unist",
     "util"
   ],
-  "dependencies": {},
+  "dependencies": {
+    "unist-util-is": "^1.0.0"
+  },
   "devDependencies": {
     "tape": "^4.4.0",
     "unist-builder": "^1.0.0"

test/opts.js

@@ -15,12 +15,10 @@ test('opts.cascade', function (t) {
       u('leaf', 2)
     ]);
 
-    var newAst = remove(ast, [
+    var newAst = remove(ast, { cascade: true }, [
       ast.children[0].children[0],
       ast.children[1]
-    ], {
-      cascade: true
-    });
+    ]);
 
     t.equal(newAst, null);
     t.end();
@@ -37,12 +35,10 @@ test('opts.cascade', function (t) {
     var innerNode = ast.children[0];
     var grandChildren = ast.children[0].children;
 
-    var newAst = remove(ast, [
+    var newAst = remove(ast, { cascade: false }, [
       ast.children[0].children[0],
       ast.children[1]
-    ], {
-      cascade: false
-    });
+    ]);
 
     t.equal(newAst, ast);
     t.deepEqual(ast, u('root', [

test/test.js

@@ -118,3 +118,60 @@ it('should cascade remove parent nodes', function (t) {
     t.end();
   });
 });
+
+
+it('should support type tests and predicate functions', function (t) {
+  t.test(function (t) {
+    var ast = u('node', [
+      u('node', [
+        u('leaf', 1)
+      ]),
+      u('leaf', 2)
+    ]);
+
+    ast = remove(ast, { cascade: false }, 'leaf');
+
+    t.deepEqual(ast, u('node', [
+      u('node', [])
+    ]));
+    t.end();
+  });
+
+  t.test(function (t) {
+    var ast = u('node', [
+      u('node', [
+        u('leaf', 1)
+      ]),
+      u('leaf', 2)
+    ]);
+
+    ast = remove(ast, { cascade: false }, function (node) {
+      return node.value == 1;
+    });
+
+    t.deepEqual(ast, u('node', [
+      u('node', []),
+      u('leaf', 2)
+    ]));
+    t.end();
+  });
+
+  t.test(function (t) {
+    var ast = u('node', [
+      u('node', [
+        u('leaf', 1)
+      ]),
+      u('leaf', 2)
+    ]);
+
+    ast = remove(ast, { cascade: false }, function (node, index, parent) {
+      return index == 0 && parent.children.length == 1;
+    });
+
+    t.deepEqual(ast, u('node', [
+      u('node', []),
+      u('leaf', 2)
+    ]));
+    t.end();
+  });
+});