prettier 1.6.1 → 2.0.0.pre.rc1

data/dist/ruby/nodes/conditionals.js

@@ -0,0 +1,242 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printUnlessModifier = exports.printUnless = exports.printIfModifier = exports.printIf = exports.printElsif = exports.printElse = exports.printTernary = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const utils_1 = require("../../utils");
+const { align, breakParent, hardline, group, ifBreak, indent, softline } = prettier_1.default;
+// If the statements are just a single if/unless, in block or modifier form, or
+// a ternary
+function containsSingleConditional(stmts) {
+    return (stmts.body.length === 1 &&
+        ["if", "if_mod", "ifop", "unless", "unless_mod"].includes(stmts.body[0].type));
+}
+function printWithAddition(keyword, path, print, breaking) {
+    return [
+        `${keyword} `,
+        align(keyword.length + 1, path.call(print, "body", 0)),
+        indent([softline, path.call(print, "body", 1)]),
+        [softline, path.call(print, "body", 2)],
+        [softline, "end"],
+        breaking ? breakParent : ""
+    ];
+}
+// For the unary `not` operator, we need to explicitly add parentheses to it in
+// order for it to be valid from within a ternary. Otherwise if the clause of
+// the ternary isn't a unary `not`, we can just pass it along.
+function printTernaryClause(clause) {
+    if (Array.isArray(clause)) {
+        const [part] = clause;
+        if (Array.isArray(part) && part[0] === "not") {
+            // We are inside of a statements list and the statement is a unary `not`.
+            return ["not(", part[2], ")"];
+        }
+        if (clause[0] === "not") {
+            // We are inside a ternary condition and the clause is a unary `not`.
+            return ["not(", clause[2], ")"];
+        }
+    }
+    return clause;
+}
+// The conditions for a ternary look like `foo : bar` where `foo` represents
+// the truthy clause and `bar` represents the falsy clause. In the case that the
+// parent node is an `unless`, these have to flip in order.
+function printTernaryClauses(keyword, truthyClause, falsyClause) {
+    const parts = [
+        printTernaryClause(truthyClause),
+        " : ",
+        printTernaryClause(falsyClause)
+    ];
+    return keyword === "if" ? parts : parts.reverse();
+}
+// Handles ternary nodes. If it does not fit on one line, then we break out into
+// an if/else statement. Otherwise we remain as a ternary.
+const printTernary = (path, _opts, print) => {
+    const [predicate, truthyClause, falsyClause] = path.map(print, "body");
+    const ternaryClauses = printTernaryClauses("if", truthyClause, falsyClause);
+    return group(ifBreak([
+        "if ",
+        align(3, predicate),
+        indent([softline, truthyClause]),
+        [softline, "else"],
+        indent([softline, falsyClause]),
+        [softline, "end"]
+    ], [predicate, " ? ", ...ternaryClauses]));
+};
+exports.printTernary = printTernary;
+// Prints an `if_mod` or `unless_mod` node. Because it was previously in the
+// modifier form, we're guaranteed to not have an additional node, so we can
+// just work with the predicate and the body.
+function printSingle(keyword, modifier = false) {
+    return function printSingleWithKeyword(path, { rubyModifier }, print) {
+        const [, statementsNode] = path.getValue().body;
+        const predicateDoc = path.call(print, "body", 0);
+        const statementsDoc = path.call(print, "body", 1);
+        const multilineParts = [
+            `${keyword} `,
+            align(keyword.length + 1, predicateDoc),
+            indent([softline, statementsDoc]),
+            softline,
+            "end"
+        ];
+        // If we do not allow modifier form conditionals or there are comments
+        // inside of the body of the conditional, then we must print in the
+        // multiline form.
+        if (!rubyModifier ||
+            (!modifier && statementsNode.body[0].comments)) {
+            return [multilineParts, breakParent];
+        }
+        const inline = (0, utils_1.inlineEnsureParens)(path, [
+            path.call(print, "body", 1),
+            ` ${keyword} `,
+            path.call(print, "body", 0)
+        ]);
+        // An expression with a conditional modifier (expression if true), the
+        // conditional body is parsed before the predicate expression, meaning that
+        // if the parser encountered a variable declaration, it would initialize
+        // that variable first before evaluating the predicate expression. That
+        // parse order means the difference between a NameError or not. #591
+        // https://docs.ruby-lang.org/en/2.0.0/syntax/control_expressions_rdoc.html#label-Modifier+if+and+unless
+        if (modifier && (0, utils_1.containsAssignment)(statementsNode)) {
+            return inline;
+        }
+        return group(ifBreak(multilineParts, inline));
+    };
+}
+const noTernary = [
+    "alias",
+    "assign",
+    "break",
+    "command",
+    "command_call",
+    "heredoc",
+    "if",
+    "if_mod",
+    "ifop",
+    "lambda",
+    "massign",
+    "next",
+    "opassign",
+    "rescue_mod",
+    "return",
+    "return0",
+    "super",
+    "undef",
+    "unless",
+    "unless_mod",
+    "until_mod",
+    "var_alias",
+    "void_stmt",
+    "while_mod",
+    "yield",
+    "yield0",
+    "zsuper"
+];
+// Certain expressions cannot be reduced to a ternary without adding parens
+// around them. In this case we say they cannot be ternaried and default instead
+// to breaking them into multiple lines.
+function canTernaryStmts(stmts) {
+    if (stmts.body.length !== 1) {
+        return false;
+    }
+    const stmt = stmts.body[0];
+    // If the user is using one of the lower precedence "and" or "or" operators,
+    // then we can't use a ternary expression as it would break the flow control.
+    if (stmt.type === "binary" && ["and", "or"].includes(stmt.body[1])) {
+        return false;
+    }
+    // Check against the blocklist of statement types that are not allowed to be
+    // a part of a ternary expression.
+    return !noTernary.includes(stmt.type);
+}
+// In order for an `if` or `unless` expression to be shortened to a ternary,
+// there has to be one and only one "addition" (another clause attached) which
+// is of the "else" type. Both the body of the main node and the body of the
+// additional node must have only one statement, and that statement list must
+// pass the `canTernaryStmts` check.
+function canTernary(path) {
+    const [predicate, stmts, addition] = path.getValue().body;
+    return (!["assign", "opassign", "command_call", "command"].includes(predicate.type) &&
+        addition &&
+        addition.type === "else" &&
+        [stmts, addition.body[0]].every(canTernaryStmts));
+}
+// A normalized print function for both `if` and `unless` nodes.
+function printConditional(keyword) {
+    return (path, opts, print) => {
+        if (canTernary(path)) {
+            let ternaryParts = [
+                path.call(print, "body", 0),
+                " ? ",
+                ...printTernaryClauses(keyword, path.call(print, "body", 1), path.call(print, "body", 2, "body", 0))
+            ];
+            if (["binary", "call"].includes(path.getParentNode().type)) {
+                ternaryParts = ["(", ...ternaryParts, ")"];
+            }
+            return group(ifBreak(printWithAddition(keyword, path, print, false), ternaryParts));
+        }
+        const [predicate, statements, addition] = path.getValue().body;
+        // If there's an additional clause that wasn't matched earlier, we know we
+        // can't go for the inline option.
+        if (addition) {
+            return group(printWithAddition(keyword, path, print, true));
+        }
+        // If the body of the conditional is empty, then we explicitly have to use the
+        // block form.
+        if ((0, utils_1.isEmptyStmts)(statements)) {
+            return [
+                `${keyword} `,
+                align(keyword.length + 1, path.call(print, "body", 0)),
+                hardline,
+                "end"
+            ];
+        }
+        // Two situations in which we need to use the block form:
+        //
+        // 1. If the predicate of the conditional contains an assignment, then we can't
+        // know for sure that it doesn't impact the body of the conditional.
+        //
+        // 2. If the conditional contains just another conditional, then collapsing it
+        // would result in double modifiers on the same line.
+        if ((0, utils_1.containsAssignment)(predicate) ||
+            containsSingleConditional(statements)) {
+            return [
+                `${keyword} `,
+                align(keyword.length + 1, path.call(print, "body", 0)),
+                indent([hardline, path.call(print, "body", 1)]),
+                hardline,
+                "end"
+            ];
+        }
+        return printSingle(keyword)(path, opts, print);
+    };
+}
+const printElse = (path, opts, print) => {
+    const stmts = path.getValue().body[0];
+    return [
+        stmts.body.length === 1 && stmts.body[0].type === "command"
+            ? breakParent
+            : "",
+        "else",
+        indent([softline, path.call(print, "body", 0)])
+    ];
+};
+exports.printElse = printElse;
+const printElsif = (path, opts, print) => {
+    const [, , addition] = path.getValue().body;
+    const parts = [
+        group(["elsif ", align("elsif".length - 1, path.call(print, "body", 0))]),
+        indent([hardline, path.call(print, "body", 1)])
+    ];
+    if (addition) {
+        parts.push(group([hardline, path.call(print, "body", 2)]));
+    }
+    return group(parts);
+};
+exports.printElsif = printElsif;
+exports.printIf = printConditional("if");
+exports.printIfModifier = printSingle("if", true);
+exports.printUnless = printConditional("unless");
+exports.printUnlessModifier = printSingle("unless", true);

