prettier 1.3.0 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 657db7d1eef6e33d72337eb6b666678675c9eced4cc19716466b4bd74c039cfc
-  data.tar.gz: d69ffa4e3b2b48146c112a9ceb0d4ddab3351119c1bb2b9d92848f7beb3f40e4
+  metadata.gz: b87bc10882cc30779fa7d83d4b52bada919561ed298c0a42331f6df5b8681fb4
+  data.tar.gz: fc46f3778f9824d8a9b5f2d15e70a6419e01ed921b3ed3c7f4a0ff4699b7aa2a
 SHA512:
-  metadata.gz: d7c4d27daddee1e5d07393c5358e48a419c75a6e1aff62b36779d093f16f3da613c938b98c188752c93835e66ddd9578ebf6595fcde1a1f69f40f2613b492ddd
-  data.tar.gz: c586e33dcd0057779689df71ab68d8858aac27c9e89cf2f500edd2b55779b26693cf6756815cc616054c364b6bc4e1adff05263036f74025425218c04676969c
+  metadata.gz: 76a79ab1910791821427f896140c008a3b5430a99236c65225b24c633bd333462ad77fd5f90c6f9de060568809aa05585198aba8fcfe64f1c30c381c9c6f8ce7
+  data.tar.gz: 408d7cabd27ce93415ee1cf5248746c62fbba32ab3cab820fbdc02f45da2ae2555a89eca2d3be81573acfa02d331a06628a332e22021e4771d51dd2c2a51adf4

data/CHANGELOG.md

@@ -6,6 +6,20 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [1.4.0] - 2021-01-15
+
+### Added
+
+- [@ianks], [@kddeisz] - Use `netcat` to communicate to a parser server for better performance when formatting multiple files.
+
+### Changed
+
+- [@jeffcarbs], [@kddeisz] - Long strings with interpolated expressions should only break if the contents in the original source is broken.
+- [@johannesluedke], [@kddeisz] - Fix for rescues with inline comments.
+- [@johncsnyder], [@kddeisz] - Comments should not attach to nodes beyond a double newline.
+- [@blampe], [@kddeisz] - Comments inside of a broken method chain get dropped.
+- [@clarkdave], [@kddeisz] - Don't ignore Sorbet `sig` transformations.
+
 ## [1.3.0] - 2021-01-05
 
 ### Added
@@ -1035,7 +1049,8 @@ would previously result in `array[]`, but now prints properly.
 
 - Initial release 🎉
 
-[unreleased]: https://github.com/prettier/plugin-ruby/compare/v1.3.0...HEAD
+[unreleased]: https://github.com/prettier/plugin-ruby/compare/v1.4.0...HEAD
+[1.4.0]: https://github.com/prettier/plugin-ruby/compare/v1.3.0...v1.4.0
 [1.3.0]: https://github.com/prettier/plugin-ruby/compare/v1.2.5...v1.3.0
 [1.2.5]: https://github.com/prettier/plugin-ruby/compare/v1.2.4...v1.2.5
 [1.2.4]: https://github.com/prettier/plugin-ruby/compare/v1.2.3...v1.2.4
@@ -1107,6 +1122,7 @@ would previously result in `array[]`, but now prints properly.
 [@bugthing]: https://github.com/bugthing
 [@cbothner]: https://github.com/cbothner
 [@christoomey]: https://github.com/christoomey
+[@clarkdave]: https://github.com/clarkdave
 [@cldevs]: https://github.com/cldevs
 [@codingitwrong]: https://github.com/CodingItWrong
 [@coiti]: https://github.com/coiti
@@ -1126,7 +1142,9 @@ would previously result in `array[]`, but now prints properly.
 [@jamescostian]: https://github.com/jamescostian
 [@janklimo]: https://github.com/janklimo
 [@jbielick]: https://github.com/jbielick
+[@jeffcarbs]: https://github.com/jeffcarbs
 [@joeyjoejoejr]: https://github.com/joeyjoejoejr
