prettier 2.0.0.pre.rc1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1015fa9f7c5b4f580afa9c6b24042c8799762e5d13835dbb492abfe33f676b8
-  data.tar.gz: 53045f82f75561082c6120d836d3abdffb07cccb31e5272442ef2608014f8f6d
+  metadata.gz: a8393d82622bcce83298aa8e2833b37bccf9742b0a67e81cd3b730e57e6795b8
+  data.tar.gz: a66af4efc73854f143e0faa288fdde112bf87ba45364af3efd862a179734453c
 SHA512:
-  metadata.gz: 4f4541af3e4e4047f03c4c34890506b25126d34e052b92023d40e7bb68b5184cfce9c91ba5794478b21b61952e1823d4f7e08d51b52d468a9de61f270f9d61a0
-  data.tar.gz: 983d6da92e456dae0f081a2ee4b77f4a47d540415f991c51d91006a2847ac38937574e76f82bd376fb9e47401deeb5bd77414c10b3ab80a9d4adaa7a7e66499e
+  metadata.gz: f780174b5b038bfd9583c637caefff23e442f4aef626e9e33769811c15afd7c267bb78f20c4eb223ab4b50f3c0b6664123c6ce00d997ff0a571b0d57228f5070
+  data.tar.gz: bdfbd3f42b4db020059b511b3176ee7b5393a5a008136dd06a584c26df69afbcfe7d937e6151e22029858d71bad68e8c68eb07241e67771debd802cf733c282d

data/CHANGELOG.md

