Refactor code-style

Author: wooorm

.prettierignore

@@ -0,0 +1,3 @@
+coverage/
+unist-util-find-after.js
+unist-util-find-after.min.js

index.js

@@ -1,38 +1,38 @@
-'use strict';
+'use strict'
 
-var is = require('unist-util-is');
+var is = require('unist-util-is')
 
-module.exports = findAfter;
+module.exports = findAfter
 
 /* Find a node after `index` in `parent` which passes
  * `test`. */
 function findAfter(parent, index, test) {
-  var children;
-  var child;
-  var length;
+  var children
+  var child
+  var length
 
   if (!parent || !parent.type || !parent.children) {
-    throw new Error('Expected parent node');
+    throw new Error('Expected parent node')
   }
 
-  children = parent.children;
-  length = children.length;
+  children = parent.children
+  length = children.length
 
   if (index && index.type) {
-    index = children.indexOf(index);
+    index = children.indexOf(index)
   }
 
   if (isNaN(index) || index < 0 || index === Infinity) {
-    throw new Error('Expected positive finite index or child node');
+    throw new Error('Expected positive finite index or child node')
   }
 
   while (++index < length) {
-    child = children[index];
+    child = children[index]
 
     if (is(test, child, index, parent)) {
-      return child;
+      return child
     }
   }
 
-  return null;
+  return null
 }

package.json

@@ -26,31 +26,39 @@
   "devDependencies": {
     "browserify": "^16.0.0",
     "esmangle": "^1.0.0",
+    "nyc": "^11.0.0",
+    "prettier": "^1.12.1",
     "remark": "^9.0.0",
     "remark-cli": "^5.0.0",
     "remark-preset-wooorm": "^4.0.0",
-    "nyc": "^11.0.0",
     "tape": "^4.6.2",
     "xo": "^0.20.0"
   },
   "scripts": {
-    "build-md": "remark . -foq",
+    "format": "remark . -qfo && prettier --write '**/*.js' && xo --fix",
     "build-bundle": "browserify index.js --no-builtins -s unistUtilFindAfter > unist-util-find-after.js",
     "build-mangle": "esmangle unist-util-find-after.js > unist-util-find-after.min.js",
-    "build": "npm run build-md && npm run build-bundle && npm run build-mangle",
-    "lint": "xo",
+    "build": "npm run build-bundle && npm run build-mangle",
     "test-api": "node test",
     "test-coverage": "nyc --reporter lcov tape test.js",
-    "test": "npm run build && npm run lint && npm run test-coverage"
+    "test": "npm run format && npm run build && npm run test-coverage"
   },
   "nyc": {
     "check-coverage": true,
     "lines": 100,
     "functions": 100,
     "branches": 100
   },