+[@johannesluedke]: https://github.com/johannesluedke
 [@johncsnyder]: https://github.com/johncsnyder
 [@johnschoeman]: https://github.com/johnschoeman
 [@joshuakgoldberg]: https://github.com/JoshuaKGoldberg

data/README.md

@@ -138,7 +138,7 @@ Below are the options (from [`src/plugin.js`](src/plugin.js)) that `@prettier/pl
 | `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`     | `"es5"` | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#trailing-comma)). `"es5"` is equivalent to `true`. |
+| `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`. |
 
 Any of these can be added to your existing [prettier configuration
 file](https://prettier.io/docs/en/configuration.html). For example:

data/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "prettier plugin for the Ruby programming language",
   "main": "src/plugin.js",
   "scripts": {
     "check-format": "prettier --check '**/*'",
     "lint": "eslint --cache .",
-    "test": "PORT=$(bin/port) jest"
+    "test": "jest"
   },
   "repository": {
     "type": "git",

data/src/haml/parser.js

@@ -1,18 +1,7 @@
-const { spawnSync } = require("child_process");
-const path = require("path");
-
-const parser = path.join(__dirname, "./parser.rb");
+const parseSync = require("../parser/parseSync");
 
 const parse = (text, _parsers, _opts) => {
-  const child = spawnSync("ruby", [parser], { input: text });
-
-  const error = child.stderr.toString();
-  if (error) {
-    throw new Error(error);
-  }
-
-  const response = child.stdout.toString();
-  return JSON.parse(response);
+  return parseSync("haml", text);
 };
 
 const pragmaPattern = /^\s*-#\s*@(prettier|format)/;

data/src/haml/parser.rb

@@ -1,10 +1,26 @@
 # frozen_string_literal: true
 
-require 'bundler/setup' if ENV['CI']
-require 'haml'
-require 'json'
 require 'ripper'
 
+begin
+  require 'haml'
+rescue LoadError
+  # If we can't load the haml gem, then we're going to provide a shim parser
+  # that will warn and bail out.
+  class Prettier::HAMLParser
+    def self.parse(text)
+      warn(
+        'The `haml` gem could not be loaded. Please ensure you have it ' \
+          'installed and that it is available in the gem path.'
+      )
+
+      false
+    end
+  end
+
+  return
+end
+
 class Haml::Parser::ParseNode
   class DeepAttributeParser
     def parse(string)
@@ -120,22 +136,3 @@ module Prettier
     end
   end
 end
-
-# If this is the main file we're executing, then most likely this is being
-# executed from the haml.js spawn. In that case, read the ruby source from
-# stdin and report back the AST over stdout.
-if $0 == __FILE__
-  response = Prettier::HAMLParser.parse($stdin.read)
-
-  if !response
-    warn(
-      '@prettier/plugin-ruby encountered an error when attempting to parse ' \
-        'the HAML source. This usually means there was a syntax error in the ' \
-        'file in question.'
-    )
-
-    exit 1
-  end
-
-  puts JSON.fast_generate(response)
-end

data/src/parser/getLang.js

@@ -0,0 +1,32 @@
+// In order to properly parse ruby code, we need to tell the ruby process to
+// parse using UTF-8. Unfortunately, the way that you accomplish this looks
+// differently depending on your platform.
+/* istanbul ignore next */
+function getLang() {
+  const { env, platform } = process;
+  const envValue = env.LC_ALL || env.LC_CTYPE || env.LANG;
+
+  // If an env var is set for the locale that already includes UTF-8 in the
+  // name, then assume we can go with that.
+  if (envValue && envValue.includes("UTF-8")) {
+    return envValue;
+  }
+
+  // Otherwise, we're going to guess which encoding to use based on the system.
+  // This is probably not the best approach in the world, as you could be on
+  // linux and not have C.UTF-8, but in that case you're probably passing an env
+  // var for it. This object below represents all of the possible values of
+  // process.platform per:
+  // https://nodejs.org/api/process.html#process_process_platform
+  return {
+    aix: "C.UTF-8",
+    darwin: "en_US.UTF-8",
+    freebsd: "C.UTF-8",
+    linux: "C.UTF-8",
+    openbsd: "C.UTF-8",
+    sunos: "C.UTF-8",
+    win32: ".UTF-8"
+  }[platform];
+}
+
+module.exports = getLang;

data/src/parser/getNetcat.js

@@ -0,0 +1,50 @@
+const { spawnSync } = require("child_process");
+const os = require("os");
+
+// Checks to see if an executable is available.
+function hasCommand(name) {
+  let result;
+
+  if (os.type() === "Windows_NT") {
+    result = spawnSync("where", [name]);
+  } else {
+    result = spawnSync("command", ["-v", name]);
+  }
+
+  return result.status === 0;
+}
+
+// Finds an netcat-like adapter to use for sending data to a socket. We order
+// these by likelihood of being found so we can avoid some shell-outs.
+function getCommandAndArg() {
+  if (hasCommand("nc")) {
+    return ["nc", "-U"];
+  }
+
+  if (hasCommand("telnet")) {
+    return ["telnet", "-u"];
+  }
+
+  if (hasCommand("ncat")) {
+    return ["ncat", "-U"];
+  }
+
+  if (hasCommand("socat")) {
+    return ["socat", "-"];
+  }
+
+  return ["node", require.resolve("./netcat.js")];
+}
+
+let command;
+let arg;
+
+function getNetcat() {
+  if (!command) {
+    [command, arg] = getCommandAndArg();
+  }
+
+  return { command, arg };
+}
+
+module.exports = getNetcat;

data/src/parser/netcat.js

@@ -0,0 +1,15 @@
+// A simple fallback when no netcat-compatible adapter is found on the system.
+// On average, this is 2-3x slower than netcat, but still much faster than
+// spawning a new Ruby process.
+
+const { createConnection } = require("net");
+
+const sock = process.argv[process.argv.length - 1];
+
+const client = createConnection(sock, () => process.stdin.pipe(client));
+
+client.on("data", (data) => process.stdout.write(data));
+
+client.on("error", (error) => {
+  console.error(error);
+});

data/src/parser/parseSync.js

@@ -0,0 +1,33 @@
+const requestParse = require("./requestParse");
+
+// 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) {
+  const response = requestParse(parser, source);
+
+  if (
+    response.stdout.length === 0 ||
+    (response.status !== null && response.status !== 0)
+  ) {
+    console.error("Could not parse response from server");
+    console.error(response);
+
+    throw new Error(response.stderr || "An unknown error occurred");
+  }
+
+  const parsed = JSON.parse(response.stdout);
+
+  if (parsed.error) {
+    throw new Error(
+      `@prettier/plugin-ruby encountered an error when attempting to parse \
+the ruby source. This usually means there was a syntax error in the \
+file in question. You can verify by running \`ruby -i [path/to/file]\`.`
+    );
+  }
+
+  return parsed;
+}
+
+module.exports = parseSync;

