prettier 2.0.0 → 2.1.0

data/dist/ruby/nodes/hooks.js

@@ -25,8 +25,8 @@ function printHook(name) {
         return group([
             name,
             " ",
-            path.call(print, "body", 0),
-            indent([line, path.call(print, "body", 1)]),
+            path.call(print, "lbrace"),
+            indent([line, path.call(print, "stmts")]),
             [line, "}"]
         ]);
     };

data/dist/ruby/nodes/ints.js

@@ -6,22 +6,22 @@ exports.printInt = void 0;
 //
 // Binary (2)       - 0b0110
 // Octal (8)        - 0o34 or 034
-// Decimal (10)     - a normal number like 159
+// Decimal (10)     - 159 or 0d159
 // 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).
 const printInt = (path) => {
-    const { body } = path.getValue();
+    const { value } = 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("_")) {
+    if (!value.startsWith("0") && value.length >= 5 && !value.includes("_")) {
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const segments = `  ${body}`.slice((body.length + 2) % 3).match(/.{3}/g);
+        const segments = `  ${value}`.slice((value.length + 2) % 3).match(/.{3}/g);
         return segments.join("_").trim();
     }
-    return body;
+    return value;
 };
 exports.printInt = printInt;

data/dist/ruby/nodes/lambdas.js

@@ -12,19 +12,19 @@ const { group, ifBreak, indent, line } = prettier_1.default;
 // 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];
+    let node = path.getValue().params;
     // 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];
+        node = node.cnts;
     }
     // 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)) {
+    if ((0, utils_1.isEmptyParams)(node)) {
         return "";
     }
-    return path.call(print, "body", 0);
+    return path.call(print, "params");
 }
 // 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
@@ -56,14 +56,15 @@ function printLambdaParams(path, print) {
 const printLambda = (path, opts, print) => {
     const params = printLambdaParams(path, print);
     const inCommand = (0, utils_1.hasAncestor)(path, ["command", "command_call"]);
+    const stmtsDoc = path.call(print, "stmts");
     return group(ifBreak([
         "->",
         params,
         " ",
         inCommand ? "{" : "do",
-        indent([line, path.call(print, "body", 1)]),
+        indent([line, stmtsDoc]),
         line,
         inCommand ? "}" : "end"
-    ], ["->", params, " { ", path.call(print, "body", 1), " }"]));
+    ], ["->", params, " { ", stmtsDoc, " }"]));
 };
 exports.printLambda = printLambda;

data/dist/ruby/nodes/loops.js

@@ -3,26 +3,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printUntilModifer = exports.printUntil = exports.printWhileModifier = exports.printWhile = exports.printFor = void 0;
+exports.printUntil = exports.printWhile = exports.printFor = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
 const utils_1 = require("../../utils");
 const { align, breakParent, group, hardline, ifBreak, indent, join, softline } = prettier_1.default;
