prettier 2.1.0 → 3.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 34ffeeada2b06900ec6759f31a42ca387c8748a6a22843a1792fd906bfb4ffda
-  data.tar.gz: ddbceb38e8263f881fd12f66560615db880cf7870f0cb926671c2da656aad6f8
+  metadata.gz: 967c98f2226d3ae025e0fe136f8cddd80115480baaa375a4906a8b7729cf5549
+  data.tar.gz: 31c55db39cdeb5e423ddd89d5000217d7dd226ada3a854e6a36b5ddf0274b807
 SHA512:
-  metadata.gz: 300acaf432b28f15d5b7690effbe7ca8fff778af699c5f79d0872c15f3241ec9be2e8fd83f86a9e65e6807cd152504b78d79760b30926c418bc7358d5d9f7524
-  data.tar.gz: a7d658200446e7dde838d07b502303fa30e168e800f3053e48e6cf05940fbb92892d0eaca9c48304a48b13d6c94dce09019bb7a2c18acc18c48b3c241d4d4637
+  metadata.gz: 4411eeaefa1cc33f118a6f4660801cd1da8341f1954e8993a9b5e20f5c3a148b220899bde756fa359080f393b567d5312cb0774571b9ec859af0d1cba1a9e2da
+  data.tar.gz: fda90238c9d58046c394ba09b11671ba0d617efff319a21077638ac86ed18f2cd2bfbf81192e92f0b0c62fd48987290276ca114202fcd5e00136512622d6ffe3

data/CHANGELOG.md

