prettier 1.6.1 → 2.0.0.pre.rc1

data/{src → dist}/ruby/nodes/aref.js

@@ -1,12 +1,11 @@
-const {
-  concat,
-  group,
-  indent,
-  join,
-  line,
-  softline
-} = require("../../prettier");
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printArefField = exports.printAref = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const { group, indent, join, line, softline } = prettier_1.default;
 // `aref` nodes are when you're pulling a value out of a collection at a
 // specific index. Put another way, it's any time you're calling the method
 // `#[]`.
@@ -19,16 +18,14 @@ const {
 //
 //     foo[]
 //
-function printAref(path, opts, print) {
-  const indexNode = path.getValue().body[1];
-
-  if (!indexNode) {
-    return concat([path.call(print, "body", 0), "[]"]);
-  }
-
-  return printArefField(path, opts, print);
-}
-
+const printAref = (path, opts, print) => {
+    const indexNode = path.getValue().body[1];
+    if (!indexNode) {
+        return [path.call(print, "body", 0), "[]"];
+    }
+    return (0, exports.printArefField)(path, opts, print);
+};
+exports.printAref = printAref;
 // `aref_field` nodes are for assigning values into collections at specific
 // indices. Put another way, it's any time you're calling the method `#[]=`.
 // The `aref_field` node itself is just the left side of the assignment, and
@@ -43,20 +40,14 @@ function printAref(path, opts, print) {
 //
 //     foo[bar] = baz
 //
-function printArefField(path, opts, print) {
-  const [printedArray, printedIndex] = path.map(print, "body");
-
-  return group(
-    concat([
-      printedArray,
-      "[",
-      indent(concat([softline, join(concat([",", line]), printedIndex)])),
-      concat([softline, "]"])
-    ])
-  );
-}
-
-module.exports = {
-  aref: printAref,
-  aref_field: printArefField
+const printArefField = (path, opts, print) => {
+    const [printedArray, printedIndex] = path.map(print, "body");
+    return group([
+        printedArray,
+        "[",
+        indent([softline, join([",", line], printedIndex)]),
+        softline,
+        "]"
+    ]);
 };
+exports.printArefField = printArefField;

data/dist/ruby/nodes/args.js

@@ -0,0 +1,165 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printBlockArg = exports.printArgsAddStar = exports.printArgsAddBlock = exports.printArgs = exports.printArgParen = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const utils_1 = require("../../utils");
+const toProc_1 = __importDefault(require("../toProc"));
+const { group, ifBreak, indent, join, line, softline } = prettier_1.default;
+const noTrailingComma = ["command", "command_call"];
+function getArgParenTrailingComma(node) {
+    // If we have a block, then we don't want to add a trailing comma.
+    if (node.type === "args_add_block" && node.body[1]) {
+        return "";
+    }
+    // If we only have one argument and that first argument necessitates that we
+    // skip putting a comma (because it would interfere with parsing the argument)
+    // then we don't want to add a trailing comma.
+    if (node.body.length === 1 && noTrailingComma.includes(node.body[0].type)) {
+        return "";
+    }
+    return ifBreak(",", "");
+}
+const printArgParen = (path, opts, print) => {
+    const argsNode = path.getValue().body[0];
+    if (argsNode === null) {
+        return "";
+    }
+    // Here we can skip the entire rest of the method by just checking if it's
+    // an args_forward node, as we're guaranteed that there are no other arg
+    // nodes.
+    if (argsNode.type === "args_forward") {
+        return group([
+            "(",
+            indent([softline, path.call(print, "body", 0)]),
+            softline,
+            ")"
+        ]);
+    }
+    // Now here we return a doc that represents the whole grouped expression,
+    // including the surrouding parentheses.
+    return group([
+        "(",
+        indent([
+            softline,
+            join([",", line], path.call(print, "body", 0)),
+            (0, utils_1.getTrailingComma)(opts) ? getArgParenTrailingComma(argsNode) : ""
+        ]),
+        softline,
+        ")"
+    ]);
+};
+exports.printArgParen = printArgParen;
+const printArgs = (path, { rubyToProc }, print) => {
+    const args = path.map(print, "body");
+    // Don't bother trying to do any kind of fancy toProc transform if the
+    // option is disabled.
+    if (rubyToProc) {
+        let blockNode = null;
+        // Look up the chain to see if these arguments are contained within a
+        // method_add_block node, and if they are that that node has a block
+        // associated with it. If it does, we're going to attempt to transform it
+        // into the to_proc shorthand and add it to the list of arguments.
+        [1, 2, 3].find((parent) => {
+            const parentNode = path.getParentNode(parent);
+            blockNode =
+                parentNode &&
+                    parentNode.type === "method_add_block" &&
+                    parentNode.body[1];
+            return blockNode;
+        });
+        const proc = blockNode && (0, toProc_1.default)(path, blockNode);
+        // If we have a successful to_proc transformation, but we're part of an
+        // aref node, that means it's something to the effect of
+        //
+        //     foo[:bar].each(&:to_s)
+        //
+        // In this case we need to just return regular arguments, otherwise we
+        // would end up putting &:to_s inside the brackets accidentally.
+        if (proc && path.getParentNode(1).type !== "aref") {
+            args.push(proc);
+        }
+    }
+    return args;
+};
+exports.printArgs = printArgs;
+const printArgsAddBlock = (path, opts, print) => {
+    const node = path.getValue();
+    const blockNode = node.body[1];
+    const parts = path.call(print, "body", 0);
+    if (blockNode) {
+        let blockDoc = path.call(print, "body", 1);
+        if (!(blockNode.comments || []).some(({ leading }) => leading)) {
+            // If we don't have any leading comments, we can just prepend the
+            // operator.
+            blockDoc = ["&", blockDoc];
+        }
+        else {
+            // If we have a method call like:
+            //
+            //     foo(
+            //       # comment
+            //       &block
+            //     )
+            //
+            // then we need to make sure we don't accidentally prepend the operator
+            // before the comment.
+            //
+            // In prettier >= 2.3.0, the comments are printed as an array before the
+            // content. I don't love this kind of reflection, but it's the simplest
+            // way at the moment to get this right.
+            blockDoc = blockDoc[0].concat(["&", blockDoc[1]], blockDoc.slice(2));
+        }
+        parts.push(blockDoc);
+    }
+    return parts;
+};
+exports.printArgsAddBlock = printArgsAddBlock;
+const printArgsAddStar = (path, opts, print) => {
+    let docs = [];
+    path.each((argPath, argIndex) => {
+        const doc = print(argPath);
+        // If it's the first child, then it's an array of args, so we're going to
+        // concat that onto the existing docs if there are any.
+        if (argIndex === 0) {
+            if (doc.length > 0) {
+                docs = docs.concat(doc);
+            }
+            return;
+        }
+        // If it's after the splat, then it's an individual arg, so we're just going
+        // to push it onto the array.
+        if (argIndex !== 1) {
+            docs.push(doc);
+            return;
+        }
+        // If we don't have any leading comments, we can just prepend the operator.
+        const argsNode = argPath.getValue();
+        if (!(argsNode.comments || []).some(({ leading }) => leading)) {
+            docs.push(["*", doc]);
+            return;
+        }
+        // If we have an array like:
+        //
+        //     [
+        //       # comment
+        //       *values
+        //     ]
+        //
+        // then we need to make sure we don't accidentally prepend the operator
+        // before the comment(s).
+        //
+        // In prettier >= 2.3.0, the comments are printed as an array before the
+        // content. I don't love this kind of reflection, but it's the simplest way
+        // at the moment to get this right.
+        docs.push(doc[0].concat(["*", doc[1]], doc.slice(2)));
+    }, "body");
+    return docs;
+};
+exports.printArgsAddStar = printArgsAddStar;
+const printBlockArg = (path, opts, print) => {
+    return ["&", path.call(print, "body", 0)];
+};
+exports.printBlockArg = printBlockArg;

data/dist/ruby/nodes/arrays.js

@@ -0,0 +1,126 @@
+"use strict";
+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;
+const prettier_1 = __importDefault(require("../../prettier"));
+const utils_1 = require("../../utils");
+const { group, ifBreak, indent, join, line, softline } = prettier_1.default;
+// Checks that every argument within this args node is a string_literal node
+// that has no spaces or interpolations. This means we're dealing with an array
+// that looks something like:
+//
+//     ['a', 'b', 'c']
+//
+function isStringArray(args) {
+    return (args.body.length > 1 &&
+        args.body.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) {
+                return false;
+            }
+            // 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) {
+                return false;
+            }
+            const part = arg.body[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") {
+                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);
+        }));
+}
+// Checks that every argument within this args node is a symbol_literal node (as
+// opposed to a dyna_symbol) so it has no interpolation. This means we're
+// dealing with an array that looks something like:
+//
+//     [:a, :b, :c]
+//
+function isSymbolArray(args) {
+    return (args.body.length > 1 &&
+        args.body.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");
+};
+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) {
+    return group([
+        start,
+        "[",
+        indent([softline, join(line, parts)]),
+        softline,
+        "]"
+    ]);
+}
+const arrayLiteralStarts = {
+    qsymbols: "%i",
+    qwords: "%w",
+    symbols: "%I",
+    words: "%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];
+    // 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) {
+        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);
+            const nodePath = path;
+            const parts = nodePath.map(printString, "body", 0, "body");
+            return printArrayLiteral("%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);
+            const nodePath = path;
+            const parts = nodePath.map(printSymbol, "body", 0, "body");
+            return printArrayLiteral("%i", parts);
+        }
+    }
+    // Here we have a normal array of any type of object with no special literal
+    // types or anything.
+    return group([
+        "[",
+        indent([
+            softline,
+            join([",", line], path.call(print, "body", 0)),
+            (0, utils_1.getTrailingComma)(opts) ? ifBreak(",", "") : ""
+        ]),
+        softline,
+        "]"
+    ]);
+};
+exports.printArray = printArray;

