prettier 0.20.0 → 1.0.0.pre.rc2

data/src/nodes/heredocs.js

@@ -0,0 +1,34 @@
+const { concat, group, lineSuffix, join } = require("../prettier");
+const { literalLineNoBreak } = require("../utils");
+
+function printHeredoc(path, opts, print) {
+  const { body, ending } = path.getValue();
+
+  const parts = body.map((part, index) => {
+    if (part.type !== "@tstring_content") {
+      // In this case, the part of the string is an embedded expression
+      return path.call(print, "body", index);
+    }
+
+    // In this case, the part of the string is just regular string content
+    return join(literalLineNoBreak, part.body.split("\n"));
+  });
+
+  // We use a literalline break because matching indentation is required
+  // for the heredoc contents and ending. If the line suffix contains a
+  // break-parent, all ancestral groups are broken, and heredocs automatically
+  // break lines in groups they appear in. We prefer them to appear in-line if
+  // possible, so we use a literalline without the break-parent.
+  return group(
+    concat([
+      path.call(print, "beging"),
+      lineSuffix(
+        group(concat([literalLineNoBreak].concat(parts).concat(ending)))
+      )
+    ])
+  );
+}
+
+module.exports = {
+  heredoc: printHeredoc
+};

data/src/nodes/hooks.js

@@ -1,13 +1,42 @@
 const { concat, group, indent, line } = require("../prettier");
+const { isEmptyStmts } = require("../utils");
 
