prettier 2.0.0 → 3.1.0

data/dist/ruby/nodes/conditionals.js

@@ -1,242 +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, "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

@@ -1,38 +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, 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

@@ -1,66 +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 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

@@ -1,130 +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.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

@@ -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 { 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

@@ -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, "body", 0),
-            indent([line, path.call(print, "body", 1)]),
-            [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)     - 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

@@ -1,69 +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().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;