prettier 1.5.1 → 1.6.0

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

@@ -1,30 +1,169 @@
-const requestParse = require("./requestParse");
+const { spawn, spawnSync, execSync } = require("child_process");
+const { existsSync, mkdtempSync } = require("fs");
+const os = require("os");
+const path = require("path");
+const process = require("process");
+
+let sockfile = process.env.PRETTIER_RUBY_HOST;
+let netcat;
+
+// 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];
+}
+
+// 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 tmpDir = mkdtempSync(path.join(os.tmpdir(), "prettier-ruby"));
+  const tmpFile = path.join(tmpDir, `${process.pid}.sock`);
+
+  const server = spawn("ruby", [path.join(__dirname, "./server.rb"), tmpFile], {
+    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(tmpFile) && new Date() - now < 3000) {
+    execSync("sleep 0.1");
+  }
+
+  return tmpFile;
+}
+
+// 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 a 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 findNetcat(opts) {
+  if (opts.rubyNetcatCommand) {
+    const splits = opts.rubyNetcatCommand.split(" ");
+    return { command: splits[0], args: splits.slice(1) };
+  }
+
+  if (hasCommand("nc")) {
+    return { command: "nc", args: ["-U"] };
+  }
+
+  if (hasCommand("telnet")) {
+    return { command: "telnet", args: ["-u"] };
+  }
+
+  if (hasCommand("ncat")) {
+    return { command: "ncat", args: ["-U"] };
+  }
+
+  if (hasCommand("socat")) {
+    return { command: "socat", args: ["-"] };
+  }
+
+  return { command: "node", args: [require.resolve("./netcat.js")] };
+}
 
 // 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);
