prettier 1.3.0 → 1.5.3

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;

data/src/ruby/nodes/args.js

@@ -8,9 +8,26 @@ const {
   softline
 } = require("../../prettier");
 const { getTrailingComma } = require("../../utils");
-
 const toProc = require("../toProc");
 
+const noTrailingComma = ["command", "command_call"];
+
+function getArgParenTrailingComma(node) {
+  // If we have a block, then we don't want to add a trailing comma.
+  if (node.type === "args_add_block" && node.body[1]) {
+    return "";
+  }
+
+  // If we only have one argument and that first argument necessitates that we
+  // skip putting a comma (because it would interfere with parsing the argument)
+  // then we don't want to add a trailing comma.
+  if (node.body.length === 1 && noTrailingComma.includes(node.body[0].type)) {
+    return "";
+  }
+
+  return ifBreak(",", "");
+}
+
 function printArgParen(path, opts, print) {
   const argsNode = path.getValue().body[0];
 
@@ -32,9 +49,6 @@ function printArgParen(path, opts, print) {
     );
   }
 
-  const args = path.call(print, "body", 0);
-  const hasBlock = argsNode.type === "args_add_block" && argsNode.body[1];
-
   // Now here we return a doc that represents the whole grouped expression,
   // including the surrouding parentheses.
   return group(
@@ -43,8 +57,8 @@ function printArgParen(path, opts, print) {
       indent(
         concat([
           softline,
-          join(concat([",", line]), args),
-          getTrailingComma(opts) && !hasBlock ? ifBreak(",", "") : ""
+          join(concat([",", line]), path.call(print, "body", 0)),
+          getTrailingComma(opts) && getArgParenTrailingComma(argsNode)
         ])
       ),
       softline,
@@ -92,25 +106,66 @@ function printArgs(path, { rubyToProc }, print) {
   return args;
 }
 
+function printArgsAddBlock(path, opts, print) {
+  const node = path.getValue();
+  const parts = path.call(print, "body", 0);
+
+  if (node.body[1]) {
+    let blockDoc = path.call(print, "body", 1);
+
+    if (node.body[1].comments) {
+      // 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.
+      blockDoc.parts[2] = concat(["&", blockDoc.parts[2]]);
+    } else {
+      // If we don't have any comments, we can just prepend the operator
+      blockDoc = concat(["&", blockDoc]);
+    }
+
+    parts.push(blockDoc);
+  }
+
+  return parts;
+}
+
+function printArgsAddStar(path, opts, print) {
+  const node = path.getValue();
+  const docs = path.map(print, "body");
+
+  if (node.body[1].comments) {
+    // If we have an array like:
+    //
+    //     [
+    //       # comment
+    //       *values
+    //     ]
+    //
+    // then we need to make sure we don't accidentally prepend the operator
+    // before the comment.
+    docs[1].parts[2] = concat(["*", docs[1].parts[2]]);
+  } else {
+    // If we don't have any comments, we can just prepend the operator
+    docs[1] = concat(["*", docs[1]]);
+  }
+
+  return docs[0].concat(docs[1]).concat(docs.slice(2));
+}
+
+function printBlockArg(path, opts, print) {
+  return concat(["&", path.call(print, "body", 0)]);
+}
+
 module.exports = {
   arg_paren: printArgParen,
   args: printArgs,
-  args_add_block: (path, opts, print) => {
-    const parts = path.call(print, "body", 0);
-
-    if (path.getValue().body[1]) {
-      parts.push(concat(["&", path.call(print, "body", 1)]));
-    }
-
-    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)])
+  args_add_block: printArgsAddBlock,
+  args_add_star: printArgsAddStar,
+  blockarg: printBlockArg
 };

data/src/ruby/nodes/arrays.js