-function printLoop(keyword, modifier) {
+function isModifier(node) {
+    return node.type === "while_mod" || node.type === "until_mod";
+}
+function printLoop(keyword) {
     return function printLoopWithOptions(path, { rubyModifier }, print) {
-        const [, stmts] = path.getValue().body;
+        const node = path.getValue();
+        const predicateDoc = path.call(print, "pred");
         // 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 ((0, utils_1.isEmptyStmts)(stmts)) {
-            return group([
-                group([keyword, " ", path.call(print, "body", 0)]),
-                hardline,
-                "end"
-            ]);
+        if (!isModifier(node) && (0, utils_1.isEmptyStmts)(node.stmts)) {
+            return group([group([keyword, " ", predicateDoc]), hardline, "end"]);
         }
+        const statementDoc = path.call(print, isModifier(node) ? "stmt" : "stmts");
         const inlineLoop = (0, utils_1.inlineEnsureParens)(path, [
-            path.call(print, "body", 1),
+            statementDoc,
             ` ${keyword} `,
-            path.call(print, "body", 0)
+            predicateDoc
         ]);
         // 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
@@ -34,12 +35,12 @@ function printLoop(keyword, modifier) {
         //
         // The above is effectively a `do...while` loop (which we don't have in
         // ruby).
-        if (modifier && path.getValue().body[1].type === "begin") {
+        if (isModifier(node) && node.stmt.type === "begin") {
             return inlineLoop;
         }
         const blockLoop = [
-            [`${keyword} `, align(keyword.length + 1, path.call(print, "body", 0))],
-            indent([softline, path.call(print, "body", 1)]),
+            [`${keyword} `, align(keyword.length + 1, predicateDoc)],
+            indent([softline, statementDoc]),
             softline,
             "end"
         ];
@@ -47,27 +48,28 @@ function printLoop(keyword, modifier) {
         // contains 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 (!rubyModifier || (0, utils_1.containsAssignment)(path.getValue().body[0])) {
+        if (!rubyModifier || (0, utils_1.containsAssignment)(node.pred)) {
             return [breakParent, blockLoop];
         }
         return group(ifBreak(blockLoop, inlineLoop));
     };
 }
 const printFor = (path, opts, print) => {
-    const [varDoc, rangeDoc, stmtsDoc] = path.map(print, "body");
-    const varsDoc = path.getValue().body[0].type === "mlhs" ? join(", ", varDoc) : varDoc;
+    const node = path.getValue();
+    let indexDoc = path.call(print, "index");
+    if (node.index.type === "mlhs") {
+        indexDoc = join(", ", indexDoc);
+    }
     return group([
         "for ",
-        varsDoc,
+        indexDoc,
         " in ",
-        rangeDoc,
-        indent([hardline, stmtsDoc]),
+        path.call(print, "collection"),
+        indent([hardline, path.call(print, "stmts")]),
         hardline,
         "end"
     ]);
 };
 exports.printFor = printFor;
-exports.printWhile = printLoop("while", false);
-exports.printWhileModifier = printLoop("while", true);
-exports.printUntil = printLoop("until", false);
-exports.printUntilModifer = printLoop("until", true);
+exports.printWhile = printLoop("while");
+exports.printUntil = printLoop("until");

data/dist/ruby/nodes/massign.js

@@ -3,71 +3,58 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printMRHSNewFromArgs = exports.printMRHSAddStar = exports.printMRHS = exports.printMLHSParen = exports.printMLHSAddStar = exports.printMLHSAddPost = exports.printMLHS = exports.printMAssign = void 0;
+exports.printMRHSNewFromArgs = exports.printMRHSAddStar = exports.printMRHS = exports.printMLHSParen = exports.printMLHS = exports.printMAssign = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
 const { group, indent, join, line, softline } = prettier_1.default;
 const 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([",", line], right));
+    const node = path.getValue();
+    let valueDoc = path.call(print, "value");
+    if (["mrhs", "mrhs_add_star", "mrhs_new_from_args"].includes(node.value.type)) {
+        valueDoc = group(join([",", line], valueDoc));
     }
-    const parts = [join([",", line], path.call(print, "body", 0))];
-    if (path.getValue().body[0].comma) {
-        parts.push(",");
+    const targetDoc = [
+        join([",", line], path.call(print, "target"))
+    ];
+    if (node.target.type === "mlhs" && node.target.comma) {
+        targetDoc.push(",");
     }
-    return group([group(parts), " =", indent([line, right])]);
+    return group([group(targetDoc), " =", indent([line, valueDoc])]);
 };
 exports.printMAssign = printMAssign;
 const printMLHS = (path, opts, print) => {
-    return path.map(print, "body");
+    return path.map(print, "parts");
 };
 exports.printMLHS = printMLHS;
-const printMLHSAddPost = (path, opts, print) => {
-    return [
-        ...path.call(print, "body", 0),
-        ...path.call(print, "body", 1)
-    ];
-};
-exports.printMLHSAddPost = printMLHSAddPost;
-const printMLHSAddStar = (path, opts, print) => {
-    const parts = ["*"];
-    if (path.getValue().body[1]) {
-        parts.push(path.call(print, "body", 1));
-    }
-    return [...path.call(print, "body", 0), parts];
-};
-exports.printMLHSAddStar = printMLHSAddStar;
 const 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);
+        return path.call(print, "cnts");
     }
+    const node = path.getValue();
     const parts = [
         softline,
-        join([",", line], path.call(print, "body", 0))
+        join([",", line], path.call(print, "cnts"))
     ];
-    if (path.getValue().body[0].comma) {
+    if (node.cnts.comma) {
         parts.push(",");
     }
     return group(["(", indent(parts), [softline, ")"]]);
 };
 exports.printMLHSParen = printMLHSParen;
 const printMRHS = (path, opts, print) => {
-    return path.map(print, "body");
+    return path.map(print, "parts");
 };
 exports.printMRHS = printMRHS;
 const printMRHSAddStar = (path, opts, print) => {
-    const [leftDoc, rightDoc] = path.map(print, "body");
-    return [...leftDoc, ["*", rightDoc]];
+    return [
+        ...path.call(print, "mrhs"),
+        ["*", path.call(print, "star")]
+    ];
 };
 exports.printMRHSAddStar = printMRHSAddStar;
 const 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;
+    return path.call(print, "args");
 };
 exports.printMRHSNewFromArgs = printMRHSNewFromArgs;

data/dist/ruby/nodes/methods.js

@@ -3,68 +3,48 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printAccessControl = exports.printSingleLineMethod = exports.printDef = void 0;
+exports.printAccessControl = exports.printDefEndless = exports.printDef = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
 const utils_1 = require("../../utils");
 const { group, hardline, indent, line } = prettier_1.default;
 const printDef = (path, opts, print) => {
     const node = path.getValue();
     const declaration = ["def "];
-    let paramsNode;
-    let bodystmtNode;
-    let nameDoc;
-    let paramsDoc;
-    let bodystmtDoc;
-    if (node.type === "def") {
-        paramsNode = node.body[1];
-        bodystmtNode = node.body[2];
-        nameDoc = path.call(print, "body", 0);
-        paramsDoc = path.call(print, "body", 1);
-        bodystmtDoc = path.call(print, "body", 2);
+    // In this case, we're printing a method that's defined as a singleton, so
+    // we need to include the target and the operator before the name.
+    if (node.type === "defs") {
+        declaration.push(path.call(print, "target"), path.call(print, "op"));
     }
-    else {
-        // In this case, we're printing a method that's defined as a singleton, so
-        // we need to include the target and the operator
-        declaration.push(path.call(print, "body", 0), path.call(print, "body", 1));
-        paramsNode = node.body[3];
-        bodystmtNode = node.body[4];
-        nameDoc = path.call(print, "body", 2);
-        paramsDoc = path.call(print, "body", 3);
-        bodystmtDoc = path.call(print, "body", 4);
-    }
-    // In case there are no parens but there are arguments
-    const parens = paramsNode.type === "params" && paramsNode.body.some((type) => type);
-    declaration.push(nameDoc, parens ? "(" : "", paramsDoc, parens ? ")" : "");
-    if ((0, utils_1.isEmptyBodyStmt)(bodystmtNode)) {
+    // In case there are no parens but there are parameters
+    const useParens = node.params.type === "params" && !(0, utils_1.isEmptyParams)(node.params);
+    declaration.push(path.call(print, "name"), useParens ? "(" : "", path.call(print, "params"), useParens ? ")" : "");
+    if ((0, utils_1.isEmptyBodyStmt)(node.bodystmt)) {
         return group([...declaration, "; end"]);
     }
     return group([
         group(declaration),
-        indent([hardline, bodystmtDoc]),
+        indent([hardline, path.call(print, "bodystmt")]),
         hardline,
         "end"
     ]);
 };
 exports.printDef = printDef;
-const printSingleLineMethod = (path, opts, print) => {
-    const parensNode = path.getValue().body[1];
+const printDefEndless = (path, opts, print) => {
+    const node = path.getValue();
     let paramsDoc = "";
-    if (parensNode) {
-        const paramsNode = parensNode.body[0];
-        if (paramsNode.body.some((type) => type)) {
-            paramsDoc = path.call(print, "body", 1);
-        }
+    // If we have any kind of parameters, we're going to print the whole
+    // parentheses. If we don't, then we're just going to skip them entirely.
+    if (node.paren && !(0, utils_1.isEmptyParams)(node.paren.cnts)) {
+        paramsDoc = path.call(print, "paren");
     }
     return group([
         "def ",
-        path.call(print, "body", 0),
+        path.call(print, "name"),
         paramsDoc,
         " =",
-        indent(group([line, path.call(print, "body", 2)]))
+        indent(group([line, path.call(print, "stmt")]))
     ]);
 };
-exports.printSingleLineMethod = printSingleLineMethod;
-const printAccessControl = (path, opts, print) => {
-    return path.call(print, "body", 0);
-};
+exports.printDefEndless = printDefEndless;
+const printAccessControl = (path, opts, print) => path.call(print, "value");
 exports.printAccessControl = printAccessControl;

data/dist/ruby/nodes/operators.js

@@ -3,29 +3,29 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printUnary = exports.printDot3 = exports.printDot2 = exports.printBinary = void 0;
+exports.printNot = exports.printUnary = exports.printDot3 = exports.printDot2 = exports.printBinary = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
 const utils_1 = require("../../utils");
 const { group, indent, line, softline } = prettier_1.default;
 const printBinary = (path, opts, print) => {
-    const [, operator, rightNode] = path.getValue().body;
-    const space = operator === "**" ? "" : " ";
-    if (utils_1.noIndent.includes(rightNode.type)) {
+    const node = path.getValue();
+    const space = node.op === "**" ? "" : " ";
+    if (utils_1.noIndent.includes(node.right.type)) {
         return group([
-            group(path.call(print, "body", 0)),
+            group(path.call(print, "left")),
             space,
-            operator,
+            node.op,
             space,
-            group(path.call(print, "body", 2))
+            group(path.call(print, "right"))
         ]);
     }
     return group([
-        group(path.call(print, "body", 0)),
+        group(path.call(print, "left")),
         space,
         group(indent([
-            operator,
+            node.op,
             space === "" ? softline : line,
-            path.call(print, "body", 2)
+            path.call(print, "right")
         ]))
     ]);
 };
@@ -33,38 +33,36 @@ exports.printBinary = printBinary;
 // dot2 nodes are used with ranges (or flip-flops). They can optionally drop
 // their left side for beginless ranges or their right side for endless ranges.
 const printDot2 = (path, opts, print) => {
-    const [leftNode, rightNode] = path.getValue().body;
+    const node = path.getValue();
     return [
-        leftNode ? path.call(print, "body", 0) : "",
+        node.left ? path.call(print, "left") : "",
         "..",
-        rightNode ? path.call(print, "body", 1) : ""
+        node.right ? path.call(print, "right") : ""
     ];
 };
 exports.printDot2 = printDot2;
 // dot3 nodes are used with ranges (or flip-flops). They can optionally drop
 // their left side for beginless ranges or their right side for endless ranges.
 const printDot3 = (path, opts, print) => {
-    const [leftNode, rightNode] = path.getValue().body;
+    const node = path.getValue();
     return [
-        leftNode ? path.call(print, "body", 0) : "",
+        node.left ? path.call(print, "left") : "",
         "...",
-        rightNode ? path.call(print, "body", 1) : ""
+        node.right ? path.call(print, "right") : ""
     ];
 };
 exports.printDot3 = printDot3;
 const printUnary = (path, opts, print) => {
     const node = path.getValue();
-    const contentsDoc = path.call(print, "body", 0);
-    if (node.oper === "not") {
-        // Here we defer to the original source, as it's kind of difficult to
-        // determine if we can actually remove the parentheses being used.
-        if (node.paren) {
-            return ["not", "(", contentsDoc, ")"];
-        }
-        else {
-            return ["not", " ", contentsDoc];
-        }
-    }
-    return [node.oper, contentsDoc];
+    return [node.op, path.call(print, "value")];
 };
 exports.printUnary = printUnary;
+const printNot = (path, opts, print) => {
+    const node = path.getValue();
+    const valueDoc = path.call(print, "value");
+    if (node.paren) {
+        return ["not", "(", valueDoc, ")"];
+    }
+    return ["not", " ", valueDoc];
+};
+exports.printNot = printNot;

data/dist/ruby/nodes/params.js

@@ -3,51 +3,51 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printRestParam = exports.printKeywordRestParam = exports.printArgsForward = exports.printParams = void 0;
+exports.printExcessedComma = exports.printRestParam = exports.printKeywordRestParam = exports.printArgsForward = exports.printParams = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
 const { group, hardline, join, indent, line, lineSuffix, softline } = prettier_1.default;
 function printRestParamSymbol(symbol) {
     return function printRestParamWithSymbol(path, opts, print) {
-        return path.getValue().body[0]
-            ? [symbol, path.call(print, "body", 0)]
-            : symbol;
+        const node = path.getValue();
+        return node.name ? [symbol, path.call(print, "name")] : symbol;
     };
 }
 const printParams = (path, opts, print) => {
-    const [reqs, optls, rest, post, kwargs, kwargRest, block] = path.getValue().body;
+    const node = path.getValue();
     let parts = [];
-    if (reqs) {
+    if (node.reqs) {
         path.each((reqPath) => {
             // For some very strange reason, if you have a comment attached to a
             // rest_param, it shows up here in the list of required params.
             if (reqPath.getValue().type !== "rest_param") {
                 parts.push(print(reqPath));
             }
-        }, "body", 0);
+        }, "reqs");
     }
-    if (optls) {
-        parts = parts.concat(path.map((optlPath) => join(" = ", optlPath.map(print)), "body", 1));
+    if (node.opts) {
+        parts = parts.concat(path.map((optlPath) => join(" = ", optlPath.map(print)), "opts"));
     }
-    if (rest && rest.type !== "excessed_comma") {
-        parts.push(path.call(print, "body", 2));
+    if (node.rest && node.rest.type !== "excessed_comma") {
+        parts.push(path.call(print, "rest"));
     }
-    if (post) {
-        parts = parts.concat(path.map(print, "body", 3));
+    if (node.posts) {
+        parts = parts.concat(path.map(print, "posts"));
     }
-    if (kwargs) {
+    if (node.keywords) {
         parts = parts.concat(path.map((kwargPath) => {
-            if (!kwargPath.getValue()[1]) {
-                return kwargPath.call(print, 0);
+            const kwarg = kwargPath.getValue();
+            const keyDoc = kwargPath.call(print, 0);
+            if (kwarg[1]) {
+                return group([keyDoc, " ", kwargPath.call(print, 1)]);
             }
-            return group(join(" ", kwargPath.map(print)));
-        }, "body", 4));
+            return keyDoc;
+        }, "keywords"));
     }
-    if (kwargRest) {
-        parts.push(kwargRest === "nil" ? "**nil" : path.call(print, "body", 5));
+    if (node.kwrest) {
+        parts.push(node.kwrest === "nil" ? "**nil" : path.call(print, "kwrest"));
     }
-    if (block) {
-        parts.push(path.call(print, "body", 6));
+    if (node.block) {
+        parts.push(path.call(print, "block"));
     }
     const contents = [join([",", line], parts)];
     // You can put an extra comma at the end of block args between pipes to
@@ -59,7 +59,8 @@ const printParams = (path, opts, print) => {
     // In ruby 2.5, the excessed comma is indicated by having a 0 in the rest
     // param position. In ruby 2.6+ it's indicated by having an "excessed_comma"
     // node in the rest position. Seems odd, but it's true.
-    if (rest === 0 || (rest && rest.type === "excessed_comma")) {
+    if (node.rest === 0 ||
+        (node.rest && node.rest.type === "excessed_comma")) {
         contents.push(",");
     }
     // If the parent node is a paren then we skipped printing the parentheses so
@@ -84,6 +85,11 @@ const printParams = (path, opts, print) => {
     return group(contents);
 };
 exports.printParams = printParams;
-exports.printArgsForward = (0, utils_1.literal)("...");
+const printArgsForward = (path) => path.getValue().value;
+exports.printArgsForward = printArgsForward;
 exports.printKeywordRestParam = printRestParamSymbol("**");
 exports.printRestParam = printRestParamSymbol("*");
+const printExcessedComma = (path, opts, print) => {
+    return path.call(print, "value");
+};
+exports.printExcessedComma = printExcessedComma;