data/dist/ruby/nodes/constants.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printTopConst = exports.printField = exports.printDefined = exports.printConstRef = exports.printConstPath = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const utils_1 = require("../../utils");
+const { group, indent, join, softline } = prettier_1.default;
+const printConstPath = (path, opts, print) => {
+    return join("::", path.map(print, "body"));
+};
+exports.printConstPath = printConstPath;
+const printConstRef = (path, opts, print) => {
+    return path.call(print, "body", 0);
+};
+exports.printConstRef = printConstRef;
+const printDefined = (path, opts, print) => {
+    return group([
+        "defined?(",
+        indent([softline, path.call(print, "body", 0)]),
+        softline,
+        ")"
+    ]);
+};
+exports.printDefined = printDefined;
+const printField = (path, opts, print) => {
+    return group([
+        path.call(print, "body", 0),
+        (0, utils_1.makeCall)(path, opts, print),
+        path.call(print, "body", 2)
+    ]);
+};
+exports.printField = printField;
+const printTopConst = (path, opts, print) => {
+    return ["::", path.call(print, "body", 0)];
+};
+exports.printTopConst = printTopConst;

data/dist/ruby/nodes/flow.js

@@ -0,0 +1,66 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printYield0 = exports.printYield = exports.printNext = exports.printBreak = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const utils_1 = require("../../utils");
+const { join } = prettier_1.default;
+function nodeDive(node, steps) {
+    let current = node;
+    steps.forEach((step) => {
+        current = current[step];
+    });
+    return current;
+}
+const unskippableParens = [
+    "if_mod",
+    "rescue_mod",
+    "unless_mod",
+    "until_mod",
+    "while_mod"
+];
+function maybeHandleParens(path, print, keyword, steps) {
+    const node = nodeDive(path.getValue(), steps);
+    if (node.type !== "paren") {
+        return null;
+    }
+    const stmts = node.body[0].body;
+    if (stmts.length === 1 && !unskippableParens.includes(stmts[0].type)) {
+        return [`${keyword} `, path.call(print, ...steps, "body", 0)];
+    }
+    return [keyword, path.call(print, ...steps)];
+}
+const printBreak = (path, opts, print) => {
+    const content = path.getValue().body[0];
+    if (content.body.length === 0) {
+        return "break";
+    }
+    const steps = ["body", 0, "body", 0, "body", 0];
+    return (maybeHandleParens(path, print, "break", steps) || [
+        "break ",
+        join(", ", path.call(print, "body", 0))
+    ]);
+};
+exports.printBreak = printBreak;
+const printNext = (path, opts, print) => {
+    const args = path.getValue().body[0].body[0];
+    if (!args) {
+        return "next";
+    }
+    const steps = ["body", 0, "body", 0, "body", 0];
+    return (maybeHandleParens(path, print, "next", steps) || [
+        "next ",
+        join(", ", path.call(print, "body", 0))
+    ]);
+};
+exports.printNext = printNext;
+const printYield = (path, opts, print) => {
+    if (path.getValue().body[0].type === "paren") {
+        return ["yield", path.call(print, "body", 0)];
+    }
+    return ["yield ", join(", ", path.call(print, "body", 0))];
+};
+exports.printYield = printYield;
+exports.printYield0 = (0, utils_1.literal)("yield");

