Refactor code-style

Author: wooorm

.prettierignore

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

index.js

@@ -1,41 +1,41 @@
-'use strict';
+'use strict'
 
-var is = require('unist-util-is');
+var is = require('unist-util-is')
 
-module.exports = findAllBefore;
+module.exports = findAllBefore
 
 /* Find nodes before `index` in `parent` which pass `test`. */
 function findAllBefore(parent, index, test) {
-  var results = [];
-  var children;
-  var child;
+  var results = []
+  var children
+  var child
 
   if (!parent || !parent.type || !parent.children) {
-    throw new Error('Expected parent node');
+    throw new Error('Expected parent node')
   }
 
-  children = parent.children;
+  children = parent.children
 
   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')
   }
 
   /* Performance. */
   if (index > children.length) {
-    index = children.length;
+    index = children.length
   }
 
   while (index--) {
-    child = children[index];
+    child = children[index]
 
     if (is(test, child, index, parent)) {
-      results.push(child);
+      results.push(child)
     }
   }
 
-  return results;
+  return results
 }

package.json

@@ -23,31 +23,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 unistUtilFindAllBefore > unist-util-find-all-before.js",
     "build-mangle": "esmangle unist-util-find-all-before.js > unist-util-find-all-before.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,14 +13,14 @@ npm install unist-util-find-all-before
 ## Usage
 
 ```js
-var remark = require('remark');
-var findAllBefore = require('unist-util-find-all-before');
+var remark = require('remark')
+var findAllBefore = require('unist-util-find-all-before')
 
-var tree = remark().parse('Some _emphasis_, **importance**, and `code`.');
-var paragraph = tree.children[0];
-var code = paragraph.children[paragraph.children.length - 1];
+var tree = remark().parse('Some _emphasis_, **importance**, and `code`.')
+var paragraph = tree.children[0]
+var code = paragraph.children[paragraph.children.length - 1]
 
-console.log(findAllBefore(paragraph, code, 'text'));
+console.log(findAllBefore(paragraph, code, 'text'))
 ```
 
 Yields:

test.js

@@ -1,131 +1,102 @@
-'use strict';
+'use strict'
 
-var assert = require('assert');
-var test = require('tape');
-var remark = require('remark');
-var findAllBefore = require('.');
+var assert = require('assert')
+var test = require('tape')
+var remark = require('remark')
+var findAllBefore = 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-all-before', function (t) {
+test('unist-util-find-all-before', function(t) {
   t.throws(
-    function () {
-      findAllBefore();
+    function() {
+      findAllBefore()
     },
     /Expected parent node/,
     'should fail without parent'
-  );
+  )
 
   t.throws(
-    function () {
-      findAllBefore({type: 'foo'});
+    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);
+  )
+
+  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 object as test/)
+
+    assert.throws(function() {
+      findAllBefore(
+        {
+          type: 'foo',
+          children: [{type: 'bar'}]
         },
-        /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 object as test/
-      );
-
-      assert.throws(
-        function () {
-          findAllBefore({
-            type: 'foo',
-            children: [{type: 'bar'}]
-          }, 1, true);
-        },
-        /Expected function, string, or object 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();
-});
+        1,
+        true
+      )
+    }, /Expected function, string, or object 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()
+})