Refactor code-style

Author: wooorm

.prettierignore

@@ -0,0 +1,3 @@
+coverage/
+nlcst-is-literal.js
+nlcst-is-literal.min.js

index.js

@@ -1,16 +1,16 @@
-'use strict';
+'use strict'
 
-var toString = require('nlcst-to-string');
+var toString = require('nlcst-to-string')
 
-module.exports = isLiteral;
+module.exports = isLiteral
 
 var single = {
   '-': true, // Hyphen-minus
   '–': true, // En dash
   '—': true, // Em dash
   ':': true, // Colon
   ';': true // Semi-colon
-};
+}
 
 /* Pair delimiters. From common sense, and wikipedia:
  * Mostly from https://en.wikipedia.org/wiki/Quotation_mark. */
@@ -30,8 +30,8 @@ var pairs = {
   '"': {
     '"': true
   },
-  '\'': {
-    '\'': true
+  "'": {
+    "'": true
   },
   '‘': {
     '’': true
@@ -80,122 +80,123 @@ var pairs = {
   '「': {
     '」': true
   }
-};
+}
 
 /* Check if the node in `parent` at `position` is enclosed
  * by matching delimiters. */
 function isLiteral(parent, index) {
   if (!(parent && parent.children)) {
-    throw new Error('Parent must be a node');
+    throw new Error('Parent must be a node')
   }
 
   if (isNaN(index)) {
-    throw new Error('Index must be a number');
+    throw new Error('Index must be a number')
   }
 
   if (
     (!hasWordsBefore(parent, index) && nextDelimiter(parent, index, single)) ||
-    (!hasWordsAfter(parent, index) && previousDelimiter(parent, index, single)) ||
+    (!hasWordsAfter(parent, index) &&
+      previousDelimiter(parent, index, single)) ||
     isWrapped(parent, index, pairs)
   ) {
-    return true;
+    return true
   }
 
-  return false;
+  return false
 }
 
 /* Check if the node in `parent` at `position` is enclosed
  * by matching delimiters. */
 function isWrapped(parent, position, delimiters) {
-  var prev = previousDelimiter(parent, position, delimiters);
-  var next;
+  var prev = previousDelimiter(parent, position, delimiters)
+  var next
 
   if (prev) {
-    next = nextDelimiter(parent, position, delimiters[toString(prev)]);
+    next = nextDelimiter(parent, position, delimiters[toString(prev)])
   }
 
-  return Boolean(next);
+  return Boolean(next)
 }
 
 /* Find the previous delimiter before `position` in
  * `parent`. Returns the delimiter node when found. */
 function previousDelimiter(parent, position, delimiters) {
-  var siblings = parent.children;
-  var index = position;
-  var result;
+  var siblings = parent.children
+  var index = position
+  var result
 
   while (index--) {
-    result = delimiterCheck(siblings[index], delimiters);
+    result = delimiterCheck(siblings[index], delimiters)
 
     if (result === null) {
-      continue;
+      continue
     }
 
-    return result;
+    return result
   }
 
-  return null;
+  return null
 }
 
 /* Find the next delimiter after `position` in
  * `parent`. Returns the delimiter node when found. */
 function nextDelimiter(parent, position, delimiters) {
-  var siblings = parent.children;
-  var index = position;
-  var length = siblings.length;
-  var result;
+  var siblings = parent.children
+  var index = position
+  var length = siblings.length
+  var result
 
   while (++index < length) {
-    result = delimiterCheck(siblings[index], delimiters);
+    result = delimiterCheck(siblings[index], delimiters)
 
     if (result === null) {
-      continue;
+      continue
     }
 
-    return result;
+    return result
   }
 
-  return null;
+  return null
 }
 
 /* Check if `node` is in `delimiters`. */
 function delimiterCheck(node, delimiters) {
-  var type = node.type;
+  var type = node.type
 
   if (type === 'WordNode' || type === 'SourceNode') {
-    return false;
+    return false
   }
 
   if (type === 'WhiteSpaceNode') {
-    return null;
+    return null
   }
 
-  return toString(node) in delimiters ? node : false;
+  return toString(node) in delimiters ? node : false
 }
 
 /* Check if there are word nodes before `position`
  * in `parent`. */
 function hasWordsBefore(parent, position) {
-  return containsWord(parent, 0, position);
+  return containsWord(parent, 0, position)
 }
 
 /* Check if there are word nodes before `position`
  * in `parent`. */
 function hasWordsAfter(parent, position) {
-  return containsWord(parent, position + 1, parent.children.length);
+  return containsWord(parent, position + 1, parent.children.length)
 }
 
 /* Check if parent contains word-nodes between
  * `start` and `end`. */
 function containsWord(parent, start, end) {
-  var siblings = parent.children;
-  var index = start - 1;
+  var siblings = parent.children
+  var index = start - 1
 
   while (++index < end) {
     if (siblings[index].type === 'WordNode') {
-      return true;
+      return true
     }
   }
 
-  return false;
+  return false
 }

package.json

@@ -27,6 +27,7 @@
     "browserify": "^16.0.0",
     "esmangle": "^1.0.0",
     "nyc": "^11.0.0",
+    "prettier": "^1.12.1",
     "remark-cli": "^5.0.0",
     "remark-preset-wooorm": "^4.0.0",
     "retext": "^5.0.0",
@@ -35,23 +36,30 @@
     "xo": "^0.20.0"
   },
   "scripts": {
-    "build-md": "remark . --quiet --frail --output",
+    "format": "remark . -qfo && prettier --write '**/*.js' && xo --fix",
     "build-bundle": "browserify index.js --bare -s nlcstIsLiteral > nlcst-is-literal.js",
     "build-mangle": "esmangle < nlcst-is-literal.js > nlcst-is-literal.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

@@ -33,21 +33,23 @@ The word — quux — is meant as a literal.
 And our script, `example.js`, looks as follows:
 
 ```javascript
-var vfile = require('to-vfile');
-var unified = require('unified');
-var english = require('retext-english');
-var visit = require('unist-util-visit');
-var toString = require('nlcst-to-string');
-var literal = require('nlcst-is-literal');
+var vfile = require('to-vfile')
+var unified = require('unified')
+var english = require('retext-english')
+var visit = require('unist-util-visit')
+var toString = require('nlcst-to-string')
+var literal = require('nlcst-is-literal')
 
-var file = vfile.readSync('example.txt');
-var tree = unified().use(english).parse(file);
+var file = vfile.readSync('example.txt')
+var tree = unified()
+  .use(english)
+  .parse(file)
 
-visit(tree, 'WordNode', visitor);
+visit(tree, 'WordNode', visitor)
 
 function visitor(node, index, parent) {
   if (literal(parent, index)) {
-    console.log(toString(node));
+    console.log(toString(node))
   }
 }
 ```