prettier 2.1.0 → 3.0.0

data/dist/ruby/nodes/conditionals.js

@@ -1,246 +0,0 @@
-"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, "pred")),
-        indent([softline, path.call(print, "stmts")]),
-        [softline, path.call(print, "cons")],
-        [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 predicateDoc = path.call(print, "pred");
-    const truthyDoc = path.call(print, "tthy");
-    const falsyDoc = path.call(print, "flsy");
-    return group(ifBreak([
-        "if ",
-        align(3, predicateDoc),
-        indent([softline, truthyDoc]),
-        [softline, "else"],
-        indent([softline, falsyDoc]),
-        [softline, "end"]
-    ], [predicateDoc, " ? ", ...printTernaryClauses("if", truthyDoc, falsyDoc)]));
-};
-exports.printTernary = printTernary;
-function isModifier(node) {
-    return node.type === "if_mod" || node.type === "unless_mod";
-}
-// 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) {
-    return function printSingleWithKeyword(path, { rubyModifier }, print) {
-        const node = path.getValue();
-        const predicateDoc = path.call(print, "pred");
-        const statementsDoc = path.call(print, isModifier(node) ? "stmt" : "stmts");
-        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 || (!isModifier(node) && node.stmts.body[0].comments)) {
-            return [multilineParts, breakParent];
-        }
-        const inline = (0, utils_1.inlineEnsureParens)(path, [
-            statementsDoc,
-            ` ${keyword} `,
-            predicateDoc
-        ]);
-        // With 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 (isModifier(node) && (0, utils_1.containsAssignment)(node.stmt)) {
-            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.op)) {
-        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 node = path.getValue();
-    return (!["assign", "opassign", "command_call", "command"].includes(node.pred.type) &&
-        node.cons &&
-        node.cons.type === "else" &&
-        canTernaryStmts(node.stmts) &&
-        canTernaryStmts(node.cons.stmts));
-}
-// A normalized print function for both `if` and `unless` nodes.
-function printConditional(keyword) {
-    return function printConditionalWithKeyword(path, opts, print) {
-        if (canTernary(path)) {
-            let ternaryParts = [
-                path.call(print, "pred"),
-                " ? ",
-                ...printTernaryClauses(keyword, path.call(print, "stmts"), path.call(print, "cons", "stmts"))
-            ];
-            if (["binary", "call"].includes(path.getParentNode().type)) {
-                ternaryParts = ["(", ...ternaryParts, ")"];
-            }
-            return group(ifBreak(printWithAddition(keyword, path, print, false), ternaryParts));
-        }
-        const node = path.getValue();
-        // If there's an additional clause that wasn't matched earlier, we know we
-        // can't go for the inline option.
-        if (node.cons) {
-            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)(node.stmts)) {
-            return [
-                `${keyword} `,
-                align(keyword.length + 1, path.call(print, "pred")),
-                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)(node.pred) ||
-            containsSingleConditional(node.stmts)) {
-            return [
-                `${keyword} `,
-                align(keyword.length + 1, path.call(print, "pred")),
-                indent([hardline, path.call(print, "stmts")]),
-                hardline,
-                "end"
-            ];
-        }
-        return printSingle(keyword)(path, opts, print);
-    };
-}
-const printElse = (path, opts, print) => {
-    const node = path.getValue();
-    return [
-        node.stmts.body.length === 1 && node.stmts.body[0].type === "command"
-            ? breakParent
-            : "",
-        "else",
-        indent([softline, path.call(print, "stmts")])
-    ];
-};
-exports.printElse = printElse;
-const printElsif = (path, opts, print) => {
-    const node = path.getValue();
-    const parts = [
-        group(["elsif ", align("elsif".length - 1, path.call(print, "pred"))]),
-        indent([hardline, path.call(print, "stmts")])
-    ];
-    if (node.cons) {
-        parts.push(group([hardline, path.call(print, "cons")]));
-    }
-    return group(parts);
-};
-exports.printElsif = printElsif;
-exports.printIf = printConditional("if");
-exports.printIfModifier = printSingle("if");
-exports.printUnless = printConditional("unless");
-exports.printUnlessModifier = printSingle("unless");

data/dist/ruby/nodes/constants.js

@@ -1,35 +0,0 @@
-"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, softline } = prettier_1.default;
-const printConstPath = (path, opts, print) => [path.call(print, "parent"), "::", path.call(print, "constant")];
-exports.printConstPath = printConstPath;
-const printConstRef = (path, opts, print) => path.call(print, "constant");
-exports.printConstRef = printConstRef;
-const printDefined = (path, opts, print) => {
-    return group([
-        "defined?(",
-        indent([softline, path.call(print, "value")]),
-        softline,
-        ")"
-    ]);
-};
-exports.printDefined = printDefined;
-const printField = (path, opts, print) => {
-    return group([
-        path.call(print, "parent"),
-        (0, utils_1.makeCall)(path, opts, print),
-        path.call(print, "name")
-    ]);
-};
-exports.printField = printField;
-const printTopConst = (path, opts, print) => [
-    "::",
-    path.call(print, "constant")
-];
-exports.printTopConst = printTopConst;

data/dist/ruby/nodes/flow.js

