prettier 0.21.0 → 0.22.0

data/src/nodes/arrays.js

@@ -1,40 +1,72 @@
 const {
   concat,
   group,
+  hardline,
   ifBreak,
   indent,
   join,
   line,
-  literalline,
   softline
 } = require("../prettier");
 
-const preserveArraySubstrings = [" ", "\\"];
-
-const isStringArray = (args) =>
-  args.body.every(
-    (arg) =>
-      arg.type === "string_literal" &&
-      arg.body[0].body.length === 1 &&
-      arg.body[0].body[0].type === "@tstring_content" &&
-      !preserveArraySubstrings.some((str) =>
-        arg.body[0].body[0].body.includes(str)
-      )
-  );
+// Checks that every argument within this args node is a string_literal node
+// that has no spaces or interpolations. This means we're dealing with an array
+// that looks something like:
+//
+//     ['a', 'b', 'c']
+//
+function isStringArray(args) {
+  return args.body.every((arg) => {
+    // We want to verify that every node inside of this array is a string
+    // literal. We also want to make sure none of them have comments attached.
+    if (arg.type !== "string_literal" || arg.comments) {
+      return false;
+    }
+
+    // If the string has multiple parts (meaning plain string content but also
+    // interpolated content) then we know it's not a simple string.
+    if (arg.body.length !== 1) {
+      return false;
+    }
 
-const isSymbolArray = (args) =>
-  args.body.every((arg) => arg.type === "symbol_literal");
+    const part = arg.body[0];
 
-const makeArray = (start) => (path, opts, print) =>
-  [start].concat(path.map(print, "body"));
+    // If the only part of this string is not @tstring_content then it's
+    // interpolated, so again we can return false.
+    if (part.type !== "@tstring_content") {
+      return false;
+    }
 
-const getSpecialArrayParts = (path, print, args) =>
-  args.body.map((_arg, index) =>
-    path.call(print, "body", 0, "body", index, "body", 0, "body", 0)
+    // Finally, verify that the string doesn't contain a space or an escape
+    // character so that we know it can be put into a string literal array.
+    return !part.body.includes(" ") && !part.body.includes("\\");
+  });
+}
+
+// Checks that every argument within this args node is a symbol_literal node (as
+// opposed to a dyna_symbol) so it has no interpolation. This means we're
+// dealing with an array that looks something like:
+//
+//     [:a, :b, :c]
+//
+function isSymbolArray(args) {
+  return args.body.every(
+    (arg) => arg.type === "symbol_literal" && !arg.comments
   );
-
-const printSpecialArray = (parts) =>
-  group(
+}
+
+// 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) {
+  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) {
+  return group(
     concat([
       parts[0],
       "[",
@@ -42,93 +74,99 @@ const printSpecialArray = (parts) =>
       concat([softline, "]"])
     ])
   );
-
-// Extract out the actual elements, taking into account nesting with
-// `args_add_star` nodes. The only nodes that get passed into this function are
-// `args` or `args_add_star`.
-const getElements = (node, elementPath) => {
-  if (node.type === "args") {
-    return node.body.map((element, index) => ({
-      element,
-      elementPath: elementPath.concat(["body", index])
-    }));
+}
+
+// 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"));
+  };
+}
+
+function printEmptyArrayWithComments(path, opts) {
+  const arrayNode = path.getValue();
+
+  const printComment = (commentPath, index) => {
+    arrayNode.comments[index].printed = true;
+    return opts.printer.printComment(commentPath);
+  };
+
+  return concat([
+    "[",
+    indent(
+      concat([hardline, join(hardline, path.map(printComment, "comments"))])
+    ),
+    line,
+    "]"
+  ]);
+}
+
+// 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
+// then it will have one child that represents the special array, otherwise it
+// will have one child that contains all of the elements of the array.
+function printArray(path, opts, print) {
+  const array = path.getValue();
+  const args = array.body[0];
+
+  // If there is no inner arguments node, then we're dealing with an empty
+  // array, so we can go ahead and return.
+  if (args === null) {
+    return array.comments ? printEmptyArrayWithComments(path, opts) : "[]";
   }
 
-  return getElements(node.body[0], elementPath.concat(["body", 0])).concat(
-    node.body.slice(1).map((element, index) => ({
-      element,
-      elementPath: elementPath.concat(["body", index + 1])
-    }))
-  );
-};
+  // 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");
 
-module.exports = {
-  array: (path, { addTrailingCommas }, print) => {
-    const args = path.getValue().body[0];
+    return printSpecialArrayParts(["%w"].concat(parts));
+  }
 
-    if (args === null) {
-      return "[]";
-    }
+  // 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");
 
-    if (isStringArray(args)) {
-      return printSpecialArray(
-        ["%w"].concat(getSpecialArrayParts(path, print, args))
-      );
-    }
+    return printSpecialArrayParts(["%i"].concat(parts));
+  }
 
-    if (isSymbolArray(args)) {
-      return printSpecialArray(
-        ["%i"].concat(getSpecialArrayParts(path, print, args))
-      );
-    }
+  // 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.
+  if (!["args", "args_add_star"].includes(args.type)) {
+    return printSpecialArrayParts(path.call(print, "body", 0));
+  }
 
-    if (!["args", "args_add_star"].includes(args.type)) {
-      return printSpecialArray(path.call(print, "body", 0));
-    }
+  // Here we have a normal array of any type of object with no special literal
+  // types or anything.
+  return group(
+    concat([
+      "[",
+      indent(
+        concat([
+          softline,
+          join(concat([",", line]), path.call(print, "body", 0)),
+          opts.addTrailingCommas ? ifBreak(",", "") : ""
+        ])
+      ),
+      softline,
+      "]"
+    ])
+  );
+}
 
