prettier 1.6.1 → 2.0.0.pre.rc1

data/CONTRIBUTING.md

@@ -78,16 +78,14 @@ Effectively, it walks the AST in the reverse direction from the way `Ripper` bui
 As the nodes are printing themselves and their children, they're additionally building up a second AST. That AST is built using the `builder` commands from prettier core, described [here](https://github.com/prettier/prettier/blob/main/commands.md). As an example, below is how a `binary` node (like the one representing the `1 + 1` above) would handle printing itself:
 
 ```javascript
-const { concat, group, indent, line } = require("prettier").doc.builders;
+const { group, indent, line } = require("prettier").doc.builders;
 
 const printBinary = (path, opts, print) =>
-  group(
-    concat([
-      concat([path.call(print, "body", 0), " "]),
-      path.getValue().body[1],
-      indent(concat([line, path.call(print, "body", 2)]))
-    ])
-  );
+  group([
+    [path.call(print, "body", 0), " "],
+    path.getValue().body[1],
+    indent([line, path.call(print, "body", 2)])
+  ]);
 ```
 
 Recall that the `binary` node looks like this:
@@ -100,7 +98,6 @@ This means that there is a node in the `0` position of the array that represents
 
 So, the `printBinary` function is going to use the following `prettier` builders to build up the intermediate represention:
 
-- `concat` - puts multiple nodes together and prints them without breaking them apart
 - `group` - marks places where `prettier` could split text if the line gets too long; if the max line length is hit, `prettier` will break apart the outermost `group` node first
 - `indent` - increases the current print indent for the contents of the node if the parent node is broken, e.g., if the `binary` node is too long to fit on one line, it will indent the right-hand operand
 - `line` - puts a space if the group is not broken, otherwise puts a newline

