Refactor code-style

Author: wooorm

.prettierignore

@@ -0,0 +1,3 @@
+coverage/
+hast-util-find-and-replace.js
+hast-util-find-and-replace.min.js

index.js

@@ -1,173 +1,179 @@
-'use strict';
+'use strict'
 
-var array = require('isarray');
-var regexp = require('is-regex');
-var visit = require('unist-util-visit-parents');
-var is = require('hast-util-is-element');
-var escape = require('escape-string-regexp');
+var array = require('isarray')
+var regexp = require('is-regex')
+var visit = require('unist-util-visit-parents')
+var is = require('hast-util-is-element')
+var escape = require('escape-string-regexp')
 
-var IGNORE = ['title', 'script', 'style', 'svg', 'math'];
+var IGNORE = ['title', 'script', 'style', 'svg', 'math']
 
-module.exports = findAndReplace;
+module.exports = findAndReplace
 
-findAndReplace.ignore = IGNORE;
+findAndReplace.ignore = IGNORE
 
 function findAndReplace(tree, find, replace, options) {
-  var settings;
-  var schema;
+  var settings
+  var schema
 
   if (typeof find === 'string' || regexp(find)) {
-    schema = [[find, replace]];
+    schema = [[find, replace]]
   } else {
-    schema = find;
-    options = replace;
+    schema = find
+    options = replace
   }
 
-  settings = options || {};
+  settings = options || {}
 
-  search(tree, settings, handlerFactory(toPairs(schema)));
+  search(tree, settings, handlerFactory(toPairs(schema)))
 
-  return tree;
+  return tree
 
   function handlerFactory(pairs) {
-    var pair = pairs[0];
+    var pair = pairs[0]
 
-    return handler;
+    return handler
 
     function handler(node, parent) {
-      var siblings = parent.children;
-      var pos = siblings.indexOf(node);
-      var value = node.value;
-      var find = pair[0];
-      var replace = pair[1];
-      var lastIndex = 0;
-      var nodes = [];
-      var subvalue;
-      var index;
-      var length;
-      var match;
-      var subhandler;
-
-      find.lastIndex = 0;
-
-      match = find.exec(value);
+      var siblings = parent.children
+      var pos = siblings.indexOf(node)
+      var value = node.value
+      var find = pair[0]
+      var replace = pair[1]
+      var lastIndex = 0
+      var nodes = []
+      var subvalue
+      var index
+      var length
+      var match
+      var subhandler
+
+      find.lastIndex = 0
+
+      match = find.exec(value)
 
       while (match) {
-        index = match.index;
-        subvalue = value.slice(lastIndex, index);
+        index = match.index
+        subvalue = value.slice(lastIndex, index)
 
         if (subvalue) {
-          nodes.push({type: 'text', value: subvalue});
+          nodes.push({type: 'text', value: subvalue})
         }
 
-        subvalue = replace.apply(null, match);
+        subvalue = replace.apply(null, match)
 
         if (subvalue) {
           if (typeof subvalue === 'string') {
-            subvalue = {type: 'text', value: subvalue};
+            subvalue = {type: 'text', value: subvalue}
           }
 
-          nodes.push(subvalue);
+          nodes.push(subvalue)
         }
 
-        lastIndex = index + match[0].length;
+        lastIndex = index + match[0].length
 
         if (!find.global) {
-          break;
+          break
         }
 
-        match = find.exec(value);
+        match = find.exec(value)
       }
 
       if (index === undefined) {
-        nodes = [node];
+        nodes = [node]
       } else {
-        subvalue = value.slice(lastIndex);
+        subvalue = value.slice(lastIndex)
 
         if (subvalue) {
-          nodes.push({type: 'text', value: subvalue});
+          nodes.push({type: 'text', value: subvalue})
         }
 
-        parent.children = siblings.slice(0, pos).concat(nodes).concat(siblings.slice(pos + 1));
+        parent.children = siblings
+          .slice(0, pos)
+          .concat(nodes)
+          .concat(siblings.slice(pos + 1))
       }
 
       if (pairs.length <= 1) {
-        return;
+        return
       }
 
-      length = nodes.length;
-      index = -1;
-      subhandler = handlerFactory(pairs.slice(1));
+      length = nodes.length
+      index = -1
+      subhandler = handlerFactory(pairs.slice(1))
 
       while (++index < length) {
-        node = nodes[index];
+        node = nodes[index]
 
         if (node.type === 'text') {
-          subhandler(node, parent);
+          subhandler(node, parent)
         } else {
-          search(node, settings, subhandler);
+          search(node, settings, subhandler)
         }
       }
     }
   }
 }
 
 function search(tree, options, handler) {
-  var ignore = options.ignore || IGNORE;
-  var result = [];
+  var ignore = options.ignore || IGNORE
+  var result = []
 
-  visit(tree, 'text', visitor);
+  visit(tree, 'text', visitor)
 
-  return result;
+  return result
 
   function visitor(node, parents) {
-    var length = parents.length;
-    var index = length;
+    var length = parents.length
+    var index = length
 
     while (index--) {
       if (is(parents[index], ignore)) {
-        return;
+        return
       }
     }
 
-    handler(node, parents[length - 1]);
+    handler(node, parents[length - 1])
   }
 }
 
 function toPairs(schema) {
-  var result = [];
-  var key;
-  var length;
-  var index;
+  var result = []
+  var key
+  var length
+  var index
 
   if (typeof schema !== 'object') {
-    throw new Error('Expected array or object as schema');
+    throw new Error('Expected array or object as schema')
   }
 
   if (array(schema)) {
-    length = schema.length;
-    index = -1;
+    length = schema.length
+    index = -1
 
     while (++index < length) {
-      result.push([toExpression(schema[index][0]), toFunction(schema[index][1])]);
+      result.push([
+        toExpression(schema[index][0]),
+        toFunction(schema[index][1])
+      ])
     }
   } else {
     for (key in schema) {
-      result.push([toExpression(key), toFunction(schema[key])]);
+      result.push([toExpression(key), toFunction(schema[key])])
     }
   }
 
-  return result;
+  return result
 }
 
 function toExpression(find) {
-  return typeof find === 'string' ? new RegExp(escape(find), 'g') : find;
+  return typeof find === 'string' ? new RegExp(escape(find), 'g') : find
 }
 
 function toFunction(replace) {
-  return typeof replace === 'function' ? replace : returner;
+  return typeof replace === 'function' ? replace : returner
 
   function returner() {
-    return replace;
+    return replace
   }
 }