data/dist/ruby/nodes/hashes.js

@@ -0,0 +1,130 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printHash = exports.printHashContents = exports.printAssocSplat = exports.printAssocNew = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const utils_1 = require("../../utils");
+const { group, ifBreak, indent, join, line } = prettier_1.default;
+// When attempting to convert a hash rocket into a hash label, you need to take
+// care because only certain patterns are allowed. Ruby source says that they
+// have to match keyword arguments to methods, but don't specify what that is.
+// After some experimentation, it looks like it's:
+//
+// * Starts with a letter (either case) or an underscore
+// * Does not end in equal
+//
+// This function represents that check, as it determines if it can convert the
+// symbol node into a hash label.
+function isValidHashLabel(symbolLiteral) {
+    const label = symbolLiteral.body[0].body;
+    return label.match(/^[_A-Za-z]/) && !label.endsWith("=");
+}
+function canUseHashLabels(contentsNode) {
+    return contentsNode.body.every((assocNode) => {
+        if (assocNode.type === "assoc_splat") {
+            return true;
+        }
+        switch (assocNode.body[0].type) {
+            case "@label":
+                return true;
+            case "symbol_literal":
+                return isValidHashLabel(assocNode.body[0]);
+            case "dyna_symbol":
+                return true;
+            default:
+                return false;
+        }
+    });
+}
+const printHashKeyLabel = (path, print) => {
+    const node = path.getValue();
+    switch (node.type) {
+        case "@label":
+            return print(path);
+        case "symbol_literal": {
+            const nodePath = path;
+            return [nodePath.call(print, "body", 0), ":"];
+        }
+        case "dyna_symbol":
+            return [print(path), ":"];
+        default:
+            // This should never happen, but keeping it here so that the two key
+            // printers can maintain the same signature.
+            return "";
+    }
+};
+const printHashKeyRocket = (path, print) => {
+    const node = path.getValue();
+    let doc = print(path);
+    if (node.type === "@label") {
+        const sDoc = doc; // since we know this is a label
+        doc = [":", sDoc.slice(0, sDoc.length - 1)];
+    }
+    else if (node.type === "dyna_symbol") {
+        doc = [":", doc];
+    }
+    return [doc, " =>"];
+};
+const printAssocNew = (path, opts, print) => {
+    const [keyNode, valueNode] = path.getValue().body;
+    const { keyPrinter } = path.getParentNode();
+    const parts = [path.call((keyPath) => keyPrinter(keyPath, print), "body", 0)];
+    const valueDoc = path.call(print, "body", 1);
+    // If we're printing a child hash then we want it to break along with its
+    // parent hash, so we don't group the parts.
+    if (valueNode.type === "hash") {
+        parts.push(" ", valueDoc);
+        return parts;
+    }
+    if (!(0, utils_1.skipAssignIndent)(valueNode) || keyNode.comments) {
+        parts.push(indent([line, valueDoc]));
+    }
+    else {
+        parts.push(" ", valueDoc);
+    }
+    return group(parts);
+};
+exports.printAssocNew = printAssocNew;
+const printAssocSplat = (path, opts, print) => {
+    return ["**", path.call(print, "body", 0)];
+};
+exports.printAssocSplat = printAssocSplat;
+const printHashContents = (path, opts, print) => {
+    const node = path.getValue();
+    // First determine which key printer we're going to use, so that the child
+    // nodes can reference it when they go to get printed.
+    node.keyPrinter =
+        opts.rubyHashLabel && canUseHashLabels(path.getValue())
+            ? printHashKeyLabel
+            : printHashKeyRocket;
+    return join([",", line], path.map(print, "body"));
+};
+exports.printHashContents = printHashContents;
+const printHash = (path, opts, print) => {
+    const hashNode = path.getValue();
+    // Hashes normally have a single assoclist_from_args child node. If it's
+    // missing, then it means we're dealing with an empty hash, so we can just
+    // exit here and print.
+    if (hashNode.body[0] === null) {
+        return (0, utils_1.printEmptyCollection)(path, opts, "{", "}");
+    }
+    const hashDoc = [
+        "{",
+        indent([
+            line,
+            path.call(print, "body", 0),
+            (0, utils_1.getTrailingComma)(opts) ? ifBreak(",", "") : ""
+        ]),
+        line,
+        "}"
+    ];
+    // If we're inside another hash, then we don't want to group our contents
+    // because we want this hash to break along with its parent hash.
+    if (path.getParentNode().type === "assoc_new") {
+        return hashDoc;
+    }
+    return group(hashDoc);
+};
+exports.printHash = printHash;

