feat: support prettier configuration (#119)

This actually is a partial solution to #118.

BREAKING CHANGE: the API is now async 100% of the time. It's a shame,
but we have to do that due to the async nature of resolving the prettier
config.

Author: Kent C. Dodds

.babelrc

@@ -5,7 +5,8 @@
       {
         "targets": {
           "node": "4.5"
-        }
+        },
+        "exclude": ["transform-regenerator"]
       }
     ]
   ],

.eslintrc

@@ -6,6 +6,13 @@
   ],
   "rules": {
     "valid-jsdoc": "off",
-    "max-len": "off"
+    "max-len": "off",
+    "semi": "off",
+    "quotes": "off",
+    "space-before-function-paren": ["error", {
+      "anonymous": "never",
+      "named": "never",
+      "asyncArrow": "always"
+    }],
   }
 }

package.json

@@ -1,16 +1,15 @@
 {
   "name": "prettier-eslint",
   "version": "0.0.0-development",
-  "description": "Formats your JavaScript using prettier followed by eslint --fix",
+  "description":
+    "Formats your JavaScript using prettier followed by eslint --fix",
   "main": "dist/index.js",
   "scripts": {
     "start": "nps",
     "test": "nps test",
     "precommit": "opt --in pre-commit --exec \"npm start validate\""
   },
-  "files": [
-    "dist"
-  ],
+  "files": ["dist"],
   "keywords": [],
   "author": "Kent C. Dodds <kent@doddsfamily.us> (http://kentcdodds.com/)",
   "license": "MIT",

src/__mocks__/eslint.js

@@ -9,7 +9,7 @@ mockGetConfigForFileSpy.overrides = {}
 const mockExecuteOnTextSpy = jest.fn(mockExecuteOnText)
 
 module.exports = Object.assign(eslint, {
-  CLIEngine: MockCLIEngine,
+  CLIEngine: jest.fn(MockCLIEngine),
   mock: {
     getConfigForFile: mockGetConfigForFileSpy,
     executeOnText: mockExecuteOnTextSpy,
@@ -27,6 +27,7 @@ function MockCLIEngine(...args) {
 
 MockCLIEngine.prototype = Object.create(CLIEngine.prototype)
 
+// eslint-disable-next-line complexity
 function mockGetConfigForFile(filePath) {
   if (mockGetConfigForFileSpy.throwError) {
     throw mockGetConfigForFileSpy.throwError
@@ -42,11 +43,7 @@ function mockGetConfigForFile(filePath) {
         semi: [2, 'never'],
         'max-len': [2, 120, 2],
         indent: [2, 2, {SwitchCase: 1}],
-        quotes: [
-          2,
-          'single',
-          {avoidEscape: true, allowTemplateLiterals: true},
-        ],
+        quotes: [2, 'single', {avoidEscape: true, allowTemplateLiterals: true}],
         'comma-dangle': [
           2,
           {

src/__mocks__/prettier.js

@@ -5,7 +5,10 @@ module.exports = prettier
 
 const mockFormatSpy = jest.fn(mockFormat)
 
-Object.assign(prettier, {format: mockFormatSpy})
+Object.assign(prettier, {
+  format: mockFormatSpy,
+  resolveConfig: jest.fn(prettier.resolveConfig),
+})
 
 function mockFormat(...args) {
   global.__PRETTIER_ESLINT_TEST_STATE__.prettierPath = __filename

src/__tests__/index.js

@@ -176,6 +176,7 @@ beforeEach(() => {
   eslintMock.mock.executeOnText.mockClear()
   eslintMock.mock.getConfigForFile.mockClear()
   prettierMock.format.mockClear()
+  prettierMock.resolveConfig.mockClear()
   fsMock.readFileSync.mockClear()
   loglevelMock.mock.clearAll()
   global.__PRETTIER_ESLINT_TEST_STATE__ = {}
@@ -186,93 +187,89 @@ tests.forEach(({title, modifier, input, output}) => {
   if (modifier) {
     fn = test[modifier]
   }
-  fn(title, () => {
+  fn(title, async () => {
     input.text = stripIndent(input.text).trim()
     const expected = stripIndent(output).trim()
-    const actual = format(input)
+    const actual = await format(input)
     // adding the newline in the expected because
     // prettier adds a newline to the end of the input
     expect(actual).toBe(`${expected}\n`)
   })
 })
 
-test('failure to fix with eslint throws and logs an error', () => {
+test('failure to fix with eslint throws and logs an error', async () => {
   const {executeOnText} = eslintMock.mock
-  const error = 'Something happened'
-  executeOnText.throwError = new Error(error)
-  expect(() => format({text: ''})).toThrowError(error)
-  expect(logger.error).toHaveBeenCalledTimes(1)
+  const error = new Error('Something happened')
+  executeOnText.throwError = error
+  const errorThrown = await format({text: ''}).catch(e => e)
   executeOnText.throwError = null
+
+  expect(errorThrown).toBe(error)
+  expect(logger.error).toHaveBeenCalledTimes(1)
 })
 
-test('logLevel is used to configure the logger', () => {
+test('logLevel is used to configure the logger', async () => {
   logger.setLevel = jest.fn()
-  format({text: '', logLevel: 'silent'})
+  await format({text: '', logLevel: 'silent'})
   expect(logger.setLevel).toHaveBeenCalledTimes(1)
   expect(logger.setLevel).toHaveBeenCalledWith('silent')
 })
 
-test(`when prettier throws, log to logger.error and throw the error`, () => {
-  const {format: prettierMockFormat} = prettierMock
-  const error = 'something bad happened'
-  prettierMockFormat.throwError = new Error(error)
+test(`when prettier throws, log to logger.error and throw the error`, async () => {
+  const error = new Error('something bad happened')
+  prettierMock.format.throwError = error
+  const errorThrown = await format({text: ''}).catch(e => e)
+  prettierMock.format.throwError = null
 
-  expect(() => format({text: ''})).toThrowError(error)
+  expect(errorThrown).toBe(error)
   expect(logger.error).toHaveBeenCalledTimes(1)
-
-  prettierMockFormat.throwError = null
 })
 
-test('can accept a path to an eslint module and uses that instead.', () => {
+test('can accept a path to an eslint module and uses that instead.', async () => {
   const eslintPath = path.join(__dirname, '../__mocks__/eslint')
-  const {executeOnText} = eslintMock.mock
-  format({text: '', eslintPath})
-  expect(executeOnText).toHaveBeenCalledTimes(1)
+  await format({text: '', eslintPath})
+  expect(eslintMock.mock.executeOnText).toHaveBeenCalledTimes(1)
 })
 
-test('fails with an error if the eslint module cannot be resolved.', () => {
+test('fails with an error if the eslint module cannot be resolved.', async () => {
   const eslintPath = path.join(
     __dirname,
     '../__mocks__/non-existant-eslint-module',
   )
 
-  expect(() => format({text: '', eslintPath})).toThrowError(
-    /non-existant-eslint-module/,
-  )
+  const error = await format({text: '', eslintPath}).catch(e => e)
+
+  expect(error.message).toMatch(/non-existant-eslint-module/)
   expect(logger.error).toHaveBeenCalledTimes(1)
 
   const errorString = expect.stringMatching(
-    /ESLint.*?eslintPath.*non-existant-eslint-module/,
+    /trouble getting.*?eslint.*non-existant-eslint-module/,
   )
 
   expect(logger.error).toHaveBeenCalledWith(errorString)
 })
 
-test('can accept a path to a prettier module and uses that instead.', () => {
+test('can accept a path to a prettier module and uses that instead.', async () => {
   const prettierPath = path.join(__dirname, '../__mocks__/prettier')
-  const {format: prettierMockFormat} = prettierMock
-  format({text: '', prettierPath})
-  expect(prettierMockFormat).toHaveBeenCalledTimes(1)
+  await format({text: '', prettierPath})
+  expect(prettierMock.format).toHaveBeenCalledTimes(1)
 })
 
-test('fails with an error if the prettier module cannot be resolved.', () => {
+test('fails with an error if the prettier module cannot be resolved.', async () => {
   const prettierPath = path.join(
     __dirname,
     '../__mocks__/non-existant-prettier-module',
   )
-  expect(() => format({text: '', prettierPath})).toThrowError(
-    /non-existant-prettier-module/,
-  )
+  const error = await format({text: '', prettierPath}).catch(e => e)
+  expect(error.message).toMatch(/non-existant-prettier-module/)
   expect(logger.error).toHaveBeenCalledTimes(1)
-  const errorString = expect.stringMatching(
-    /prettier.*?prettierPath.*non-existant-prettier-module/,
-  )
+  const errorString = expect.stringMatching(/trouble getting.*prettier/)
   expect(logger.error).toHaveBeenCalledWith(errorString)
 })
 
-test('resolves to the eslint module relative to the given filePath', () => {
+test('resolves to the eslint module relative to the given filePath', async () => {
   const filePath = require.resolve('../../tests/fixtures/paths/foo.js')
-  format({text: '', filePath})
+  await format({text: '', filePath})
   const stateObj = {
     eslintPath: require.resolve(
       '../../tests/fixtures/paths/node_modules/eslint/index.js',
@@ -284,9 +281,9 @@ test('resolves to the eslint module relative to the given filePath', () => {
   expect(global.__PRETTIER_ESLINT_TEST_STATE__).toMatchObject(stateObj)
 })
 
-test('resolves to the local eslint module', () => {
+test('resolves to the local eslint module', async () => {
   const filePath = '/blah-blah/default-config'
-  format({text: '', filePath})
+  await format({text: '', filePath})
   expect(global.__PRETTIER_ESLINT_TEST_STATE__).toMatchObject({
     // without Jest's mocking, these would actually resolve to the
     // project modules :) The fact that jest's mocking is being
@@ -296,28 +293,47 @@ test('resolves to the local eslint module', () => {
   })
 })
 
-test('reads text from fs if filePath is provided but not text', () => {
+test('reads text from fs if filePath is provided but not text', async () => {
   const filePath = '/blah-blah/some-file.js'
-  try {
-    format({filePath})
-  } catch (e) {
-    // ignore
-  }
+  await format({filePath}).catch(() => {})
   // one hit to get the file and one for the eslintignore
   expect(fsMock.readFileSync).toHaveBeenCalledTimes(2)
   expect(fsMock.readFileSync).toHaveBeenCalledWith(filePath, 'utf8')
 })
 
-test('logs error if it cannot read the file from the filePath', () => {
+test('logs error if it cannot read the file from the filePath', async () => {
   const originalMock = fsMock.readFileSync
   fsMock.readFileSync = jest.fn(() => {
     throw new Error('some error')
   })
-  expect(() => format({filePath: '/some-path.js'})).toThrowError(/some error/)
+  const error = await format({filePath: '/some-path.js'}).catch(e => e)
+  expect(error.message).toMatch(/some error/)
   expect(logger.error).toHaveBeenCalledTimes(1)
   fsMock.readFileSync = originalMock
 })
 
+test('calls prettier.resolveConfig with the file path', async () => {
+  const filePath = require.resolve('../../tests/fixtures/paths/foo.js')
+  await format({
+    filePath,
+    text: defaultInputText(),
+    eslintConfig: getESLintConfigWithDefaultRules(),
+  })
+  expect(prettierMock.resolveConfig).toHaveBeenCalledTimes(1)
+  expect(prettierMock.resolveConfig).toHaveBeenCalledWith(filePath)
+})
+
+test('logs if there is a problem making the CLIEngine', async () => {
+  const error = new Error('fake error')
+  eslintMock.CLIEngine.mockImplementation(() => {
+    throw error
+  })
+  const errorThrown = await format({text: ''}).catch(e => e)
+  eslintMock.CLIEngine.mockReset()
+  expect(errorThrown).toBe(error)
+  expect(logger.error).toHaveBeenCalledTimes(1)
+})
+
 function getESLintConfigWithDefaultRules(overrides) {
   return {
     parserOptions: {ecmaVersion: 7},