@@ -63,33 +63,30 @@ function isSymbolArray(args) {
 // Prints out a word that is a part of a special array literal that accepts
 // interpolation. The body is an array of either plain strings or interpolated
 // expressions.
-function printSpecialArrayWord(path, opts, print) {
+function printArrayLiteralWord(path, opts, print) {
   return concat(path.map(print, "body"));
 }
 
 // Prints out a special array literal. Accepts the parts of the array literal as
 // an argument, where the first element of the parts array is a string that
 // contains the special start.
-function printSpecialArrayParts(parts) {
+function printArrayLiteral(start, parts) {
   return group(
     concat([
-      parts[0],
+      start,
       "[",
-      indent(concat([softline, join(line, parts.slice(1))])),
+      indent(concat([softline, join(line, parts)])),
       concat([softline, "]"])
     ])
   );
 }
 
-// Generates a print function with an embedded special start character for the
-// specific type of array literal that we're dealing with. The print function
-// returns an array as it expects to eventually be handed off to
-// printSpecialArrayParts.
-function printSpecialArray(start) {
-  return function printSpecialArrayWithStart(path, opts, print) {
-    return [start].concat(path.map(print, "body"));
-  };
-}
+const arrayLiteralStarts = {
+  qsymbols: "%i",
+  qwords: "%w",
+  symbols: "%I",
+  words: "%W"
+};
 
 // An array node is any literal array in Ruby. This includes all of the special
 // array literals as well as regular arrays. If it is a special array literal
@@ -105,30 +102,40 @@ function printArray(path, opts, print) {
     return printEmptyCollection(path, opts, "[", "]");
   }
 
-  // If we have an array that contains only simple string literals with no
-  // spaces or interpolation, then we're going to print a %w array.
-  if (opts.rubyArrayLiteral && isStringArray(args)) {
-    const printString = (stringPath) => stringPath.call(print, "body", 0);
-    const parts = path.map(printString, "body", 0, "body");
+  if (opts.rubyArrayLiteral) {
+    // If we have an array that contains only simple string literals with no
+    // spaces or interpolation, then we're going to print a %w array.
+    if (isStringArray(args)) {
+      const printString = (stringPath) => stringPath.call(print, "body", 0);
+      const parts = path.map(printString, "body", 0, "body");
 
-    return printSpecialArrayParts(["%w"].concat(parts));
-  }
+      return printArrayLiteral("%w", parts);
+    }
 
-  // If we have an array that contains only simple symbol literals with no
-  // interpolation, then we're going to print a %i array.
-  if (opts.rubyArrayLiteral && isSymbolArray(args)) {
-    const printSymbol = (symbolPath) => symbolPath.call(print, "body", 0);
-    const parts = path.map(printSymbol, "body", 0, "body");
+    // If we have an array that contains only simple symbol literals with no
+    // interpolation, then we're going to print a %i array.
+    if (isSymbolArray(args)) {
+      const printSymbol = (symbolPath) => symbolPath.call(print, "body", 0);
+      const parts = path.map(printSymbol, "body", 0, "body");
 
-    return printSpecialArrayParts(["%i"].concat(parts));
+      return printArrayLiteral("%i", parts);
+    }
   }
 
   // If we don't have a regular args node at this point then we have a special
   // array literal. In that case we're going to print out the body (which will
   // return to us an array with the first one being the start of the array) and
-  // send that over to the printSpecialArrayParts function.
+  // send that over to the printArrayLiteral function.
   if (!["args", "args_add_star"].includes(args.type)) {
-    return printSpecialArrayParts(path.call(print, "body", 0));
+    return path.call(
+      (arrayPath) =>
+        printArrayLiteral(
+          arrayLiteralStarts[arrayPath.getValue().type],
+          arrayPath.map(print, "body")
+        ),
+      "body",
+      0
+    );
   }
 
   // Here we have a normal array of any type of object with no special literal
@@ -151,9 +158,5 @@ function printArray(path, opts, print) {
 
 module.exports = {
   array: printArray,
-  qsymbols: printSpecialArray("%i"),
-  qwords: printSpecialArray("%w"),
-  symbols: printSpecialArray("%I"),
-  word: printSpecialArrayWord,
-  words: printSpecialArray("%W")
+  word: printArrayLiteralWord
 };

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/class.js

@@ -1,34 +1,22 @@
-const {
-  concat,
-  group,
-  hardline,
-  ifBreak,
-  indent,
-  line
-} = require("../../prettier");
+const { concat, group, hardline, indent } = require("../../prettier");
+const { isEmptyBodyStmt } = require("../../utils");
 
 function printClass(path, opts, print) {
   const [_constant, superclass, bodystmt] = path.getValue().body;
-  const stmts = bodystmt.body[0];
 
   const parts = ["class ", path.call(print, "body", 0)];
   if (superclass) {
     parts.push(" < ", path.call(print, "body", 1));
   }
 
-  // If the body is empty and does not contain any comments, we can just
-  // replace the body with a semi-colon.
-  if (
-    stmts.body.length === 1 &&
-    stmts.body[0].type === "void_stmt" &&
-    !stmts.body[0].comments
-  ) {
-    return group(concat([concat(parts), ifBreak(line, "; "), "end"]));
+  const declaration = group(concat(parts));
+  if (isEmptyBodyStmt(bodystmt)) {
+    return group(concat([declaration, hardline, "end"]));
   }
 
   return group(
     concat([
-      concat(parts),
+      declaration,
       indent(concat([hardline, path.call(print, "body", 2)])),
       concat([hardline, "end"])
     ])
@@ -36,16 +24,11 @@ function printClass(path, opts, print) {
 }
 
 function printModule(path, opts, print) {
+  const node = path.getValue();
   const declaration = group(concat(["module ", path.call(print, "body", 0)]));
 
-  // If the body is empty, we can replace with a ;
-  const stmts = path.getValue().body[1].body[0];
-  if (
-    stmts.body.length === 1 &&
-    stmts.body[0].type === "void_stmt" &&
-    !stmts.body[0].comments
-  ) {
-    return group(concat([declaration, ifBreak(line, "; "), "end"]));
+  if (isEmptyBodyStmt(node.body[1])) {
+    return group(concat([declaration, hardline, "end"]));
   }
 
   return group(
@@ -58,9 +41,16 @@ function printModule(path, opts, print) {
 }
 
 function printSClass(path, opts, print) {
+  const bodystmt = path.getValue().body[1];
+  const declaration = concat(["class << ", path.call(print, "body", 0)]);
+
+  if (isEmptyBodyStmt(bodystmt)) {
+    return group(concat([declaration, hardline, "end"]));
+  }
+
   return group(
     concat([
-      concat(["class << ", path.call(print, "body", 0)]),
+      declaration,
       indent(concat([hardline, path.call(print, "body", 1)])),
       concat([hardline, "end"])
     ])