prettier 1.5.4 → 2.0.0.pre.rc1

data/CONTRIBUTING.md

@@ -75,19 +75,17 @@ Once prettier has a working AST, it will take it and call the selected plugin's
 
 Effectively, it walks the AST in the reverse direction from the way `Ripper` built it (top-down instead of bottom-up). The first node that gets passed into the `print` function is the `program` node as that's always on top. Then it is the `program` node's responsibility to recursively call print on its child nodes as it best sees fit.
 
-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/master/commands.md). As an example, below is how a `binary` node (like the one representing the `1 + 1` above) would handle printing itself:
+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
@@ -159,7 +156,7 @@ Links relating to `ripper` and how it parses Ruby source.
 Links relating to `prettier` and its plugins.
 
 - [Prettier plugin documentation](https://prettier.io/docs/en/plugins.html) - documentation around `prettier`'s plugin system
-- [Builder commands](https://github.com/prettier/prettier/blob/master/commands.md) - the functions used to build the `prettier` IR
+- [Builder commands](https://github.com/prettier/prettier/blob/main/commands.md) - the functions used to build the `prettier` IR
 - [Writing a Prettier plugin](https://medium.com/@fvictorio/how-to-write-a-plugin-for-prettier-a0d98c845e70) - a nice tutorial on how to build a `prettier` plugin
 
 ## Useful commands

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,19 +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` | `false` | 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:
@@ -154,7 +152,7 @@ file](https://prettier.io/docs/en/configuration.html). For example:
 Or, they can be passed to `prettier` as arguments:
 
 ```bash
-prettier --ruby-single-quote false --write '**/*'
+bundle exec rbprettier --ruby-single-quote false --write '**/*'
 ```
 
 ### Usage with RuboCop
@@ -179,6 +177,25 @@ inherit_from:
   - node_modules/@prettier/plugin-ruby/rubocop.yml
 ```
 
+### Usage with an editor
+
+For [supported editor integrations](https://github.com/prettier/prettier/blob/main/website/data/editors.yml), you should follow the instructions for installing the integration, then install the npm version of this plugin as a development dependency of your project. For most integrations, that should be sufficient. For convenience, the instructions for integrating with VSCode are used as an example below:
+
+- Install the [Prettier - Code Formatter](https://github.com/prettier/prettier-vscode) extension.
+- Add the npm `@prettier/plugin-ruby` package to your project as described above.
+- Configure in your `settings.json` (`formatOnSave` is optional):
+
+```json
+{
+  "[ruby]": {
+    "editor.defaultFormatter": "esbenp.prettier-vscode",
+    "editor.formatOnSave": true
+  }
+}
+```
+
+Refer to [this issue](https://github.com/prettier/plugin-ruby/issues/113#issuecomment-783426539) if you're having difficulties.
+
 ## Contributing
 
 Check out our [contributing guide](CONTRIBUTING.md). Bug reports and pull requests are welcome on GitHub at https://github.com/prettier/plugin-ruby.

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/{src → dist}/haml/parser.rb

@@ -86,7 +86,14 @@ class Haml::Parser::ParseNode
         json[:value][:text] = "\\#{text}" if text.match?(SPECIAL_START)
       end
     when :root
-      to_h.tap { |json| json[:children] = children.map(&:as_json) }
+      to_h.tap do |json|
+        json[:children] = children.map(&:as_json)
+
+        # We need this information in the printer to know how to lay out
+        # multi-line attributes.
+        json[:supports_multiline] =
+          Gem::Version.new(Haml::VERSION) >= Gem::Version.new('5.2')
+      end
     when :script
       to_h.tap do |json|
         json.delete(:parent)

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];