data/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2019-present Kevin Deisz
+Copyright (c) 2019-present Kevin Newton
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -128,18 +128,17 @@ 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.                                                                                                    |
-| `rubyNetcatCommand` | `--ruby-netcat-command` |          | The prefix of the command to execute to communicate between the node.js process and the Ruby process. (For example, `"nc -U"` or `"telnet -u"`) Normally you should not set this option. |
-| `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)).                                  |
+| `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`. |
 
 Any of these can be added to your existing [prettier configuration
 file](https://prettier.io/docs/en/configuration.html). For example:

data/dist/haml/embed.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prettier_1 = __importDefault(require("../prettier"));
+const { hardline, indent, literalline, markAsRoot, mapDoc, stripTrailingHardline } = prettier_1.default;
+// This function is in here because it handles embedded parser values. I don't
+// have a test that exercises it because I'm not sure for which parser it is
+// necessary, but since it's in prettier core I'm keeping it here.
+/* istanbul ignore next */
+function replaceNewlines(doc) {
+    return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" && currentDoc.includes("\n")
+        ? currentDoc.split(/(\n)/g).map((v, i) => (i % 2 === 0 ? v : literalline))
+        : currentDoc);
+}
+const embed = (path, _print, textToDoc, opts) => {
+    const node = path.getValue();
+    // We're only going to embed other languages on filter nodes.
+    if (node.type !== "filter") {
+        return null;
+    }
+    let parser = node.value.name;
+    // We don't want to deal with some weird recursive parser situation, so we
+    // need to explicitly call out the HAML parser here and just return null.
+    if (parser === "haml") {
+        return null;
+    }
+    // In HAML the name of the JS filter is :javascript, whereas in prettier the
+    // name of the JS parser is babel. Here we explicitly handle that conversion.
+    if (parser === "javascript") {
+        parser = "babel";
+    }
+    // If there aren't any plugins that look like the name of the filter, then we
+    // will just exit early.
+    if (!opts.plugins.some((plugin) => typeof plugin !== "string" &&
+        plugin.parsers &&
+        Object.prototype.hasOwnProperty.call(plugin.parsers, parser))) {
+        return null;
+    }
+    // If there is a plugin that has a parser that matches the name of this
+    // filter, then we're going to assume that's correct for embedding and go
+    // ahead and switch to that parser.
+    return markAsRoot([
+        ":",
+        node.value.name,
+        indent([
+            hardline,
+            replaceNewlines(stripTrailingHardline(textToDoc(node.value.text, { parser })))
+        ])
+    ]);
+};
+exports.default = embed;

data/dist/haml/parser.js

@@ -0,0 +1,31 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseSync_1 = __importDefault(require("../parser/parseSync"));
+const parser = {
+    // This function is responsible for taking an input string of text and
+    // returning to prettier a JavaScript object that is the equivalent AST that
+    // represents the code stored in that string. We accomplish this by spawning a
+    // new process and reading JSON off STDOUT.
+    parse(text) {
+        return (0, parseSync_1.default)("haml", text);
+    },
+    astFormat: "haml",
+    // This function handles checking whether or not the source string has the
+    // pragma for prettier. This is an optional workflow for incremental adoption.
+    hasPragma(text) {
+        return /^\s*-#\s*@(prettier|format)/.test(text);
+    },
+    // These functions are just placeholders until we can actually perform this
+    // properly. The functions are necessary otherwise the format with cursor
+    // functions break.
+    locStart() {
+        return 0;
+    },
+    locEnd() {
+        return 0;
+    }
+};
+exports.default = parser;

data/dist/haml/printer.js

@@ -0,0 +1,336 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const prettier_1 = __importDefault(require("../prettier"));
+const embed_1 = __importDefault(require("./embed"));
+const { align, fill, group, hardline, ifBreak, indent, join, line, makeString, softline } = prettier_1.default;
+const docTypes = {
+    basic: "Basic",
+    frameset: "Frameset",
+    mobile: "Mobile",
+    rdfa: "RDFa",
+    strict: "Strict",
+    xml: "XML"
+};
+const docVersions = ["1.1", "5"];
+// Prints out a hash key according to the configured prettier options.
+function printHashKey(key, opts) {
+    let quoted = key;
+    const joiner = opts.rubyHashLabel ? ":" : " =>";
+    if (key.includes(":") || key.includes("-")) {
+        const quote = opts.rubySingleQuote ? "'" : '"';
+        quoted = `${quote}${key}${quote}`;
+    }
+    return `${opts.rubyHashLabel ? "" : ":"}${quoted}${joiner}`;
+}
+// Prints out the value inside of a hash key-value pair according to the
+// configured prettier options.
+function printHashValue(value, opts) {
+    if (typeof value !== "string") {
+        return value.toString();
+    }
+    // This is a very special syntax created by the parser to let us know that
+    // this should be printed literally instead of as a string.
+    if (value.startsWith("&")) {
+        return value.slice(1);
+    }
+    const quote = opts.rubySingleQuote && !value.includes("#{") && !value.includes("'")
+        ? "'"
+        : '"';
+    return makeString(value, quote);
+}
+// This will print an attributes object to a Doc node. It handles nesting on
+// multiple levels and will print out according to whether or not the version of
+// HAML being used supports multi-line attributes.
+function printAttributes(object, opts, level = 0) {
+    if (typeof object !== "object") {
+        return printHashValue(object, opts);
+    }
+    const boundary = level === 0 ? softline : line;
+    const parts = Object.keys(object).map((key) => [
+        printHashKey(key, opts),
+        " ",
+        printAttributes(object[key], opts, level + 1)
+    ]);
+    // If we have support for multi-line attributes laid out like a regular hash,
+    // then we print them that way here.
+    if (opts.supportsMultiline) {
+        return group([
+            "{",
+            indent(group([boundary, join([",", line], parts)])),
+            boundary,
+            "}"
+        ]);
+    }
+    // Otherwise, if we only have one attribute, then just print it inline
+    // regardless of how long it is.
+    if (parts.length === 0) {
+        return group(["{", parts[0], "}"]);
+    }
+    // Otherwise, depending on how long the line is it will split the content into
+    // multi-line attributes that old Haml understands.
+    return group([
+        "{",
+        parts[0],
+        ",",
+        align(opts.headerLength + 1, [line, join([",", line], parts.slice(1))]),
+        "}"
+    ]);
+}
+// A utility function used in a silent script that is meant to determine if a
+// child node is a continuation of a parent node (as in a when clause within a
+// case statement or an else clause within an if).
+function isContinuation(parentNode, childNode) {
+    if (childNode.type !== "silent_script") {
+        return false;
+    }
+    const parent = parentNode.value.keyword;
+    const child = childNode.value.keyword;
+    return ((parent === "case" && ["when", "else"].includes(child)) ||
+        (["if", "unless"].includes(parent) && ["elsif", "else"].includes(child)));
+}
+const printer = {
+    embed: embed_1.default,
+    // This is our printer's main print function that will switch on the type of
+    // node and print it out by returning a Doc tree.
+    print(path, opts, print) {
+        const node = path.getValue();
+        switch (node.type) {
+            // https://haml.info/docs/yardoc/file.REFERENCE.html#html-comments-
+            case "comment": {
+                const { value } = node;
+                const parts = ["/"];
+                if (value.revealed) {
+                    parts.push("!");
+                }
+                if (value.conditional) {
+                    parts.push(value.conditional);
+                }
+                else if (value.text) {
+                    parts.push(" ", value.text);
+                }
+                return printWithChildren(node, group(parts));
+            }
+            // https://haml.info/docs/yardoc/file.REFERENCE.html#doctype-
+            case "doctype": {
+                const { value } = node;
+                const parts = ["!!!"];
+                if (value.type in docTypes) {
+                    parts.push(docTypes[value.type]);
+                }
+                else if (value.version && docVersions.includes(value.version)) {
+                    parts.push(value.version);
+                }
+                else {
+                    parts.push(value.type);
+                }
+                if (value.encoding) {
+                    parts.push(value.encoding);
+                }
+                return group(join(" ", parts));
+            }
+            // https://haml.info/docs/yardoc/file.REFERENCE.html#filters
+            case "filter":
+                return group([
+                    ":",
+                    node.value.name,
+                    indent([hardline, join(hardline, node.value.text.trim().split("\n"))])
+                ]);
+            // https://haml.info/docs/yardoc/file.REFERENCE.html#haml-comments--
+            case "haml_comment": {
+                const { value } = node;
+                const parts = ["-#"];
+                if (value.text) {
+                    if (opts.originalText.split("\n")[node.line - 1].trim() === "-#") {
+                        const lines = value.text.trim().split("\n");
+                        parts.push(indent([hardline, join(hardline, lines)]));
+                    }
+                    else {
+                        parts.push(" ", value.text.trim());
+                    }
+                }
+                return parts;
+            }
+            // https://haml.info/docs/yardoc/file.REFERENCE.html#plain-text
+            case "plain":
+                return node.value.text;
+            // The root node in the AST that we build in the parser.
+            case "root": {
+                const nodePath = path;
+                return [join(hardline, nodePath.map(print, "children")), hardline];
+            }
+            // https://haml.info/docs/yardoc/file.REFERENCE.html#inserting_ruby
+            case "script": {
+                const { value } = node;
+                const parts = [];
+                if (value.escape_html) {
+                    parts.unshift("&");
+                }
+                if (value.preserve) {
+                    parts.push("~");
+                }
+                else if (!value.interpolate) {
+                    parts.push("=");
+                }
+                if (value.escape_html && !value.preserve && value.interpolate) {
+                    parts.push(" ", value.text.trim().slice(1, -1));
+                }
+                else {
+                    parts.push(" ", value.text.trim());
+                }
+                return printWithChildren(node, group(parts));
+            }
+            // https://haml.info/docs/yardoc/file.REFERENCE.html#running-ruby--
+            case "silent_script": {
+                const parts = [`- ${node.value.text.trim()}`];
+                if (node.children.length > 0) {
+                    const nodePath = path;
+                    parts.push(nodePath.map((childPath) => {
+                        const child = childPath.getValue();
+                        const concated = [hardline, print(childPath)];
+                        return isContinuation(node, child) ? concated : indent(concated);
+                    }, "children"));
+                }
+                return group(parts);
+            }
+            // https://haml.info/docs/yardoc/file.REFERENCE.html#element-name-
+            case "tag": {
+                const { value } = node;
+                const { attributes, dynamic_attributes } = value;
+                const parts = [];
+                // If we have a tag that isn't a div, then we need to print out that
+                // name of that tag first. If it is a div, first we'll check if there
+                // are any other things that would force us to print out the div
+                // explicitly, and otherwise we'll leave it off.
+                if (value.name !== "div") {
+                    parts.push(`%${value.name}`);
+                }
+                // If we have a class attribute, then we're going to print that here
+                // using the special class syntax.
+                if (attributes.class) {
+                    parts.push(`.${attributes.class.replace(/ /g, ".")}`);
+                }
+                // If we have an id attribute, then we're going to print that here using
+                // the special id syntax.
+                if (attributes.id) {
+                    parts.push(`#${attributes.id}`);
+                }
+                // If we're using dynamic attributes on this tag, then they come in as a
+                // string that looks like the output of Hash#inspect from Ruby. So here
+                // we're going to split it all up and print it out nicely.
+                if (dynamic_attributes.new) {
+                    const docs = [];
+                    dynamic_attributes.new
+                        .slice(1, -2)
+                        .split(",")
+                        .forEach((pair, index) => {
+                        if (index !== 0) {
+                            docs.push(line);
+                        }
+                        docs.push(join("=", pair.slice(1).split('" => ')));
+                    });
+                    parts.push(group(["(", align(parts.join("").length + 1, fill(docs)), ")"]));
+                }
+                // If there are any static attributes that are not class or id (because
+                // we already took care of those), then we're going to print them out
+                // here.
+                const staticAttributes = Object.keys(attributes).filter((name) => !["class", "id"].includes(name));
+                if (staticAttributes.length > 0) {
+                    const docs = staticAttributes.reduce((accum, key) => {
+                        const doc = `${printHashKey(key, opts)} ${printHashValue(attributes[key], opts)}`;
+                        return accum.length === 0 ? [doc] : [...accum, ",", line, doc];
+                    }, []);
+                    parts.push(group(["{", align(parts.join("").length + 1, fill(docs)), "}"]));
+                }
+                // If there are dynamic attributes that don't use the newer syntax, then
+                // we're going to print them out here.
+                if (dynamic_attributes.old) {
+                    if (parts.length === 0) {
+                        parts.push("%div");
+                    }
+                    if (typeof dynamic_attributes.old === "string") {
+                        parts.push(dynamic_attributes.old);
+                    }
+                    else {
+                        // This is kind of a total hack in that I don't think you're
+                        // really supposed to directly use `path.stack`, but it's the
+                        // easiest way to get the root node without having to know how
+                        // many levels deep we are.
+                        const root = path.stack[0];
+                        parts.push(printAttributes(dynamic_attributes.old, {
+                            ...opts,
+                            supportsMultiline: root.supports_multiline,
+                            headerLength: parts.join("").length
+                        }));
+                    }
+                }
+                // https://haml.info/docs/yardoc/file.REFERENCE.html#object-reference-
+                if (value.object_ref) {
+                    if (parts.length === 0) {
+                        parts.push("%div");
+                    }
+                    parts.push(value.object_ref);
+                }
+                // https://haml.info/docs/yardoc/file.REFERENCE.html#whitespace-removal--and-
+                if (value.nuke_outer_whitespace) {
+                    parts.push(">");
+                }
+                if (value.nuke_inner_whitespace) {
+                    parts.push("<");
+                }
+                // https://haml.info/docs/yardoc/file.REFERENCE.html#empty-void-tags-
+                if (value.self_closing) {
+                    parts.push("/");
+                }
+                if (value.value) {
+                    let contents;
+                    if (value.parse && value.value.match(/#[{$@]/)) {
+                        // There's a weird case here where if the value includes
+                        // interpolation and it's marked as { parse: true }, then we don't
+                        // actually want the = prefix, and we want to remove extra escaping.
+                        contents = [
+                            ifBreak("", " "),
+                            value.value.slice(1, -1).replace(/\\"/g, '"')
+                        ];
+                    }
+                    else if (value.parse) {
+                        contents = ["= ", value.value];
+                    }
+                    else {
+                        contents = [ifBreak("", " "), value.value];
+                    }
+                    return printWithChildren(node, group([group(parts), indent([softline, ...contents])]));
+                }
+                // In case none of the other if statements have matched and we're
+                // printing a div, we need to explicitly add it back into the array.
+                if (parts.length === 0 && value.name === "div") {
+                    parts.push("%div");
+                }
+                return printWithChildren(node, group(parts));
+            }
+            default:
+                throw new Error(`Unsupported node encountered: ${node.type}`);
+        }
+        // It's common to a couple of nodes to attach nested child nodes on the
+        // children property. This utility prints them out grouped together with
+        // their parent node docs.
+        function printWithChildren(node, docs) {
+            if (node.children.length === 0) {
+                return docs;
+            }
+            const nodePath = path;
+            return group([
+                docs,
+                indent([hardline, join(hardline, nodePath.map(print, "children"))])
+            ]);
+        }
+    },
+    // This function handles adding the format pragma to a source string. This is
+    // an optional workflow for incremental adoption.
+    insertPragma(text) {
+        return `-# @format${text.startsWith("-#") ? "\n" : "\n\n"}${text}`;
+    }
+};
+exports.default = printer;