data/src/parser/requestParse.js

@@ -0,0 +1,74 @@
+const { spawn, spawnSync, execSync } = require("child_process");
+const path = require("path");
+const { existsSync, mkdtempSync } = require("fs");
+const process = require("process");
+const os = require("os");
+
+const getNetcat = require("./getNetcat");
+const getLang = require("./getLang");
+
+let sockfile = process.env.PRETTIER_RUBY_HOST;
+
+// Spawn the parser.rb subprocess. We do this since booting Ruby is slow, and we
+// can re-use the parser process multiple times since it is statelesss.
+function spawnParseServer() {
+  const server = spawn(
+    "ruby",
+    [path.join(__dirname, "./server.rb"), sockfile],
+    {
+      env: Object.assign({}, process.env, { LANG: getLang() }),
+      detached: true,
+      stdio: "inherit"
+    }
+  );
+
+  process.on("exit", () => {
+    try {
+      process.kill(-server.pid);
+    } catch (e) {
+      // ignore
+    }
+  });
+
+  server.unref();
+  const now = new Date();
+
+  // Wait for server to go live.
+  while (!existsSync(sockfile) && new Date() - now < 3000) {
+    execSync("sleep 0.1");
+  }
+}
+
+// Ensures that a parser server is currently running by checking against the
+// sockfile variable. If it is not, create a temporary directory to house the
+// sockfile and spawn the ruby process.
+function ensureParseServer() {
+  if (sockfile) {
+    return;
+  }
+
+  const tmpDir = mkdtempSync(path.join(os.tmpdir(), "prettier-ruby"));
+  sockfile = path.join(tmpDir, `${process.pid}.sock`);
+
+  spawnParseServer();
+}
+
+// Sends a request to the parse server to parse the given content.
+function requestParse(parser, source) {
+  ensureParseServer();
+
+  const { command, arg } = getNetcat();
+  const { stdout, stderr, status } = spawnSync(command, [arg, sockfile], {
+    input: `${parser}|${source}`,
+    maxBuffer: 15 * 1024 * 1024
+  });
+
+  return {
+    command,
+    stdout: stdout.toString(),
+    stderr: stderr.toString(),
+    status
+  };
+}
+
+module.exports = requestParse;

