Replace istanbul with nyc, mocha with tape

Author: wooorm

.gitignore

@@ -1,4 +1,5 @@
 .DS_Store
 *.log
+.nyc_output/
 coverage/
 node_modules/

package.json

@@ -34,27 +34,31 @@
   "devDependencies": {
     "browserify": "^11.0.0",
     "esmangle": "^1.0.0",
-    "istanbul": "^0.3.0",
     "mdast": "^1.0.0",
     "mdast-comment-config": "^1.0.0",
     "mdast-github": "^1.0.0",
     "mdast-lint": "^1.0.0",
     "mdast-slug": "^2.0.0",
     "mdast-validate-links": "^1.0.0",
-    "mocha": "^2.0.0",
+    "nyc": "^9.0.1",
+    "tape": "^4.6.2",
     "xo": "^0.17.1"
   },
   "scripts": {
-    "test-api": "mocha --check-leaks test.js",
-    "test-coverage": "istanbul cover _mocha -- test.js",
-    "test-travis": "npm run test-coverage",
-    "test": "npm run test-api",
     "lint": "xo",
-    "make": "npm run lint && npm run test-coverage",
     "bundle": "browserify index.js --no-builtins -s unistUtilFindAllBefore > unist-util-find-all-before.js",
     "postbundle": "esmangle unist-util-find-all-before.js > unist-util-find-all-before.min.js",
     "build-md": "mdast . --quiet",
-    "build": "npm run bundle && npm run build-md"
+    "build": "npm run bundle && npm run build-md",
+    "test-api": "node test",
+    "test-coverage": "nyc --reporter lcov tape test.js",
+    "test": "npm run build && npm run lint && npm run test-coverage"
+  },
+  "nyc": {
+    "check-coverage": true,
+    "lines": 100,
+    "functions": 100,
+    "branches": 100
   },
   "xo": {
     "space": true,

test.js

@@ -1,114 +1,131 @@
 'use strict';
 
-/* eslint-env mocha */
-
 var assert = require('assert');
+var test = require('tape');
 var mdast = require('mdast');
 var findAllBefore = require('./');
 
 var tree = mdast.parse('Some *emphasis*, **strongness**, and `code`.');
 var paragraph = tree.children[0];
 var children = paragraph.children;
 
-describe('unist-util-find-all-before', function () {
-  it('should fail without parent', function () {
-    assert.throws(
-      function () {
-        findAllBefore();
-      },
-      /Expected parent node/
-    );
-  });
-
-  it('should fail without parent node', function () {
-    assert.throws(
-      function () {
-        findAllBefore({type: 'foo'});
-      },
-      /Expected parent node/
-    );
-  });
-
-  it('should fail without index', function () {
-    assert.throws(
-      function () {
-        findAllBefore({type: 'foo', children: []});
-      },
-      /Expected positive finite index or child node/
-    );
-
-    assert.throws(
-      function () {
-        findAllBefore({type: 'foo', children: []}, -1);
-      },
-      /Expected positive finite index or child node/
-    );
-
-    assert.throws(
-      function () {
-        findAllBefore({type: 'foo', children: []}, {type: 'bar'});
-      },
-      /Expected positive finite index or child node/
-    );
-  });
-
-  it('should fail for invalid `test`', function () {
-    assert.throws(
-      function () {
-        findAllBefore({type: 'foo', children: [{type: 'bar'}]}, 1, false);
-      },
-      /Expected function, string, or node as test/
-    );
-
-    assert.throws(
-      function () {
-        findAllBefore({
-          type: 'foo',
-          children: [{type: 'bar'}]
-        }, 1, true);
-      },
-      /Expected function, string, or node as test/
-    );
-  });
-
-  it('should return the preceding nodes when without `test`', function () {
-    var res = [children[0]];
-
-    assert.deepEqual(findAllBefore(paragraph, children[1]), res);
-    assert.deepEqual(findAllBefore(paragraph, 1), res);
-    assert.deepEqual(findAllBefore(paragraph, 0), []);
-  });
-
-  it('should return `[node]` when given a `node` and existing', function () {
-    var res = [children[0]];
-
-    assert.deepEqual(findAllBefore(paragraph, 100, children[0]), res);
-    assert.deepEqual(findAllBefore(paragraph, children[1], children[0]), res);
-    assert.deepEqual(findAllBefore(paragraph, 1, children[0]), res);
-    assert.deepEqual(findAllBefore(paragraph, children[0], children[0]), []);
-    assert.deepEqual(findAllBefore(paragraph, 0, children[0]), []);
-    assert.deepEqual(findAllBefore(paragraph, 1, children[1]), []);
-  });
-
-  it('should return children when given a `type` and existing', function () {
-    var result = [children[3]];
-
-    assert.deepEqual(findAllBefore(paragraph, 100, 'strong'), result);
-    assert.deepEqual(findAllBefore(paragraph, 3, 'strong'), []);
-    assert.deepEqual(findAllBefore(paragraph, children[4], 'strong'), result);
-    assert.deepEqual(findAllBefore(paragraph, children[3], 'strong'), []);
-  });
-
-  it('should return children when given a `test` and existing', function () {
-    var res = children.slice(4).reverse();
-
-    assert.deepEqual(findAllBefore(paragraph, 100, test), res);
-    assert.deepEqual(findAllBefore(paragraph, 3, test), []);
-    assert.deepEqual(findAllBefore(paragraph, children[4], test), []);
-    assert.deepEqual(findAllBefore(paragraph, children[3], test), []);
-
-    function test(node, n) {
-      return n > 3;
-    }
-  });
+test('unist-util-find-all-before', function (t) {
+  t.throws(
+    function () {
+      findAllBefore();
+    },
+    /Expected parent node/,
+    'should fail without parent'
+  );
+
+  t.throws(
+    function () {
+      findAllBefore({type: 'foo'});
+    },
+    /Expected parent node/,
+    'should fail without parent node'
+  );
+
+  t.doesNotThrow(
+    function () {
+      assert.throws(
+        function () {
+          findAllBefore({type: 'foo', children: []});
+        },
+        /Expected positive finite index or child node/
+      );
+
+      assert.throws(
+        function () {
+          findAllBefore({type: 'foo', children: []}, -1);
+        },
+        /Expected positive finite index or child node/
+      );
+
+      assert.throws(
+        function () {
+          findAllBefore({type: 'foo', children: []}, {type: 'bar'});
+        },
+        /Expected positive finite index or child node/
+      );
+    },
+    'should fail without index'
+  );
+
+  t.doesNotThrow(
+    function () {
+      assert.throws(
+        function () {
+          findAllBefore({type: 'foo', children: [{type: 'bar'}]}, 1, false);
+        },
+        /Expected function, string, or node as test/
+      );
+
+      assert.throws(
+        function () {
+          findAllBefore({
+            type: 'foo',
+            children: [{type: 'bar'}]
+          }, 1, true);
+        },
+        /Expected function, string, or node as test/
+      );
+    },
+    'should fail for invalid `test`'
+  );
+
+  t.doesNotThrow(
+    function () {
+      var res = [children[0]];
+
+      assert.deepEqual(findAllBefore(paragraph, children[1]), res);
+      assert.deepEqual(findAllBefore(paragraph, 1), res);
+      assert.deepEqual(findAllBefore(paragraph, 0), []);
+    },
+    'should return the preceding nodes when without `test`'
+  );
+
+  t.doesNotThrow(
+    function () {
+      var res = [children[0]];
+
+      assert.deepEqual(findAllBefore(paragraph, 100, children[0]), res);
+      assert.deepEqual(findAllBefore(paragraph, children[1], children[0]), res);
+      assert.deepEqual(findAllBefore(paragraph, 1, children[0]), res);
+      assert.deepEqual(findAllBefore(paragraph, children[0], children[0]), []);
+      assert.deepEqual(findAllBefore(paragraph, 0, children[0]), []);
+      assert.deepEqual(findAllBefore(paragraph, 1, children[1]), []);
+    },
+    'should return `[node]` when given a `node` and existing'
+  );
+
+  t.doesNotThrow(
+    function () {
+      var result = [children[3]];
+
+      assert.deepEqual(findAllBefore(paragraph, 100, 'strong'), result);
+      assert.deepEqual(findAllBefore(paragraph, 3, 'strong'), []);
+      assert.deepEqual(findAllBefore(paragraph, children[4], 'strong'), result);
+      assert.deepEqual(findAllBefore(paragraph, children[3], 'strong'), []);
+    },
+    'should return children when given a `type` and existing'
+  );
+
+  t.doesNotThrow(
+    function () {
+      var res = children.slice(4).reverse();
+
+      assert.deepEqual(findAllBefore(paragraph, 100, test), res);
+      assert.deepEqual(findAllBefore(paragraph, 3, test), []);
+      assert.deepEqual(findAllBefore(paragraph, children[4], test), []);
+      assert.deepEqual(findAllBefore(paragraph, children[3], test), []);
+
+      function test(node, n) {
+        return n > 3;
+      }
+    },
+    'should return children when given a `test` and existing'
+  );
+
+  t.end();
 });