-const printHook = (name) => (path, opts, print) =>
-  group(
-    concat([
-      `${name} {`,
-      indent(concat([line, path.call(print, "body", 0)])),
+// 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) {
+  return function printHookWithName(path, opts, print) {
+    const stmtsNode = path.getValue().body[1];
+    const printedStmts = path.call(print, "body", 1);
+
+    const parts = [
+      name,
+      " ",
+      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));
+  };
+}
 
 module.exports = {
   BEGIN: printHook("BEGIN"),

data/src/nodes/ints.js

@@ -1,24 +1,31 @@
-module.exports = {
-  "@int": (path, _opts, _print) => {
-    const { body } = path.getValue();
+// An @int node is any literal integer in Ruby. They can come in a number of
+// bases, and look like the following:
+//
+// Binary (2)       - 0b0110
+// Octal (8)        - 0o34 or 034
+// Decimal (10)     - a normal number like 159
+// Hexidecimal (16) - 0xac5
+//
+// If it's a decimal number, it can be optional separated by any number of
+// arbitrarily places underscores. This can be useful for dollars and cents
+// (34_99), dates (2020_11_30), and normal 3 digit separation (1_222_333).
+function printInt(path, _opts, _print) {
+  const { body } = path.getValue();
 
-    // If the number is octal and does not contain the optional "o" character
-    // after the leading 0, add it in.
-    if (/^0[0-9]/.test(body)) {
-      return `0o${body.slice(1)}`;
-    }
+  // If the number is a base 10 number, is sufficiently large, and is not
+  // already formatted with underscores, then add them in in between the
+  // numbers every three characters starting from the right.
+  if (!body.startsWith("0") && body.length >= 5 && !body.includes("_")) {
+    return `  ${body}`
+      .slice((body.length + 2) % 3)
+      .match(/.{3}/g)
+      .join("_")
+      .trim();
+  }
 
-    // If the number is a base 10 number, is sufficiently large, and is not
-    // already formatted with underscores, then add them in in between the
-    // numbers every three characters starting from the right.
-    if (!body.startsWith("0") && body.length >= 5 && !body.includes("_")) {
-      return `  ${body}`
-        .slice((body.length + 2) % 3)
-        .match(/.{3}/g)
-        .join("_")
-        .trim();
-    }
+  return body;
+}
 
-    return body;
-  }
+module.exports = {
+  "@int": printInt
 };

data/src/nodes/lambdas.js

@@ -1,59 +1,76 @@
-const {
-  concat,
-  group,
-  ifBreak,
-  indent,
-  line,
-  removeLines,
-  softline
-} = require("../prettier");
+const { concat, group, ifBreak, indent, line } = require("../prettier");
 const { hasAncestor } = 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.
+function printLambdaParams(path, print) {
+  let node = path.getValue().body[0];
 
-    if (params.type === "params") {
-      paramsConcat = path.call(print, "body", 0);
-    } else {
-      [params] = params.body;
-      paramsConcat = path.call(print, "body", 0, "body", 0);
-    }
+  // In this case we had something like -> (foo) { bar } which would mean that
+  // we're looking at a paren node, so we'll descend one level deeper to get at
+  // the actual params node.
+  if (node.type !== "params") {
+    node = node.body[0];
+  }
 
-    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 (node.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 path.call(print, "body", 0);
+}
 
-    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.
+function 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
 };

data/src/nodes/loops.js

@@ -1,5 +1,6 @@
 const {
   align,
+  breakParent,
   concat,
   group,
   hardline,
@@ -7,14 +8,20 @@ const {
   indent,
   softline
 } = require("../prettier");
+
 const { containsAssignment } = require("../utils");
+const inlineEnsureParens = require("../utils/inlineEnsureParens");
 
-const printLoop = (keyword, modifier) => (path, { inlineLoops }, print) => {
-  const [_predicate, statements] = path.getValue().body;
+const printLoop = (keyword, modifier) => (path, { rubyModifier }, print) => {
+  const [_predicate, stmts] = path.getValue().body;
 
   // If the only statement inside this while loop is a void statement, then we
   // can shorten to just displaying the predicate and then a semicolon.
-  if (statements.body.length === 1 && statements.body[0].type === "void_stmt") {
+  if (
+    stmts.body.length === 1 &&
+    stmts.body[0].type === "void_stmt" &&
+    !stmts.body[0].comments
+  ) {
     return group(
       concat([
         keyword,
@@ -26,30 +33,13 @@ const printLoop = (keyword, modifier) => (path, { inlineLoops }, print) => {
     );
   }
 
-  let inlineParts = [
-    path.call(print, "body", 1),
-    ` ${keyword} `,
-    path.call(print, "body", 0)
-  ];
-
-  // If the return value of this loop 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] = break :value while false
-  //     hash[:key] = while false do break :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] = (break :value while false)
-  if (["assign", "massign"].includes(path.getParentNode().type)) {
-    inlineParts = ["("].concat(inlineParts).concat(")");
-  }
-
-  const inlineLoop = concat(inlineParts);
+  const inlineLoop = concat(
+    inlineEnsureParens(path, [
+      path.call(print, "body", 1),
+      ` ${keyword} `,
+      path.call(print, "body", 0)
+    ])
+  );
 
   // If we're in the modifier form and we're modifying a `begin`, then this is a
   // special case where we need to explicitly use the modifier form because
@@ -77,8 +67,8 @@ const printLoop = (keyword, modifier) => (path, { inlineLoops }, print) => {
   // an assignment (in which case we can't know for certain that that
   // assignment doesn't impact the statements inside the loop) then we can't
   // use the modifier form and we must use the block form.
-  if (!inlineLoops || containsAssignment(path.getValue().body[0])) {
-    return blockLoop;
+  if (!rubyModifier || containsAssignment(path.getValue().body[0])) {
+    return concat([breakParent, blockLoop]);
   }
 
   return group(ifBreak(blockLoop, inlineLoop));

data/src/nodes/massign.js

@@ -1,69 +1,91 @@
 const { concat, group, indent, join, line, softline } = require("../prettier");
-const { makeList } = require("../utils");
 
-module.exports = {
-  massign: (path, opts, print) => {
-    let right = path.call(print, "body", 1);
-
-    if (
-      ["mrhs_add_star", "mrhs_new_from_args"].includes(
-        path.getValue().body[1].type
-      )
-    ) {
-      right = group(join(concat([",", line]), right));
-    }
-
-    const parts = [join(concat([",", line]), path.call(print, "body", 0))];
-    if (path.getValue().body[0].comma) {
-      parts.push(",");
-    }
-
-    return group(
-      concat([group(concat(parts)), " =", indent(concat([line, right]))])
-    );
-  },
-  mlhs: makeList,
-  mlhs_add_post: (path, opts, print) =>
-    path.call(print, "body", 0).concat(path.call(print, "body", 1)),
-  mlhs_add_star: (path, opts, print) =>
-    path
-      .call(print, "body", 0)
-      .concat([
-        path.getValue().body[1]
-          ? concat(["*", path.call(print, "body", 1)])
-          : "*"
-      ]),
-  mlhs_paren: (path, opts, print) => {
-    if (["massign", "mlhs_paren"].includes(path.getParentNode().type)) {
-      // If we're nested in brackets as part of the left hand side of an
-      // assignment, i.e., (a, b, c) = 1, 2, 3
-      // ignore the current node and just go straight to the content
-      return path.call(print, "body", 0);
-    }
-
-    const parts = [
-      softline,
-      join(concat([",", line]), path.call(print, "body", 0))
-    ];
-
-    if (path.getValue().body[0].comma) {
-      parts.push(",");
-    }
-
-    return group(concat(["(", indent(concat(parts)), concat([softline, ")"])]));
-  },
-  mrhs: makeList,
-  mrhs_add_star: (path, opts, print) =>
-    path
-      .call(print, "body", 0)
-      .concat([concat(["*", path.call(print, "body", 1)])]),
-  mrhs_new_from_args: (path, opts, print) => {
-    const parts = path.call(print, "body", 0);
-
-    if (path.getValue().body.length > 1) {
-      parts.push(path.call(print, "body", 1));
-    }
-
-    return parts;
+function printMAssign(path, opts, print) {
+  let right = path.call(print, "body", 1);
+
+  if (
+    ["mrhs_add_star", "mrhs_new_from_args"].includes(
+      path.getValue().body[1].type
+    )
+  ) {
+    right = group(join(concat([",", line]), right));
+  }
+
+  const parts = [join(concat([",", line]), path.call(print, "body", 0))];
+  if (path.getValue().body[0].comma) {
+    parts.push(",");
+  }
+
+  return group(
+    concat([group(concat(parts)), " =", indent(concat([line, right]))])
+  );
+}
+
+function printMLHS(path, opts, print) {
+  return path.map(print, "body");
+}
+
+function printMLHSAddPost(path, opts, print) {
+  return path.call(print, "body", 0).concat(path.call(print, "body", 1));
+}
+
+function printMLHSAddStar(path, opts, print) {
+  const rightParts = ["*"];
+
+  if (path.getValue().body[1]) {
+    rightParts.push(path.call(print, "body", 1));
+  }
+
+  return path.call(print, "body", 0).concat(concat(rightParts));
+}
+
+function printMLHSParen(path, opts, print) {
+  if (["massign", "mlhs_paren"].includes(path.getParentNode().type)) {
+    // If we're nested in brackets as part of the left hand side of an
+    // assignment, i.e., (a, b, c) = 1, 2, 3
+    // ignore the current node and just go straight to the content
+    return path.call(print, "body", 0);
   }
+
+  const parts = [
+    softline,
+    join(concat([",", line]), path.call(print, "body", 0))
+  ];
+
+  if (path.getValue().body[0].comma) {
+    parts.push(",");
+  }
+
+  return group(concat(["(", indent(concat(parts)), concat([softline, ")"])]));
+}
+
+function printMRHS(path, opts, print) {
+  return path.map(print, "body");
+}
+
+function printMRHSAddStar(path, opts, print) {
+  const [leftDoc, rightDoc] = path.map(print, "body");
+
+  return leftDoc.concat([concat(["*", rightDoc])]);
+}
+
+function printMRHSNewFromArgs(path, opts, print) {
+  const parts = path.call(print, "body", 0);
+
+  if (path.getValue().body[1]) {
+    parts.push(path.call(print, "body", 1));
+  }
+
+  return parts;
+}
+
+module.exports = {
+  massign: printMAssign,
+  mlhs: printMLHS,
+  mlhs_add_post: printMLHSAddPost,
+  mlhs_add_star: printMLHSAddStar,
+  mlhs_paren: printMLHSParen,
+  mrhs: printMRHS,
+  mrhs_add_star: printMRHSAddStar,
+  mrhs_new_from_args: printMRHSNewFromArgs
 };