-    const normalDocs = [];
-
-    const elementDocs = path.call(print, "body", 0);
-    const elements = getElements(path.getValue().body[0], ["body", 0]);
-
-    // We need to manually loop through the elements in the array in order to
-    // take care of heredocs printing (their commas go after the opening, as
-    // opposed to at the end).
-    elements.forEach(({ element, elementPath }, index) => {
-      const isInner = index !== elements.length - 1;
-
-      if (element.type === "heredoc") {
-        normalDocs.push(
-          element.beging,
-          isInner || addTrailingCommas ? "," : "",
-          literalline,
-          concat(
-            path.map.apply(path, [print].concat(elementPath).concat("body"))
-          ),
-          element.ending,
-          isInner ? line : ""
-        );
-      } else {
-        normalDocs.push(elementDocs[index]);
-
-        if (isInner) {
-          normalDocs.push(concat([",", line]));
-        } else if (addTrailingCommas) {
-          normalDocs.push(ifBreak(",", ""));
-        }
-      }
-    });
-
-    return group(
-      concat([
-        "[",
-        indent(concat([softline].concat(normalDocs))),
-        concat([softline, "]"])
-      ])
-    );
-  },
-  qsymbols: makeArray("%i"),
-  qwords: makeArray("%w"),
-  symbols: makeArray("%I"),
-  words: makeArray("%W")
+module.exports = {
+  array: printArray,
+  qsymbols: printSpecialArray("%i"),
+  qwords: printSpecialArray("%w"),
+  symbols: printSpecialArray("%I"),
+  word: printSpecialArrayWord,
+  words: printSpecialArray("%W")
 };

data/src/nodes/assign.js

@@ -1,39 +1,39 @@
 const { concat, group, indent, join, line } = require("../prettier");
 const { concatBody, first, skipAssignIndent } = require("../utils");
 