data/dist/ruby/nodes/heredocs.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printHeredoc = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const utils_1 = require("../../utils");
+const { group, lineSuffix, join } = prettier_1.default;
+const 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(utils_1.literallineWithoutBreakParent, part.body.split(/\r?\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([
+        path.call(print, "beging"),
+        lineSuffix(group([utils_1.literallineWithoutBreakParent, ...parts, ending]))
+    ]);
+};
+exports.printHeredoc = printHeredoc;

data/dist/ruby/nodes/hooks.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printEND = exports.printBEGIN = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const { group, indent, line } = prettier_1.default;
+// 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) {
+        return group([
+            name,
+            " ",
+            path.call(print, "body", 0),
+            indent([line, path.call(print, "body", 1)]),
+            [line, "}"]
+        ]);
+    };
+}
+exports.printBEGIN = printHook("BEGIN");
+exports.printEND = printHook("END");

data/dist/ruby/nodes/ints.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printInt = void 0;
+// 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).
+const printInt = (path) => {
+    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("_")) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const segments = `  ${body}`.slice((body.length + 2) % 3).match(/.{3}/g);
+        return segments.join("_").trim();
+    }
+    return body;
+};
+exports.printInt = printInt;

data/dist/ruby/nodes/lambdas.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printLambda = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const utils_1 = require("../../utils");
+const { group, ifBreak, indent, line } = prettier_1.default;
+// 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];
+    // 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];
+    }
+    // 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 "";
+    }
+    return path.call(print, "body", 0);
+}
+// 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.
+const printLambda = (path, opts, print) => {
+    const params = printLambdaParams(path, print);
+    const inCommand = (0, utils_1.hasAncestor)(path, ["command", "command_call"]);
+    return group(ifBreak([
+        "->",
+        params,
+        " ",
+        inCommand ? "{" : "do",
+        indent([line, path.call(print, "body", 1)]),
+        line,
+        inCommand ? "}" : "end"
+    ], ["->", params, " { ", path.call(print, "body", 1), " }"]));
+};
+exports.printLambda = printLambda;