Format generated files using Prettier (#952)

package.json

@@ -76,7 +76,7 @@
     "mz": "^2.7.0",
     "node-fetch": "^1.3.3",
     "power-assert": "^1.3.1",
-    "prettier": "^1.12.1",
+    "prettier": "^1.14.3",
     "sinon": "^1.17.3",
     "snazzy": "^7.0.0",
     "systemjs": "^0.19.39",

scripts/build/_lib/prettier.js

@@ -0,0 +1,7 @@
+const prettier = require('prettier')
+const packageJSON = require('../../../package.json')
+const config = packageJSON.prettier
+
+module.exports = (code, parser = 'babylon') => {
+  return prettier.format(code, Object.assign(config, { parser }))
+}

scripts/build/_lib/typings/flow.js

@@ -1,53 +1,47 @@
 const fs = require('fs')
+const path = require('path')
+const prettier = require('../prettier')
 
-const {
-  getParams,
-  getType,
-  getFPFnType
-} = require('./common')
+const { getParams, getType, getFPFnType } = require('./common')
 
-const {
-  addSeparator,
-  formatBlock,
-  formatFlowFile
-} = require('./formatBlock')
+const { addSeparator, formatBlock, formatFlowFile } = require('./formatBlock')
 
 /**
  * Return curried function type aliases for a specific FP function arity.
  * @param {Number} [arity=4]
  */
-const getFlowFPTypeAliases = (arity = 4) => [
-  'type CurriedFn1<A, R> = <A>(a: A) => R',
+const getFlowFPTypeAliases = (arity = 4) =>
+  [
+    'type CurriedFn1<A, R> = <A>(a: A) => R',
 
-  formatBlock`
+    formatBlock`
     type CurriedFn2<A, B, R> = <A>(a: A) => CurriedFn1<B, R>
       | <A, B>(a: A, b: B) => R
   `,
 
-  formatBlock`
+    formatBlock`
     type CurriedFn3<A, B, C, R> = <A>(a: A) => CurriedFn2<B, C, R>
       | <A,B>(a: A, b: B) => CurriedFn1<C, R>
       | <A,B,C>(a: A, b: B, c: C) => R
   `,
 
-  formatBlock`
+    formatBlock`
     type CurriedFn4<A, B, C, D, R> = <A>(a: A) => CurriedFn3<B, C, D, R>
       | <A,B>(a: A, b: B) => CurriedFn2<C, D, R>
       | <A,B,C>(a: A, b: B, c: C) => CurriedFn1<D, R>
       | <A,B,C,D>(a: A, b: B, c: C, d: D) => R
   `
-].slice(0, arity)
+  ].slice(0, arity)
 
-function getFlowTypeAlias (type) {
-  const {title, properties} = type
+function getFlowTypeAlias(type) {
+  const { title, properties } = type
   return `type ${title} = ${getParams(properties)}`
 }
 
-function generateFlowFnTyping (fn, aliasDeclarations) {
-  const {title, args, content} = fn
-  const filename = `./src/${title}/index.js.flow`
+function generateFlowFnTyping(fn, aliasDeclarations) {
+  const { title, args, content } = fn
 
-  const params = getParams(args, {leftBorder: '(', rightBorder: ')'})
+  const params = getParams(args, { leftBorder: '(', rightBorder: ')' })
   const returns = getType(content.returns[0].type.names)
 
   const moduleDeclaration = `declare module.exports: ${params} => ${returns}`
@@ -58,14 +52,12 @@ function generateFlowFnTyping (fn, aliasDeclarations) {
     ${moduleDeclaration}
   `
 
-  fs.writeFileSync(filename, typingFile)
+  writeFile(`src/${title}/index.js.flow`, typingFile)
 }
 
-function generateFlowFnIndexTyping (fns, aliasDeclarations) {
-  const filename = `./src/index.js.flow`
-
-  const fnsDeclarations = fns.map(({title, args, content}) => {
-    const params = getParams(args, {leftBorder: '(', rightBorder: ')'})
+function generateFlowFnIndexTyping(fns, aliasDeclarations) {
+  const fnsDeclarations = fns.map(({ title, args, content }) => {
+    const params = getParams(args, { leftBorder: '(', rightBorder: ')' })
     const returns = getType(content.returns[0].type.names)
     return `${title}: ${params} => ${returns}`
   })
@@ -78,12 +70,11 @@ function generateFlowFnIndexTyping (fns, aliasDeclarations) {
     }
   `
 
-  fs.writeFileSync(filename, typingFile)
+  writeFile(`src/index.js.flow`, typingFile)
 }
 
-function generateFlowFPFnTyping (fn, aliasDeclarations) {
-  const {title, args, content} = fn
-  const filename = `./src/fp/${title}/index.js.flow`
+function generateFlowFPFnTyping(fn, aliasDeclarations) {
+  const { title, args, content } = fn
 
   const type = getFPFnType(args, content.returns[0].type.names)
 
@@ -95,14 +86,13 @@ function generateFlowFPFnTyping (fn, aliasDeclarations) {
     declare module.exports: ${type}
   `
 
-  fs.writeFileSync(filename, typingFile)
+  writeFile(`src/fp/${title}/index.js.flow`, typingFile)
 }
 
-function generateFlowFPFnIndexTyping (fns, aliasDeclarations) {
-  const filename = `./src/fp/index.js.flow`
-
-  const fnsDeclarations = fns.map(({title, args, content}) =>
-    `${title}: ${getFPFnType(args, content.returns[0].type.names)}`
+function generateFlowFPFnIndexTyping(fns, aliasDeclarations) {
+  const fnsDeclarations = fns.map(
+    ({ title, args, content }) =>
+      `${title}: ${getFPFnType(args, content.returns[0].type.names)}`
   )
 
   const typingFile = formatFlowFile`
@@ -115,39 +105,38 @@ function generateFlowFPFnIndexTyping (fns, aliasDeclarations) {
     }
   `
 
-  fs.writeFileSync(filename, typingFile)
+  writeFile(`src/fp/index.js.flow`, typingFile)
 }
 
-function generateFlowLocaleTyping (locale, localeAliasDeclaration) {
-  const {fullPath} = locale
-  const filename = `${fullPath}.flow`
+function generateFlowLocaleTyping(locale, localeAliasDeclaration) {
+  const { fullPath } = locale
 
   const typingFile = formatFlowFile`
     ${localeAliasDeclaration}
 
     declare module.exports: Locale
   `
 
-  fs.writeFileSync(filename, typingFile)
+  writeFile(`${fullPath}.flow`, typingFile)
 }
 
-function generateFlowLocaleIndexTyping (locales, localeAliasDeclaration) {
-  const filename = './src/locale/index.js.flow'
-
+function generateFlowLocaleIndexTyping(locales, localeAliasDeclaration) {
   const typingFile = formatFlowFile`
     ${localeAliasDeclaration}
 
     declare module.exports: {
-      ${addSeparator(locales.map(({name}) => `${name}: Locale`), ',')}
+      ${addSeparator(locales.map(({ name }) => `${name}: Locale`), ',')}
     }
   `
 
-  fs.writeFileSync(filename, typingFile)
+  writeFile('src/locale/index.js.flow', typingFile)
 }
 
-function generateFlowTypings (fns, aliases, locales) {
+function generateFlowTypings(fns, aliases, locales) {
   const aliasDeclarations = aliases.map(getFlowTypeAlias)
-  const localeAliasDeclaration = getFlowTypeAlias(aliases.find((alias) => alias.title === 'Locale'))
+  const localeAliasDeclaration = getFlowTypeAlias(
+    aliases.find(alias => alias.title === 'Locale')
+  )
 
   fns.forEach((fn, index) => {
     if (fn.isFPFn) {
@@ -157,15 +146,28 @@ function generateFlowTypings (fns, aliases, locales) {
     }
   })
 
-  locales.forEach((locale) => {
+  locales.forEach(locale => {
     generateFlowLocaleTyping(locale, localeAliasDeclaration)
   })
 
-  generateFlowFnIndexTyping(fns.filter(({isFPFn}) => !isFPFn), aliasDeclarations)
-  generateFlowFPFnIndexTyping(fns.filter(({isFPFn}) => isFPFn), aliasDeclarations)
+  generateFlowFnIndexTyping(
+    fns.filter(({ isFPFn }) => !isFPFn),
+    aliasDeclarations
+  )
+  generateFlowFPFnIndexTyping(
+    fns.filter(({ isFPFn }) => isFPFn),
+    aliasDeclarations
+  )
   generateFlowLocaleIndexTyping(locales, localeAliasDeclaration)
 }
 
+function writeFile(relativePath, content) {
+  return fs.writeFileSync(
+    path.resolve(process.cwd(), relativePath),
+    prettier(content, 'flow')
+  )
+}
+
 module.exports = {
   generateFlowTypings
 }