prettier 0.21.0 → 0.22.0

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 { beging, 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([
+      beging,
+      lineSuffix(
+        group(concat([literalLineNoBreak].concat(parts).concat(ending)))
+      )
+    ])
+  );
+}
+
+module.exports = {
+  heredoc: printHeredoc
+};

data/src/nodes/hooks.js

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

data/src/nodes/ints.js

@@ -1,24 +1,37 @@
-module.exports = {
-  "@int": (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)}`;
-    }
+// 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 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 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)}`;
+  }
 
-    return body;
+  // 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;
+}
+
+module.exports = {
+  "@int": printInt
 };

data/src/nodes/lambdas.js

@@ -6,36 +6,39 @@ const {
   line,
   softline
 } = require("../prettier");
-const { hasAncestor, nodeDive } = require("../utils");
+const { hasAncestor } = require("../utils");
 
 // 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);
+function printLambdaParams(path, print) {
+  const paramsPath = [print, "body", 0];
+  let paramsNode = path.getValue().body[0];
 
-  if (params.type !== "params") {
-    steps.push("body", 0);
-    params = nodeDive(path.getValue(), steps);
+  // 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 (paramsNode.type !== "params") {
+    paramsPath.push("body", 0);
+    paramsNode = paramsNode.body[0];
   }
 
   // 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)) {
+  if (paramsNode.body.every((type) => !type)) {
     return "";
   }
 
   return group(
     concat([
       "(",
-      indent(concat([softline, path.call.apply(path, [print].concat(steps))])),
+      indent(concat([softline, path.call.apply(path, paramsPath)])),
       softline,
       ")"
     ])
   );
-};
+}
 
 // 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
@@ -64,7 +67,7 @@ const printLambdaParams = (path, print) => {
 // 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) => {
+function printLambda(path, opts, print) {
   const params = printLambdaParams(path, print);
   const inCommand = hasAncestor(path, ["command", "command_call"]);
 
@@ -82,7 +85,7 @@ const printLambda = (path, opts, print) => {
       concat(["->", params, " { ", path.call(print, "body", 1), " }"])
     )
   );
-};
+}
 
 module.exports = {
   lambda: printLambda

data/src/nodes/loops.js

@@ -12,11 +12,15 @@ const { containsAssignment } = require("../utils");
 const inlineEnsureParens = require("../utils/inlineEnsureParens");
 
 const printLoop = (keyword, modifier) => (path, { inlineLoops }, print) => {
-  const [_predicate, statements] = path.getValue().body;
+  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,

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
 };

data/src/nodes/methods.js

@@ -1,80 +1,53 @@
-const {
-  align,
-  concat,
-  group,
-  hardline,
-  indent,
-  join,
-  line
-} = require("../prettier");
-const { first, literal } = require("../utils");
-
-const printMethod = (offset) => (path, opts, print) => {
-  const [_name, params, body] = path.getValue().body.slice(offset);
-  const declaration = ["def "];
-
-  // In this case, we're printing a method that's defined as a singleton, so we
-  // need to include the target and the operator
-  if (offset > 0) {
-    declaration.push(path.call(print, "body", 0), path.call(print, "body", 1));
-  }
-
-  // In case there are no parens but there are arguments
-  const parens =
-    params.type === "params" && params.body.some((paramType) => paramType);
-
-  declaration.push(
-    path.call(print, "body", offset),
-    parens ? "(" : "",
-    path.call(print, "body", offset + 1),
-    parens ? ")" : ""
-  );
+const { concat, group, hardline, indent } = require("../prettier");
+const { first } = require("../utils");
+
+function printMethod(offset) {
+  return function printMethodWithOffset(path, opts, print) {
+    const [_name, params, body] = path.getValue().body.slice(offset);
+    const declaration = ["def "];
+
+    // In this case, we're printing a method that's defined as a singleton, so
+    // we need to include the target and the operator
+    if (offset > 0) {
+      declaration.push(
+        path.call(print, "body", 0),
+        path.call(print, "body", 1)
+      );
+    }
 
-  // If the body is empty, we can replace with a ;
-  const stmts = body.body[0].body;
-  if (stmts.length === 1 && stmts[0].type === "void_stmt") {
-    return group(concat(declaration.concat(["; end"])));
-  }
+    // In case there are no parens but there are arguments
+    const parens =
+      params.type === "params" && params.body.some((paramType) => paramType);
+
+    declaration.push(
+      path.call(print, "body", offset),
+      parens ? "(" : "",
+      path.call(print, "body", offset + 1),
+      parens ? ")" : ""
+    );
+
+    // If the body is empty, we can replace with a ;
+    const stmts = body.body[0].body;
+    if (
+      stmts.length === 1 &&
+      stmts[0].type === "void_stmt" &&
+      !stmts[0].comments
+    ) {
+      return group(concat(declaration.concat(["; end"])));
+    }
 
-  return group(
-    concat([
-      group(concat(declaration)),
-      indent(concat([hardline, path.call(print, "body", offset + 2)])),
-      group(concat([hardline, "end"]))
-    ])
-  );
-};
+    return group(
+      concat([
+        group(concat(declaration)),
+        indent(concat([hardline, path.call(print, "body", offset + 2)])),
+        group(concat([hardline, "end"]))
+      ])
+    );
+  };
+}
 
 module.exports = {
   access_ctrl: first,
   def: printMethod(0),
-  defs: printMethod(2),
-  methref: (path, opts, print) => join(".:", path.map(print, "body")),
-  super: (path, opts, print) => {
-    const args = path.getValue().body[0];
-
-    if (args.type === "arg_paren") {
-      // In case there are explicitly no arguments but they are using parens,
-      // we assume they are attempting to override the initializer and pass no
-      // arguments up.
-      if (args.body[0] === null) {
-        return "super()";
-      }
-
-      return concat(["super", path.call(print, "body", 0)]);
-    }
-
-    return concat(["super ", join(", ", path.call(print, "body", 0))]);
-  },
-  undef: (path, opts, print) =>
-    group(
-      concat([
-        "undef ",
-        align(
-          "undef ".length,
-          join(concat([",", line]), path.map(print, "body", 0))
-        )
-      ])
-    ),
-  zsuper: literal("super")
+  defs: printMethod(2)
 };