data/dist/parser/getInfo.js

@@ -0,0 +1,17 @@
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const { existsSync, readFileSync } = require("fs");
+
+const filepath = process.argv[process.argv.length - 1];
+
+const timeout = setTimeout(() => {
+  clearInterval(interval);
+  throw new Error("Failed to get information from parse server in time.");
+}, 5000);
+
+const interval = setInterval(() => {
+  if (existsSync(filepath)) {
+    process.stdout.write(readFileSync(filepath).toString("utf8"));
+    clearTimeout(timeout);
+    clearInterval(interval);
+  }
+}, 100);

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

@@ -2,6 +2,7 @@
 // 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/dist/parser/parseSync.js

@@ -0,0 +1,128 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInfoFilepath = exports.getLang = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const process_1 = __importDefault(require("process"));
+let parserArgs;
+if (process_1.default.env.PRETTIER_RUBY_HOST) {
+    const [cmd, ...args] = process_1.default.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_1.default;
+    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];
+}
+exports.getLang = getLang;
+// Generate the filepath that should be used to communicate the connection
+// information between this process and the parser server.
+function getInfoFilepath() {
+    return path_1.default.join(os_1.default.tmpdir(), `prettier-ruby-parser-${process_1.default.pid}.info`);
+}
+exports.getInfoFilepath = getInfoFilepath;
+// 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() {
+    const filepath = getInfoFilepath();
+    const server = (0, child_process_1.spawn)("ruby", [path_1.default.join(__dirname, "./server.rb"), filepath], {
+        env: Object.assign({}, process_1.default.env, { LANG: getLang() }),
+        detached: true,
+        stdio: "inherit"
+    });
+    server.unref();
+    process_1.default.on("exit", () => {
+        if ((0, fs_1.existsSync)(filepath)) {
+            (0, fs_1.unlinkSync)(filepath);
+        }
+        try {
+            if (server.pid) {
+                process_1.default.kill(-server.pid);
+            }
+        }
+        catch (e) {
+            if (process_1.default.env.PLUGIN_RUBY_CI) {
+                throw new Error(`Failed to kill the parser server: ${e}`);
+            }
+        }
+    });
+    const info = (0, child_process_1.spawnSync)("node", [
+        path_1.default.join(__dirname, "./getInfo.js"),
+        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 };
+}
+// 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) {
+    if (!parserArgs) {
+        parserArgs = spawnServer();
+    }
+    const response = (0, child_process_1.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;
+}
+exports.default = parseSync;