+function parseSync(parser, source, opts) {
+  if (!sockfile) {
+    sockfile = spawnParseServer();
+  }
+
+  if (!netcat) {
+    netcat = findNetcat(opts);
+  }
 
+  const response = spawnSync(netcat.command, netcat.args.concat(sockfile), {
+    input: `${parser}|${source}`,
+    maxBuffer: 15 * 1024 * 1024
+  });
+
+  const stdout = response.stdout.toString();
+  const stderr = response.stderr.toString();
+  const { status } = response;
+
+  // We need special handling in case the user's version of nc doesn't support
+  // using unix sockets.
   if (
-    response.stdout.length === 0 ||
-    (response.status !== null && response.status !== 0)
+    stderr.includes("invalid option -- U") ||
+    stderr.includes("invalid option -- 'u'") ||
+    stderr.includes("Protocol not supported")
   ) {
-    console.error("Could not parse response from server");
-    console.error(response);
+    throw new Error(`
+      @prettier/plugin-ruby uses unix sockets to communicate between the node.js
+      process running prettier and an underlying Ruby process used for parsing.
+      Unfortunately the command that it tried to use to do that
+      (${netcat.command}) does not support unix sockets. To solve this either
+      uninstall the version of ${netcat.command} that you're using 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/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

@@ -10,7 +10,7 @@ const hamlParser = require("./haml/parser");
 /*
  * metadata mostly pulled from linguist and rubocop:
  * https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
- * https://github.com/rubocop-hq/rubocop/blob/master/spec/rubocop/target_finder_spec.rb
+ * https://github.com/rubocop/rubocop/blob/master/spec/rubocop/target_finder_spec.rb
  */
 
 module.exports = {
@@ -119,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,16 +4,14 @@ 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)/;
-
 // This function handles checking whether or not the source string has the
 // pragma for prettier. This is an optional workflow for incremental adoption.
 function hasPragma(text) {
-  return pragmaPattern.test(text);
+  return /^\s*#[^\S\n]*@(format|prettier)\s*(\n|$)/.test(text);
 }
 
 // This function is critical for comments and cursor support, and is responsible

data/src/rbs/parser.rb

@@ -86,9 +86,13 @@ end
 module Prettier
   class RBSParser
     def self.parse(text)
-      { declarations: RBS::Parser.parse_signature(text) }
-    rescue StandardError
-      false
+      {
+        declarations: RBS::Parser.parse_signature(text),
+        location: {
+          start_pos: 0,
+          end_pos: text.length
+        }
+      }
     end
   end
 end

data/src/rbs/printer.js

@@ -147,7 +147,7 @@ function printNode(path, opts, print) {
 
   // This is the big function that prints out any individual type, which can
   // look like all kinds of things, listed in the case statement below.
-  function printType(path) {
+  function printType(path, { forceParens = false } = {}) {
     const node = path.getValue();
 
     switch (node.class) {
@@ -157,7 +157,13 @@ function printNode(path, opts, print) {
         }
         return node.literal;
       case "optional":
-        return concat([path.call(printType, "type"), "?"]);
+        return concat([
+          path.call(
+            (typePath) => printType(typePath, { forceParens: true }),
+            "type"
+          ),
+          "?"
+        ]);
       case "tuple":
         // If we don't have any sub types, we explicitly need the space in between
         // the brackets to not confuse the parser.
@@ -173,11 +179,29 @@ function printNode(path, opts, print) {
           join(concat([line, "| "]), path.map(printType, "types"))
         );
 
-        const parentType = path.getParentNode().class;
-        return parentType === "intersection" ? concat(["(", doc, ")"]) : doc;
+        if (forceParens) {
+          return concat(["(", doc, ")"]);
+        }
+
+        return doc;
+      }
+      case "intersection": {
+        const doc = group(
+          join(
+            concat([line, "& "]),
+            path.map(
+              (typePath) => printType(typePath, { forceParens: true }),
+              "types"
+            )
+          )
+        );
+
+        if (forceParens) {
+          return concat(["(", doc, ")"]);
+        }
+
+        return doc;
       }
-      case "intersection":
-        return group(join(concat([line, "& "]), path.map(printType, "types")));
       case "class_singleton":
         return concat(["singleton(", node.name, ")"]);
       case "proc":
@@ -515,7 +539,14 @@ function printNode(path, opts, print) {
       );
     }
 
-    parts.push("-> ", path.call(printType, "type", "return_type"));
+    parts.push(
+      "-> ",
+      path.call(
+        (typePath) => printType(typePath, { forceParens: true }),
+        "type",
+        "return_type"
+      )
+    );
 
     return group(concat(parts));
   }
@@ -599,7 +630,14 @@ function hasPrettierIgnore(path) {
   return node.comment && node.comment.string.includes("prettier-ignore");
 }
 
+// This function handles adding the format pragma to a source string. This is an
+// optional workflow for incremental adoption.
+function insertPragma(text) {
+  return `# @format\n${text}`;
+}
+
 module.exports = {
   print: printNode,
-  hasPrettierIgnore
+  hasPrettierIgnore,
+  insertPragma
 };

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",
@@ -30,7 +30,7 @@ function replaceNewlines(doc) {
       ? concat(
           currentDoc
             .split(/(\n)/g)
-            .map((v, i) => (i % 2 === 0 ? v : literalLineNoBreak))
+            .map((v, i) => (i % 2 === 0 ? v : literallineWithoutBreakParent))
         )
       : currentDoc
   );
@@ -106,7 +106,7 @@ function embed(path, print, textToDoc, _opts) {
 
   // Pass that content into the embedded parser. Get back the doc node.
   const formatted = concat([
-    literalLineNoBreak,
+    literallineWithoutBreakParent,
     replaceNewlines(stripTrailingHardline(textToDoc(content, { parser })))
   ]);
 
@@ -119,7 +119,7 @@ function embed(path, print, textToDoc, _opts) {
         group(
           concat([
             indent(markAsRoot(formatted)),
-            literalLineNoBreak,
+            literallineWithoutBreakParent,
             ending.trim()
           ])
         )
@@ -132,7 +132,9 @@ function 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()]))
+      )
     ])
   );
 }

data/src/ruby/nodes/args.js

@@ -58,7 +58,7 @@ function printArgParen(path, opts, print) {
         concat([
           softline,
           join(concat([",", line]), path.call(print, "body", 0)),
-          getTrailingComma(opts) && getArgParenTrailingComma(argsNode)
+          getTrailingComma(opts) ? getArgParenTrailingComma(argsNode) : ""
         ])
       ),
       softline,
@@ -106,25 +106,117 @@ function printArgs(path, { rubyToProc }, print) {
   return args;
 }
 
-module.exports = {
-  arg_paren: printArgParen,
-  args: printArgs,
-  args_add_block: (path, opts, print) => {
-    const parts = path.call(print, "body", 0);
+function printArgsAddBlock(path, opts, print) {
+  const node = path.getValue();
+  const blockNode = node.body[1];
+
+  const parts = path.call(print, "body", 0);
+
+  if (blockNode) {
+    let blockDoc = path.call(print, "body", 1);
+
+    if (!(blockNode.comments || []).some(({ leading }) => leading)) {
+      // If we don't have any leading comments, we can just prepend the
+      // operator.
+      blockDoc = concat(["&", blockDoc]);
+    } else if (Array.isArray(blockDoc[0])) {
+      // If we have a method call like:
+      //
+      //     foo(
+      //       # comment
+      //       &block
+      //     )
+      //
+      // then we need to make sure we don't accidentally prepend the operator
+      // before the comment.
+      //
+      // In prettier >= 2.3.0, the comments are printed as an array before the
+      // content. I don't love this kind of reflection, but it's the simplest
+      // way at the moment to get this right.
+      blockDoc = blockDoc[0].concat(
+        concat(["&", blockDoc[1]]),
+        blockDoc.slice(2)
+      );
+    } else {
+      // In prettier < 2.3.0, the comments are printed as part of a concat, so
+      // we can reflect on how many leading comments there are to determine
+      // which doc node we should modify.
+      const index = blockNode.comments.filter(({ leading }) => leading).length;
+      blockDoc.parts[index] = concat(["&", blockDoc.parts[index]]);
+    }
+
+    parts.push(blockDoc);
+  }
+
+  return parts;
+}
+
+function printArgsAddStar(path, opts, print) {
+  let docs = [];
+
+  path.each((argPath, argIndex) => {
+    const doc = print(argPath);
+
+    // If it's the first child, then it's an array of args, so we're going to
+    // concat that onto the existing docs if there are any.
+    if (argIndex === 0) {
+      if (doc.length > 0) {
+        docs = docs.concat(doc);
+      }
+      return;
+    }
+
+    // If it's after the splat, then it's an individual arg, so we're just going
+    // to push it onto the array.
+    if (argIndex !== 1) {
+      docs.push(doc);
+      return;
+    }
 
-    if (path.getValue().body[1]) {
-      parts.push(concat(["&", path.call(print, "body", 1)]));
+    // If we don't have any leading comments, we can just prepend the operator.
+    const argsNode = argPath.getValue();
+    if (!(argsNode.comments || []).some(({ leading }) => leading)) {
+      docs.push(concat(["*", doc]));
+      return;
     }
 
-    return parts;
-  },
-  args_add_star: (path, opts, print) => {
-    const printed = path.map(print, "body");
-    const parts = printed[0]
-      .concat([concat(["*", printed[1]])])
-      .concat(printed.slice(2));
-
-    return parts;
-  },
-  blockarg: (path, opts, print) => concat(["&", path.call(print, "body", 0)])
+    // If we have an array like:
+    //
+    //     [
+    //       # comment
+    //       *values
+    //     ]
+    //
+    // then we need to make sure we don't accidentally prepend the operator
+    // before the comment(s).
+    //
+    // In prettier >= 2.3.0, the comments are printed as an array before the
+    // content. I don't love this kind of reflection, but it's the simplest way
+    // at the moment to get this right.
+    if (Array.isArray(doc[0])) {
+      docs.push(doc[0].concat(concat(["*", doc[1]]), doc.slice(2)));
+      return;
+    }
+
+    // In prettier < 2.3.0, the comments are printed as part of a concat, so
+    // we can reflect on how many leading comments there are to determine which
+    // doc node we should modify.
+    const index = argsNode.comments.filter(({ leading }) => leading).length;
+    doc.parts[index] = concat(["*", doc.parts[index]]);
+    docs = docs.concat(doc);
+  }, "body");
+
+  return docs;
+}
+
+function printBlockArg(path, opts, print) {
+  return concat(["&", path.call(print, "body", 0)]);
+}
+
+module.exports = {
+  arg_paren: printArgParen,
+  args: printArgs,
+  args_add_block: printArgsAddBlock,
+  args_add_star: printArgsAddStar,
+  blockarg: printBlockArg
 };