prettier 0.20.1 → 0.21.0

data/src/nodes/calls.js

@@ -4,20 +4,6 @@ const { concatBody, first, makeCall } = require("../utils");
 
 const noIndent = ["array", "hash", "if", "method_add_block", "xstring_literal"];
 
-const getHeredoc = (path, print, node) => {
-  if (node.type === "heredoc") {
-    const { beging, ending } = node;
-    return { beging, ending, content: ["body", 0, "body"] };
-  }
-
-  if (node.type === "string_literal" && node.body[0].type === "heredoc") {
-    const { beging, ending } = node.body[0];
-    return { beging, ending, content: ["body", 0, "body", 0, "body"] };
-  }
-
-  return null;
-};
-
 module.exports = {
   call: (path, opts, print) => {
     const [receiverNode, _operatorNode, messageNode] = path.getValue().body;
@@ -36,15 +22,14 @@ module.exports = {
     //     <<~TEXT.strip
     //       content
     //     TEXT
-    const heredoc = getHeredoc(path, print, receiverNode);
-    if (heredoc) {
+    if (receiverNode.type === "heredoc") {
       return concat([
-        heredoc.beging,
+        receiverNode.beging,
         printedOperator,
         printedMessage,
         literalline,
-        concat(path.map.apply(path, [print].concat(heredoc.content))),
-        heredoc.ending
+        concat(path.map(print, "body", 0, "body")),
+        receiverNode.ending
       ]);
     }
 

data/src/nodes/conditionals.js

@@ -8,7 +8,9 @@ const {
   indent,
   softline
 } = require("../prettier");
+
 const { containsAssignment } = require("../utils");
+const inlineEnsureParens = require("../utils/inlineEnsureParens");
 
 const printWithAddition = (keyword, path, print, { breaking = false } = {}) =>
   concat([
@@ -95,30 +97,14 @@ const printSingle = (keyword) => (path, { inlineConditionals }, print) => {
     return multiline;
   }
 
-  let inlineParts = [
-    path.call(print, "body", 1),
-    ` ${keyword} `,
-    path.call(print, "body", 0)
-  ];
-
-  // If the return value of this conditional expression is being assigned to
-  // anything besides a local variable then we can't inline the entire
-  // expression without wrapping it in parentheses. This is because the
-  // following expressions have different semantic meaning:
-  //
-  //     hash[:key] = :value if false
-  //     hash[:key] = if false then :value end
-  //
-  // The first one will not result in an empty hash, whereas the second one
-  // will result in `{ key: nil }`. In this case what we need to do for the
-  // first expression to align is wrap it in parens, as in:
-  //
-  //     hash[:key] = (:value if false)
-  if (["assign", "massign"].includes(path.getParentNode().type)) {
-    inlineParts = ["("].concat(inlineParts).concat(")");
-  }
+  const inline = concat(
+    inlineEnsureParens(path, [
+      path.call(print, "body", 1),
+      ` ${keyword} `,
+      path.call(print, "body", 0)
+    ])
+  );
 
-  const inline = concat(inlineParts);
   return group(ifBreak(multiline, inline));
 };
 
@@ -180,7 +166,9 @@ const canTernary = (path) => {
   const [predicate, stmts, addition] = path.getValue().body;
 
   return (
-    !["assign", "opassign"].includes(predicate.type) &&
+    !["assign", "opassign", "command_call", "command"].includes(
+      predicate.type
+    ) &&
     addition &&
     addition.type === "else" &&
     [stmts, addition.body[0]].every(canTernaryStmts)

data/src/nodes/flow.js

@@ -1,5 +1,30 @@
 const { concat, join } = require("../prettier");
-const { literal } = require("../utils");
+const { literal, nodeDive } = require("../utils");
+
+const unskippableParens = [
+  "if_mod",
+  "rescue_mod",
+  "unless_mod",
+  "until_mod",
+  "while_mod"
+];
+
+const maybeHandleParens = (path, print, keyword, steps) => {
+  const node = nodeDive(path.getValue(), steps);
+  if (node.type !== "paren") {
+    return null;
+  }
+
+  const stmts = node.body[0].body;
+  if (stmts.length === 1 && !unskippableParens.includes(stmts[0].type)) {
+    return concat([
+      `${keyword} `,
+      path.call.apply(path, [print].concat(steps).concat("body", 0))
+    ]);
+  }
+
+  return concat([keyword, path.call.apply(path, [print].concat(steps))]);
+};
 
 module.exports = {
   break: (path, opts, print) => {
@@ -9,14 +34,11 @@ module.exports = {
       return "break";
     }
 
-    if (content.body[0].body[0].type === "paren") {
-      return concat([
-        "break ",
-        path.call(print, "body", 0, "body", 0, "body", 0, "body", 0)
-      ]);
-    }
-
-    return concat(["break ", join(", ", path.call(print, "body", 0))]);
+    const steps = ["body", 0, "body", 0, "body", 0];
+    return (
+      maybeHandleParens(path, print, "break", steps) ||
+      concat(["break ", join(", ", path.call(print, "body", 0))])
+    );
   },
   next: (path, opts, print) => {
     const args = path.getValue().body[0].body[0];
@@ -25,15 +47,11 @@ module.exports = {
       return "next";
     }
 
-    if (args.body[0].type === "paren") {
-      // Ignoring the parens node and just going straight to the content
-      return concat([
-        "next ",
-        path.call(print, "body", 0, "body", 0, "body", 0, "body", 0)
-      ]);
-    }
-
-    return concat(["next ", join(", ", path.call(print, "body", 0))]);
+    const steps = ["body", 0, "body", 0, "body", 0];
+    return (
+      maybeHandleParens(path, print, "next", steps) ||
+      concat(["next ", join(", ", path.call(print, "body", 0))])
+    );
   },
   yield: (path, opts, print) => {
     if (path.getValue().body[0].type === "paren") {

data/src/nodes/hashes.js

@@ -7,17 +7,8 @@ const {
   line,
   literalline
 } = require("../prettier");
-const { prefix, skipAssignIndent } = require("../utils");
 
-const nodeDive = (node, steps) => {
-  let current = node;
-
-  steps.forEach((step) => {
-    current = current[step];
-  });
-
-  return current;
-};
+const { nodeDive, prefix, skipAssignIndent } = require("../utils");
 
 // When attempting to convert a hash rocket into a hash label, you need to take
 // care because only certain patterns are allowed. Ruby source says that they
@@ -65,6 +56,45 @@ const makeLabel = (path, { preferHashLabels }, print, steps) => {
   }
 };
 
+function printHash(path, { addTrailingCommas }, print) {
+  const hashNode = path.getValue();
+
+  // Hashes normally have a single assoclist_from_args child node. If it's
+  // missing, then it means we're dealing with an empty hash, so we can just
+  // exit here and print.
+  if (hashNode.body[0] === null) {
+    return "{}";
+  }
+
+  // Here we get a reference to the printed assoclist_from_args child node,
+  // which handles printing all of the key-value pairs of the hash. We're
+  // wrapping it in an array in case we need to append a trailing comma.
+  const assocDocs = [path.call(print, "body", 0)];
+
+  // Here we get a reference to the last key-value pair's value node, in order
+  // to check if we're dealing with a heredoc. If we are, then the trailing
+  // comma printing is handled from within the assoclist_from_args node
+  // printing, because the trailing comma has to go after the heredoc
+  // declaration.
+  const assocNodes = hashNode.body[0].body[0];
+  const lastAssocValueNode = assocNodes[assocNodes.length - 1].body[1];
+
+  // If we're adding a trailing comma and the last key-value pair's value node
+  // is not a heredoc node, then we can safely append the extra comma if the
+  // hash ends up getting printed on multiple lines.
+  if (addTrailingCommas && lastAssocValueNode.type !== "heredoc") {
+    assocDocs.push(ifBreak(",", ""));
+  }
+
+  return group(
+    concat([
+      "{",
+      indent(concat([line, concat(assocDocs)])),
+      concat([line, "}"])
+    ])
+  );
+}
+
 module.exports = {
   assoc_new: (path, opts, print) => {
     const valueDoc = path.call(print, "body", 1);
@@ -89,31 +119,15 @@ module.exports = {
       const isInner = index !== assocNodes.length - 1;
       const valueNode = assocNode.body[1];
 
-      const isStraightHeredoc = valueNode && valueNode.type === "heredoc";
-      const isSquigglyHeredoc =
-        valueNode &&
-        valueNode.type === "string_literal" &&
-        valueNode.body[0].type === "heredoc";
-
-      if (isStraightHeredoc || isSquigglyHeredoc) {
-        const heredocSteps = isStraightHeredoc
-          ? ["body", 1]
-          : ["body", 1, "body", 0];
-        const { beging, ending } = nodeDive(assocNode, heredocSteps);
-
+      if (valueNode && valueNode.type === "heredoc") {
         assocDocs.push(
           makeLabel(path, opts, print, ["body", 0, index, "body", 0]),
           " ",
-          beging,
+          valueNode.beging,
           isInner || addTrailingCommas ? "," : "",
           literalline,
-          concat(
-            path.map.apply(
-              path,
-              [print, "body", 0, index].concat(heredocSteps).concat("body")
-            )
-          ),
-          ending,
+          concat(path.map(print, "body", 0, index, "body", 1, "body")),
+          valueNode.ending,
           isInner ? line : ""
         );
       } else {
@@ -121,8 +135,6 @@ module.exports = {
 
         if (isInner) {
           assocDocs.push(concat([",", line]));
-        } else if (addTrailingCommas) {
-          assocDocs.push(ifBreak(",", ""));
         }
       }
     });
@@ -131,17 +143,5 @@ module.exports = {
   },
   bare_assoc_hash: (path, opts, print) =>
     group(join(concat([",", line]), path.map(print, "body", 0))),
-  hash: (path, opts, print) => {
-    if (path.getValue().body[0] === null) {
-      return "{}";
-    }
-
-    return group(
-      concat([
-        "{",
-        indent(concat([line, concat(path.map(print, "body"))])),
-        concat([line, "}"])
-      ])
-    );
-  }
+  hash: printHash
 };

data/src/nodes/hooks.js

@@ -1,13 +1,43 @@
 const { concat, group, indent, line } = require("../prettier");
+const { isEmptyStmts } = require("../utils");
 
-const printHook = (name) => (path, opts, print) =>
-  group(
-    concat([
+/* The `BEGIN` and `END` keywords are used to hook into the Ruby process. Any
+ * `BEGIN` blocks are executed right when the process starts up, and the `END`
+ * blocks are executed right before exiting.
+ *
+ *     BEGIN {
+ *       # content goes here
+ *     }
+ *
+ *     END {
+ *       # content goes here
+ *     }
+ *
+ * Interesting side note, you don't use `do...end` blocks with these hooks. Both
+ * nodes contain one child which is a `stmts` node.
+ */
+function printHook(name) {
+  function printHookWithName(path, opts, print) {
+    const stmtsNode = path.getValue().body[0];
+    const printedStmts = path.call(print, "body", 0);
+
+    const parts = [
       `${name} {`,
-      indent(concat([line, path.call(print, "body", 0)])),
+      indent(concat([line, printedStmts])),
       concat([line, "}"])
-    ])
-  );
+    ];
+
+    // If there are no statements but there are comments, then we want to skip
+    // printing the newline so that we don't end up with multiple spaces.
+    if (isEmptyStmts(stmtsNode) && stmtsNode.comments) {
+      parts[1] = indent(printedStmts);
+    }
+
+    return group(concat(parts));
+  }
+
+  return printHookWithName;
+}
 
 module.exports = {
   BEGIN: printHook("BEGIN"),

data/src/nodes/lambdas.js

@@ -4,56 +4,86 @@ const {
   ifBreak,
   indent,
   line,
-  removeLines,
   softline
 } = require("../prettier");
-const { hasAncestor } = require("../utils");
+const { hasAncestor, nodeDive } = require("../utils");
 
-module.exports = {
-  lambda: (path, opts, print) => {
-    let params = path.getValue().body[0];
-    let paramsConcat = "";
+// We can have our params coming in as the first child of the main lambda node,
+// or if we have them wrapped in parens then they'll be one level deeper. Even
+// though it's possible to omit the parens if you only have one argument, we're
+// going to keep them in no matter what for consistency.
+const printLambdaParams = (path, print) => {
+  const steps = ["body", 0];
+  let params = nodeDive(path.getValue(), steps);
 
-    if (params.type === "params") {
-      paramsConcat = path.call(print, "body", 0);
-    } else {
-      [params] = params.body;
-      paramsConcat = path.call(print, "body", 0, "body", 0);
-    }
+  if (params.type !== "params") {
+    steps.push("body", 0);
+    params = nodeDive(path.getValue(), steps);
+  }
 
-    const noParams = params.body.every((type) => !type);
-    const inlineLambda = concat([
-      "->",
-      noParams ? "" : concat(["(", paramsConcat, ")"]),
-      " { ",
-      path.call(print, "body", 1),
-      " }"
-    ]);
+  // If we don't have any params at all, then we're just going to bail out and
+  // print nothing. This is to avoid printing an empty set of parentheses.
+  if (params.body.every((type) => !type)) {
+    return "";
+  }
 
-    if (hasAncestor(path, ["command", "command_call"])) {
-      return group(
-        ifBreak(
-          concat([
-            "lambda {",
-            noParams ? "" : concat([" |", removeLines(paramsConcat), "|"]),
-            indent(concat([line, path.call(print, "body", 1)])),
-            concat([line, "}"])
-          ]),
-          inlineLambda
-        )
-      );
-    }
+  return group(
+    concat([
+      "(",
+      indent(concat([softline, path.call.apply(path, [print].concat(steps))])),
+      softline,
+      ")"
+    ])
+  );
+};
 
-    return group(
-      ifBreak(
-        concat([
-          "lambda do",
-          noParams ? "" : concat([" |", removeLines(paramsConcat), "|"]),
-          indent(concat([softline, path.call(print, "body", 1)])),
-          concat([softline, "end"])
-        ]),
-        inlineLambda
-      )
-    );
-  }
+// Lambda nodes represent stabby lambda literals, which can come in a couple of
+// flavors. They can use either braces or do...end for their block, and their
+// arguments can be not present, have no parentheses for a single argument, or
+// have parentheses for multiple arguments. Below are a couple of examples:
+//
+//     -> { 1 }
+//     -> a { a + 1 }
+//     ->(a) { a + 1 }
+//     ->(a, b) { a + b }
+//     ->(a, b = 1) { a + b }
+//
+//     -> do
+//       1
+//     end
+//
+//     -> a do
+//       a + 1
+//     end
+//
+//     ->(a, b) do
+//       a + b
+//     end
+//
+// Generally, we're going to favor do...end for the multi-line form and braces
+// for the single-line form. However, if we have an ancestor that is a command
+// or command_call node, then we'll need to use braces either way because of
+// operator precendence.
+const printLambda = (path, opts, print) => {
+  const params = printLambdaParams(path, print);
+  const inCommand = hasAncestor(path, ["command", "command_call"]);
+
+  return group(
+    ifBreak(
+      concat([
+        "->",
+        params,
+        " ",
+        inCommand ? "{" : "do",
+        indent(concat([line, path.call(print, "body", 1)])),
+        line,
+        inCommand ? "}" : "end"
+      ]),
+      concat(["->", params, " { ", path.call(print, "body", 1), " }"])
+    )
+  );
+};
+
+module.exports = {
+  lambda: printLambda
 };