prettier 1.4.0 → 1.5.4

data/README.md

@@ -128,17 +128,19 @@ The `prettier` executable is now installed and ready for use:
 
 Below are the options (from [`src/plugin.js`](src/plugin.js)) that `@prettier/plugin-ruby` currently supports:
 
-| API Option         | CLI Option             | Default | Description                                                                                                                          |
-| ------------------ | ---------------------- | :-----: | ------------------------------------------------------------------------------------------------------------------------------------ |
-| `printWidth`       | `--print-width`        |  `80`   | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#print-width)).                                     |
-| `requirePragma`    | `--require-pragma`     | `false` | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#require-pragma)).                                  |
-| `rubyArrayLiteral` | `--ruby-array-literal` | `true`  | When possible, favor the use of string and symbol array literals.                                                                    |
-| `rubyHashLabel`    | `--ruby-hash-label`    | `true`  | When possible, uses the shortened hash key syntax, as opposed to hash rockets.                                                       |
-| `rubyModifier`     | `--ruby-modifier`      | `true`  | When it fits on one line, allows while and until statements to use the modifier form.                                                |
-| `rubySingleQuote`  | `--ruby-single-quote`  | `true`  | When double quotes are not necessary for interpolation, prefers the use of single quotes for string literals.                        |
-| `rubyToProc`       | `--ruby-to-proc`       | `false` | When possible, convert blocks to the more concise `Symbol#to_proc` syntax.                                                           |
-| `tabWidth`         | `--tab-width`          |   `2`   | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#tab-width)).                                       |
-| `trailingComma`    | `--trailing-comma`     | `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.                                                                                                    |
+| `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`. |
 
 Any of these can be added to your existing [prettier configuration
 file](https://prettier.io/docs/en/configuration.html). For example:
@@ -163,11 +165,20 @@ with some of RuboCop's functionality.
 Prettier provides a RuboCop configuration file to disable the rules which clash.
 To enable, add the following config at the top of your project's `.rubocop.yml`:
 
+#### Ruby gem
+
 ```yaml
 inherit_gem:
   prettier: rubocop.yml
 ```
 
+#### `npm` package
+
+```yaml
+inherit_from:
+  - node_modules/@prettier/plugin-ruby/rubocop.yml
+```
+
 ## 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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "1.4.0",
+  "version": "1.5.4",
   "description": "prettier plugin for the Ruby programming language",
   "main": "src/plugin.js",
   "scripts": {
@@ -22,9 +22,9 @@
     "prettier": ">=1.10"
   },
   "devDependencies": {
-    "eslint": "^7.8.1",
-    "eslint-config-prettier": "^7.0.0",
-    "husky": "^4.3.5",
+    "eslint": "^7.22.0",
+    "eslint-config-prettier": "^8.0.0",
+    "husky": "^5.0.9",
     "jest": "^26.0.0",
     "pretty-quick": "^3.1.0"
   },

data/rubocop.yml

@@ -24,3 +24,6 @@ Style/TrailingCommaInArrayLiteral: # trailingComma
 
 Style/TrailingCommaInHashLiteral: # trailingComma
   Enabled: false
+
+Style/Lambda:
+  Enabled: false

data/src/haml/parser.js

@@ -1,7 +1,7 @@
 const parseSync = require("../parser/parseSync");
 
-const parse = (text, _parsers, _opts) => {
-  return parseSync("haml", text);
+const parse = (text, _parsers, opts) => {
+  return parseSync("haml", text, opts);
 };
 
 const pragmaPattern = /^\s*-#\s*@(prettier|format)/;

data/src/haml/parser.rb

@@ -131,8 +131,6 @@ module Prettier
   class HAMLParser
     def self.parse(source)
       Haml::Parser.new({}).call(source).as_json
-    rescue StandardError
-      false
     end
   end
 end

data/src/parser/getNetcat.js

@@ -16,35 +16,42 @@ function hasCommand(name) {
 
 // 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() {
+function getCommandAndArgs() {
   if (hasCommand("nc")) {
-    return ["nc", "-U"];
+    return ["nc", ["-U"]];
   }
 
   if (hasCommand("telnet")) {
-    return ["telnet", "-u"];
+    return ["telnet", ["-u"]];
   }
 
   if (hasCommand("ncat")) {
-    return ["ncat", "-U"];
+    return ["ncat", ["-U"]];
   }
 
   if (hasCommand("socat")) {
-    return ["socat", "-"];
+    return ["socat", ["-"]];
   }
 
-  return ["node", require.resolve("./netcat.js")];
+  return ["node", [require.resolve("./netcat.js")]];
 }
 
 let command;
-let arg;
+let args;
 
-function getNetcat() {
+function getNetcat(opts) {
   if (!command) {
-    [command, arg] = getCommandAndArg();
+    if (opts.rubyNetcatCommand) {
+      const splits = opts.rubyNetcatCommand.split(" ");
+
+      command = splits[0];
+      args = splits.slice(1);
+    } else {
+      [command, args] = getCommandAndArgs();
+    }
   }
 
-  return { command, arg };
+  return { command, args };
 }
 
 module.exports = getNetcat;

data/src/parser/netcat.js

@@ -5,11 +5,9 @@
 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

@@ -4,27 +4,37 @@ const requestParse = require("./requestParse");
 // 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);
+function parseSync(parser, source, opts) {
+  const { stdout, stderr, status } = requestParse(parser, source, opts);
 
-  if (
-    response.stdout.length === 0 ||
-    (response.status !== null && response.status !== 0)
-  ) {
-    console.error("Could not parse response from server");
-    console.error(response);
+  // We need special handling in case the user's version of nc doesn't support
+  // using unix sockets.
+  if (stderr.includes("invalid option -- U")) {
+    throw new Error(`
+      @prettier/plugin-ruby uses netcat to communicate over unix sockets between
+      the node.js process running prettier and an underlying Ruby process used
+      for parsing. Unfortunately the version of netcat that you have installed
+      (GNU netcat) does not support unix sockets. To solve this either uninstall
+      GNU netcat and use a different implementation, or change the value of the
+      rubyNetcatCommand option in your prettier configuration.
+    `);
+  }
 
-    throw new Error(response.stderr || "An unknown error occurred");
+  // 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(response.stdout);
+  const parsed = JSON.parse(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]\`.`
-    );
+    const error = new Error(parsed.error);
+    if (parsed.loc) {
+      error.loc = parsed.loc;
+    }
+
+    throw error;
   }
 
   return parsed;