@@ -1,59 +0,0 @@
-"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 { join } = prettier_1.default;
-// If there are parentheses around these nodes, then we can't skip printing them
-// without changing the semantic meaning of the statement.
-const unskippableParens = [
-    "if_mod",
-    "rescue_mod",
-    "unless_mod",
-    "until_mod",
-    "while_mod"
-];
-function printFlowControl(keyword) {
-    return function printFlowControlWithKeyword(path, opts, print) {
-        const node = path.getValue();
-        // If we don't have any arguments to the keyword, then it's always going to
-        // come in as an args node, in which case we can just print the keyword.
-        if (node.args.type === "args") {
-            return keyword;
-        }
-        // Special handling if we've got parentheses on this call to the keyword. If
-        // we do and we can skip them, then we will. If we don't, then we'll print
-        // them right after the keyword with no space.
-        const paren = node.args.args.type === "args" && node.args.args.parts[0];
-        if (paren && paren.type === "paren") {
-            const stmts = paren.cnts.body;
-            // Here we're checking if we can skip past the parentheses entirely.
-            if (stmts.length === 1 && !unskippableParens.includes(stmts[0].type)) {
-                return [
-                    `${keyword} `,
-                    path.call(print, "args", "args", "parts", 0, "cnts")
-                ];
-            }
-            // Here we know we can't, so just printing out the parentheses as normal.
-            return [keyword, path.call(print, "args", "args", "parts", 0)];
-        }
-        // If we didn't hit the super special handling, then we're just going to
-        // print out the arguments to the keyword like normal.
-        return [`${keyword} `, join(", ", path.call(print, "args"))];
-    };
-}
-exports.printBreak = printFlowControl("break");
-exports.printNext = printFlowControl("next");
-const printYield = (path, opts, print) => {
-    const node = path.getValue();
-    const argsDoc = path.call(print, "args");
-    if (node.args.type === "paren") {
-        return ["yield", argsDoc];
-    }
-    return ["yield ", join(", ", argsDoc)];
-};
-exports.printYield = printYield;
-const printYield0 = (path) => path.getValue().value;
-exports.printYield0 = printYield0;

data/dist/ruby/nodes/hashes.js

@@ -1,126 +0,0 @@
-"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.printAssoc = 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.value.value;
-    return label.match(/^[_A-Za-z]/) && !label.endsWith("=");
-}
-function canUseHashLabels(contentsNode) {
-    return contentsNode.assocs.every((assocNode) => {
-        if (assocNode.type === "assoc_splat") {
-            return true;
-        }
-        switch (assocNode.key.type) {
-            case "label":
-                return true;
-            case "symbol_literal":
-                return isValidHashLabel(assocNode.key);
-            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":
-            return [path.call(print, "value"), ":"];
-        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 printAssoc = (path, opts, print) => {
-    const node = path.getValue();
-    const { keyPrinter } = path.getParentNode();
-    const parts = [path.call((keyPath) => keyPrinter(keyPath, print), "key")];
-    const valueDoc = path.call(print, "value");
-    // 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 (node.value.type === "hash") {
-        parts.push(" ", valueDoc);
-        return parts;
-    }
-    if (!(0, utils_1.skipAssignIndent)(node.value) || node.key.comments) {
-        parts.push(indent([line, valueDoc]));
-    }
-    else {
-        parts.push(" ", valueDoc);
-    }
-    return group(parts);
-};
-exports.printAssoc = printAssoc;
-const printAssocSplat = (path, opts, print) => ["**", path.call(print, "value")];
-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, "assocs"));
-};
-exports.printHashContents = printHashContents;
-const printHash = (path, opts, print) => {
-    const node = 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 (node.cnts === null) {
-        return (0, utils_1.printEmptyCollection)(path, opts, "{", "}");
-    }
-    const doc = [
-        "{",
-        indent([
-            line,
-            path.call(print, "cnts"),
-            (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") {
-        return doc;
-    }
-    return group(doc);
-};
-exports.printHash = printHash;

data/dist/ruby/nodes/heredocs.js

@@ -1,30 +0,0 @@
-"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 node = path.getValue();
-    // Print out each part of the heredoc to its own doc node.
-    const parts = path.map((partPath) => {
-        const part = partPath.getValue();
-        if (part.type !== "tstring_content") {
-            return print(partPath);
-        }
-        return join(utils_1.literallineWithoutBreakParent, part.value.split(/\r?\n/));
-    }, "parts");
-    // 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, node.ending]))
-    ]);
-};
-exports.printHeredoc = printHeredoc;

data/dist/ruby/nodes/hooks.js

@@ -1,35 +0,0 @@
-"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, "lbrace"),
-            indent([line, path.call(print, "stmts")]),
-            [line, "}"]
-        ]);
-    };
-}
-exports.printBEGIN = printHook("BEGIN");
-exports.printEND = printHook("END");

data/dist/ruby/nodes/ints.js

@@ -1,27 +0,0 @@
-"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)     - 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 { 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 (!value.startsWith("0") && value.length >= 5 && !value.includes("_")) {
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const segments = `  ${value}`.slice((value.length + 2) % 3).match(/.{3}/g);
-        return segments.join("_").trim();
-    }
-    return value;
-};
-exports.printInt = printInt;

data/dist/ruby/nodes/lambdas.js

@@ -1,70 +0,0 @@
-"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().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.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 ((0, utils_1.isEmptyParams)(node)) {
-        return "";
-    }
-    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
-// 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"]);
-    const stmtsDoc = path.call(print, "stmts");
-    return group(ifBreak([
-        "->",
-        params,
-        " ",
-        inCommand ? "{" : "do",
-        indent([line, stmtsDoc]),
-        line,
-        inCommand ? "}" : "end"
-    ], ["->", params, " { ", stmtsDoc, " }"]));
-};
-exports.printLambda = printLambda;