data/src/parser/server.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'bundler/setup' if ENV['CI']
+require 'socket'
+require 'json'
+
+require_relative '../ruby/parser'
+require_relative '../rbs/parser'
+require_relative '../haml/parser'
+
+# Set the program name so that it's easy to find if we need it
+$PROGRAM_NAME = 'prettier-ruby-parser'
+
+# Make sure we trap these signals to be sure we get the quit command coming from
+# the parent node process
+quit = false
+trap(:QUIT) { quit = true }
+trap(:INT) { quit = true }
+trap(:TERM) { quit = true }
+
+sockfile = ARGV.first || "/tmp/#{$PROGRAM_NAME}.sock"
+server = UNIXServer.new(sockfile)
+
+at_exit do
+  server.close
+  File.unlink(sockfile)
+end
+
+loop do
+  break if quit
+
+  # Start up a new thread that will handle each successive connection.
+  Thread.new(server.accept_nonblock) do |socket|
+    parser, source = socket.read.force_encoding('UTF-8').split('|', 2)
+
+    response =
+      case parser
+      when 'ruby'
+        Prettier::Parser.parse(source)
+      when 'rbs'
+        Prettier::RBSParser.parse(source)
+      when 'haml'
+        Prettier::HAMLParser.parse(source)
+      end
+
+    if response
+      socket.write(JSON.fast_generate(response))
+    else
+      socket.write('{ "error": true }')
+    end
+  ensure
+    socket.close
+  end
+rescue IO::WaitReadable, Errno::EINTR
+  # Wait for select(2) to give us a connection that has content for 1 second.
+  # Otherwise timeout and continue on (so that we hit our "break if quit"
+  # pretty often).
+  IO.select([server], nil, nil, 1)
+
+  retry unless quit
+end

data/src/rbs/parser.js

@@ -1,23 +1,11 @@
-const { spawnSync } = require("child_process");
-const path = require("path");
+const parseSync = require("../parser/parseSync");
 
 // 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 Ruby
 // process of parser.rb and reading JSON off STDOUT.
 function parse(text, _parsers, _opts) {
-  const child = spawnSync("ruby", [path.join(__dirname, "./parser.rb")], {
-    input: text,
-    maxBuffer: 15 * 1024 * 1024 // 15MB
-  });
-
-  const error = child.stderr.toString();
-  if (error) {
-    throw new Error(error);
-  }
-
-  const response = child.stdout.toString();
-  return JSON.parse(response);
+  return parseSync("rbs", text);
 }
 
 const pragmaPattern = /#\s*@(prettier|format)/;

data/src/rbs/parser.rb

@@ -1,8 +1,23 @@
 #!/usr/bin/env ruby
 