data/src/parser/requestParse.js

@@ -54,11 +54,11 @@ function ensureParseServer() {
 }
 
 // Sends a request to the parse server to parse the given content.
-function requestParse(parser, source) {
+function requestParse(parser, source, opts) {
   ensureParseServer();
 
-  const { command, arg } = getNetcat();
-  const { stdout, stderr, status } = spawnSync(command, [arg, sockfile], {
+  const { command, args } = getNetcat(opts);
+  const { stdout, stderr, status } = spawnSync(command, args.concat(sockfile), {
     input: `${parser}|${source}`,
     maxBuffer: 15 * 1024 * 1024
   });

data/src/parser/server.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'bundler/setup' if ENV['CI']
+require 'bundler/setup' if ENV['PLUGIN_RUBY_CI']
 require 'socket'
 require 'json'
 
@@ -14,7 +14,7 @@ $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(:QUIT) { quit = true } if RUBY_PLATFORM != 'java'
 trap(:INT) { quit = true }
 trap(:TERM) { quit = true }
 
@@ -48,6 +48,11 @@ loop do
     else
       socket.write('{ "error": true }')
     end
+  rescue Prettier::Parser::ParserError => error
+    loc = { start: { line: error.lineno, column: error.column } }
+    socket.write(JSON.fast_generate(error: error.message, loc: loc))
+  rescue StandardError => error
+    socket.write(JSON.fast_generate(error: error.message))
   ensure
     socket.close
   end

data/src/plugin.js

@@ -36,6 +36,7 @@ module.exports = {
         ".rabl",
         ".rake",
         ".rb",
+        ".rbi",
         ".rbuild",
         ".rbw",
         ".rbx",
@@ -118,6 +119,12 @@ module.exports = {
       description:
         "When it fits on one line, allows if, unless, while, and until statements to use the modifier form."
     },
+    rubyNetcatCommand: {
+      type: "string",
+      category: "Ruby",
+      description:
+        '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: {
       type: "boolean",
       category: "Ruby",

data/src/rbs/parser.js

@@ -4,8 +4,8 @@ const parseSync = require("../parser/parseSync");
 // 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) {
-  return parseSync("rbs", text);
+function parse(text, _parsers, opts) {
+  return parseSync("rbs", text, opts);
 }
 
 const pragmaPattern = /#\s*@(prettier|format)/;

data/src/rbs/parser.rb

@@ -23,8 +23,14 @@ end
 class RBS::Location
   def to_json(*args)
     {
-      start: { line: start_line, column: start_column },
-      end: { line: end_line, column: end_column },
+      start: {
+        line: start_line,
+        column: start_column
+      },
+      end: {
+        line: end_line,
+        column: end_column
+      },
       start_pos: start_pos,
       end_pos: end_pos
     }.to_json(*args)
@@ -81,8 +87,6 @@ module Prettier
   class RBSParser
     def self.parse(text)
       { declarations: RBS::Parser.parse_signature(text) }
-    rescue StandardError
-      false
     end
   end
 end

data/src/ruby/embed.js

@@ -8,7 +8,7 @@ const {
   stripTrailingHardline
 } = require("../prettier");
 
-const { literalLineNoBreak } = require("../utils");
+const { literallineWithoutBreakParent } = require("../utils");
 
 const parsers = {
   css: "css",
@@ -24,18 +24,54 @@ const parsers = {
 // 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 */
-const replaceNewlines = (doc) =>
-  mapDoc(doc, (currentDoc) =>
+function replaceNewlines(doc) {
+  return mapDoc(doc, (currentDoc) =>
     typeof currentDoc === "string" && currentDoc.includes("\n")
       ? concat(
           currentDoc
             .split(/(\n)/g)
-            .map((v, i) => (i % 2 === 0 ? v : literalLineNoBreak))
+            .map((v, i) => (i % 2 === 0 ? v : literallineWithoutBreakParent))
         )
       : currentDoc
   );
+}
 
-const embed = (path, print, textToDoc, _opts) => {
+// Returns a number that represents the minimum amount of leading whitespace
+// that is present on every line in the given string. So for example if you have
+// the following heredoc:
+//
+//     <<~HERE
+//       my
+//       content
+//       here
+//     HERE
+//
+// then the return value of this function would be 2. If you indented every line
+// of the inner content 2 more spaces then this function would return 4.
+function getCommonLeadingWhitespace(content) {
+  const pattern = /^\s+/;
+
+  return content
+    .split("\n")
+    .slice(0, -1)
+    .reduce((minimum, line) => {
+      const matched = pattern.exec(line);
+      const length = matched ? matched[0].length : 0;
+
+      return minimum === null ? length : Math.min(minimum, length);
+    }, null);
+}
+
+// Returns a new string with the common whitespace stripped out. Effectively it
+// emulates what a squiggly heredoc does in Ruby.
+function stripCommonLeadingWhitespace(content) {
+  const lines = content.split("\n");
+  const minimum = getCommonLeadingWhitespace(content);
+
+  return lines.map((line) => line.slice(minimum)).join("\n");
+}
+
+function embed(path, print, textToDoc, _opts) {
   const node = path.getValue();
 
   // Currently we only support embedded formatting on heredoc nodes
@@ -45,6 +81,8 @@ const embed = (path, print, textToDoc, _opts) => {
 
   // First, ensure that we don't have any interpolation
   const { beging, body, ending } = node;
+  const isSquiggly = beging.body[2] === "~";
+
   if (body.some((part) => part.type !== "@tstring_content")) {
     return null;
   }
@@ -56,24 +94,32 @@ const embed = (path, print, textToDoc, _opts) => {
     return null;
   }
 
-  // Get the content as if it were a source string, and then pass that content
-  // into the embedded parser. Get back the doc node.
-  const content = body.map((part) => part.body).join("");
+  // Get the content as if it were a source string.
+  let content = body.map((part) => part.body).join("");
+
+  // If we're using a squiggly heredoc, then we're going to manually strip off
+  // the leading whitespace of each line up to the minimum leading whitespace so
+  // that the embedded parser can handle that for us.
+  if (isSquiggly) {
+    content = stripCommonLeadingWhitespace(content);
+  }
+
+  // Pass that content into the embedded parser. Get back the doc node.
   const formatted = concat([
-    literalLineNoBreak,
+    literallineWithoutBreakParent,
     replaceNewlines(stripTrailingHardline(textToDoc(content, { parser })))
   ]);
 
   // If we're using a squiggly heredoc, then we can properly handle indentation
   // ourselves.
-  if (beging.body[2] === "~") {
+  if (isSquiggly) {
     return concat([
       path.call(print, "beging"),
       lineSuffix(
         group(
           concat([
             indent(markAsRoot(formatted)),
-            literalLineNoBreak,
+            literallineWithoutBreakParent,
             ending.trim()
           ])
         )
@@ -86,9 +132,11 @@ const embed = (path, print, textToDoc, _opts) => {
   return markAsRoot(
     concat([
       path.call(print, "beging"),
-      lineSuffix(group(concat([formatted, literalLineNoBreak, ending.trim()])))
+      lineSuffix(
+        group(concat([formatted, literallineWithoutBreakParent, ending.trim()]))
+      )
     ])
   );
-};
+}
 
 module.exports = embed;