Refactor and enforce code-style

wooorm · wooorm · commit 2b42f9e0ed0d · 2018-05-02T12:02:16.000+02:00
diff --git a/.editorconfig b/.editorconfig
@@ -0,0 +1,9 @@
+root = true
+
+[*]
+indent_style = space
+indent_size = 2
+end_of_line = lf
+charset = utf-8
+trim_trailing_whitespace = true
+insert_final_newline = true
diff --git a/README.md b/README.md
@@ -1,14 +1,16 @@
-# unist-util-map [![Build Status](https://travis-ci.org/syntax-tree/unist-util-map.svg?branch=master)](https://travis-ci.org/syntax-tree/unist-util-map)
+# unist-util-visit-parents [![Build Status][build-badge]][build-page]
 
 Create a new Unist tree with all nodes that mapped by the provided function.
 
-Helper for creating [unist: Universal Syntax Tree](https://github.com/wooorm/unist "wooorm/unist: Universal Syntax Tree").
+Helper for creating [unist: Universal Syntax Tree][unist].
 
-- retext, remark, hast, textlint
+*   retext, remark, hast, textlint
 
 ## Installation
 
-    npm install unist-util-map
+```sh
+npm install unist-util-map
+```
 
 ## Usage
 
@@ -60,22 +62,34 @@ assert.deepEqual(actual, expected);
 
 ## Tests
 
-    npm test
+```sh
+npm test
+```
 
 ## Contributing
 
-1. Fork it!
-2. Create your feature branch: `git checkout -b my-new-feature`
-3. Commit your changes: `git commit -am 'Add some feature'`
-4. Push to the branch: `git push origin my-new-feature`
-5. Submit a pull request :D
+1.  Fork it!
+2.  Create your feature branch: `git checkout -b my-new-feature`
+3.  Commit your changes: `git commit -am 'Add some feature'`
+4.  Push to the branch: `git push origin my-new-feature`
+5.  Submit a pull request :D
 
-## Contribute
+See [`contribute.md` in `syntax-tree/unist`][contributing] for ways to get
+started.
 
-See [`contribute.md` in `syntax-tree/unist`](https://github.com/syntax-tree/unist/blob/master/contributing.md) for ways to get started.
-
-This organisation has a [Code of Conduct](https://github.com/syntax-tree/unist/blob/master/code-of-conduct.md).  By interacting with this repository, organisation, or community you agree to abide by its terms.
+This organisation has a [Code of Conduct][coc].  By interacting with this
+repository, organisation, or community you agree to abide by its terms.
 
 ## License
 
 MIT
+
+[build-badge]: https://img.shields.io/travis/syntax-tree/unist-util-map.svg
+
+[build-page]: https://travis-ci.org/syntax-tree/unist-util-map
+
+[unist]: https://github.com/wooorm/unist "wooorm/unist: Universal Syntax Tree"
+
+[contributing]: https://github.com/syntax-tree/unist/blob/master/contributing.md
+
+[coc]: https://github.com/syntax-tree/unist/blob/master/code-of-conduct.md
diff --git a/lib/unist-util-map.js b/lib/unist-util-map.js
@@ -1,14 +1,25 @@
 // LICENSE : MIT
-"use strict";
-var ObjectAssign = require("object-assign");
-module.exports = function map(ast, mapFn) {
-    return (function preorder(node, index, parent) {
-        const newNode = ObjectAssign({}, mapFn(node, index, parent));
-        if (node.children) {
-            newNode.children = node.children.map(function (child, index) {
-                return preorder(child, index, node);
-            });
-        }
-        return newNode;
-    }(ast, null, null));
-};
+'use strict'
+
+var assign = require('object-assign')
+
+module.exports = map
+
+function map(ast, iteratee) {
+  return preorder(ast, null, null)
+
+  function preorder(node, index, parent) {
+    var children = node.children
+    var newNode = assign({}, iteratee(node, index, parent))
+
+    if (children) {
+      newNode.children = children.map(bound)
+    }
+
+    return newNode
+
+    function bound(child, index) {
+      return preorder(child, index, node)
+    }
+  }
+}
diff --git a/package.json b/package.json
@@ -23,10 +23,36 @@
     "object-assign": "^4.0.1"
   },
   "devDependencies": {
-    "@textlint/text-to-ast": "^3.0.0",
-    "mocha": "^5.0.0"
+    "mocha": "^5.0.0",
+    "prettier": "^1.12.1",
+    "remark-cli": "^5.0.0",
+    "remark-preset-wooorm": "^4.0.0",
+    "xo": "^0.20.3"
   },
   "scripts": {
-    "test": "mocha"
+    "format": "remark . -qfo && prettier --write '**/*.js' && xo --fix",
+    "test-api": "mocha",
+    "test": "npm run format && npm run test-api"
+  },
+  "prettier": {
+    "tabWidth": 2,
+    "useTabs": false,
+    "singleQuote": true,
+    "bracketSpacing": false,
+    "semi": false,
+    "trailingComma": "none"
+  },
+  "xo": {
+    "prettier": true,
+    "esnext": false,
+    "rules": {
+      "no-var": "off",
+      "prefer-arrow-callback": "off"
+    }
+  },
+  "remarkConfig": {
+    "plugins": [
+      "preset-wooorm"
+    ]
   }
 }
diff --git a/test.js b/test.js
@@ -1,97 +1,90 @@
 // LICENSE : MIT
-"use strict";
-const assert = require("assert");
-const map = require(".");
-const parse = require("@textlint/text-to-ast").parse;
-const Syntax = require("@textlint/text-to-ast").Syntax;
-const ObjectAssign = require("object-assign");
-describe('should not traverse into children of filtered out nodes', function (t) {
-    it("should map specified node", function () {
-        const ast = {
-            "type": "root",
-            "children": [
-                {
-                    "type": "node",
-                    "children": [
-                        {"type": "leaf", "value": "1"}
-                    ]
-                },
-                {"type": "leaf", "value": "2"}
-            ]
-        };
-        const actual = map(ast, function (node) {
-            if (node.type === "leaf") {
-                return ObjectAssign({}, node, {
-                    value: "CHANGED"
-                });
-            }
-            // no change
-            return node;
-        });
-        const expected = {
-            "type": "root",
-            "children": [
-                {
-                    "type": "node",
-                    "children": [
-                        {"type": "leaf", "value": "CHANGED"}
-                    ]
-                },
-                {"type": "leaf", "value": "CHANGED"}
-            ]
-        };
-        assert.deepEqual(actual, expected);
-    });
-    context("when return null", function () {
-        it("should map as empty object", function () {
-            const ast = {
-                "type": "root",
-                "children": [
-                    {
-                        "type": "node",
-                        "children": [
-                            {"type": "leaf", "value": "1"}
-                        ]
-                    },
-                    {"type": "leaf", "value": "2"}
-                ]
-            };
-            const actual = map(ast, function (node) {
-                if (node.type === "leaf") {
-                    return null;
-                }
-                // no change
-                return node;
-            });
-            const expected = {
-                "type": "root",
-                "children": [
-                    {
-                        "type": "node",
-                        "children": [
-                            {}
-                        ]
-                    },
-                    {}
-                ]
-            };
-            assert.deepEqual(actual, expected);
-        });
-    });
+'use strict'
 
-    context("when pass empty object", function () {
-        it("should work map", function () {
-            const ast = {};
-            const actual = map(ast, function (node) {
-                return {
-                    value: "test"
-                };
-            });
-            const expected = {};
-            assert.deepEqual(actual, {
-                value: "test"
-            });
-        });
-    });
-});
+/* eslint-env mocha */
 
+const assert = require('assert')
+const assign = require('object-assign')
+const map = require('.')
+
+describe('should not traverse into children of filtered out nodes', function() {
+  it('should map specified node', function() {
+    const ast = {
+      type: 'root',
+      children: [
+        {
+          type: 'node',
+          children: [{type: 'leaf', value: '1'}]
+        },
+        {type: 'leaf', value: '2'}
+      ]
+    }
+    const actual = map(ast, function(node) {
+      if (node.type === 'leaf') {
+        return assign({}, node, {
+          value: 'CHANGED'
+        })
+      }
+      // No change
+      return node
+    })
+    const expected = {
+      type: 'root',
+      children: [
+        {
+          type: 'node',
+          children: [{type: 'leaf', value: 'CHANGED'}]
+        },
+        {type: 'leaf', value: 'CHANGED'}
+      ]
+    }
+    assert.deepEqual(actual, expected)
+  })
+  context('when return null', function() {
+    it('should map as empty object', function() {
+      const ast = {
+        type: 'root',
+        children: [
+          {
+            type: 'node',
+            children: [{type: 'leaf', value: '1'}]
+          },
+          {type: 'leaf', value: '2'}
+        ]
+      }
+      const actual = map(ast, function(node) {
+        if (node.type === 'leaf') {
+          return null
+        }
+        // No change
+        return node
+      })
+      const expected = {
+        type: 'root',
+        children: [
+          {
+            type: 'node',
+            children: [{}]
+          },
+          {}
+        ]
+      }
+      assert.deepEqual(actual, expected)
+    })
+  })
+
+  context('when pass empty object', function() {
+    it('should work map', function() {
+      const ast = {}
+      const actual = map(ast, function() {
+        return {
+          value: 'test'
+        }
+      })
+      const expected = {
+        value: 'test'
+      }
+      assert.deepEqual(actual, expected)
+    })
+  })
+})