-require 'bundler/setup' if ENV['CI']
-require 'json'
-require 'rbs'
+begin
+  require 'rbs'
+rescue LoadError
+  # If we can't load the rbs gem, then we're going to provide a shim parser that
+  # will warn and bail out.
+  class Prettier::RBSParser
+    def self.parse(text)
+      warn(
+        'The `rbs` gem could not be loaded. Please ensure you have it ' \
+          'installed and that it is available in the gem path.'
+      )
+
+      false
+    end
+  end
+
+  return
+end
 
 # Monkey-patch this so that we can get the character positions.
 class RBS::Location
@@ -16,6 +31,7 @@ class RBS::Location
   end
 end
 
+# Monkey-patch this so that we get whether or not it needs to be escaped.
 class RBS::Types::Function::Param
   def to_json(*a)
     escaped = name && /\A#{RBS::Parser::KEYWORDS_RE}\z/.match?(name)
@@ -60,6 +76,7 @@ class RBS::Types::Record
   end
 end
 
+# The main parser interface.
 module Prettier
   class RBSParser
     def self.parse(text)
@@ -69,23 +86,3 @@ module Prettier
     end
   end
 end
-
-# If this is the main file we're executing, then most likely this is being
-# executed from the parser.js spawn. In that case, read the rbs source from
-# stdin and report back the AST over stdout.
-
-if $0 == __FILE__
-  response = Prettier::RBSParser.parse($stdin.read)
-
-  if !response
-    warn(
-      '@prettier/plugin-ruby encountered an error when attempting to parse ' \
-        'the RBS source. This usually means there was a syntax error in the ' \
-        'file in question.'
-    )
-
-    exit 1
-  end
-
-  puts JSON.fast_generate(response)
-end

data/src/ruby/nodes/calls.js

