prettier 0.20.0 → 1.0.0.pre.rc2

data/src/nodes/conditionals.js

@@ -8,7 +8,9 @@ const {
   indent,
   softline
 } = require("../prettier");
-const { containsAssignment } = require("../utils");
+
+const { containsAssignment, isEmptyStmts } = require("../utils");
+const inlineEnsureParens = require("../utils/inlineEnsureParens");
 
 const printWithAddition = (keyword, path, print, { breaking = false } = {}) =>
   concat([
@@ -78,52 +80,50 @@ const printTernary = (path, _opts, print) => {
 // Prints an `if_mod` or `unless_mod` node. Because it was previously in the
 // modifier form, we're guaranteed to not have an additional node, so we can
 // just work with the predicate and the body.
-const printSingle = (keyword) => (path, { inlineConditionals }, print) => {
-  const multiline = concat([
-    `${keyword} `,
-    align(keyword.length + 1, path.call(print, "body", 0)),
-    indent(concat([softline, path.call(print, "body", 1)])),
-    concat([softline, "end"])
-  ]);
+function printSingle(keyword, modifier = false) {
+  return function printSingleWithKeyword(path, { rubyModifier }, print) {
+    const [_predicateNode, statementsNode] = path.getValue().body;
+    const predicateDoc = path.call(print, "body", 0);
+    const statementsDoc = path.call(print, "body", 1);
 
-  const [_predicate, stmts] = path.getValue().body;
-  const hasComments =
-    stmts.type === "stmts" &&
-    stmts.body.some((stmt) => stmt.type === "@comment");
+    const multilineParts = [
+      `${keyword} `,
+      align(keyword.length + 1, predicateDoc),
+      indent(concat([softline, statementsDoc])),
+      softline,
+      "end"
+    ];
 
-  if (!inlineConditionals || hasComments) {
-    return multiline;
-  }
+    // If we do not allow modifier form conditionals or there are comments
+    // inside of the body of the conditional, then we must print in the
+    // multiline form.
+    if (!rubyModifier || (!modifier && statementsNode.body[0].comments)) {
+      return concat([concat(multilineParts), breakParent]);
+    }
 
-  let inlineParts = [
-    path.call(print, "body", 1),
-    ` ${keyword} `,
-    path.call(print, "body", 0)
-  ];
+    const inline = concat(
+      inlineEnsureParens(path, [
+        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(")");
-  }
+    // An expression with a conditional modifier (expression if true), the
+    // conditional body is parsed before the predicate expression, meaning that
+    // if the parser encountered a variable declaration, it would initialize
+    // that variable first before evaluating the predicate expression. That
+    // parse order means the difference between a NameError or not. #591
+    // https://docs.ruby-lang.org/en/2.0.0/syntax/control_expressions_rdoc.html#label-Modifier+if+and+unless
+    if (modifier && containsAssignment(statementsNode)) {
+      return inline;
+    }
 
-  const inline = concat(inlineParts);
-  return group(ifBreak(multiline, inline));
-};
+    return group(ifBreak(concat(multilineParts), inline));
+  };
+}
 
 const noTernary = [
-  "@comment",
   "alias",
   "assign",
   "break",
@@ -180,7 +180,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)
@@ -188,7 +190,7 @@ const canTernary = (path) => {
 };
 
 // A normalized print function for both `if` and `unless` nodes.
-const printConditional = (keyword) => (path, { inlineConditionals }, print) => {
+const printConditional = (keyword) => (path, { rubyModifier }, print) => {
   if (canTernary(path)) {
     let ternaryParts = [path.call(print, "body", 0), " ? "].concat(
       printTernaryClauses(
@@ -217,7 +219,7 @@ const printConditional = (keyword) => (path, { inlineConditionals }, print) => {
 
   // If the body of the conditional is empty, then we explicitly have to use the
   // block form.
-  if (statements.type === "stmts" && statements.body[0].type === "void_stmt") {
+  if (isEmptyStmts(statements) && !statements.body[0].comments) {
     return concat([
       `${keyword} `,
       align(keyword.length + 1, path.call(print, "body", 0)),
@@ -237,7 +239,7 @@ const printConditional = (keyword) => (path, { inlineConditionals }, print) => {
     ]);
   }
 
-  return printSingle(keyword)(path, { inlineConditionals }, print);
+  return printSingle(keyword)(path, { rubyModifier }, print);
 };
 
 module.exports = {
@@ -272,7 +274,7 @@ module.exports = {
   },
   if: printConditional("if"),
   ifop: printTernary,
-  if_mod: printSingle("if"),
+  if_mod: printSingle("if", true),
   unless: printConditional("unless"),
-  unless_mod: printSingle("unless")
+  unless_mod: printSingle("unless", true)
 };

data/src/nodes/constants.js

@@ -1,25 +1,43 @@
 const { concat, group, indent, join, softline } = require("../prettier");
-const { first, makeCall, prefix } = require("../utils");
+const { makeCall } = require("../utils");
+
+function printConstPath(path, opts, print) {
+  return join("::", path.map(print, "body"));
+}
+
+function printConstRef(path, opts, print) {
+  return path.call(print, "body", 0);
+}
+
+function printDefined(path, opts, print) {
+  return group(
+    concat([
+      "defined?(",
+      indent(concat([softline, path.call(print, "body", 0)])),
+      concat([softline, ")"])
+    ])
+  );
+}
+
+function printField(path, opts, print) {
+  return group(
+    concat([
+      path.call(print, "body", 0),
+      concat([makeCall(path, opts, print), path.call(print, "body", 2)])
+    ])
+  );
+}
+
+function printTopConst(path, opts, print) {
+  return concat(["::", path.call(print, "body", 0)]);
+}
 
 module.exports = {
-  const_path_field: (path, opts, print) => join("::", path.map(print, "body")),
-  const_path_ref: (path, opts, print) => join("::", path.map(print, "body")),
-  const_ref: first,
-  defined: (path, opts, print) =>
-    group(
-      concat([
-        "defined?(",
-        indent(concat([softline, path.call(print, "body", 0)])),
-        concat([softline, ")"])
-      ])
-    ),
-  field: (path, opts, print) =>
-    group(
-      concat([
-        path.call(print, "body", 0),
-        concat([makeCall(path, opts, print), path.call(print, "body", 2)])
-      ])
-    ),
-  top_const_field: prefix("::"),
-  top_const_ref: prefix("::")
+  const_path_field: printConstPath,
+  const_path_ref: printConstPath,
+  const_ref: printConstRef,
+  defined: printDefined,
+  field: printField,
+  top_const_field: printTopConst,
+  top_const_ref: printTopConst
 };

data/src/nodes/flow.js

@@ -1,6 +1,41 @@
 const { concat, join } = require("../prettier");
 const { literal } = require("../utils");
 
+const nodeDive = (node, steps) => {
+  let current = node;
+
+  steps.forEach((step) => {
+    current = current[step];
+  });
+
+  return current;
+};
+
+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) => {
     const content = path.getValue().body[0];
@@ -9,14 +44,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 +57,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

@@ -1,23 +1,14 @@
 const {
   concat,
   group,
+  hardline,
   ifBreak,
   indent,
   join,
-  line,
-  literalline
+  line
 } = require("../prettier");
-const { prefix, skipAssignIndent } = require("../utils");
 
-const nodeDive = (node, steps) => {
-  let current = node;
-
-  steps.forEach((step) => {
-    current = current[step];
-  });
-
-  return current;
-};
+const { getTrailingComma, 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
@@ -29,119 +20,142 @@ const nodeDive = (node, steps) => {
 //
 // This function represents that check, as it determines if it can convert the
 // symbol node into a hash label.
-const isValidHashLabel = (symbolLiteral) => {
-  const label = symbolLiteral.body[0].body[0].body;
+function isValidHashLabel(symbolLiteral) {
+  const label = symbolLiteral.body[0].body;
   return label.match(/^[_A-Za-z]/) && !label.endsWith("=");
-};
+}
 
-const makeLabel = (path, { preferHashLabels }, print, steps) => {
-  const labelNode = nodeDive(path.getValue(), steps);
-  const labelDoc = path.call.apply(path, [print].concat(steps));
+function canUseHashLabels(contentsNode) {
+  return contentsNode.body.every((assocNode) => {
+    if (assocNode.type === "assoc_splat") {
+      return true;
+    }
 
-  switch (labelNode.type) {
-    case "@label":
-      if (preferHashLabels) {
-        return labelDoc;
-      }
-      return `:${labelDoc.slice(0, labelDoc.length - 1)} =>`;
-    case "symbol_literal": {
-      if (preferHashLabels && isValidHashLabel(labelNode)) {
-        const symbolSteps = steps.concat("body", 0, "body", 0);
-
-        return concat([
-          path.call.apply(path, [print].concat(symbolSteps)),
-          ":"
-        ]);
-      }
-      return concat([labelDoc, " =>"]);
+    switch (assocNode.body[0].type) {
+      case "@label":
+        return true;
+      case "symbol_literal":
+        return isValidHashLabel(assocNode.body[0]);
+      case "dyna_symbol":
+        return true;
+      default:
+        return false;
     }
+  });
+}
+
+function printHashKeyLabel(path, print) {
+  const node = path.getValue();
+
+  switch (node.type) {
+    case "@label":
+      return print(path);
+    case "symbol_literal":
+      return concat([path.call(print, "body", 0), ":"]);
     case "dyna_symbol":
-      if (preferHashLabels) {
-        return concat(labelDoc.parts.slice(1).concat(":"));
-      }
-      return concat([labelDoc, " =>"]);
-    default:
-      return concat([labelDoc, " =>"]);
+      return concat(print(path).parts.slice(1).concat(":"));
   }
-};
+}
 
-module.exports = {
-  assoc_new: (path, opts, print) => {
-    const valueDoc = path.call(print, "body", 1);
-    const parts = [makeLabel(path, opts, print, ["body", 0])];
-
-    if (skipAssignIndent(path.getValue().body[1])) {
-      parts.push(" ", valueDoc);
-    } else {
-      parts.push(indent(concat([line, valueDoc])));
-    }
+function printHashKeyRocket(path, print) {
+  const node = path.getValue();
+  const doc = print(path);
 
-    return group(concat(parts));
-  },
-  assoc_splat: prefix("**"),
-  assoclist_from_args: (path, opts, print) => {
-    const { addTrailingCommas } = opts;
-
-    const assocNodes = path.getValue().body[0];
-    const assocDocs = [];
-
-    assocNodes.forEach((assocNode, index) => {
-      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);
-
-        assocDocs.push(
-          makeLabel(path, opts, print, ["body", 0, index, "body", 0]),
-          " ",
-          beging,
-          isInner || addTrailingCommas ? "," : "",
-          literalline,
-          concat(
-            path.map.apply(
-              path,
-              [print, "body", 0, index].concat(heredocSteps).concat("body")
-            )
-          ),
-          ending,
-          isInner ? line : ""
-        );
-      } else {
-        assocDocs.push(path.call(print, "body", 0, index));
-
-        if (isInner) {
-          assocDocs.push(concat([",", line]));
-        } else if (addTrailingCommas) {
-          assocDocs.push(ifBreak(",", ""));
-        }
-      }
-    });
-
-    return group(concat(assocDocs));
-  },
-  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 "{}";
-    }
+  if (node.type === "@label") {
+    return `:${doc.slice(0, doc.length - 1)} =>`;
+  }
+
+  return concat([doc, " =>"]);
+}
+
+function printAssocNew(path, opts, print) {
+  const { keyPrinter } = path.getParentNode();
+
+  const parts = [path.call((keyPath) => keyPrinter(keyPath, print), "body", 0)];
+  const valueDoc = path.call(print, "body", 1);
+
+  if (skipAssignIndent(path.getValue().body[1])) {
+    parts.push(" ", valueDoc);
+  } else {
+    parts.push(indent(concat([line, valueDoc])));
+  }
+
+  return group(concat(parts));
+}
+
+function printHashContents(path, opts, print) {
+  const node = path.getValue();
 
+  // First determine which key printer we're going to use, so that the child
+  // nodes can reference it when they go to get printed.
+  node.keyPrinter =
+    opts.rubyHashLabel && canUseHashLabels(path.getValue())
+      ? printHashKeyLabel
+      : printHashKeyRocket;
+
+  const contents = join(concat([",", line]), path.map(print, "body"));
+
+  // If we're inside a hash literal, then we want to add the braces at this
+  // level so that the grouping is correct. Otherwise you could end up with
+  // opening and closing braces being split up, but the contents not being split
+  // correctly.
+  if (path.getParentNode().type === "hash") {
     return group(
       concat([
         "{",
-        indent(concat([line, concat(path.map(print, "body"))])),
-        concat([line, "}"])
+        indent(
+          concat([
+            line,
+            contents,
+            getTrailingComma(opts) ? ifBreak(",", "") : ""
+          ])
+        ),
+        line,
+        "}"
       ])
     );
   }
+
+  // Otherwise, we're inside a bare_assoc_hash, so we don't want to print
+  // braces at all.
+  return group(contents);
+}
+
+function printEmptyHashWithComments(path, opts) {
+  const hashNode = path.getValue();
+
+  const printComment = (commentPath, index) => {
+    hashNode.comments[index].printed = true;
+    return opts.printer.printComment(commentPath);
+  };
+
+  return concat([
+    "{",
+    indent(
+      concat([hardline, join(hardline, path.map(printComment, "comments"))])
+    ),
+    line,
+    "}"
+  ]);
+}
+
+function printHash(path, opts, 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 hashNode.comments ? printEmptyHashWithComments(path, opts) : "{}";
+  }
+
+  return path.call(print, "body", 0);
+}
+
+module.exports = {
+  assoc_new: printAssocNew,
+  assoc_splat: prefix("**"),
+  assoclist_from_args: printHashContents,
+  bare_assoc_hash: printHashContents,
+  hash: printHash
 };