@@ -6,6 +6,35 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [3.1.1] - 2022-05-12
+
+### Changed
+
+- [#1125](https://github.com/prettier/plugin-ruby/pull/1225) - kddnewton - Update the bundled rubocop config to be in sync with Syntax Tree.
+
+## [3.1.0] - 2022-05-12
+
+### Added
+
+- [#1224](https://github.com/prettier/plugin-ruby/pull/1224) - kddnewton - Support passing the `rubyPlugins` option to configure Syntax Tree.
+
+## [3.0.0] - 2022-05-04
+
+### Added
+
+- [#1190](https://github.com/prettier/plugin-ruby/pull/1190) - kddnewton - Encoding for source files is now guessed in a much better way.
+
+### Changed
+
+- [#1198](https://github.com/prettier/plugin-ruby/issues/1198) - pas-f, kddnewton - Fix crashes on JRuby with do blocks.
+- [#1131](https://github.com/prettier/plugin-ruby/issues/1131) - hyrious, kddnewton - Ensure zombie processes are not left around when the server exits.
+- [#1206](https://github.com/prettier/plugin-ruby/pull/1206) - kddnewton - Switch back to plain JavaScript for development.
+- [#1190](https://github.com/prettier/plugin-ruby/pull/1190) - kddnewton - Switch over to using Syntax Tree for the backend.
+
+### Removed
+
+- [#1190](https://github.com/prettier/plugin-ruby/pull/1190) - kddnewton - The configuration options have been removed. Instead, configuration is to be done through modifying Syntax Tree.
+
 ## [2.1.0] - 2022-04-04
 
 ### Added
@@ -316,7 +345,6 @@ The comment in the above example should stay in place.
 
 ```ruby
 begin
-
 rescue Foo, Bar
   # comment
 end
@@ -472,7 +500,8 @@ return (a or b) if c?
 - kddnewton - Support for the `nokw_param` node for specifying when methods should no accept keywords, as in:
 
 ```ruby
-def foo(**nil); end
+def foo(**nil)
+end
 ```
 
 - kddnewton - Support for the `args_forward` node for forwarding all types of arguments, as in:
@@ -518,9 +547,9 @@ will now be printed as:
 
 ```ruby
 Config::Download.new(
-  'prettier',
-  filename: 'prettier.yml',
-  url: 'https://raw.githubusercontent.com/...'
+  "prettier",
+  filename: "prettier.yml",
+  url: "https://raw.githubusercontent.com/..."
 ).perform
 ```
 
@@ -1208,7 +1237,8 @@ would previously result in `array[]`, but now prints properly.
 
 - Initial release 🎉
 
-[unreleased]: https://github.com/prettier/plugin-ruby/compare/v2.1.0...HEAD
+[unreleased]: https://github.com/prettier/plugin-ruby/compare/v3.0.0...HEAD
+[3.0.0]: https://github.com/prettier/plugin-ruby/compare/v2.1.0...v3.0.0
 [2.1.0]: https://github.com/prettier/plugin-ruby/compare/v2.0.0...v2.1.0
 [2.0.0]: https://github.com/prettier/plugin-ruby/compare/v2.0.0-rc4...v2.0.0
 [2.0.0-rc4]: https://github.com/prettier/plugin-ruby/compare/v2.0.0-rc3...v2.0.0-rc4

data/README.md

@@ -59,9 +59,9 @@ d = [
   30_643_069_058
 ]
 a, s = [], $*[0]
-s.each_byte { |b| a << ('%036b' % d[b.chr.to_i]).scan(/\d{6}/) }
+s.each_byte { |b| a << ("%036b" % d[b.chr.to_i]).scan(/\d{6}/) }
 a.transpose.each do |a|
-  a.join.each_byte { |i| print i == 49 ? ($*[1] || '#') : 32.chr }
+  a.join.each_byte { |i| print i == 49 ? ($*[1] || "#") : 32.chr }
   puts
 end
 ```
@@ -83,7 +83,7 @@ This plugin currently supports formatting the following kinds of files:
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'prettier'
+gem "prettier"
 ```
 
 And then execute:
@@ -118,6 +118,12 @@ Or if you're using `yarn`, then add the plugin by:
 yarn add --dev prettier @prettier/plugin-ruby
 ```
 
+You'll also need to add the necessary Ruby dependencies. You can do this by running:
+
+```bash
+gem install bundler syntax_tree syntax_tree-haml syntax_tree-rbs
+```
+
 The `prettier` executable is now installed and ready for use:
 
 ```bash
@@ -128,31 +134,26 @@ The `prettier` executable is now installed and ready for use:
 
 Below are the options (from [`src/plugin.js`](src/plugin.js)) that `@prettier/plugin-ruby` currently supports:
 
-| API Option         | CLI Option             | Default  | Description                                                                                                                          |
-| ------------------ | ---------------------- | :------: | ------------------------------------------------------------------------------------------------------------------------------------ |
-| `printWidth`       | `--print-width`        |   `80`   | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#print-width)).                                     |
-| `requirePragma`    | `--require-pragma`     | `false`  | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#require-pragma)).                                  |
-| `rubyArrayLiteral` | `--ruby-array-literal` |  `true`  | When possible, favor the use of string and symbol array literals.                                                                    |
-| `rubyHashLabel`    | `--ruby-hash-label`    |  `true`  | When possible, uses the shortened hash key syntax, as opposed to hash rockets.                                                       |
-| `rubyModifier`     | `--ruby-modifier`      |  `true`  | When it fits on one line, allows while and until statements to use the modifier form.                                                |
-| `rubySingleQuote`  | `--ruby-single-quote`  |  `true`  | When double quotes are not necessary for interpolation, prefers the use of single quotes for string literals.                        |
-| `rubyToProc`       | `--ruby-to-proc`       | `false`  | When possible, convert blocks to the more concise `Symbol#to_proc` syntax.                                                           |
-| `tabWidth`         | `--tab-width`          |   `2`    | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#tab-width)).                                       |
-| `trailingComma`    | `--trailing-comma`     | `"none"` | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#trailing-comma)). `"es5"` is equivalent to `true`. |
+| API Option      | CLI Option         | Default | Description                                                                                                                 |
+| --------------- | ------------------ | :-----: | --------------------------------------------------------------------------------------------------------------------------- |
+| `printWidth`    | `--print-width`    |  `80`   | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#print-width)).                            |
+| `requirePragma` | `--require-pragma` | `false` | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#require-pragma)).                         |
+| `rubyPlugins`   | `--ruby-plugins`   |  `""`   | The comma-separated list of plugins to require. See [Syntax Tree](https://github.com/ruby-syntax-tree/syntax_tree#plugins). |
+| `tabWidth`      | `--tab-width`      |   `2`   | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#tab-width)).                              |
 
 Any of these can be added to your existing [prettier configuration
 file](https://prettier.io/docs/en/configuration.html). For example:
 
 ```json
 {
-  "rubySingleQuote": false
+  "tabWidth": 4
 }
 ```
 
 Or, they can be passed to `prettier` as arguments:
 
 ```bash
-bundle exec rbprettier --ruby-single-quote false --write '**/*'
+bundle exec rbprettier --tab-width 4 --write '**/*'
 ```
 
 ### Usage with RuboCop

data/exe/rbprettier

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-$:.unshift(File.expand_path(File.join('..', 'lib'), __dir__))
-require 'prettier'
+$:.unshift(File.expand_path(File.join("..", "lib"), __dir__))
+require "prettier"
 
 exit(Prettier.run(ARGV))

data/lib/prettier/rake/task.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'rake'
-require 'rake/tasklib'
+require "rake"
+require "rake/tasklib"
 
 module Prettier
   module Rake
@@ -35,7 +35,7 @@ module Prettier
       def initialize(name = :prettier)
         @name = name
         @write = true
-        @source_files = 'lib/**/*.rb'
+        @source_files = "lib/**/*.rb"
 
         yield self if block_given?
         define_task
@@ -44,12 +44,12 @@ module Prettier
       private
 
       def define_task
-        desc 'Runs prettier over source files'
+        desc "Runs prettier over source files"
         task(name) { run_task }
       end
 
       def run_task
-        Prettier.run([('--write' if write), source_files].compact)
+        Prettier.run([("--write" if write), source_files].compact)
         exit($?.exitstatus) if $?&.exited?
       end
     end

data/lib/prettier.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
-require 'json' unless defined?(JSON)
-require 'open3'
+require "json" unless defined?(JSON)
+require "open3"
 
 module Prettier
-  PLUGIN = -File.expand_path('..', __dir__)
-  BINARY = -File.join(PLUGIN, 'node_modules', 'prettier', 'bin-prettier.js')
-  VERSION = -JSON.parse(File.read(File.join(PLUGIN, 'package.json')))['version']
+  PLUGIN = -File.expand_path("..", __dir__)
+  BINARY = -File.join(PLUGIN, "node_modules", "prettier", "bin-prettier.js")
+  VERSION = -JSON.parse(File.read(File.join(PLUGIN, "package.json")))["version"]
 
   def self.run(args)
-    quoted = args.map { |arg| arg.start_with?('-') ? arg : "\"#{arg}\"" }
-    command = "node #{BINARY} --plugin \"#{PLUGIN}\" #{quoted.join(' ')}"
+    quoted = args.map { |arg| arg.start_with?("-") ? arg : "\"#{arg}\"" }
+    command = "node #{BINARY} --plugin \"#{PLUGIN}\" #{quoted.join(" ")}"
 
     stdout, stderr, status =
-      Open3.capture3({ 'RBPRETTIER' => '1' }, command, stdin_data: STDIN)
+      Open3.capture3({ "RBPRETTIER" => "1" }, command, stdin_data: STDIN)
     STDOUT.puts(stdout)
 
     # If we completed successfully, then just exit out.
@@ -30,11 +30,11 @@ module Prettier
         If you installed this dependency through git instead of from rubygems,
         it does not install the necessary files by default. To fix this you can
         either install them yourself by cd-ing into the directory where this gem
-        is located (#{File.expand_path('..', __dir__)}) and running:
+        is located (#{File.expand_path("..", __dir__)}) and running:
           
-          `yarn && yarn prepublishOnly`
+          `yarn install`
            or
-           `npm install && npm run prepublishOnly`
+           `npm install`
            or
            you can change the source in your Gemfile to point directly to rubygems.
       MSG

data/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "2.1.0",
+  "version": "3.1.1",
   "description": "prettier plugin for the Ruby programming language",
-  "main": "dist/plugin.js",
+  "main": "src/plugin.js",
   "scripts": {
     "checkFormat": "prettier --check '**/*'",
     "lint": "eslint --cache .",
-    "prepublishOnly": "tsc -p tsconfig.build.json && cp src/parser/getInfo.js dist/parser && cp src/parser/netcat.js dist/parser && cp src/parser/server.rb dist/parser && cp src/haml/parser.rb dist/haml && cp src/rbs/parser.rb dist/rbs && cp src/ruby/parser.rb dist/ruby",
     "test": "jest"
   },
   "repository": {
@@ -23,24 +22,15 @@
     "prettier": ">=2.3.0"
   },
   "devDependencies": {
-    "@types/jest": "^27.0.1",
-    "@types/node": "^17.0.0",
-    "@types/prettier": "^2.4.2",
-    "@typescript-eslint/eslint-plugin": "^5.18.0",
-    "@typescript-eslint/parser": "^5.18.0",
-    "eslint": "^8.1.0",
+    "eslint": "^8.15.0",
     "eslint-config-prettier": "^8.0.0",
-    "husky": "^7.0.0",
-    "jest": "^27.0.1",
-    "pretty-quick": "^3.1.2",
-    "ts-jest": "^27.0.5",
-    "ts-node": "^10.2.1",
-    "typescript": "^4.5.2"
+    "husky": "^8.0.1",
+    "jest": "^28.0.1",
+    "pretty-quick": "^3.1.2"
   },
   "eslintConfig": {
     "extends": [
       "eslint:recommended",
-      "plugin:@typescript-eslint/recommended",
       "prettier"
     ],
     "env": {
@@ -48,21 +38,17 @@
       "jest": true,
       "node": true
     },
-    "parser": "@typescript-eslint/parser",
     "rules": {
-      "no-unused-vars": "off",
-      "@typescript-eslint/explicit-module-boundary-types": "off",
-      "@typescript-eslint/no-explicit-any": "off"
+      "no-unused-vars": "off"
     }
   },
   "jest": {
-    "globalSetup": "./test/js/globalSetup.ts",
-    "globalTeardown": "./test/js/globalTeardown.ts",
-    "preset": "ts-jest",
+    "globalSetup": "./test/js/globalSetup.js",
+    "globalTeardown": "./test/js/globalTeardown.js",
     "setupFilesAfterEnv": [
-      "./test/js/setupTests.ts"
+      "./test/js/setupTests.js"
     ],
-    "testRegex": ".test.ts$"
+    "testRegex": ".test.js$"
   },
   "husky": {
     "hooks": {

data/rubocop.yml

@@ -1,6 +1,5 @@
 # Disabling all Layout/* rules, as they're unnecessary when the user is using
-# prettier to handle all of the formatting.
-
+# Syntax Tree to handle all of the formatting.
 Layout:
   Enabled: false
 
@@ -13,7 +12,17 @@ Layout:
 Layout/LineLength:
   Enabled: true
 
-Style/MultilineIfModifier: # rubyModifier
+Style/MultilineIfModifier:
+  Enabled: false
+
+# Syntax Tree will expand empty methods to put the end keyword on the subsequent
+# line to reduce git diff noise.
+Style/EmptyMethod:
+  EnforcedStyle: expanded
+
+# lambdas that are constructed with the lambda method call cannot be safely
+# turned into lambda literals without removing a method call.
+Style/Lambda:
   Enabled: false
 
 # When method chains with multiple blocks are chained together, rubocop will let
@@ -23,22 +32,33 @@ Style/MultilineIfModifier: # rubyModifier
 Style/MultilineBlockChain:
   Enabled: false
 
-Style/SymbolArray: # rubyArrayLiteral
-  Enabled: false
+# Syntax Tree by default uses double quotes, so changing the configuration here
+# to match that.
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/QuotedSymbols:
+  EnforcedStyle: double_quotes
 
-Style/WordArray: # rubyArrayLiteral
+# We let users have a little more freedom with symbol and words arrays. If the
+# user only has an individual item like ["value"] then we don't bother
+# converting it because it ends up being just noise.
+Style/SymbolArray:
   Enabled: false
 
-Style/TrailingCommaInArguments: # trailingComma
+Style/WordArray:
   Enabled: false
 
-Style/TrailingCommaInArrayLiteral: # trailingComma
+# We don't support trailing commas in Syntax Tree by default, so just turning
+# these off for now.
+Style/TrailingCommaInArguments:
   Enabled: false
 
-Style/TrailingCommaInHashLiteral: # trailingComma
+Style/TrailingCommaInArrayLiteral:
   Enabled: false
 
-# lambdas that are constructed with the lambda method call cannot be safely
-# turned into lambda literals without removing a method call.
-Style/Lambda:
+Style/TrailingCommaInHashLiteral:
   Enabled: false

data/{dist/parser → src}/getInfo.js

@@ -1,4 +1,3 @@
-// eslint-disable-next-line @typescript-eslint/no-var-requires
 const { existsSync, readFileSync } = require("fs");
 
 // This is how long to wait for the parser to spin up. For the most part, 5

data/{dist/parser → src}/netcat.js

@@ -2,7 +2,6 @@
 // On average, this is 2-3x slower than netcat, but still much faster than
 // spawning a new Ruby process.
 
-// eslint-disable-next-line @typescript-eslint/no-var-requires
 const { createConnection } = require("net");
 
 const sock = process.argv[process.argv.length - 1];

data/src/parseSync.js

@@ -0,0 +1,216 @@
+const { spawn, spawnSync } = require("child_process");
+const {
+  existsSync,
+  unlinkSync,
+  mkdtempSync,
+  copyFileSync,
+  mkdirSync,
+  rmdirSync
+} = require("fs");
+const os = require("os");
+const path = require("path");
+const process = require("process");
+
+let parserArgs;
+
+if (process.env.PRETTIER_RUBY_HOST) {
+  const [cmd, ...args] = process.env.PRETTIER_RUBY_HOST.split(" ");
+  parserArgs = { cmd, args };
+}
+
+// In order to properly parse ruby code, we need to tell the ruby process to
+// parse using UTF-8. Unfortunately, the way that you accomplish this looks
+// differently depending on your platform.
+/* istanbul ignore next */
+function getLang() {
+  const { env, platform } = process;
+  const envValue = env.LC_ALL || env.LC_CTYPE || env.LANG;
+
+  // If an env var is set for the locale that already includes UTF-8 in the
+  // name, then assume we can go with that.
+  if (envValue && envValue.includes("UTF-8")) {
+    return envValue;
+  }
+
+  // Otherwise, we're going to guess which encoding to use based on the system.
+  // This is probably not the best approach in the world, as you could be on
+  // linux and not have C.UTF-8, but in that case you're probably passing an env
+  // var for it. This object below represents all of the possible values of
+  // process.platform per:
+  // https://nodejs.org/api/process.html#process_process_platform
+  return {
+    aix: "C.UTF-8",
+    android: "C.UTF-8",
+    cygwin: "C.UTF-8",
+    darwin: "en_US.UTF-8",
+    freebsd: "C.UTF-8",
+    haiku: "C.UTF-8",
+    linux: "C.UTF-8",
+    netbsd: "C.UTF-8",
+    openbsd: "C.UTF-8",
+    sunos: "C.UTF-8",
+    win32: ".UTF-8"
+  }[platform];
+}
+
+// Generate the filepath that should be used to communicate the connection
+// information between this process and the parser server.
+function getInfoFilepath() {
+  return path.join(os.tmpdir(), `prettier-ruby-parser-${process.pid}.info`);
+}
+
+// Create a file that will act as a communication mechanism, spawn a parser
+// server with that filepath as an argument, then spawn another process that
+// will read that information in order to enable us to connect to it in the
+// spawnSync function.
+function spawnServer(opts) {
+  const tempDir = mkdtempSync(path.join(os.tmpdir(), "prettier-plugin-ruby-"));
+  const filepath = getInfoFilepath();
+
+  let serverRbPath = path.join(__dirname, "./server.rb");
+  let getInfoJsPath = path.join(__dirname, "./getInfo.js");
+  let cleanupTempFiles;
+
+  if (runningInPnPZip()) {
+    // If we're running in a Yarn PnP environment inside a ZIP file, it's not possible to run
+    // the Ruby server or the getInfo.js script directly.  Instead, we need to copy them and all
+    // the files they depend on to a temporary directory.
+
+    const sourceFiles = ["server.rb", "getInfo.js", "netcat.js"];
+    serverRbPath = path.join(tempDir, "server.rb");
+    getInfoJsPath = path.join(tempDir, "getInfo.js");
+
+    sourceFiles.forEach((rubyFile) => {
+      const destDir = path.join(tempDir, path.dirname(rubyFile));
+      if (!existsSync(destDir)) {
+        mkdirSync(destDir);
+      }
+      copyFileSync(
+        path.join(__dirname, "..", "src", rubyFile),
+        path.join(tempDir, rubyFile)
+      );
+    });
+
+    cleanupTempFiles = () => {
+      [
+        getInfoJsPath,
+        ...sourceFiles.map((rubyFile) => path.join(tempDir, rubyFile))
+      ].forEach((tmpFilePath) => {
+        if (existsSync(tmpFilePath)) {
+          unlinkSync(tmpFilePath);
+        }
+      });
+
+      sourceFiles.forEach((rubyFile) => {
+        const tempSubdir = path.join(tempDir, path.dirname(rubyFile));
+        if (existsSync(tempSubdir)) {
+          rmdirSync(tempSubdir);
+        }
+      });
+
+      if (existsSync(tempDir)) {
+        rmdirSync(tempDir);
+      }
+    };
+  }
+
+  const server = spawn(
+    "ruby",
+    [serverRbPath, `--plugins=${opts.rubyPlugins}`, filepath],
+    {
+      env: Object.assign({}, process.env, { LANG: getLang() }),
+      detached: true,
+      stdio: "inherit"
+    }
+  );
+
+  server.unref();
+  process.on("exit", () => {
+    if (existsSync(filepath)) {
+      unlinkSync(filepath);
+    }
+
+    if (cleanupTempFiles != null) {
+      cleanupTempFiles();
+    }
+
+    try {
+      if (server.pid) {
+        // Kill the server process if it's still running. If we're on windows
+        // we're going to use the process ID number. If we're not, we're going
+        // to use the negative process ID to indicate the group.
+        const pid = process.platform === "win32" ? server.pid : -server.pid;
+        process.kill(pid);
+      }
+    } catch (e) {
+      if (process.env.PLUGIN_RUBY_CI) {
+        throw new Error(`Failed to kill the parser server: ${e}`);
+      }
+    }
+  });
+
+  const info = spawnSync("node", [getInfoJsPath, filepath]);
+
+  if (info.status !== 0) {
+    throw new Error(`
+      We failed to spawn our parser server. Please report this error on GitHub
+      at https://github.com/prettier/plugin-ruby. The error message was:
+
+        ${info.stderr.toString()}.
+    `);
+  }
+
+  const [cmd, ...args] = info.stdout.toString().split(" ");
+  return { cmd, args };
+}
+
+// If we're in a yarn Plug'n'Play environment, then the relative paths being
+// used by the parser server and the various scripts used to communicate
+// therein are not going to work with its virtual file system.
+function runningInPnPZip() {
+  return process.versions.pnp && __dirname.includes(".zip");
+}
+
+// Formats and sends a request to the parser server. We use netcat (or something
+// like it) here since Prettier requires the results of `parse` to be
+// synchronous and Node.js does not offer a mechanism for synchronous socket
+// requests.
+function parseSync(parser, source, opts) {
+  if (!parserArgs) {
+    parserArgs = spawnServer(opts);
+  }
+
+  const response = spawnSync(parserArgs.cmd, parserArgs.args, {
+    input: `${parser}|${source}`,
+    maxBuffer: 15 * 1024 * 1024
+  });
+
+  const stdout = response.stdout.toString();
+  const stderr = response.stderr.toString();
+  const { status } = response;
+
+  // If we didn't receive anything over stdout or we have a bad exit status,
+  // then throw whatever we can.
+  if (stdout.length === 0 || (status !== null && status !== 0)) {
+    throw new Error(stderr || "An unknown error occurred");
+  }
+
+  const parsed = JSON.parse(stdout);
+
+  if (parsed.error) {
+    const error = new Error(parsed.error);
+    if (parsed.loc) {
+      error.loc = parsed.loc;
+    }
+
+    throw error;
+  }
+
+  return parsed;
+}
+
+module.exports = {
+  getLang,
+  getInfoFilepath,
+  parseSync
+};