@@ -43,7 +43,7 @@ function printCall(path, opts, print) {
 
   // If our parent node is a chained node then we're not going to group the
   // right side of the expression, as we want to have a nice multi-line layout.
-  if (chained.includes(parentNode.type)) {
+  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);
@@ -103,7 +103,7 @@ function printMethodAddArg(path, opts, print) {
 
   // If our parent node is a chained node then we're not going to group the
   // right side of the expression, as we want to have a nice multi-line layout.
-  if (chained.includes(parentNode.type)) {
+  if (chained.includes(parentNode.type) && !node.comments) {
     parentNode.chain = (node.chain || 0) + 1;
     parentNode.breakDoc = (node.breakDoc || [methodDoc]).concat(argsDoc);
     parentNode.firstReceiverType = node.firstReceiverType;
@@ -136,41 +136,12 @@ function printMethodAddArg(path, opts, print) {
   return concat([methodDoc, argsDoc]);
 }
 
-// Sorbet type annotations look like the following:
-//
-//     {method_add_block
-//       [{method_add_arg
-//          [{fcall
-//             [{@ident "sig"}]},
-//           {args []}]},
-//        {brace_block [nil, {stmts}]}}]}
-//
-function isSorbetTypeAnnotation(node) {
-  const [callNode, blockNode] = node.body;
-
-  return (
-    callNode.type === "method_add_arg" &&
-    callNode.body[0].type === "fcall" &&
-    callNode.body[0].body[0].body === "sig" &&
-    callNode.body[1].type === "args" &&
-    callNode.body[1].body.length === 0 &&
-    blockNode
-  );
-}
-
 function printMethodAddBlock(path, opts, print) {
   const node = path.getValue();
 
   const [callNode, blockNode] = node.body;
   const [callDoc, blockDoc] = path.map(print, "body");
 
-  // Very special handling here for sorbet type annotations. They look like Ruby
-  // code, but they're not actually Ruby code, so we're not going to mess with
-  // them at all.
-  if (isSorbetTypeAnnotation(node)) {
-    return opts.originalText.slice(opts.locStart(node), opts.locEnd(node));
-  }
-
   // Don't bother trying to do any kind of fancy toProc transform if the option
   // is disabled.
   if (opts.rubyToProc) {

data/src/ruby/nodes/rescue.js

@@ -26,28 +26,10 @@ function printEnsure(path, opts, print) {
 }
 
 function printRescue(path, opts, print) {
-  const [exception, variable, _stmts, addition] = path.getValue().body;
   const parts = ["rescue"];
 
-  if (exception || variable) {
-    if (exception) {
-      if (Array.isArray(exception)) {
-        // In this case, it's actually only the one exception (it's an array
-        // of length 1).
-        parts.push(" ", path.call(print, "body", 0, 0));
-      } else {
-        // Here we have multiple exceptions from which we're rescuing, so we
-        // need to align them and join them together.
-        const joiner = concat([",", line]);
-        const exceptions = group(join(joiner, path.call(print, "body", 0)));
-
-        parts.push(" ", align("rescue ".length, exceptions));
-      }
-    }
-
-    if (variable) {
-      parts.push(" => ", path.call(print, "body", 1));
-    }
+  if (path.getValue().body[0]) {
+    parts.push(align("rescue ".length, path.call(print, "body", 0)));
   } else {
     // If you don't specify an error to rescue in a `begin/rescue` block, then
     // implicitly you're rescuing from `StandardError`. In this case, we're
@@ -55,16 +37,40 @@ function printRescue(path, opts, print) {
     parts.push(" StandardError");
   }
 
-  const rescueBody = path.call(print, "body", 2);
+  const bodystmt = path.call(print, "body", 1);
 
-  if (rescueBody.parts.length > 0) {
-    parts.push(indent(concat([hardline, rescueBody])));
+  if (bodystmt.parts.length > 0) {
+    parts.push(indent(concat([hardline, bodystmt])));
   }
 
   // This is the next clause on the `begin` statement, either another
   // `rescue`, and `ensure`, or an `else` clause.
-  if (addition) {
-    parts.push(concat([hardline, path.call(print, "body", 3)]));
+  if (path.getValue().body[2]) {
+    parts.push(concat([hardline, path.call(print, "body", 2)]));
+  }
+
+  return group(concat(parts));
+}
+
+// This is a container node that we're adding into the AST that isn't present in
+// Ripper solely so that we have a nice place to attach inline comments.
+function printRescueEx(path, opts, print) {
+  const [exception, variable] = path.getValue().body;
+  const parts = [];
+
+  if (exception) {
+    let exceptionDoc = path.call(print, "body", 0);
+
+    if (Array.isArray(exceptionDoc)) {
+      const joiner = concat([",", line]);
+      exceptionDoc = group(join(joiner, exceptionDoc));
+    }
+
+    parts.push(" ", exceptionDoc);
+  }
+
+  if (variable) {
+    parts.push(" => ", path.call(print, "body", 1));
   }
 
   return group(concat(parts));
@@ -89,6 +95,7 @@ module.exports = {
   ensure: printEnsure,
   redo: literal("redo"),
   rescue: printRescue,
+  rescue_ex: printRescueEx,
   rescue_mod: printRescueMod,
   retry: literal("retry")
 };

data/src/ruby/nodes/statements.js

@@ -79,6 +79,9 @@ module.exports = {
     const { body } = path.getValue();
     return concat([trim, "__END__", literalline, body]);
   },
+  "@comment"(path, opts, _print) {
+    return opts.printer.printComment(path);
+  },
   bodystmt: printBodyStmt,
   paren: printParen,
   program: (path, opts, print) =>

data/src/ruby/nodes/strings.js

@@ -4,6 +4,7 @@ const {
   hardline,
   indent,
   literalline,
+  removeLines,
   softline,
   join
 } = require("../../prettier");
@@ -103,14 +104,14 @@ function printStringDVar(path, opts, print) {
 }
 
 function printStringEmbExpr(path, opts, print) {
+  const node = path.getValue();
   const parts = path.call(print, "body", 0);
 
-  // If the interpolated expression is inside of a heredoc or an xstring
-  // literal (a string that gets sent to the command line) then we don't want
-  // to automatically indent, as this can lead to some very odd looking
-  // expressions
-  if (["heredoc", "xstring_literal"].includes(path.getParentNode().type)) {
-    return concat(["#{", parts, "}"]);
+  // If the contents of this embedded expression were originally on the same
+  // line in the source, then we're going to leave them in place and assume
+  // that's the way the developer wanted this expression represented.
+  if (node.sl === node.el) {
+    return concat(["#{", removeLines(parts), "}"]);
   }
 
   return group(

data/src/ruby/parser.js

@@ -1,59 +1,11 @@
-const { spawnSync } = require("child_process");
-const path = require("path");
-
-// 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 */
-const LANG = (() => {
-  const { env, platform } = process;
-  const envValue = env.LC_ALL || env.LC_CTYPE || env.LANG;
-
-  // If an env var is set for the locale that already includes UTF-8 in the
-  // name, then assume we can go with that.
-  if (envValue && envValue.includes("UTF-8")) {
-    return envValue;
-  }
-
-  // Otherwise, we're going to guess which encoding to use based on the system.
-  // This is probably not the best approach in the world, as you could be on
-  // linux and not have C.UTF-8, but in that case you're probably passing an env
-  // var for it. This object below represents all of the possible values of
-  // process.platform per:
-  // https://nodejs.org/api/process.html#process_process_platform
-  return {
-    aix: "C.UTF-8",
-    darwin: "en_US.UTF-8",
-    freebsd: "C.UTF-8",
-    linux: "C.UTF-8",
-    openbsd: "C.UTF-8",
-    sunos: "C.UTF-8",
-    win32: ".UTF-8"
-  }[platform];
-})();
+const parseSync = require("../parser/parseSync");
 
 // 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 Ruby
 // process of parser.rb and reading JSON off STDOUT.
 function parse(text, _parsers, _opts) {
-  const child = spawnSync(
-    "ruby",
-    ["--disable-gems", path.join(__dirname, "./parser.rb")],
-    {
-      env: Object.assign({}, process.env, { LANG }),
-      input: text,
-      maxBuffer: 15 * 1024 * 1024 // 15MB
-    }
-  );
-
-  const error = child.stderr.toString();
-  if (error) {
-    throw new Error(error);
-  }
-
-  const response = child.stdout.toString();
-  return JSON.parse(response);
+  return parseSync("ruby", text);
 }
 
 const pragmaPattern = /#\s*@(prettier|format)/;

data/src/ruby/parser.rb

@@ -22,6 +22,10 @@ module Prettier; end
 class Prettier::Parser < Ripper
   attr_reader :source, :lines, :scanner_events, :line_counts
 
+  # This is an attr_accessor so Stmts objects can grab comments out of this
+  # array and attach them to themselves.
+  attr_accessor :comments
+
   def initialize(source, *args)
     super(source, *args)
 
@@ -125,6 +129,7 @@ class Prettier::Parser < Ripper
     @comments << {
       type: :@comment,
       value: value[1..-1].chomp.force_encoding('UTF-8'),
+      inline: value.strip != lines[lineno - 1],
       sl: lineno,
       el: lineno,
       sc: char_pos,
@@ -1768,8 +1773,8 @@ class Prettier::Parser < Ripper
     def bind_end(ec)
       merge!(ec: ec)
 
-      stmts = self[:body][2]
-      consequent = self[:body][3]
+      stmts = self[:body][1]
+      consequent = self[:body][2]
 
       if consequent
         consequent.bind_end(ec)
@@ -1784,16 +1789,30 @@ class Prettier::Parser < Ripper
   # inside of a bodystmt.
   def on_rescue(exceptions, variable, stmts, consequent)
     beging = find_scanner_event(:@kw, 'rescue')
+    exceptions = exceptions[0] if exceptions.is_a?(Array)
 
-    last_exception = exceptions.is_a?(Array) ? exceptions[-1] : exceptions
-    last_node = variable || last_exception || beging
-
+    last_node = variable || exceptions || beging
     stmts.bind(find_next_statement_start(last_node[:ec]), char_pos)
 
+    # We add an additional inner node here that ripper doesn't provide so that
+    # we have a nice place to attach inline comment. But we only need it if we
+    # have an exception or a variable that we're rescuing.
+    rescue_ex =
+      if exceptions || variable
+        {
+          type: :rescue_ex,
+          body: [exceptions, variable],
+          sl: beging[:sl],
+          sc: beging[:ec] + 1,
+          el: last_node[:el],
+          ec: last_node[:ec]
+        }
+      end
+
     Rescue.new(
       beging.merge!(
         type: :rescue,
-        body: [exceptions, variable, stmts, consequent],
+        body: [rescue_ex, stmts, consequent],
         el: lineno,
         ec: char_pos
       )
@@ -1892,12 +1911,21 @@ class Prettier::Parser < Ripper
   # propagate that onto void_stmt nodes inside the stmts in order to make sure
   # all comments get printed appropriately.
   class Stmts < SimpleDelegator
+    attr_reader :parser
+
+    def initialize(parser, values)
+      @parser = parser
+      __setobj__(values)
+    end
+
     def bind(sc, ec)
       merge!(sc: sc, ec: ec)
 
       if self[:body][0][:type] == :void_stmt
         self[:body][0].merge!(sc: sc, ec: sc)
       end
+
+      attach_comments(sc, ec)
     end
 
     def bind_end(ec)
@@ -1914,6 +1942,22 @@ class Prettier::Parser < Ripper
       self[:body] << statement
       self
     end
+
+    private
+
+    def attach_comments(sc, ec)
+      attachable =
+        parser.comments.select do |comment|
+          comment[:type] == :@comment && !comment[:inline] &&
+            sc <= comment[:sc] && ec >= comment[:ec] &&
+            !comment[:value].include?('prettier-ignore')
+        end
+
+      return if attachable.empty?
+
+      parser.comments -= attachable
+      self[:body] = (self[:body] + attachable).sort_by! { |node| node[:sc] }
+    end
   end
 
   # stmts_new is a parser event that represents the beginning of a list of
@@ -1921,6 +1965,7 @@ class Prettier::Parser < Ripper
   # stmts_add events, which we'll append onto an array body.
   def on_stmts_new
     Stmts.new(
+      self,
       type: :stmts,
       body: [],
       sl: lineno,
@@ -2549,23 +2594,3 @@ class Prettier::Parser < Ripper
     find_scanner_event(:@kw, 'super').merge!(type: :zsuper)
   end
 end
-
-# If this is the main file we're executing, then most likely this is being
-# executed from the parser.js spawn. In that case, read the ruby source from
-# stdin and report back the AST over stdout.
-
-if $0 == __FILE__
-  response = Prettier::Parser.parse($stdin.read)
-
-  if !response
-    warn(
-      '@prettier/plugin-ruby encountered an error when attempting to parse ' \
-        'the ruby source. This usually means there was a syntax error in the ' \
-        'file in question. You can verify by running `ruby -i [path/to/file]`.'
-    )
-
-    exit 1
-  end
-
-  puts JSON.fast_generate(response)
-end

data/src/ruby/printer.js

@@ -54,8 +54,6 @@ function getCommentChildNodes(node) {
   switch (node.type) {
     case "heredoc":
       return [node.beging];
-    case "rescue":
-      return [].concat(node.body[0]).concat(node.body.slice(1));
     case "aryptn":
       return [node.body[0]]
         .concat(node.body[1])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prettier
 version: !ruby/object:Gem::Version
-  version: 1.3.0
+  version: 1.4.0
 platform: ruby
 authors:
 - Kevin Deisz
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-01-05 00:00:00.000000000 Z
+date: 2021-01-15 00:00:00.000000000 Z
 dependencies: []
 description:
 email:
@@ -44,6 +44,12 @@ files:
 - src/haml/parser.js
 - src/haml/parser.rb
 - src/haml/printer.js
+- src/parser/getLang.js
+- src/parser/getNetcat.js
+- src/parser/netcat.js
+- src/parser/parseSync.js
+- src/parser/requestParse.js
+- src/parser/server.rb
 - src/plugin.js
 - src/prettier.js
 - src/rbs/parser.js
@@ -117,7 +123,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.1.4
 signing_key:
 specification_version: 4
 summary: prettier plugin for the Ruby programming language