+  "prettier": {
+    "tabWidth": 2,
+    "useTabs": false,
+    "singleQuote": true,
+    "bracketSpacing": false,
+    "semi": false,
+    "trailingComma": "none"
+  },
   "xo": {
-    "space": true,
+    "prettier": true,
     "esnext": false,
     "rules": {
       "guard-for-in": "off",

readme.md

@@ -13,13 +13,13 @@ npm install unist-util-find-after
 ## Usage
 
 ```js
-var remark = require('remark');
-var findAfter = require('unist-util-find-after');
+var remark = require('remark')
+var findAfter = require('unist-util-find-after')
 
-var tree = remark().parse('Some _emphasis_, **importance**, and `code`.');
-var paragraph = tree.children[0];
+var tree = remark().parse('Some _emphasis_, **importance**, and `code`.')
+var paragraph = tree.children[0]
 
-console.log(findAfter(paragraph, 1, 'strong'));
+console.log(findAfter(paragraph, 1, 'strong'))
 ```
 
 Yields:

test.js

@@ -1,126 +1,104 @@
-'use strict';
+'use strict'
 
-var assert = require('assert');
-var test = require('tape');
-var remark = require('remark');
-var findAfter = require('.');
+var assert = require('assert')
+var test = require('tape')
+var remark = require('remark')
+var findAfter = require('.')
 
-var tree = remark().parse('Some _emphasis_, **importance**, and `code`.');
-var paragraph = tree.children[0];
-var children = paragraph.children;
+var tree = remark().parse('Some _emphasis_, **importance**, and `code`.')
+var paragraph = tree.children[0]
+var children = paragraph.children
 
-test('unist-util-find-after', function (t) {
+test('unist-util-find-after', function(t) {
   t.throws(
-    function () {
-      findAfter();
+    function() {
+      findAfter()
     },
     /Expected parent node/,
     'should fail without parent'
-  );
+  )
 
   t.throws(
-    function () {
-      findAfter({type: 'foo'});
+    function() {
+      findAfter({type: 'foo'})
     },
     /Expected parent node/,
     'should fail without parent node'
-  );
+  )
 
-  t.doesNotThrow(
-    function () {
-      assert.throws(
-        function () {
-          findAfter({type: 'foo', children: []});
-        },
-        /Expected positive finite index or child node/
-      );
+  t.doesNotThrow(function() {
+    assert.throws(function() {
+      findAfter({type: 'foo', children: []})
+    }, /Expected positive finite index or child node/)
 
-      assert.throws(
-        function () {
-          findAfter({type: 'foo', children: []}, -1);
-        },
-        /Expected positive finite index or child node/
-      );
+    assert.throws(function() {
+      findAfter({type: 'foo', children: []}, -1)
+    }, /Expected positive finite index or child node/)
 
-      assert.throws(
-        function () {
-          findAfter({type: 'foo', children: []}, {type: 'bar'});
-        },
-        /Expected positive finite index or child node/
-      );
-    },
-    'should fail without index'
-  );
+    assert.throws(function() {
+      findAfter({type: 'foo', children: []}, {type: 'bar'})
+    }, /Expected positive finite index or child node/)
+  }, 'should fail without index')
 
-  t.doesNotThrow(
-    function () {
-      assert.throws(
-        function () {
-          findAfter({
-            type: 'foo',
-            children: [{type: 'bar'}, {type: 'baz'}]
-          }, 0, false);
+  t.doesNotThrow(function() {
+    assert.throws(function() {
+      findAfter(
+        {
+          type: 'foo',
+          children: [{type: 'bar'}, {type: 'baz'}]
         },
-        /Expected function, string, or object as test/
-      );
+        0,
+        false
+      )
+    }, /Expected function, string, or object as test/)
 
-      assert.throws(
-        function () {
-          findAfter({
-            type: 'foo',
-            children: [{type: 'bar'}, {type: 'baz'}]
-          }, 0, true);
+    assert.throws(function() {
+      findAfter(
+        {
+          type: 'foo',
+          children: [{type: 'bar'}, {type: 'baz'}]
         },
-        /Expected function, string, or object as test/
-      );
-    },
-    'should fail for invalid `test`'
-  );
+        0,
+        true
+      )
+    }, /Expected function, string, or object as test/)
+  }, 'should fail for invalid `test`')
 
-  t.doesNotThrow(
-    function () {
-      assert.strictEqual(findAfter(paragraph, children[1]), children[2]);
-      assert.strictEqual(findAfter(paragraph, 1), children[2]);
-      assert.strictEqual(findAfter(paragraph, 7), null);
-    },
-    'should return the following node when without `test`'
-  );
+  t.doesNotThrow(function() {
+    assert.strictEqual(findAfter(paragraph, children[1]), children[2])
+    assert.strictEqual(findAfter(paragraph, 1), children[2])
+    assert.strictEqual(findAfter(paragraph, 7), null)
+  }, 'should return the following node when without `test`')
 
-  t.doesNotThrow(
-    function () {
-      assert.strictEqual(findAfter(paragraph, 0, children[6]), children[6]);
-      assert.strictEqual(findAfter(paragraph, children[0], children[1]), children[1]);
-      assert.strictEqual(findAfter(paragraph, 0, children[1]), children[1]);
-      assert.strictEqual(findAfter(paragraph, children[0], children[0]), null);
-      assert.strictEqual(findAfter(paragraph, 0, children[0]), null);
-      assert.strictEqual(findAfter(paragraph, 1, children[1]), null);
-    },
-    'should return `node` when given a `node` and existing'
-  );
+  t.doesNotThrow(function() {
+    assert.strictEqual(findAfter(paragraph, 0, children[6]), children[6])
+    assert.strictEqual(
+      findAfter(paragraph, children[0], children[1]),
+      children[1]
+    )
+    assert.strictEqual(findAfter(paragraph, 0, children[1]), children[1])
+    assert.strictEqual(findAfter(paragraph, children[0], children[0]), null)
+    assert.strictEqual(findAfter(paragraph, 0, children[0]), null)
+    assert.strictEqual(findAfter(paragraph, 1, children[1]), null)
+  }, 'should return `node` when given a `node` and existing')
 
-  t.doesNotThrow(
-    function () {
-      assert.strictEqual(findAfter(paragraph, 0, 'strong'), children[3]);
-      assert.strictEqual(findAfter(paragraph, 3, 'strong'), null);
-      assert.strictEqual(findAfter(paragraph, children[0], 'strong'), children[3]);
-      assert.strictEqual(findAfter(paragraph, children[3], 'strong'), null);
-    },
-    'should return a child when given a `type` and existing'
-  );
+  t.doesNotThrow(function() {
+    assert.strictEqual(findAfter(paragraph, 0, 'strong'), children[3])
+    assert.strictEqual(findAfter(paragraph, 3, 'strong'), null)
+    assert.strictEqual(findAfter(paragraph, children[0], 'strong'), children[3])
+    assert.strictEqual(findAfter(paragraph, children[3], 'strong'), null)
+  }, 'should return a child when given a `type` and existing')
 
-  t.doesNotThrow(
-    function () {
-      assert.strictEqual(findAfter(paragraph, 0, test), children[5]);
-      assert.strictEqual(findAfter(paragraph, 5, test), null);
-      assert.strictEqual(findAfter(paragraph, children[4], test), children[5]);
-      assert.strictEqual(findAfter(paragraph, children[6], test), null);
+  t.doesNotThrow(function() {
+    assert.strictEqual(findAfter(paragraph, 0, test), children[5])
+    assert.strictEqual(findAfter(paragraph, 5, test), null)
+    assert.strictEqual(findAfter(paragraph, children[4], test), children[5])
+    assert.strictEqual(findAfter(paragraph, children[6], test), null)
 
-      function test(node, n) {
-        return n === 5;
-      }
-    },
-    'should return a child when given a `test` and existing'
-  );
+    function test(node, n) {
+      return n === 5
+    }
+  }, 'should return a child when given a `test` and existing')
 
-  t.end();
-});
+  t.end()
+})