diff --git a/.all-contributorsrc b/.all-contributorsrc
index d44891f8..ee2f3c84 100644
--- a/.all-contributorsrc
+++ b/.all-contributorsrc
@@ -301,6 +301,15 @@
       "contributions": [
         "maintenance"
       ]
+    },
+    {
+      "login": "idahogurl",
+      "name": "Rebecca Vest",
+      "avatar_url": "https://avatars.githubusercontent.com/u/10620169?v=4",
+      "profile": "https://campcode.dev/",
+      "contributions": [
+        "code"
+      ]
     }
   ],
   "repoType": "github",
diff --git a/.eslintrc.js b/.eslintrc.js
index 6f6c05b7..9c6d945d 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -1,16 +1,17 @@
 const config = {
-  extends: ["kentcdodds", "kentcdodds/jest"],
+  extends: ['kentcdodds', 'kentcdodds/jest'],
   rules: {
-    "valid-jsdoc": "off",
-    "max-len": "off",
-    "space-before-function-paren": [
-      "error",
+    'valid-jsdoc': 'off',
+    'max-len': 'off',
+    'space-before-function-paren': [
+      'error',
       {
-        anonymous: "never",
-        named: "never",
-        asyncArrow: "always"
+        anonymous: 'never',
+        named: 'never',
+        asyncArrow: 'always'
       }
-    ]
+    ],
+    'import/no-import-module-exports': 'off'
   }
 };
 
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 8cc8a935..929c5212 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,6 +1,6 @@
 name: CI
 
-on: [push]
+on: [push, pull_request]
 
 jobs:
   ci:
diff --git a/.prettierrc.js b/.prettierrc.js
new file mode 100644
index 00000000..e4d181d9
--- /dev/null
+++ b/.prettierrc.js
@@ -0,0 +1,4 @@
+module.exports = {
+  arrowParens: 'avoid',
+  singleQuote: true
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index 87e0135e..f6533150 100644
--- a/README.md
+++ b/README.md
@@ -72,7 +72,7 @@ const options = {
   },
 };
 
-const formatted = format(options);
+const formatted = await format(options);
 
 // notice no semicolon in the formatted text
 formatted; // const { foo } = bar
@@ -304,6 +304,7 @@ Thanks goes to these people ([emoji key][emojis]):
   </tr>
   <tr>
     <td align="center"><a href="https://github.com/cy6erskunk"><img src="https://avatars3.githubusercontent.com/u/754849?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Igor</b></sub></a><br /><a href="#maintenance-cy6erskunk" title="Maintenance">🚧</a></td>
+    <td align="center"><a href="https://campcode.dev/"><img src="https://avatars.githubusercontent.com/u/10620169?v=4?s=100" width="100px;" alt=""/><br /><sub><b>Rebecca Vest</b></sub></a><br /><a href="https://github.com/prettier/prettier-eslint/commits?author=idahogurl" title="Code">💻</a></td>
   </tr>
 </table>
 
diff --git a/package.json b/package.json
index 86f3d826..acbb0822 100644
--- a/package.json
+++ b/package.json
@@ -18,18 +18,18 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@typescript-eslint/parser": "^3.0.0",
+    "@typescript-eslint/parser": "^5.10.0",
     "common-tags": "^1.4.0",
     "dlv": "^1.1.0",
-    "eslint": "^7.9.0",
+    "eslint": "^8.7.0",
     "indent-string": "^4.0.0",
     "lodash.merge": "^4.6.0",
     "loglevel-colored-level-prefix": "^1.0.0",
-    "prettier": "^2.0.0",
+    "prettier": "^2.5.1",
     "pretty-format": "^23.0.1",
     "require-relative": "^0.8.7",