data/dist/ruby/nodes/assign.js

@@ -0,0 +1,41 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printVarRef = exports.printVarField = exports.printOpAssign = exports.printAssign = void 0;
+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");
+    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)) {
+        rightSideDoc = group(join([",", line], valueDoc));
+    }
+    if ((0, utils_1.skipAssignIndent)(valueNode)) {
+        return group([targetDoc, " = ", 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) : "";
+};
+exports.printVarField = printVarField;
+const printVarRef = (path, opts, print) => {
+    return path.call(print, "body", 0);
+};
+exports.printVarRef = printVarRef;

data/dist/ruby/nodes/blocks.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printDoBlock = exports.printBraceBlock = exports.printBlockVar = void 0;
+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))];
+    // 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)));
+    }
+    parts.push("| ");
+    return parts;
+};
+exports.printBlockVar = printBlockVar;
+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;
+        let doBlockBody = "";
+        if (stmts.length !== 1 ||
+            stmts[0].type !== "void_stmt" ||
+            stmts[0].comments) {
+            doBlockBody = indent([softline, path.call(print, "body", 1)]);
+        }
+        // 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
+        // node as opposed to the current node (because of the difference in
+        // operator precedence). Instead, we still use a multi-line format but
+        // switch to using braces instead.
+        const useBraces = braces && (0, utils_1.hasAncestor)(path, ["command", "command_call"]);
+        const doBlock = [
+            useBraces ? " {" : " do",
+            variables ? [" ", path.call(print, "body", 0)] : "",
+            doBlockBody,
+            [softline, useBraces ? "}" : "end"]
+        ];
+        // We can hit this next pattern if within the block the only statement is a
+        // comment.
+        if (stmts.length === 1 &&
+            stmts[0].type === "void_stmt" &&
+            stmts[0].comments) {
+            return [breakParent, doBlock];
+        }
+        const blockReceiver = path.getParentNode().body[0];
+        // 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)) {
+            return [breakParent, doBlock];
+        }
+        const hasBody = stmts.some(({ type }) => type !== "void_stmt");
+        const braceBlock = [
+            " {",
+            hasBody || variables ? " " : "",
+            variables ? path.call(print, "body", 0) : "",
+            path.call(print, "body", 1),
+            hasBody ? " " : "",
+            "}"
+        ];
+        return group(ifBreak(doBlock, braceBlock));
+    };
+}
+exports.printBraceBlock = printBlock(true);
+exports.printDoBlock = printBlock(false);