@@ -6,7 +6,43 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
-## [2.0.0-rc1]
+## [2.0.0] - 2021-10-28
+
+### Changed
+
+- [#1018](https://github.com/prettier/plugin-ruby/issues/1018) - rindek, kddnewton - Ensure brackets are used when matching an array pattern with a single element.
+- [#906](https://github.com/prettier/plugin-ruby/issues/906) - Hansenq, kddnewton - Turn off the `Style/MultilineBlockChain` rubocop rule in our shipped configuration because multiple chained method calls with blocks can potentially conflict with rubocop's desired output.
+
+## [2.0.0-rc4] - 2021-10-18
+
+### Added
+
+- [#993](https://github.com/prettier/plugin-ruby/pull/993) - kddnewton - Nicer error message if you don't have the necessary JavaScript files to run prettier.
+- [#996](https://github.com/prettier/plugin-ruby/pull/996) - nbudin - Allow `@prettier/plugin-ruby` to run in yarn's plug'n'play mode.
+
+### Changed
+
+- [#1000](https://github.com/prettier/plugin-ruby/pull/1000) - nbudin, kddnewton - Fix for rescuing single top-level exceptions in `rescue` clauses.
+
+## [2.0.0-rc3] - 2021-10-01
+
+### Changed
+
+- [#987](https://github.com/prettier/plugin-ruby/pull/9870) - valscion - Ignore stderr when checking for node <-> ruby connection clients, restoring the behavior of v1.x
+- [#989](https://github.com/prettier/plugin-ruby/issues/989) - hubertjakubiak, kddnewton - Make sure comments after the keyword/lbrace are not moved inside the body of the statements of do and brace blocks.
+
+## [2.0.0-rc2] - 2021-09-30
+
+### Added
+
+- [#979](https://github.com/prettier/plugin-ruby/issues/979) - ronocod, kddnewton - Alignment of `to_not` is explicitly allowed to not indent to better support rspec.
+- [#894](https://github.com/prettier/plugin-ruby/issues/894) - mister-what, kddnewton - Add a warning that this plugin will not function with the plug'n'play filesystem provided by yarn berry.
+
+### Changed
+
+- [#943](https://github.com/prettier/plugin-ruby/issues/943) - valscion, kddnewton - Trailing call operators that are followed by comments should stay on the first line.
+
+## [2.0.0-rc1] - 2021-09-30
 
 ### Added
 
@@ -1151,7 +1187,11 @@ would previously result in `array[]`, but now prints properly.
 
 - Initial release 🎉
 
-[unreleased]: https://github.com/prettier/plugin-ruby/compare/v2.0.0-rc1...HEAD
+[unreleased]: https://github.com/prettier/plugin-ruby/compare/v2.0.0...HEAD
+[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
+[2.0.0-rc3]: https://github.com/prettier/plugin-ruby/compare/v2.0.0-rc2...v2.0.0-rc3
+[2.0.0-rc2]: https://github.com/prettier/plugin-ruby/compare/v2.0.0-rc1...v2.0.0-rc2
 [2.0.0-rc1]: https://github.com/prettier/plugin-ruby/compare/v1.6.1...v2.0.0-rc1
 [1.6.1]: https://github.com/prettier/plugin-ruby/compare/v1.6.0...v1.6.1
 [1.6.0]: https://github.com/prettier/plugin-ruby/compare/v1.5.5...v1.6.0

data/dist/parser/parseSync.js

@@ -58,8 +58,53 @@ exports.getInfoFilepath = getInfoFilepath;
 // will read that information in order to enable us to connect to it in the
 // spawnSync function.
 function spawnServer() {
+    const tempDir = (0, fs_1.mkdtempSync)(path_1.default.join(os_1.default.tmpdir(), "prettier-plugin-ruby-"));
     const filepath = getInfoFilepath();
-    const server = (0, child_process_1.spawn)("ruby", [path_1.default.join(__dirname, "./server.rb"), filepath], {
+    let serverRbPath = path_1.default.join(__dirname, "./server.rb");
+    let getInfoJsPath = path_1.default.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 = [
+            "parser/server.rb",
+            "parser/getInfo.js",
+            "parser/netcat.js",
+            "ruby/parser.rb",
+            "rbs/parser.rb",
+            "haml/parser.rb"
+        ];
+        serverRbPath = path_1.default.join(tempDir, "parser", "server.rb");
+        getInfoJsPath = path_1.default.join(tempDir, "parser", "getInfo.js");
+        sourceFiles.forEach((rubyFile) => {
+            const destDir = path_1.default.join(tempDir, path_1.default.dirname(rubyFile));
+            if (!(0, fs_1.existsSync)(destDir)) {
+                (0, fs_1.mkdirSync)(destDir);
+            }
+            (0, fs_1.copyFileSync)(path_1.default.join(__dirname, "..", rubyFile), path_1.default.join(tempDir, rubyFile));
+        });
+        cleanupTempFiles = () => {
+            [
+                getInfoJsPath,
+                ...sourceFiles.map((rubyFile) => path_1.default.join(tempDir, rubyFile))
+            ].forEach((tmpFilePath) => {
+                if ((0, fs_1.existsSync)(tmpFilePath)) {
+                    (0, fs_1.unlinkSync)(tmpFilePath);
+                }
+            });
+            sourceFiles.forEach((rubyFile) => {
+                const tempSubdir = path_1.default.join(tempDir, path_1.default.dirname(rubyFile));
+                if ((0, fs_1.existsSync)(tempSubdir)) {
+                    (0, fs_1.rmdirSync)(tempSubdir);
+                }
+            });
+            if ((0, fs_1.existsSync)(tempDir)) {
+                (0, fs_1.rmdirSync)(tempDir);
+            }
+        };
+    }
+    const server = (0, child_process_1.spawn)("ruby", [serverRbPath, filepath], {
         env: Object.assign({}, process_1.default.env, { LANG: getLang() }),
         detached: true,
         stdio: "inherit"
@@ -69,6 +114,9 @@ function spawnServer() {
         if ((0, fs_1.existsSync)(filepath)) {
             (0, fs_1.unlinkSync)(filepath);
         }
+        if (cleanupTempFiles != null) {
+            cleanupTempFiles();
+        }
         try {
             if (server.pid) {
                 process_1.default.kill(-server.pid);
@@ -80,10 +128,7 @@ function spawnServer() {
             }
         }
     });
-    const info = (0, child_process_1.spawnSync)("node", [
-        path_1.default.join(__dirname, "./getInfo.js"),
-        filepath
-    ]);
+    const info = (0, child_process_1.spawnSync)("node", [getInfoJsPath, filepath]);
     if (info.status !== 0) {
         throw new Error(`
       We failed to spawn our parser server. Please report this error on GitHub
@@ -95,6 +140,12 @@ function spawnServer() {
     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_1.default.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

data/dist/parser/server.rb

@@ -112,8 +112,9 @@ candidates.map! do |candidate|
   Thread.new do
     Thread.current.report_on_exception = false
 
-    stdout, status =
-      Open3.capture2("#{candidate} #{information}", stdin_data: 'ping')
+    # We do not care about stderr here, so throw it away
+    stdout, _stderr, status =
+      Open3.capture3("#{candidate} #{information}", stdin_data: 'ping')
 
     candidate if JSON.parse(stdout) == 'pong' && status.exitstatus == 0
   rescue StandardError

data/dist/ruby/nodes/blocks.js

@@ -17,6 +17,23 @@ const printBlockVar = (path, opts, print) => {
     return parts;
 };
 exports.printBlockVar = printBlockVar;
+// You have to go through the main print function if you could potentially have
+// comments attached. So we're doing this weird reflection on the printed docs
+// to retroactively change the printed keyword depending on if we're using
+// braces or not. Ideally we wouldn't do this, we would instead do this
+// reflection in the child printer, but this keeps the logic to just this file
+// and contains it, so keeping it here for now.
+function printBlockBeging(path, print, useBraces) {
+    let docs = print(path);
+    const doc = useBraces ? "{" : "do";
+    if (Array.isArray(docs)) {
+        docs[1] = doc;
+    }
+    else {
+        docs = doc;
+    }
+    return docs;
+}
 function printBlock(braces) {
     return function printBlockWithBraces(path, opts, print) {
         const [variables, statements] = path.getValue().body;
@@ -34,7 +51,8 @@ function printBlock(braces) {
         // switch to using braces instead.
         const useBraces = braces && (0, utils_1.hasAncestor)(path, ["command", "command_call"]);
         const doBlock = [
-            useBraces ? " {" : " do",
+            " ",
+            path.call((begingPath) => printBlockBeging(begingPath, print, useBraces), "beging"),
             variables ? [" ", path.call(print, "body", 0)] : "",
             doBlockBody,
             [softline, useBraces ? "}" : "end"]
@@ -54,7 +72,8 @@ function printBlock(braces) {
         }
         const hasBody = stmts.some(({ type }) => type !== "void_stmt");
         const braceBlock = [
-            " {",
+            " ",
+            path.call((begingPath) => printBlockBeging(begingPath, print, true), "beging"),
             hasBody || variables ? " " : "",
             variables ? path.call(print, "body", 0) : "",
             path.call(print, "body", 1),

data/dist/ruby/nodes/calls.js

@@ -9,6 +9,10 @@ const utils_1 = require("../../utils");
 const toProc_1 = __importDefault(require("../toProc"));
 const { group, hardline, ifBreak, indent, join, softline } = prettier_1.default;
 const chained = ["call", "method_add_arg", "method_add_block"];
+function hasLeadingComments(node) {
+    var _a;
+    return (_a = node.comments) === null || _a === void 0 ? void 0 : _a.some(({ leading }) => leading);
+}
 const printCall = (path, opts, print) => {
     const node = path.getValue();
     const [receiverNode, , messageNode] = node.body;
@@ -18,26 +22,40 @@ const printCall = (path, opts, print) => {
     // In this case, "call" is returned for the 3rd child node. We don't alter
     // call syntax so if `call` is implicit, we don't print it out.
     const messageDoc = messageNode === "call" ? "" : path.call(print, "body", 2);
+    // Create some arrays that are going to represent each side of our call.
+    let leftSideDoc = [receiverDoc];
+    let rightSideDoc = [operatorDoc, messageDoc];
+    // If there are leading comments on the right side of the call, then it means
+    // we have a structure where there's a receiver and an operator together, then
+    // a comment, then the message, as in:
+    //
+    //     foo.
+    //       # comment
+    //       baz
+    //
+    // In the case we need to group the receiver and the operator together or
+    // we'll end up with a syntax error.
+    const operatorIsTrailing = messageNode !== "call" && hasLeadingComments(messageNode);
+    if (operatorIsTrailing) {
+        leftSideDoc = [receiverDoc, operatorDoc];
+        rightSideDoc = [messageDoc];
+    }
     // For certain left sides of the call nodes, we want to attach directly to
     // the } or end.
     if (utils_1.noIndent.includes(receiverNode.type)) {
-        return [receiverDoc, operatorDoc, messageDoc];
+        return [leftSideDoc, rightSideDoc];
     }
-    // The right side of the call node, as in everything including the operator
-    // and beyond.
-    let rightSideDoc = [
-        receiverNode.comments ? hardline : softline,
-        operatorDoc,
-        messageDoc
-    ];
-    // This is very specialized behavior wherein we group .where.not calls
-    // together because it looks better. For more information, see
-    // https://github.com/prettier/plugin-ruby/issues/862.
     if (receiverNode.type === "call" &&
         receiverNode.body[2] !== "call" &&
         receiverNode.body[2].body === "where" &&
         messageDoc === "not") {
-        rightSideDoc = [operatorDoc, messageDoc];
+        // This is very specialized behavior wherein we group .where.not calls
+        // together because it looks better. For more information, see
+        // https://github.com/prettier/plugin-ruby/issues/862.
+    }
+    else {
+        // Otherwise, we're going to put a line node into the right side doc.
+        rightSideDoc.unshift(receiverNode.comments ? hardline : softline);
     }
     // Get a reference to the parent node so we can check if we're inside a chain
     const parentNode = path.getParentNode();
@@ -46,8 +64,30 @@ const printCall = (path, opts, print) => {
     if (chained.includes(parentNode.type) && !node.comments) {
         parentNode.chain = (node.chain || 0) + 1;
         parentNode.callChain = (node.callChain || 0) + 1;
-        parentNode.breakDoc = (node.breakDoc || [receiverDoc]).concat(rightSideDoc);
         parentNode.firstReceiverType = node.firstReceiverType || receiverNode.type;
+        // Here we're going to determine what doc nodes to send up to the parent
+        // node to represent when we're in the multi-line form.
+        let breakDocLHS;
+        if (node.breakDoc && operatorIsTrailing) {
+            // Here we already have a child node that has passed up its
+            // representation. In this case node.breakDoc represents the receiver
+            // without any lines inserted. With regard to this node, it means it's
+            // everything up until the operator. So we're just going to append the
+            // operator.
+            breakDocLHS = node.breakDoc.concat(operatorDoc);
+        }
+        else if (node.breakDoc) {
+            // Here we don't need a trailing operator, so we're just going to use the
+            // existing node.breakDoc. The operator will be a part of the rightSideDoc
+            // variable.
+            breakDocLHS = node.breakDoc;
+        }
+        else {
+            // Here we're at the bottom of the chain, so there's no representation yet
+            // for the receiver. So we're just going to pass up the left side.
+            breakDocLHS = leftSideDoc;
+        }
+        parentNode.breakDoc = breakDocLHS.concat(rightSideDoc);
     }
     // If we're at the top of a chain, then we're going to print out a nice
     // multi-line layout if this doesn't break into multiple lines.
@@ -55,11 +95,11 @@ const printCall = (path, opts, print) => {
         (node.chain || 0) >= 3 &&
         node.breakDoc) {
         return ifBreak(group(indent(node.breakDoc.concat(rightSideDoc))), [
-            receiverDoc,
+            leftSideDoc,
             group(rightSideDoc)
         ]);
     }
-    return group([receiverDoc, group(indent(rightSideDoc))]);
+    return group([leftSideDoc, group(indent(rightSideDoc))]);
 };
 exports.printCall = printCall;
 const printMethodAddArg = (path, opts, print) => {

data/dist/ruby/nodes/commands.js

@@ -62,8 +62,8 @@ function hasDef(node) {
 //
 // In this case the arguments are aligned to the left side as opposed to being
 // aligned with the `receive` call.
-function skipArgsAlign(path) {
-    return ["to", "not_to"].includes(path.getValue().body[2].body);
+function skipArgsAlign(node) {
+    return ["to", "not_to", "to_not"].includes(node.body[2].body);
 }
 // If there is a ternary argument to a command and it's going to get broken
 // into multiple lines, then we're going to have to use parentheses around the
@@ -110,7 +110,7 @@ const printCommandCall = (path, opts, print) => {
         breakDoc = parts.concat("(", indent([softline, argDocs]), softline, ")");
         parts.push(" ");
     }
-    else if (skipArgsAlign(path)) {
+    else if (skipArgsAlign(node)) {
         parts.push(" ");
         breakDoc = parts.concat(argDocs);
     }

data/dist/ruby/nodes/patterns.js

@@ -19,24 +19,36 @@ const printPatternArg = (path, opts, print) => {
 };
 const printAryPtn = (path, opts, print) => {
     const [constant, preargs, splatarg, postargs] = path.getValue().body;
-    let args = [];
+    let argDocs = [];
     if (preargs) {
-        args = args.concat(path.map((argPath) => printPatternArg(argPath, opts, print), "body", 1));
+        argDocs = argDocs.concat(path.map((argPath) => printPatternArg(argPath, opts, print), "body", 1));
     }
     if (splatarg) {
-        args.push(["*", path.call(print, "body", 2)]);
+        argDocs.push(["*", path.call(print, "body", 2)]);
     }
     if (postargs) {
-        args = args.concat(path.map(print, "body", 3));
+        argDocs = argDocs.concat(path.map(print, "body", 3));
     }
-    args = group(join([",", line], args));
-    if (constant || patterns.includes(path.getParentNode().type)) {
-        args = ["[", args, "]"];
+    let argDoc = group(join([",", line], argDocs));
+    // There are a couple of cases where we _must_ use brackets. They include:
+    //
+    // * When the number of arguments inside the array pattern is one 1, then we
+    //   have to include them, otherwise it matches the whole array. Consider the
+    //   difference between `in [elem]` and `in elem`.
+    // * If we have a wrapping constant, then we definitely need the brackets.
+    //   Consider the difference between `in Const[elem]` and `in Const elem`
+    // * If we're nested inside a parent pattern, then we have to have brackets.
+    //   Consider the difference between `in key: first, second` and
+    //   `in key: [first, second]`.
+    if (argDocs.length === 1 ||
+        constant ||
+        patterns.includes(path.getParentNode().type)) {
+        argDoc = ["[", argDoc, "]"];
     }
     if (constant) {
-        return [path.call(print, "body", 0), args];
+        return [path.call(print, "body", 0), argDoc];
     }
-    return args;
+    return argDoc;
 };
 exports.printAryPtn = printAryPtn;
 const printFndPtn = (path, opts, print) => {
@@ -86,9 +98,10 @@ const printHshPtn = (path, opts, print) => {
 };
 exports.printHshPtn = printHshPtn;
 const printIn = (path, opts, print) => {
+    const keyword = "in ";
     const parts = [
-        "in ",
-        align("in ".length, path.call((valuePath) => printPatternArg(valuePath, opts, print), "body", 0)),
+        keyword,
+        align(keyword.length, path.call((valuePath) => printPatternArg(valuePath, opts, print), "body", 0)),
         indent([hardline, path.call(print, "body", 1)])
     ];
     if (path.getValue().body[2]) {

data/dist/ruby/nodes/rescue.js

@@ -52,10 +52,13 @@ const printRescueEx = (path, opts, print) => {
     const [exception, variable] = path.getValue().body;
     const parts = [];
     if (exception) {
+        // If there's just one exception being rescued, then it's just going to be a
+        // single doc node.
         let exceptionDoc = path.call(print, "body", 0);
-        if (Array.isArray(exceptionDoc)) {
-            const joiner = [",", line];
-            exceptionDoc = group(join(joiner, exceptionDoc));
+        // If there are multiple exceptions being rescued, then we're going to have
+        // multiple doc nodes returned as an array that we need to join together.
+        if (["mrhs_add_star", "mrhs_new_from_args"].includes(exception.type)) {
+            exceptionDoc = group(join([",", line], exceptionDoc));
         }
         parts.push(" ", exceptionDoc);
     }

data/dist/ruby/parser.rb

@@ -136,12 +136,6 @@ class Prettier::Parser < Ripper
     # keyword.
     @__end__ = nil
 
-    # Magic comments are a certain kind of comment that can impact the way the
-    # file is parsed (encoding/string frozen default/etc.). These scanner events
-    # are immediately followed by a comment scanner event, so we only need the
-    # one variable to set/unset it immediately.
-    @magic_comment = nil
-
     # Heredocs can actually be nested together if you're using interpolation, so
     # this is a stack of heredoc nodes that are currently being created. When we
     # get to the scanner event that finishes off a heredoc node, we pop the top
@@ -799,11 +793,15 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@lbrace)
     ending = find_scanner_event(:@rbrace)
 
-    stmts.bind((block_var || beging)[:ec], ending[:sc])
+    stmts.bind(
+      find_next_statement_start((block_var || beging)[:ec]),
+      ending[:sc]
+    )
 
     {
       type: :brace_block,
       body: [block_var, stmts],
+      beging: beging,
       sl: beging[:sl],
       sc: beging[:sc],
       el: [ending[:el], stmts[:el]].max,
@@ -970,22 +968,6 @@ class Prettier::Parser < Ripper
     start_line = lineno
     start_char = char_pos
 
-    # If we already had special handling of a magic comment, then we can just
-    # skip and return the value of that node.
-    if @magic_comment
-      comment = @magic_comment
-      @magic_comment = nil
-
-      # At the moment, merging in the value of the string being passed into
-      # here. In the next major version I'd like to remove this and just use the
-      # value of the magic comment. At the moment though that would change
-      # comments like -*- encoding: UTF-8 -*- into encoding: UTF-8 so need to
-
-      # wait for a major version to do that.
-      @comments << comment.merge(value: body, ec: start_char + value.length - 1)
-      return comment
-    end
-
     @comments << {
       type: :@comment,
       value: body,
@@ -1208,11 +1190,15 @@ class Prettier::Parser < Ripper
     beging = find_scanner_event(:@kw, 'do')
     ending = find_scanner_event(:@kw, 'end')
 
-    bodystmt.bind((block_var || beging)[:ec], ending[:sc])
+    bodystmt.bind(
+      find_next_statement_start((block_var || beging)[:ec]),
+      ending[:sc]
+    )
 
     {
       type: :do_block,
       body: [block_var, bodystmt],
+      beging: beging,
       sl: beging[:sl],
       sc: beging[:sc],
       el: ending[:el],
@@ -2012,20 +1998,12 @@ class Prettier::Parser < Ripper
   # magic_comment is a scanner event that represents the use of a pragma at the
   # beginning of the file. Usually it will inside something like
   # frozen_string_literal (the key) with a value of true (the value). Both
-  # children come is a string literals.
-  def on_magic_comment(key, value)
-    start_line = lineno
-    start_char = char_pos
-
-    @magic_comment = {
-      type: :@comment,
-      value: " #{key}: #{value}",
-      sl: start_line,
-      el: start_line,
-      sc: start_char,
-      ec: start_char + @line_counts[start_line][-1]
-    }
-  end
+  # children come is a string literals. We're going to leave these alone as they
+  # come in all kinds of shapes and sizes.
+  #
+  #     def on_magic_comment(key, value)
+  #       @magic_comment = { value: " #{key}: #{value}" }
+  #     end
 
   # massign is a parser event that is a parent node of any kind of multiple
   # assignment. This includes splitting out variables on the left like:

data/dist/ruby/printer.js

@@ -67,6 +67,10 @@ const printer = {
                 }
                 return parts;
             }
+            case "brace_block":
+                return [node.body[0], node.body[1], node.beging];
+            case "do_block":
+                return [node.body[0], node.body[1], node.beging];
             case "paren":
                 return [node.lparen, node.body[0]];
             default: {

data/exe/rbprettier

@@ -4,5 +4,4 @@
 $:.unshift(File.expand_path(File.join('..', 'lib'), __dir__))
 require 'prettier'
 
-Prettier.run(ARGV)
-exit($?.exitstatus) if $?.exited?
+exit(Prettier.run(ARGV))

data/lib/prettier.rb

@@ -1,18 +1,49 @@
 # frozen_string_literal: true
 
 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']
 
-  class << self
-    def run(args)
-      quoted = args.map { |arg| arg.start_with?('-') ? arg : "\"#{arg}\"" }
-      command = "node #{BINARY} --plugin \"#{PLUGIN}\" #{quoted.join(' ')}"
+  def self.run(args)
+    quoted = args.map { |arg| arg.start_with?('-') ? arg : "\"#{arg}\"" }
+    command = "node #{BINARY} --plugin \"#{PLUGIN}\" #{quoted.join(' ')}"
 
-      system({ 'RBPRETTIER' => '1' }, command)
+    stdout, stderr, status = Open3.capture3({ 'RBPRETTIER' => '1' }, command)
+    STDOUT.puts(stdout)
+
+    # If we completed successfully, then just exit out.
+    exitstatus = status.exitstatus
+    return exitstatus if exitstatus == 0
+
+    if stderr.match?(%r{Cannot find module '/.+?/bin-prettier.js'})
+      # If we're missing bin-prettier.js, then it's possible the user installed
+      # the gem through git, which wouldn't have installed the requisite
+      # JavaScript files.
+      STDERR.puts(<<~MSG)
+        Could not find the JavaScript files necessary to run 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:
+          
+          `yarn && yarn prepublishOnly`
+           or
+           `npm install && npm run prepublishOnly`
+           or
+           you can change the source in your Gemfile to point directly to rubygems.
+      MSG
+    else
+      # Otherwise, just print out the same error that prettier emitted, as it's
+      # unknown to us.
+      STDERR.puts(stderr)
     end
+
+    # Make sure we still exit with the same status code the prettier emitted.
+    exitstatus
   end
 end

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "2.0.0-rc1",
+  "version": "2.0.0",
   "description": "prettier plugin for the Ruby programming language",
   "main": "dist/plugin.js",
   "scripts": {
@@ -26,9 +26,9 @@
     "@types/jest": "^27.0.1",
     "@types/node": "^16.9.1",
     "@types/prettier": "^2.3.2",
-    "@typescript-eslint/eslint-plugin": "^4.31.2",
-    "@typescript-eslint/parser": "^4.31.2",
-    "eslint": "^7.22.0",
+    "@typescript-eslint/eslint-plugin": "^5.2.0",
+    "@typescript-eslint/parser": "^5.2.0",
+    "eslint": "^8.1.0",
     "eslint-config-prettier": "^8.0.0",
     "husky": "^7.0.0",
     "jest": "^27.0.1",

data/rubocop.yml

@@ -13,12 +13,16 @@ Layout:
 Layout/LineLength:
   Enabled: true
 
-# Disabling all of the following options because they could conflict with a
-# prettier configuration setting.
-
 Style/MultilineIfModifier: # rubyModifier
   Enabled: false
 
+# When method chains with multiple blocks are chained together, rubocop will let
+# them pass if they're using braces but not if they're using do and end
+# keywords. Because we will break individual blocks down to using keywords if
+# they are multiline, this conflicts with rubocop.
+Style/MultilineBlockChain:
+  Enabled: false
+
 Style/SymbolArray: # rubyArrayLiteral
   Enabled: false
 
@@ -34,5 +38,7 @@ Style/TrailingCommaInArrayLiteral: # trailingComma
 Style/TrailingCommaInHashLiteral: # trailingComma
   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:
   Enabled: false

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prettier
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.rc1
+  version: 2.0.0
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-30 00:00:00.000000000 Z
+date: 2021-10-28 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -129,9 +129,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.2.3
 signing_key: