prettier 2.0.0 → 2.1.0

data/dist/ruby/nodes/arrays.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printArray = exports.printWord = void 0;
+exports.printArray = exports.printWords = exports.printSymbols = exports.printQwords = exports.printQsymbols = exports.printWord = void 0;
 const prettier_1 = __importDefault(require("../../prettier"));
 const utils_1 = require("../../utils");
 const { group, ifBreak, indent, join, line, softline } = prettier_1.default;
@@ -14,8 +14,8 @@ const { group, ifBreak, indent, join, line, softline } = prettier_1.default;
 //     ['a', 'b', 'c']
 //
 function isStringArray(args) {
-    return (args.body.length > 1 &&
-        args.body.every((arg) => {
+    return (args.parts.length > 1 &&
+        args.parts.every((arg) => {
             // We want to verify that every node inside of this array is a string
             // literal. We also want to make sure none of them have comments attached.
             if (arg.type !== "string_literal" || arg.comments) {
@@ -23,19 +23,19 @@ function isStringArray(args) {
             }
             // If the string has multiple parts (meaning plain string content but also
             // interpolated content) then we know it's not a simple string.
-            if (arg.body.length !== 1) {
+            if (arg.parts.length !== 1) {
                 return false;
             }
-            const part = arg.body[0];
+            const part = arg.parts[0];
             // If the only part of this string is not @tstring_content then it's
             // interpolated, so again we can return false.
-            if (part.type !== "@tstring_content") {
+            if (part.type !== "tstring_content") {
                 return false;
             }
             // Finally, verify that the string doesn't contain a space, an escape
             // character, or brackets so that we know it can be put into a string
             // literal array.
-            return !/[\s\\[\]]/.test(part.body);
+            return !/[\s\\[\]]/.test(part.value);
         }));
 }
 // Checks that every argument within this args node is a symbol_literal node (as
@@ -45,20 +45,20 @@ function isStringArray(args) {
 //     [:a, :b, :c]
 //
 function isSymbolArray(args) {
-    return (args.body.length > 1 &&
-        args.body.every((arg) => arg.type === "symbol_literal" && !arg.comments));
+    return (args.parts.length > 1 &&
+        args.parts.every((arg) => arg.type === "symbol_literal" && !arg.comments));
 }
 // Prints out a word that is a part of a special array literal that accepts
 // interpolation. The body is an array of either plain strings or interpolated
 // expressions.
 const printWord = (path, opts, print) => {
-    return path.map(print, "body");
+    return path.map(print, "parts");
 };
 exports.printWord = printWord;
 // Prints out a special array literal. Accepts the parts of the array literal as
 // an argument, where the first element of the parts array is a string that
 // contains the special start.
-function printArrayLiteral(start, parts) {
+function printArrayLiteralParts(start, parts) {
     return group([
         start,
         "[",
@@ -67,47 +67,43 @@ function printArrayLiteral(start, parts) {
         "]"
     ]);
 }
-const arrayLiteralStarts = {
-    qsymbols: "%i",
-    qwords: "%w",
-    symbols: "%I",
-    words: "%W"
-};
+function printArrayLiteral(start) {
+    return function printArrayLiteralWithStart(path, opts, print) {
+        return printArrayLiteralParts(start, path.map(print, "elems"));
+    };
+}
+exports.printQsymbols = printArrayLiteral("%i");
+exports.printQwords = printArrayLiteral("%w");
+exports.printSymbols = printArrayLiteral("%I");
+exports.printWords = printArrayLiteral("%W");
 // An array node is any literal array in Ruby. This includes all of the special
 // array literals as well as regular arrays. If it is a special array literal
 // then it will have one child that represents the special array, otherwise it
 // will have one child that contains all of the elements of the array.
 const printArray = (path, opts, print) => {
     const array = path.getValue();
-    const args = array.body[0];
+    const contents = array.cnts;
     // If there is no inner arguments node, then we're dealing with an empty
     // array, so we can go ahead and return.
-    if (args === null) {
+    if (contents === null) {
         return (0, utils_1.printEmptyCollection)(path, opts, "[", "]");
     }
-    // If we don't have a regular args node at this point then we have a special
-    // array literal. In that case we're going to print out the body (which will
-    // return to us an array with the first one being the start of the array) and
-    // send that over to the printArrayLiteral function.
-    if (args.type !== "args" && args.type !== "args_add_star") {
-        return path.call((arrayPath) => printArrayLiteral(arrayLiteralStarts[args.type], arrayPath.map(print, "body")), "body", 0);
-    }
     if (opts.rubyArrayLiteral) {
         // If we have an array that contains only simple string literals with no
         // spaces or interpolation, then we're going to print a %w array.
-        if (isStringArray(args)) {
-            const printString = (stringPath) => stringPath.call(print, "body", 0);
+        if (isStringArray(contents)) {
+            const printString = (stringPath) => stringPath.call(print, "parts", 0);
             const nodePath = path;
-            const parts = nodePath.map(printString, "body", 0, "body");
-            return printArrayLiteral("%w", parts);
+            const parts = nodePath.map(printString, "cnts", "parts");
+            return printArrayLiteralParts("%w", parts);
         }
         // If we have an array that contains only simple symbol literals with no
         // interpolation, then we're going to print a %i array.
-        if (isSymbolArray(args)) {
-            const printSymbol = (symbolPath) => symbolPath.call(print, "body", 0);
+        if (isSymbolArray(contents)) {
+            const printSymbol = (symbolPath) => symbolPath.call(print, "value");
             const nodePath = path;
-            const parts = nodePath.map(printSymbol, "body", 0, "body");
-            return printArrayLiteral("%i", parts);
+            const parts = nodePath.map(printSymbol, "cnts", "parts");
+            return printArrayLiteralParts("%i", parts);
         }
     }
     // Here we have a normal array of any type of object with no special literal
@@ -116,7 +112,7 @@ const printArray = (path, opts, print) => {
         "[",
         indent([
             softline,
-            join([",", line], path.call(print, "body", 0)),
+            join([",", line], path.call(print, "cnts")),
             (0, utils_1.getTrailingComma)(opts) ? ifBreak(",", "") : ""
         ]),
         softline,

data/dist/ruby/nodes/assign.js

@@ -7,35 +7,31 @@ exports.printVarRef = exports.printVarField = exports.printOpAssign = exports.pr
 const prettier_1 = __importDefault(require("../../prettier"));
 const utils_1 = require("../../utils");
 const { group, indent, join, line } = prettier_1.default;
-const printAssign = (path, opts, print) => {
-    const [, valueNode] = path.getValue().body;
-    const [targetDoc, valueDoc] = path.map(print, "body");
+const printAssign = (...args) => {
+    return printOpAssignOrAssign("=", ...args);
+};
+exports.printAssign = printAssign;
+const printOpAssign = (path, opts, print) => {
+    const opDoc = path.call(print, "op");
+    return printOpAssignOrAssign(opDoc, path, opts, print);
+};
+exports.printOpAssign = printOpAssign;
+function printOpAssignOrAssign(opDoc, path, opts, print) {
+    const valueNode = path.getValue().value;
+    const targetDoc = path.call(print, "target");
+    const valueDoc = path.call(print, "value");
     let rightSideDoc = valueDoc;
     // If the right side of this assignment is a multiple assignment, then we need
     // to join it together with commas.
-    if (["mrhs_add_star", "mrhs_new_from_args"].includes(valueNode.type)) {
+    if (["mrhs", "mrhs_add_star", "mrhs_new_from_args"].includes(valueNode.type)) {
         rightSideDoc = group(join([",", line], valueDoc));
     }
     if ((0, utils_1.skipAssignIndent)(valueNode)) {
-        return group([targetDoc, " = ", rightSideDoc]);
+        return group([targetDoc, " ", opDoc, " ", rightSideDoc]);
     }
-    return group([targetDoc, " =", indent([line, rightSideDoc])]);
-};
-exports.printAssign = printAssign;
-const printOpAssign = (path, opts, print) => {
-    return group([
-        path.call(print, "body", 0),
-        " ",
-        path.call(print, "body", 1),
-        indent([line, path.call(print, "body", 2)])
-    ]);
-};
-exports.printOpAssign = printOpAssign;
-const printVarField = (path, opts, print) => {
-    return path.getValue().body ? path.call(print, "body", 0) : "";
-};
+    return group([targetDoc, " ", opDoc, indent([line, rightSideDoc])]);
+}
+const printVarField = (path, opts, print) => (path.getValue().value ? path.call(print, "value") : "");
 exports.printVarField = printVarField;
-const printVarRef = (path, opts, print) => {
-    return path.call(print, "body", 0);
-};
+const printVarRef = (path, opts, print) => path.call(print, "value");
 exports.printVarRef = printVarRef;

data/dist/ruby/nodes/blocks.js

@@ -8,10 +8,10 @@ const prettier_1 = __importDefault(require("../../prettier"));
 const utils_1 = require("../../utils");
 const { breakParent, group, ifBreak, indent, join, removeLines, softline } = prettier_1.default;
 const printBlockVar = (path, opts, print) => {
-    const parts = ["|", removeLines(path.call(print, "body", 0))];
+    const parts = ["|", removeLines(path.call(print, "params"))];
     // The second part of this node is a list of optional block-local variables
-    if (path.getValue().body[1]) {
-        parts.push("; ", join(", ", path.map(print, "body", 1)));
+    if (path.getValue().locals.length > 0) {
+        parts.push("; ", join(", ", path.map(print, "locals")));
     }
     parts.push("| ");
     return parts;
@@ -23,9 +23,9 @@ exports.printBlockVar = printBlockVar;
 // braces or not. Ideally we wouldn't do this, we would instead do this
 // reflection in the child printer, but this keeps the logic to just this file
 // and contains it, so keeping it here for now.
-function printBlockBeging(path, print, useBraces) {
+function printBlockBegin(path, print, useBraces) {
     let docs = print(path);
-    const doc = useBraces ? "{" : "do";
+    const doc = useBraces && !path.getValue().comments ? "{" : "do";
     if (Array.isArray(docs)) {
         docs[1] = doc;
     }
@@ -36,13 +36,16 @@ function printBlockBeging(path, print, useBraces) {
 }
 function printBlock(braces) {
     return function printBlockWithBraces(path, opts, print) {
-        const [variables, statements] = path.getValue().body;
-        const stmts = statements.type === "stmts" ? statements.body : statements.body[0].body;
+        const node = path.getValue();
+        const stmts = node.type === "brace_block" ? node.stmts.body : node.bodystmt.stmts.body;
         let doBlockBody = "";
         if (stmts.length !== 1 ||
             stmts[0].type !== "void_stmt" ||
             stmts[0].comments) {
-            doBlockBody = indent([softline, path.call(print, "body", 1)]);
+            doBlockBody = indent([
+                softline,
+                path.call(print, node.type === "brace_block" ? "stmts" : "bodystmt")
+            ]);
         }
         // If this block is nested underneath a command or command_call node, then
         // we can't use `do...end` because that will get associated with the parent
@@ -52,8 +55,8 @@ function printBlock(braces) {
         const useBraces = braces && (0, utils_1.hasAncestor)(path, ["command", "command_call"]);
         const doBlock = [
             " ",
-            path.call((begingPath) => printBlockBeging(begingPath, print, useBraces), "beging"),
-            variables ? [" ", path.call(print, "body", 0)] : "",
+            path.call((beginPath) => printBlockBegin(beginPath, print, useBraces), node.type === "brace_block" ? "lbrace" : "keyword"),
+            node.block_var ? [" ", path.call(print, "block_var")] : "",
             doBlockBody,
             [softline, useBraces ? "}" : "end"]
         ];
@@ -64,7 +67,7 @@ function printBlock(braces) {
             stmts[0].comments) {
             return [breakParent, doBlock];
         }
-        const blockReceiver = path.getParentNode().body[0];
+        const blockReceiver = path.getParentNode().call;
         // If the parent node is a command node, then there are no parentheses
         // around the arguments to that command, so we need to break the block
         if (["command", "command_call"].includes(blockReceiver.type)) {
@@ -73,10 +76,10 @@ function printBlock(braces) {
         const hasBody = stmts.some(({ type }) => type !== "void_stmt");
         const braceBlock = [
             " ",
-            path.call((begingPath) => printBlockBeging(begingPath, print, true), "beging"),
-            hasBody || variables ? " " : "",
-            variables ? path.call(print, "body", 0) : "",
-            path.call(print, "body", 1),
+            path.call((beginPath) => printBlockBegin(beginPath, print, true), node.type === "brace_block" ? "lbrace" : "keyword"),
+            hasBody || node.block_var ? " " : "",
+            node.block_var ? path.call(print, "block_var") : "",
+            path.call(print, node.type === "brace_block" ? "stmts" : "bodystmt"),
             hasBody ? " " : "",
             "}"
         ];

data/dist/ruby/nodes/calls.js

@@ -15,13 +15,12 @@ function hasLeadingComments(node) {
 }
 const printCall = (path, opts, print) => {
     const node = path.getValue();
-    const [receiverNode, , messageNode] = node.body;
-    const receiverDoc = path.call(print, "body", 0);
+    const receiverDoc = path.call(print, "receiver");
     const operatorDoc = (0, utils_1.makeCall)(path, opts, print);
     // You can call lambdas with a special syntax that looks like func.(*args).
     // In this case, "call" is returned for the 3rd child node. We don't alter
     // call syntax so if `call` is implicit, we don't print it out.
-    const messageDoc = messageNode === "call" ? "" : path.call(print, "body", 2);
+    const messageDoc = node.message === "call" ? "" : path.call(print, "message");
     // Create some arrays that are going to represent each side of our call.
     let leftSideDoc = [receiverDoc];
     let rightSideDoc = [operatorDoc, messageDoc];
@@ -35,19 +34,19 @@ const printCall = (path, opts, print) => {
     //
     // In the case we need to group the receiver and the operator together or
     // we'll end up with a syntax error.
-    const operatorIsTrailing = messageNode !== "call" && hasLeadingComments(messageNode);
+    const operatorIsTrailing = node.message !== "call" && hasLeadingComments(node.message);
     if (operatorIsTrailing) {
         leftSideDoc = [receiverDoc, operatorDoc];
         rightSideDoc = [messageDoc];
     }
     // For certain left sides of the call nodes, we want to attach directly to
     // the } or end.
-    if (utils_1.noIndent.includes(receiverNode.type)) {
+    if (utils_1.noIndent.includes(node.receiver.type)) {
         return [leftSideDoc, rightSideDoc];
     }
-    if (receiverNode.type === "call" &&
-        receiverNode.body[2] !== "call" &&
-        receiverNode.body[2].body === "where" &&
+    if (node.receiver.type === "call" &&
+        node.receiver.message !== "call" &&
+        node.receiver.message.value === "where" &&
         messageDoc === "not") {
         // This is very specialized behavior wherein we group .where.not calls
         // together because it looks better. For more information, see
@@ -55,7 +54,7 @@ const printCall = (path, opts, print) => {
     }
     else {
         // Otherwise, we're going to put a line node into the right side doc.
-        rightSideDoc.unshift(receiverNode.comments ? hardline : softline);
+        rightSideDoc.unshift(node.receiver.comments ? hardline : softline);
     }
     // Get a reference to the parent node so we can check if we're inside a chain
     const parentNode = path.getParentNode();
@@ -64,7 +63,7 @@ const printCall = (path, opts, print) => {
     if (chained.includes(parentNode.type) && !node.comments) {
         parentNode.chain = (node.chain || 0) + 1;
         parentNode.callChain = (node.callChain || 0) + 1;
-        parentNode.firstReceiverType = node.firstReceiverType || receiverNode.type;
+        parentNode.firstReceiverType = node.firstReceiverType || node.receiver.type;
         // Here we're going to determine what doc nodes to send up to the parent
         // node to represent when we're in the multi-line form.
         let breakDocLHS;
@@ -104,8 +103,8 @@ const printCall = (path, opts, print) => {
 exports.printCall = printCall;
 const printMethodAddArg = (path, opts, print) => {
     const node = path.getValue();
-    const [methodNode, argNode] = node.body;
-    const [methodDoc, argsDoc] = path.map(print, "body");
+    const methodDoc = path.call(print, "call");
+    const argsDoc = path.call(print, "args");
     // You can end up here if you have a method with a ? ending, presumably
     // because the parser knows that it cannot be a local variable. You can also
     // end up here if you are explicitly using an empty set of parentheses.
@@ -114,7 +113,7 @@ const printMethodAddArg = (path, opts, print) => {
         // like a constant, then we need to match that in order to maintain valid
         // Ruby. For example, you could do something like Foo(), on which we would
         // need to keep the parentheses to make it look like a method call.
-        if (methodNode.type === "fcall" && methodNode.body[0].type === "@const") {
+        if (node.call.type === "fcall" && node.call.value.type === "const") {
             return [methodDoc, "()"];
         }
         // If you're using an explicit set parentheses with the special call syntax,
@@ -122,14 +121,14 @@ const printMethodAddArg = (path, opts, print) => {
         // example, if you call something like Foo.new.() (implicitly calling the
         // #call method on a new instance of the Foo class), then we have to print
         // out those parentheses, otherwise we'll end up with Foo.new.
-        if (methodNode.type === "call" && methodNode.body[2] === "call") {
+        if (node.call.type === "call" && node.call.message === "call") {
             return [methodDoc, "()"];
         }
         return methodDoc;
     }
     // This case will ONLY be hit if we can successfully turn the block into a
     // to_proc call. In that case, we just explicitly add the parens around it.
-    if (argNode.type === "args" && argsDoc.length > 0) {
+    if (node.args.type === "args" && argsDoc.length > 0) {
         return [methodDoc, "(", ...argsDoc, ")"];
     }
     // Get a reference to the parent node so we can check if we're inside a chain
@@ -157,12 +156,16 @@ const printMethodAddArg = (path, opts, print) => {
         if (sigBlock.type === "do_block") {
             sigBlock = path.getParentNode(3);
         }
-        if (sigBlock.type === "method_add_block" &&
-            sigBlock.body[1] &&
-            sigBlock.body[0].type === "method_add_arg" &&
-            sigBlock.body[0].body[0].type === "fcall" &&
-            sigBlock.body[0].body[0].body[0].body === "sig") {
-            threshold = 2;
+        if (sigBlock.type === "method_add_block") {
+            // Pulling this out into a separate variable so we can get back some of
+            // our type safety.
+            const sigBlockNode = sigBlock;
+            if (sigBlockNode.block &&
+                sigBlockNode.call.type === "method_add_arg" &&
+                sigBlockNode.call.call.type === "fcall" &&
+                sigBlockNode.call.call.value.value === "sig") {
+                threshold = 2;
+            }
         }
     }
     // If we're at the top of a chain, then we're going to print out a nice
@@ -191,30 +194,30 @@ const printMethodAddArg = (path, opts, print) => {
     }
     // If there are already parentheses, then we can just use the doc that's
     // already printed.
-    if (argNode.type == "arg_paren") {
-        return [methodDoc, argsDoc];
+    if (node.args.type == "arg_paren") {
+        return group([methodDoc, argsDoc]);
     }
     return [methodDoc, " ", join(", ", argsDoc), " "];
 };
 exports.printMethodAddArg = printMethodAddArg;
 const printMethodAddBlock = (path, opts, print) => {
     const node = path.getValue();
-    const [callNode, blockNode] = node.body;
-    const [callDoc, blockDoc] = path.map(print, "body");
+    const callDoc = path.call(print, "call");
+    const blockDoc = path.call(print, "block");
     // Don't bother trying to do any kind of fancy toProc transform if the option
     // is disabled.
     if (opts.rubyToProc) {
-        const proc = (0, toProc_1.default)(path, blockNode);
-        if (proc && callNode.type === "call") {
+        const proc = (0, toProc_1.default)(path, node.block);
+        if (proc && node.call.type === "call") {
             return group([
-                path.call(print, "body", 0),
+                path.call(print, "call"),
                 "(",
                 indent([softline, proc]),
                 [softline, ")"]
             ]);
         }
         if (proc) {
-            return path.call(print, "body", 0);
+            return path.call(print, "call");
         }
     }
     // Get a reference to the parent node so we can check if we're inside a chain
@@ -255,6 +258,6 @@ const printMethodAddBlock = (path, opts, print) => {
 };
 exports.printMethodAddBlock = printMethodAddBlock;
 const printCallContainer = (path, opts, print) => {
-    return path.call(print, "body", 0);
+    return path.call(print, "value");
 };
 exports.printCallContainer = printCallContainer;

data/dist/ruby/nodes/case.js

@@ -10,17 +10,17 @@ const printCase = (path, opts, print) => {
     const parts = ["case"];
     // You don't need to explicitly have something to test against in a case
     // statement (without it it effectively becomes an if/elsif chain).
-    if (path.getValue().body[0]) {
-        parts.push(" ", path.call(print, "body", 0));
+    if (path.getValue().value) {
+        parts.push(" ", path.call(print, "value"));
     }
-    return [...parts, hardline, path.call(print, "body", 1), hardline, "end"];
+    return [...parts, hardline, path.call(print, "cons"), hardline, "end"];
 };
 exports.printCase = printCase;
 const printWhen = (path, opts, print) => {
-    const [, , addition] = path.getValue().body;
+    const node = path.getValue();
     // The `fill` builder command expects an array of docs alternating with
     // line breaks. This is so it can loop through and determine where to break.
-    const preds = fill(path.call(print, "body", 0).reduce((accum, pred, index) => {
+    const preds = fill(path.call(print, "args").reduce((accum, pred, index) => {
         if (index === 0) {
             return [pred];
         }
@@ -33,7 +33,7 @@ const printWhen = (path, opts, print) => {
             pred
         ];
     }, []));
-    const stmts = path.call(print, "body", 1);
+    const stmts = path.call(print, "stmts");
     const parts = [["when ", align("when ".length, preds)]];
     // It's possible in a when to just have empty void statements, in which case
     // we would skip adding the body.
@@ -42,8 +42,8 @@ const printWhen = (path, opts, print) => {
     }
     // This is the next clause on the case statement, either another `when` or
     // an `else` clause.
-    if (addition) {
-        parts.push(hardline, path.call(print, "body", 2));
+    if (node.cons) {
+        parts.push(hardline, path.call(print, "cons"));
     }
     return group(parts);
 };

data/dist/ruby/nodes/class.js

@@ -8,45 +8,45 @@ const prettier_1 = __importDefault(require("../../prettier"));
 const utils_1 = require("../../utils");
 const { group, hardline, indent } = prettier_1.default;
 const printClass = (path, opts, print) => {
-    const [, superclass, bodystmt] = path.getValue().body;
-    const parts = ["class ", path.call(print, "body", 0)];
-    if (superclass) {
-        parts.push(" < ", path.call(print, "body", 1));
+    const node = path.getValue();
+    const parts = ["class ", path.call(print, "constant")];
+    if (node.superclass) {
+        parts.push(" < ", path.call(print, "superclass"));
     }
     const declaration = group(parts);
-    if ((0, utils_1.isEmptyBodyStmt)(bodystmt)) {
+    if ((0, utils_1.isEmptyBodyStmt)(node.bodystmt)) {
         return group([declaration, hardline, "end"]);
     }
     return group([
         declaration,
-        indent([hardline, path.call(print, "body", 2)]),
+        indent([hardline, path.call(print, "bodystmt")]),
         [hardline, "end"]
     ]);
 };
 exports.printClass = printClass;
 const printModule = (path, opts, print) => {
     const node = path.getValue();
-    const declaration = group(["module ", path.call(print, "body", 0)]);
-    if ((0, utils_1.isEmptyBodyStmt)(node.body[1])) {
+    const declaration = group(["module ", path.call(print, "constant")]);
+    if ((0, utils_1.isEmptyBodyStmt)(node.bodystmt)) {
         return group([declaration, hardline, "end"]);
     }
     return group([
         declaration,
-        indent([hardline, path.call(print, "body", 1)]),
+        indent([hardline, path.call(print, "bodystmt")]),
         hardline,
         "end"
     ]);
 };
 exports.printModule = printModule;
 const printSClass = (path, opts, print) => {
-    const bodystmt = path.getValue().body[1];
-    const declaration = ["class << ", path.call(print, "body", 0)];
-    if ((0, utils_1.isEmptyBodyStmt)(bodystmt)) {
+    const node = path.getValue();
+    const declaration = ["class << ", path.call(print, "target")];
+    if ((0, utils_1.isEmptyBodyStmt)(node.bodystmt)) {
         return group([declaration, hardline, "end"]);
     }
     return group([
         declaration,
-        indent([hardline, path.call(print, "body", 1)]),
+        indent([hardline, path.call(print, "bodystmt")]),
         hardline,
         "end"
     ]);