prettier 1.5.5 → 1.6.0

data/src/parser/parseSync.js

@@ -135,15 +135,17 @@ function parseSync(parser, source, opts) {
   // using unix sockets.
   if (
     stderr.includes("invalid option -- U") ||
+    stderr.includes("invalid option -- 'u'") ||
     stderr.includes("Protocol not supported")
   ) {
     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
-      does not support unix sockets. To solve this either uninstall the version
-      of netcat that you're using and use a different implementation, or change
-      the value of the rubyNetcatCommand option in your prettier configuration.
+      @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.
     `);
   }
 

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 = {

data/src/rbs/parser.js

@@ -8,12 +8,10 @@ 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/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, { forceUnionParens = false } = {}) {
+  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,14 +179,29 @@ function printNode(path, opts, print) {
           join(concat([line, "| "]), path.map(printType, "types"))
         );
 
-        if (forceUnionParens || path.getParentNode().class === "intersection") {
+        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":
@@ -521,7 +542,7 @@ function printNode(path, opts, print) {
     parts.push(
       "-> ",
       path.call(
-        (typePath) => printType(typePath, { forceUnionParens: true }),
+        (typePath) => printType(typePath, { forceParens: true }),
         "type",
         "return_type"
       )
@@ -609,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/nodes/args.js

@@ -108,12 +108,18 @@ function printArgs(path, { rubyToProc }, print) {
 
 function printArgsAddBlock(path, opts, print) {
   const node = path.getValue();
+  const blockNode = node.body[1];
+
   const parts = path.call(print, "body", 0);
 
-  if (node.body[1]) {
+  if (blockNode) {
     let blockDoc = path.call(print, "body", 1);
 
-    if (node.body[1].comments) {
+    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(
@@ -123,10 +129,20 @@ function printArgsAddBlock(path, opts, print) {
       //
       // then we need to make sure we don't accidentally prepend the operator
       // before the comment.
-      blockDoc.parts[2] = concat(["&", blockDoc.parts[2]]);
+      //
+      // 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 {
-      // If we don't have any comments, we can just prepend the operator
-      blockDoc = concat(["&", blockDoc]);
+      // 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);
@@ -136,10 +152,34 @@ function printArgsAddBlock(path, opts, print) {
 }
 
 function printArgsAddStar(path, opts, print) {
-  const node = path.getValue();
-  const docs = path.map(print, "body");
+  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 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;
+    }
 
-  if (node.body[1].comments) {
     // If we have an array like:
     //
     //     [
@@ -147,22 +187,26 @@ function printArgsAddStar(path, opts, print) {
     //       *values
     //     ]
     //
-    // or if we have an array like:
-    //
-    //     [
-    //       *values # comment
-    //     ]
-    //
     // then we need to make sure we don't accidentally prepend the operator
-    // before the comment.
-    const index = node.body[1].comments.filter(({ leading }) => leading).length;
-    docs[1].parts[index] = concat(["*", docs[1].parts[index]]);
-  } else {
-    // If we don't have any comments, we can just prepend the operator
-    docs[1] = concat(["*", docs[1]]);
-  }
+    // 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[0].concat(docs[1]).concat(docs.slice(2));
+  return docs;
 }
 
 function printBlockArg(path, opts, print) {

data/src/ruby/nodes/calls.js

@@ -4,6 +4,7 @@ const {
   hardline,
   ifBreak,
   indent,
+  join,
   softline
 } = require("../../prettier");
 const { makeCall, noIndent } = require("../../utils");
@@ -133,7 +134,13 @@ function printMethodAddArg(path, opts, print) {
     );
   }
 
-  return concat([methodDoc, argsDoc]);
+  // If there are already parentheses, then we can just use the doc that's
+  // already printed.
+  if (argNode.type == "arg_paren") {
+    return concat([methodDoc, argsDoc]);
+  }
+
+  return concat([methodDoc, " ", join(", ", argsDoc), " "]);
 }
 
 function printMethodAddBlock(path, opts, print) {

data/src/ruby/nodes/conditionals.js

@@ -190,57 +190,59 @@ const canTernary = (path) => {
 };
 
 // A normalized print function for both `if` and `unless` nodes.
-const printConditional = (keyword) => (path, { rubyModifier }, print) => {
-  if (canTernary(path)) {
-    let ternaryParts = [path.call(print, "body", 0), " ? "].concat(
-      printTernaryClauses(
-        keyword,
-        path.call(print, "body", 1),
-        path.call(print, "body", 2, "body", 0)
-      )
-    );
-
-    if (["binary", "call"].includes(path.getParentNode().type)) {
-      ternaryParts = ["("].concat(ternaryParts).concat(")");
+const printConditional =
+  (keyword) =>
+  (path, { rubyModifier }, print) => {
+    if (canTernary(path)) {
+      let ternaryParts = [path.call(print, "body", 0), " ? "].concat(
+        printTernaryClauses(
+          keyword,
+          path.call(print, "body", 1),
+          path.call(print, "body", 2, "body", 0)
+        )
+      );
+
+      if (["binary", "call"].includes(path.getParentNode().type)) {
+        ternaryParts = ["("].concat(ternaryParts).concat(")");
+      }
+
+      return group(
+        ifBreak(printWithAddition(keyword, path, print), concat(ternaryParts))
+      );
     }
 
-    return group(
-      ifBreak(printWithAddition(keyword, path, print), concat(ternaryParts))
-    );
-  }
-
-  const [predicate, statements, addition] = path.getValue().body;
+    const [predicate, statements, addition] = path.getValue().body;
 
-  // If there's an additional clause that wasn't matched earlier, we know we
-  // can't go for the inline option.
-  if (addition) {
-    return group(printWithAddition(keyword, path, print, { breaking: true }));
-  }
+    // If there's an additional clause that wasn't matched earlier, we know we
+    // can't go for the inline option.
+    if (addition) {
+      return group(printWithAddition(keyword, path, print, { breaking: true }));
+    }
 
-  // If the body of the conditional is empty, then we explicitly have to use the
-  // block form.
-  if (isEmptyStmts(statements)) {
-    return concat([
-      `${keyword} `,
-      align(keyword.length + 1, path.call(print, "body", 0)),
-      concat([hardline, "end"])
-    ]);
-  }
+    // If the body of the conditional is empty, then we explicitly have to use the
+    // block form.
+    if (isEmptyStmts(statements)) {
+      return concat([
+        `${keyword} `,
+        align(keyword.length + 1, path.call(print, "body", 0)),
+        concat([hardline, "end"])
+      ]);
+    }
 
-  // If the predicate of the conditional contains an assignment, then we can't
-  // know for sure that it doesn't impact the body of the conditional, so we
-  // have to default to the block form.
-  if (containsAssignment(predicate)) {
-    return concat([
-      `${keyword} `,
-      align(keyword.length + 1, path.call(print, "body", 0)),
-      indent(concat([hardline, path.call(print, "body", 1)])),
-      concat([hardline, "end"])
-    ]);
-  }
+    // If the predicate of the conditional contains an assignment, then we can't
+    // know for sure that it doesn't impact the body of the conditional, so we
+    // have to default to the block form.
+    if (containsAssignment(predicate)) {
+      return concat([
+        `${keyword} `,
+        align(keyword.length + 1, path.call(print, "body", 0)),
+        indent(concat([hardline, path.call(print, "body", 1)])),
+        concat([hardline, "end"])
+      ]);
+    }
 
-  return printSingle(keyword)(path, { rubyModifier }, print);
-};
+    return printSingle(keyword)(path, { rubyModifier }, print);
+  };
 
 module.exports = {
   else: (path, opts, print) => {

data/src/ruby/nodes/hashes.js

@@ -56,28 +56,19 @@ function printHashKeyLabel(path, print) {
     case "symbol_literal":
       return concat([path.call(print, "body", 0), ":"]);
     case "dyna_symbol": {
-      const { parts } = print(path);
-
-      // We're going to slice off the starting colon character so that we can
-      // move it to the end. If there are comments, then we're going to go
-      // further into the printed doc nodes.
-      if (parts[0] === ":") {
-        parts.splice(0, 1);
-      } else {
-        parts[1].parts.splice(0, 1);
-      }
-
-      return concat(parts.concat(":"));
+      return concat([print(path), ":"]);
     }
   }
 }
 
 function printHashKeyRocket(path, print) {
   const node = path.getValue();
-  const doc = print(path);
+  let doc = print(path);
 
   if (node.type === "@label") {
-    return `:${doc.slice(0, doc.length - 1)} =>`;
+    doc = concat([":", doc.slice(0, doc.length - 1)]);
+  } else if (node.type === "dyna_symbol") {
+    doc = concat([":", doc]);
   }
 
   return concat([doc, " =>"]);

data/src/ruby/nodes/params.js

@@ -17,15 +17,8 @@ function printRestParam(symbol) {
 }
 
 function printParams(path, opts, print) {
-  const [
-    reqs,
-    optls,
-    rest,
-    post,
-    kwargs,
-    kwargRest,
-    block
-  ] = path.getValue().body;
+  const [reqs, optls, rest, post, kwargs, kwargRest, block] =
+    path.getValue().body;
   let parts = [];
 
   if (reqs) {

data/src/ruby/nodes/strings.js

@@ -82,13 +82,106 @@ function printChar(path, { rubySingleQuote }, _print) {
   return concat([quote, body.slice(1), quote]);
 }
 
+function printPercentSDynaSymbol(path, opts, print) {
+  const node = path.getValue();
+  const parts = [];
+
+  // Push on the quote, which includes the opening character.
+  parts.push(node.quote);
+
+  path.each((childPath) => {
+    const childNode = childPath.getValue();
+
+    if (childNode.type !== "@tstring_content") {
+      // Here we are printing an embedded variable or expression.
+      parts.push(print(childPath));
+    } else {
+      // Here we are printing plain string content.
+      parts.push(join(literalline, childNode.body.split("\n")));
+    }
+  }, "body");
+
+  // Push on the closing character, which is the opposite of the third
+  // character from the opening.
+  parts.push(quotePairs[node.quote[2]]);
+
+  return concat(parts);
+}
+
+// We don't actually want to print %s symbols, as they're much more rarely seen
+// in the wild. But we're going to be forced into it if it's a multi-line symbol
+// or if the quoting would get super complicated.
+function shouldPrintPercentSDynaSymbol(node) {
+  // We shouldn't print a %s dyna symbol if it was not already that way in the
+  // original source.
+  if (node.quote[0] !== "%") {
+    return false;
+  }
+
+  // Here we're going to check if there is a closing character, a new line, or a
+  // quote in the content of the dyna symbol. If there is, then quoting could
+  // get weird, so just bail out and stick to the original bounds in the source.
+  const closing = quotePairs[node.quote[2]];
+
+  return node.body.some(
+    (child) =>
+      child.type === "@tstring_content" &&
+      (child.body.includes("\n") ||
+        child.body.includes(closing) ||
+        child.body.includes("'") ||
+        child.body.includes('"'))
+  );
+}
+
 // Prints a dynamic symbol. Assumes there's a quote property attached to the
 // node that will tell us which quote to use when printing. We're just going to
 // use whatever quote was provided.
+//
+// In the case of a plain dyna symbol, node.quote will be either :" or :'
+// For %s dyna symbols, node.quote will be %s[, %s(, %s{, or %s<
 function printDynaSymbol(path, opts, print) {
-  const { quote } = path.getValue();
+  const node = path.getValue();
+
+  if (shouldPrintPercentSDynaSymbol(node)) {
+    return printPercentSDynaSymbol(path, opts, print);
+  }
+
+  const parts = [];
+  let quote;
+
+  if (isQuoteLocked(node)) {
+    if (node.quote.startsWith("%")) {
+      quote = opts.rubySingleQuote ? "'" : '"';
+    } else {
+      quote = node.quote.slice(1);
+    }
+  } else {
+    quote = opts.rubySingleQuote && isSingleQuotable(node) ? "'" : '"';
+  }
+
+  parts.push(quote);
+  path.each((childPath) => {
+    const child = childPath.getValue();
+
+    if (child.type !== "@tstring_content") {
+      parts.push(print(childPath));
+    } else {
+      parts.push(
+        join(literalline, normalizeQuotes(child.body, quote).split("\n"))
+      );
+    }
+  }, "body");
+
+  parts.push(quote);
+
+  // If we're inside of an assoc_new node as the key, then it will handle
+  // printing the : on its own since it could change sides.
+  const parentNode = path.getParentNode();
+  if (parentNode.type !== "assoc_new" || parentNode.body[0] !== node) {
+    parts.unshift(":");
+  }
 
-  return concat([":", quote].concat(path.map(print, "body")).concat(quote));
+  return concat(parts);
 }
 
 function printStringConcat(path, opts, print) {