-module.exports = {
-  assign: (path, opts, print) => {
-    const [printedTarget, printedValue] = path.map(print, "body");
-    let adjustedValue = printedValue;
+function printAssign(path, opts, print) {
+  const [_targetNode, valueNode] = path.getValue().body;
+  const [targetDoc, valueDoc] = path.map(print, "body");
+
+  let rightSideDoc = valueDoc;
+
+  // If the right side of this assignment is a multiple assignment, then we need
+  // to join it together with commas.
+  if (["mrhs_add_star", "mrhs_new_from_args"].includes(valueNode.type)) {
+    rightSideDoc = group(join(concat([",", line]), valueDoc));
+  }
 
-    if (
-      ["mrhs_add_star", "mrhs_new_from_args"].includes(
-        path.getValue().body[1].type
-      )
-    ) {
-      adjustedValue = group(join(concat([",", line]), printedValue));
-    }
+  if (skipAssignIndent(valueNode)) {
+    return group(concat([targetDoc, " = ", rightSideDoc]));
+  }
 
-    if (skipAssignIndent(path.getValue().body[1])) {
-      return group(concat([printedTarget, " = ", adjustedValue]));
-    }
+  return group(concat([targetDoc, " =", indent(concat([line, rightSideDoc]))]));
+}
 
-    return group(
-      concat([printedTarget, " =", indent(concat([line, adjustedValue]))])
-    );
-  },
-  assign_error: (_path, _opts, _print) => {
-    throw new Error("Can't set variable");
-  },
-  opassign: (path, opts, print) =>
-    group(
-      concat([
-        path.call(print, "body", 0),
-        " ",
-        path.call(print, "body", 1),
-        indent(concat([line, path.call(print, "body", 2)]))
-      ])
-    ),
+function printOpAssign(path, opts, print) {
+  return group(
+    concat([
+      path.call(print, "body", 0),
+      " ",
+      path.call(print, "body", 1),
+      indent(concat([line, path.call(print, "body", 2)]))
+    ])
+  );
+}
+
+module.exports = {
+  assign: printAssign,
+  opassign: printOpAssign,
   var_field: concatBody,
   var_ref: first
 };

data/src/nodes/blocks.js

@@ -16,7 +16,11 @@ const printBlock = (braces) => (path, opts, print) => {
     statements.type === "stmts" ? statements.body : statements.body[0].body;
 
   let doBlockBody = "";
-  if (stmts.length !== 1 || stmts[0].type !== "void_stmt") {
+  if (
+    stmts.length !== 1 ||
+    stmts[0].type !== "void_stmt" ||
+    stmts[0].comments
+  ) {
     doBlockBody = indent(concat([softline, path.call(print, "body", 1)]));
   }
 
@@ -37,8 +41,9 @@ const printBlock = (braces) => (path, opts, print) => {
   // We can hit this next pattern if within the block the only statement is a
   // comment.
   if (
-    stmts.length > 1 &&
-    stmts.filter((stmt) => stmt.type !== "@comment").length === 1
+    stmts.length === 1 &&
+    stmts[0].type === "void_stmt" &&
+    stmts[0].comments
   ) {
     return concat([breakParent, doBlock]);
   }

data/src/nodes/calls.js

@@ -1,64 +1,119 @@
-const { concat, group, indent, literalline, softline } = require("../prettier");
-const toProc = require("../toProc");
+const {
+  concat,
+  group,
+  hardline,
+  ifBreak,
+  indent,
+  softline
+} = require("../prettier");
 const { concatBody, first, makeCall } = require("../utils");
 
+const toProc = require("../toProc");
+
+const chained = ["call", "method_add_arg"];
 const noIndent = ["array", "hash", "if", "method_add_block", "xstring_literal"];
 
-module.exports = {
-  call: (path, opts, print) => {
-    const [receiverNode, _operatorNode, messageNode] = path.getValue().body;
-
-    const printedReceiver = path.call(print, "body", 0);
-    const printedOperator = makeCall(path, opts, print);
-
-    // You can call lambdas with a special syntax that looks like func.(*args).
-    // In this case, "call" is returned for the 3rd child node.
-    const printedMessage =
-      messageNode === "call" ? messageNode : path.call(print, "body", 2);
-
-    // If we have a heredoc as a receiver, then we need to move the operator and
-    // the message up to start of the heredoc declaration, as in:
-    //
-    //     <<~TEXT.strip
-    //       content
-    //     TEXT
-    if (receiverNode.type === "heredoc") {
-      return concat([
-        receiverNode.beging,
-        printedOperator,
-        printedMessage,
-        literalline,
-        concat(path.map(print, "body", 0, "body")),
-        receiverNode.ending
-      ]);
-    }
+function printCall(path, opts, print) {
+  const callNode = path.getValue();
+  const [receiverNode, _operatorNode, messageNode] = callNode.body;
 
-    // For certain left sides of the call nodes, we want to attach directly to
-    // the } or end.
-    if (noIndent.includes(receiverNode.type)) {
-      return concat([printedReceiver, printedOperator, printedMessage]);
-    }
+  const receiverDoc = path.call(print, "body", 0);
+  const operatorDoc = makeCall(path, opts, print);
+
+  // You can call lambdas with a special syntax that looks like func.(*args).
+  // In this case, "call" is returned for the 3rd child node.
+  const messageDoc =
+    messageNode === "call" ? messageNode : path.call(print, "body", 2);
+
+  // For certain left sides of the call nodes, we want to attach directly to
+  // the } or end.
+  if (noIndent.includes(receiverNode.type)) {
+    return concat([receiverDoc, operatorDoc, messageDoc]);
+  }
 
-    return group(
-      concat([
-        printedReceiver,
-        group(indent(concat([softline, printedOperator, printedMessage])))
-      ])
+  // The right side of the call node, as in everything including the operator
+  // and beyond.
+  const rightSideDoc = indent(
+    concat([
+      receiverNode.comments ? hardline : softline,
+      operatorDoc,
+      messageDoc
+    ])
+  );
+
+  // Get a reference to the parent node so we can check if we're inside a chain
+  const parentNode = path.getParentNode();
+
+  // 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)) {
+    parentNode.chain = (callNode.chain || 0) + 1;
+    parentNode.breakDoc = (callNode.breakDoc || [receiverDoc]).concat(
+      rightSideDoc
     );
-  },
-  fcall: concatBody,
-  method_add_arg: (path, opts, print) => {
-    const [method, args] = path.map(print, "body");
-    const argNode = path.getValue().body[1];
-
-    // This case will ONLY be hit if we can successfully turn the block into a
-    // to_proc call. In that case, we just explicitly add the parens around it.
-    if (argNode.type === "args" && args.length > 0) {
-      return concat([method, "("].concat(args).concat(")"));
-    }
+  }
 
-    return concat([method, args]);
-  },
+  // If we're at the top of a chain, then we're going to print out a nice
+  // multi-line layout if this doesn't break into multiple lines.
+  if (!chained.includes(parentNode.type) && (callNode.chain || 0) >= 3) {
+    return ifBreak(
+      group(concat(callNode.breakDoc.concat(rightSideDoc))),
+      concat([receiverDoc, group(rightSideDoc)])
+    );
+  }
+
+  return group(concat([receiverDoc, group(rightSideDoc)]));
+}
+
+function printMethodAddArg(path, opts, print) {
+  const methodAddArgNode = path.getValue();
+  const argNode = methodAddArgNode.body[1];
+
+  const [methodDoc, argsDoc] = path.map(print, "body");
+
+  // You can end up here if you have a method with a ? ending, presumably
+  // because the parser knows that it cannot be a local variable.
+  if (argsDoc.length === 0) {
+    return methodDoc;
+  }
+
+  // This case will ONLY be hit if we can successfully turn the block into a
+  // to_proc call. In that case, we just explicitly add the parens around it.
+  if (argNode.type === "args" && argsDoc.length > 0) {
+    return concat([methodDoc, "("].concat(argsDoc).concat(")"));
+  }
+
+  // Get a reference to the parent node so we can check if we're inside a chain
+  const parentNode = path.getParentNode();
+
+  // 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)) {
+    parentNode.chain = (methodAddArgNode.chain || 0) + 1;
+    parentNode.breakDoc = (methodAddArgNode.breakDoc || [methodDoc]).concat(
+      argsDoc
+    );
+  }
+
+  // If we're at the top of a chain, then we're going to print out a nice
+  // multi-line layout if this doesn't break into multiple lines.
+  if (
+    !chained.includes(parentNode.type) &&
+    (methodAddArgNode.chain || 0) >= 3
+  ) {
+    return ifBreak(
+      group(concat(methodAddArgNode.breakDoc.concat(argsDoc))),
+      concat([methodDoc, argsDoc])
+    );
+  }
+
+  return concat([methodDoc, argsDoc]);
+}
+
+module.exports = {
+  call: printCall,
+  fcall: concatBody,
+  method_add_arg: printMethodAddArg,
   method_add_block: (path, opts, print) => {
     const [method, block] = path.getValue().body;
     const proc = toProc(path, opts, block);