-    "typescript": "^3.9.3",
-    "vue-eslint-parser": "~7.1.0"
+    "typescript": "^4.5.4",
+    "vue-eslint-parser": "^8.0.1"
   },
   "devDependencies": {
     "@babel/cli": "^7.4.4",
@@ -40,7 +40,7 @@
     "all-contributors-cli": "^6.7.0",
     "babel-jest": "^25.0.0",
     "chalk": "^2.1.0",
-    "eslint-config-kentcdodds": "~16.0.1",
+    "eslint-config-kentcdodds": "^20.0.1",
     "husky": "^2.4.1",
     "jest": "^25.0.0",
     "jest-cli": "^25.0.0",
diff --git a/src/__mocks__/eslint.js b/src/__mocks__/eslint.js
index 10369ec7..dced55a5 100644
--- a/src/__mocks__/eslint.js
+++ b/src/__mocks__/eslint.js
@@ -2,35 +2,35 @@
 // search around the file system for stuff
 
 const eslint = jest.requireActual('eslint');
-const { CLIEngine } = eslint;
+const { ESLint } = eslint;
 
-const mockGetConfigForFileSpy = jest.fn(mockGetConfigForFile);
-mockGetConfigForFileSpy.overrides = {};
-const mockExecuteOnTextSpy = jest.fn(mockExecuteOnText);
+const mockCalculateConfigForFileSpy = jest.fn(mockCalculateConfigForFile);
+mockCalculateConfigForFileSpy.overrides = {};
+const mockLintTextSpy = jest.fn(mockLintText);
 
 module.exports = Object.assign(eslint, {
-  CLIEngine: jest.fn(MockCLIEngine),
+  ESLint: jest.fn(MockESLint),
   mock: {
-    getConfigForFile: mockGetConfigForFileSpy,
-    executeOnText: mockExecuteOnTextSpy
+    calculateConfigForFile: mockCalculateConfigForFileSpy,
+    lintText: mockLintTextSpy
   }
 });
 
-function MockCLIEngine(...args) {
+function MockESLint(...args) {
   global.__PRETTIER_ESLINT_TEST_STATE__.eslintPath = __filename;
-  const cliEngine = new CLIEngine(...args);
-  cliEngine.getConfigForFile = mockGetConfigForFileSpy;
-  cliEngine._originalExecuteOnText = cliEngine.executeOnText;
-  cliEngine.executeOnText = mockExecuteOnTextSpy;
-  return cliEngine;
+  const eslintInstance = new ESLint(...args);
+  eslintInstance.calculateConfigForFile = mockCalculateConfigForFileSpy;
+  eslintInstance._originalLintText = eslintInstance.lintText;
+  eslintInstance.lintText = mockLintTextSpy;
+  return eslintInstance;
 }
 
-MockCLIEngine.prototype = Object.create(CLIEngine.prototype);
+MockESLint.prototype = Object.create(ESLint.prototype);
 
 // eslint-disable-next-line complexity
-function mockGetConfigForFile(filePath) {
-  if (mockGetConfigForFileSpy.throwError) {
-    throw mockGetConfigForFileSpy.throwError;
+function mockCalculateConfigForFile(filePath) {
+  if (mockCalculateConfigForFileSpy.throwError) {
+    throw mockCalculateConfigForFileSpy.throwError;
   }
   if (!filePath) {
     return {
@@ -71,10 +71,10 @@ function mockGetConfigForFile(filePath) {
   }
 }
 
-function mockExecuteOnText(...args) {
-  /* eslint babel/no-invalid-this:0 */
-  if (mockExecuteOnTextSpy.throwError) {
-    throw mockExecuteOnTextSpy.throwError;
+function mockLintText(...args) {
+  /* eslint no-invalid-this:0 */
+  if (mockLintTextSpy.throwError) {
+    throw mockLintTextSpy.throwError;
   }
-  return this._originalExecuteOnText(...args);
+  return this._originalLintText(...args);
 }
diff --git a/src/__tests__/index.js b/src/__tests__/index.js
index 1098bb25..3ef58b07 100644
--- a/src/__tests__/index.js
+++ b/src/__tests__/index.js
@@ -63,7 +63,6 @@ const tests = [
     input: {
       text: 'const { foo } = bar;',
       eslintConfig: {
-        foo: true,
         // Won't be overridden
         parserOptions: {
           ecmaVersion: 7
@@ -140,6 +139,14 @@ const tests = [
     },
     output: 'var [foo, { bar }] = window.APP;'
   },
+  {
+    title: 'accepts config globals as array',
+    input: {
+      text: defaultInputText(),
+      eslintConfig: { globals: ['window:writable'] }
+    },
+    output: noopOutput()
+  },
   {
     title: 'CSS example',
     input: {
@@ -180,8 +187,7 @@ const tests = [
           'space-before-function-paren': [2, 'always']
         }
       },
-      text:
-        '<template>\n  <div></div>\n</template>\n<script>\nfunction foo() { return "foo" }\n</script>\n<style>\n</style>',
+      text: '<template>\n  <div></div>\n</template>\n<script>\nfunction foo() { return "foo" }\n</script>\n<style>\n</style>',
       filePath: path.resolve('./test.vue')
     },
     output:
@@ -226,8 +232,8 @@ const tests = [
 ];
 
 beforeEach(() => {
-  eslintMock.mock.executeOnText.mockClear();
-  eslintMock.mock.getConfigForFile.mockClear();
+  eslintMock.mock.lintText.mockClear();
+  eslintMock.mock.calculateConfigForFile.mockClear();
   prettierMock.format.mockClear();
   prettierMock.resolveConfig.sync.mockClear();
   fsMock.readFileSync.mockClear();
@@ -240,55 +246,55 @@ 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', () => {
-  const { executeOnText } = eslintMock.mock;
+test('failure to fix with eslint throws and logs an error', async () => {
+  const { lintText } = eslintMock.mock;
   const error = new Error('Something happened');
-  executeOnText.throwError = error;
+  lintText.throwError = error;
 
-  expect(() => format({ text: '' })).toThrowError(error);
+  await expect(() => format({ text: '' })).rejects.toThrowError(error);
   expect(logger.error).toHaveBeenCalledTimes(1);
-  executeOnText.throwError = null;
+  lintText.throwError = null;
 });
 
-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`, () => {
+test('when prettier throws, log to logger.error and throw the error', async () => {
   const error = new Error('something bad happened');
   prettierMock.format.throwError = error;
 
-  expect(() => format({ text: '' })).toThrowError(error);
+  await expect(() => format({ text: '' })).rejects.toThrowError(error);
   expect(logger.error).toHaveBeenCalledTimes(1);
   prettierMock.format.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');
-  format({ text: '', eslintPath });
-  expect(eslintMock.mock.executeOnText).toHaveBeenCalledTimes(1);
+  await format({ text: '', eslintPath });
+  expect(eslintMock.mock.lintText).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-existent-eslint-module'
   );
 
-  expect(() => format({ text: '', eslintPath })).toThrowError(
+  await expect(() => format({ text: '', eslintPath })).rejects.toThrowError(
     /non-existent-eslint-module/
   );
   expect(logger.error).toHaveBeenCalledTimes(1);
@@ -300,19 +306,20 @@ test('fails with an error if the eslint module cannot be resolved.', () => {
   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');
-  format({ text: '', prettierPath });
+  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-existent-prettier-module'
   );
 
-  expect(() => format({ text: '', prettierPath })).toThrowError(
+  await expect(() => format({ text: '', prettierPath })).rejects.toThrowError(
     /non-existent-prettier-module/
   );
   expect(logger.error).toHaveBeenCalledTimes(1);
@@ -322,9 +329,9 @@ test('fails with an error if the prettier module cannot be resolved.', () => {
   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'
@@ -336,9 +343,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.js';
-  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
@@ -348,31 +355,30 @@ 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 readFileSyncMockSpy = jest.spyOn(fsMock, 'readFileSync');
 
   const filePath = '/blah-blah/some-file.js';
-  format({ filePath });
-  
-  expect(readFileSyncMockSpy).toHaveBeenCalledWith(filePath, 'utf8');
+  await format({ filePath });
 
+  expect(readFileSyncMockSpy).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/
-  );
+  await expect(() =>
+    format({ filePath: '/some-path.js' })
+  ).rejects.toThrowError(/some error/);
   expect(logger.error).toHaveBeenCalledTimes(1);
   fsMock.readFileSync = originalMock;
 });
 
-test('calls prettier.resolveConfig.sync with the file path', () => {
+test('calls prettier.resolveConfig.sync with the file path', async () => {
   const filePath = require.resolve('../../tests/fixtures/paths/foo.js');
-  format({
+  await format({
     filePath,
     text: defaultInputText(),
     eslintConfig: getESLintConfigWithDefaultRules()
@@ -399,12 +405,12 @@ test('does not raise an error if prettier.resolveConfig.sync is not defined', ()
   prettierMock.resolveConfig.sync = originalPrettierMockResolveConfigSync;
 });
 
-test('does not raise an error if prettier.resolveConfig is not defined', () => {
+test('does not raise an error if prettier.resolveConfig is not defined', async () => {
   const filePath = require.resolve('../../tests/fixtures/paths/foo.js');
   const originalPrettierMockResolveConfig = prettierMock.resolveConfig;
   prettierMock.resolveConfig = undefined;
 
-  function callingFormat() {
+  async function callingFormat() {
     return format({
       filePath,
       text: defaultInputText(),
@@ -412,18 +418,18 @@ test('does not raise an error if prettier.resolveConfig is not defined', () => {
     });
   }
 
-  expect(callingFormat).not.toThrowError();
+  await expect(callingFormat).not.toThrowError();
 
   prettierMock.resolveConfig = originalPrettierMockResolveConfig;
 });
 
-test('logs if there is a problem making the CLIEngine', () => {
+test('logs if there is a problem making the CLIEngine', async () => {
   const error = new Error('fake error');
-  eslintMock.CLIEngine.mockImplementation(() => {
+  eslintMock.ESLint.mockImplementation(() => {
     throw error;
   });
-  expect(() => format({ text: '' })).toThrowError(error);
-  eslintMock.CLIEngine.mockReset();
+  await expect(() => format({ text: '' })).rejects.toThrowError(error);
+  eslintMock.ESLint.mockReset();
   expect(logger.error).toHaveBeenCalledTimes(1);
 });
 
diff --git a/src/__tests__/utils.js b/src/__tests__/utils.js
index 0a84398a..458bc0e1 100644
--- a/src/__tests__/utils.js
+++ b/src/__tests__/utils.js
@@ -211,7 +211,7 @@ test('if prettierOptions are provided, those are preferred', () => {
 });
 
 // eslint-disable-next-line max-len
-test(`if fallbacks are provided, those are preferred over disabled eslint rules`, () => {
+test('if fallbacks are provided, those are preferred over disabled eslint rules', () => {
   const { prettier } = getOptionsForFormatting(
     {
       rules: {
@@ -309,7 +309,7 @@ test('Turn off unfixable rules', () => {
       quotes: ['error', 'double']
     },
     fix: true,
-    globals: [],
+    globals: {},
     useEslintrc: false
   });
 });
diff --git a/src/index.js b/src/index.js
index 60d53eb3..e730b0ee 100644
--- a/src/index.js
+++ b/src/index.js
@@ -9,11 +9,7 @@ import { oneLine, stripIndent } from 'common-tags';
 import indentString from 'indent-string';
 import getLogger from 'loglevel-colored-level-prefix';
 import merge from 'lodash.merge';
-import {
-  getESLintCLIEngine,
-  getOptionsForFormatting,
-  requireModule
-} from './utils';
+import { getESLint, getOptionsForFormatting, requireModule } from './utils';
 
 const logger = getLogger({ prefix: 'prettier-eslint' });
 
@@ -44,7 +40,7 @@ module.exports = format;
  * @param {Boolean} options.prettierLast - Run Prettier Last
  * @return {String} - the formatted string
  */
-function format(options) {
+async function format(options) {
   const { logLevel = getDefaultLogLevel() } = options;
   logger.setLevel(logLevel);
   logger.trace('called format with options:', prettyFormat(options));
@@ -64,12 +60,6 @@ function format(options) {
     getESLintConfig(filePath, eslintPath)
   );
 
-  if (typeof eslintConfig.globals === 'object') {
-    eslintConfig.globals = Object.entries(eslintConfig.globals).map(
-      ([key, value]) => `${key}:${value}`
-    );
-  }
-
   const prettierOptions = merge(
     {},
     filePath && { filepath: filePath },
@@ -131,10 +121,11 @@ function format(options) {
       formattingOptions.eslint.parser || require.resolve('vue-eslint-parser');
   }
 
-  const eslintFix = createEslintFix(formattingOptions.eslint, eslintPath);
+  const eslintFix = await createEslintFix(formattingOptions.eslint, eslintPath);
 
   if (prettierLast) {
-    return prettify(eslintFix(text, filePath));
+    const eslintFixed = await eslintFix(text, filePath);
+    return prettify(eslintFixed);
   }
   return eslintFix(prettify(text), filePath);
 }
@@ -151,7 +142,7 @@ function createPrettify(formatOptions, prettierPath) {
     );
     const prettier = requireModule(prettierPath, 'prettier');
     try {
-      logger.trace(`calling prettier.format with the text and prettierOptions`);
+      logger.trace('calling prettier.format with the text and prettierOptions');
       const output = prettier.format(text, formatOptions);
       logger.trace('prettier: output === input', output === text);
       logger.trace(
@@ -170,18 +161,45 @@ function createPrettify(formatOptions, prettierPath) {
 }
 
 function createEslintFix(eslintConfig, eslintPath) {
-  return function eslintFix(text, filePath) {
-    const cliEngine = getESLintCLIEngine(eslintPath, eslintConfig);
+  return async function eslintFix(text, filePath) {
+    if (Array.isArray(eslintConfig.globals)) {
+      const tempGlobals = {};
+      eslintConfig.globals.forEach(g => {
+        const [key, value] = g.split(':');
+        tempGlobals[key] = value;
+      });
+      eslintConfig.globals = tempGlobals;
+    }
+
+    eslintConfig.overrideConfig = {
+      rules: eslintConfig.rules,
+      parser: eslintConfig.parser,
+      globals: eslintConfig.globals,
+      parserOptions: eslintConfig.parserOptions,
+      ignorePatterns: eslintConfig.ignorePattern,
+      ...eslintConfig.overrideConfig
+    };
+
+    delete eslintConfig.rules;
+    delete eslintConfig.parser;
+    delete eslintConfig.parserOptions;
+    delete eslintConfig.globals;
+    delete eslintConfig.ignorePattern;
+
+    const eslint = getESLint(eslintPath, eslintConfig);
     try {
-      logger.trace(`calling cliEngine.executeOnText with the text`);
-      const report = cliEngine.executeOnText(text, filePath, true);
+      logger.trace('calling cliEngine.executeOnText with the text');
+      const report = await eslint.lintText(text, {
+        filePath,
+        warnIgnored: true
+      });
       logger.trace(
-        `executeOnText returned the following report:`,
+        'executeOnText returned the following report:',
         prettyFormat(report)
       );
       // default the output to text because if there's nothing
       // to fix, eslint doesn't provide `output`
-      const [{ output = text }] = report.results;
+      const [{ output = text }] = await report;
       logger.trace('eslint --fix: output === input', output === text);
       // NOTE: We're ignoring linting errors/warnings here and
       // defaulting to the given text if there are any
@@ -233,10 +251,10 @@ function getESLintConfig(filePath, eslintPath) {
       "${filePath || process.cwd()}"
     `
   );
-  const cliEngine = getESLintCLIEngine(eslintPath, eslintOptions);
+  const eslint = getESLint(eslintPath, eslintOptions);
   try {
     logger.debug(`getting eslint config for file at "${filePath}"`);
-    const config = cliEngine.getConfigForFile(filePath);
+    const config = eslint.calculateConfigForFile(filePath);
     logger.trace(
       `eslint config for "${filePath}" received`,
       prettyFormat(config)
diff --git a/src/utils.js b/src/utils.js
index acfa3d51..3ebd1ce5 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -2,6 +2,7 @@
 import { oneLine } from 'common-tags';
 import delve from 'dlv';
 import getLogger from 'loglevel-colored-level-prefix';
+import { Linter } from 'eslint';
 
 const logger = getLogger({ prefix: 'prettier-eslint' });
 const RULE_DISABLED = {};
@@ -57,15 +58,14 @@ const OPTION_GETTERS = {
 };
 
 /* eslint import/prefer-default-export:0 */
-export { getESLintCLIEngine, getOptionsForFormatting, requireModule };
+export { getESLint, getOptionsForFormatting, requireModule };
 
 function getOptionsForFormatting(
   eslintConfig,
   prettierOptions = {},
-  fallbackPrettierOptions = {},
-  eslintPath
+  fallbackPrettierOptions = {}
 ) {
-  const eslint = getRelevantESLintConfig(eslintConfig, eslintPath);
+  const eslint = getRelevantESLintConfig(eslintConfig);
   const prettier = getPrettierOptionsFromESLintRules(
     eslintConfig,
     prettierOptions,
@@ -74,37 +74,24 @@ function getOptionsForFormatting(
   return { eslint, prettier };
 }
 
-function getRelevantESLintConfig(eslintConfig, eslintPath) {
-  const cliEngine = getESLintCLIEngine(eslintPath);
-  // TODO: Actually test this branch
-  // istanbul ignore next
-  const loadedRules =
-    (cliEngine.getRules && cliEngine.getRules()) ||
-    // XXX: Fallback list of unfixable rules, when using and old version of eslint
-    new Map([['global-require', { meta: {} }], ['no-with', { meta: {} }]]);
-
-  const { rules } = eslintConfig;
-
+function getRelevantESLintConfig(eslintConfig) {
+  const linter = new Linter();
+  const rules = linter.getRules();
   logger.debug('turning off unfixable rules');
 
-  const relevantRules = Object.entries(rules).reduce(
-    (rulesAccumulator, [name, rule]) => {
-      if (loadedRules.has(name)) {
-        const {
-          meta: { fixable }
-        } = loadedRules.get(name);
-
-        if (!fixable) {
-          logger.trace('turing off rule:', JSON.stringify({ [name]: rule }));
-          rule = ['off'];
-        }
-      }
+  const relevantRules = {};
 
-      rulesAccumulator[name] = rule;
-      return rulesAccumulator;
-    },
-    {}
-  );
+  rules.forEach((rule, name) => {
+    const {
+      meta: { fixable }
+    } = rule;
+
+    if (!fixable) {
+      logger.trace('turning off rule:', JSON.stringify({ [name]: rule }));
+      rule = ['off'];
+      relevantRules[name] = rule;
+    }
+  }, {});
 
   return {
     // defaults
@@ -114,9 +101,9 @@ function getRelevantESLintConfig(eslintConfig, eslintPath) {
     },
     ...eslintConfig,
     // overrides
-    rules: relevantRules,
+    rules: { ...eslintConfig.rules, ...relevantRules },
     fix: true,
-    globals: []
+    globals: eslintConfig.globals || {}
   };
 }
 
@@ -417,12 +404,12 @@ function requireModule(modulePath, name) {
   }
 }
 
-function getESLintCLIEngine(eslintPath, eslintOptions) {
-  const { CLIEngine } = requireModule(eslintPath, 'eslint');
+function getESLint(eslintPath, eslintOptions) {
+  const { ESLint } = requireModule(eslintPath, 'eslint');
   try {
-    return new CLIEngine(eslintOptions);
+    return new ESLint(eslintOptions);
   } catch (error) {
-    logger.error(`There was trouble creating the ESLint CLIEngine.`);
+    logger.error('There was trouble creating the ESLint CLIEngine.');
     throw error;
   }
 }
diff --git a/tests/fixtures/paths/node_modules/eslint/index.js b/tests/fixtures/paths/node_modules/eslint/index.js
index 1544d74e..592f4f48 100644
--- a/tests/fixtures/paths/node_modules/eslint/index.js
+++ b/tests/fixtures/paths/node_modules/eslint/index.js
@@ -1,11 +1,11 @@
 const eslintMock = require('../../../../../src/__mocks__/eslint')
 module.exports = Object.assign({}, eslintMock, {
-  CLIEngine: MockMockCLIEngine
+  ESLint: MockMockESLint
 })
 
-function MockMockCLIEngine(...args) {
+function MockMockESLint(...args) {
   try {
-    return eslintMock.CLIEngine.apply(this, args)
+    return eslintMock.ESLint.apply(this, args)
   } finally {
     global.__PRETTIER_ESLINT_TEST_STATE__.eslintPath = __filename
   }