package.json

@@ -32,23 +32,31 @@
     "esmangle": "^1.0.1",
     "hastscript": "^3.0.1",
     "nyc": "^12.0.0",
+    "prettier": "^1.13.5",
     "remark-cli": "^5.0.0",
     "remark-preset-wooorm": "^4.0.0",
     "tape": "^4.4.0",
     "xo": "^0.21.0"
   },
   "scripts": {
-    "build-md": "remark . --quiet --frail --output",
+    "format": "remark . -qfo && prettier --write '**/*.js' && xo --fix",
     "build-bundle": "browserify index.js --bare -s hastUtilFindAndReplace > hast-util-find-and-replace.js",
     "build-mangle": "esmangle hast-util-find-and-replace.js > hast-util-find-and-replace.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"
+  },
+  "prettier": {
+    "tabWidth": 2,
+    "useTabs": false,
+    "singleQuote": true,
+    "bracketSpacing": false,
+    "semi": false,
+    "trailingComma": "none"
   },
   "xo": {
-    "space": true,
+    "prettier": true,
     "esnext": false,
     "rules": {
       "unicorn/prefer-type-error": "off",

readme.md

@@ -13,9 +13,9 @@ npm install hast-util-find-and-replace
 ## Usage
 
 ```javascript
-var h = require('hastscript');
-var inspect = require('unist-util-inspect');
-var findAndReplace = require('hast-util-find-and-replace');
+var h = require('hastscript')
+var inspect = require('unist-util-inspect')
+var findAndReplace = require('hast-util-find-and-replace')
 
 var tree = h('p', [
   'Some ',
@@ -25,17 +25,19 @@ var tree = h('p', [
   ', and ',
   h('code', 'code'),
   '.'
-]);
+])
 
-findAndReplace(tree, 'and', 'or');
+findAndReplace(tree, 'and', 'or')
 
-findAndReplace(tree, {emphasis: 'em', importance: 'strong'});
+findAndReplace(tree, {emphasis: 'em', importance: 'strong'})
 
-findAndReplace(tree, {code: function ($0) {
-  return h('a', {href: '//example.com#' + $0}, $0);
-}});
+findAndReplace(tree, {
+  code: function($0) {
+    return h('a', {href: '//example.com#' + $0}, $0)
+  }
+})
 
-console.log(inspect(tree));
+console.log(inspect(tree))
 ```
 
 Yields: