prettier 2.1.0 → 3.0.0

data/dist/ruby/nodes/loops.js

@@ -1,75 +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.printUntil = exports.printWhile = exports.printFor = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { align, breakParent, group, hardline, ifBreak, indent, join, softline } = prettier_1.default;
-function isModifier(node) {
-    return node.type === "while_mod" || node.type === "until_mod";
-}
-function printLoop(keyword) {
-    return function printLoopWithOptions(path, { rubyModifier }, print) {
-        const node = path.getValue();
-        const predicateDoc = path.call(print, "pred");
-        // If the only statement inside this while loop is a void statement, then we
-        // can shorten to just displaying the predicate and then a semicolon.
-        if (!isModifier(node) && (0, utils_1.isEmptyStmts)(node.stmts)) {
-            return group([group([keyword, " ", predicateDoc]), hardline, "end"]);
-        }
-        const statementDoc = path.call(print, isModifier(node) ? "stmt" : "stmts");
-        const inlineLoop = (0, utils_1.inlineEnsureParens)(path, [
-            statementDoc,
-            ` ${keyword} `,
-            predicateDoc
-        ]);
-        // If we're in the modifier form and we're modifying a `begin`, then this is
-        // a special case where we need to explicitly use the modifier form because
-        // otherwise the semantic meaning changes. This looks like:
-        //
-        //     begin
-        //       foo
-        //     end while bar
-        //
-        // The above is effectively a `do...while` loop (which we don't have in
-        // ruby).
-        if (isModifier(node) && node.stmt.type === "begin") {
-            return inlineLoop;
-        }
-        const blockLoop = [
-            [`${keyword} `, align(keyword.length + 1, predicateDoc)],
-            indent([softline, statementDoc]),
-            softline,
-            "end"
-        ];
-        // If we're disallowing inline loops or if the predicate of the loop
-        // contains an assignment (in which case we can't know for certain that that
-        // assignment doesn't impact the statements inside the loop) then we can't
-        // use the modifier form and we must use the block form.
-        if (!rubyModifier || (0, utils_1.containsAssignment)(node.pred)) {
-            return [breakParent, blockLoop];
-        }
-        return group(ifBreak(blockLoop, inlineLoop));
-    };
-}
-const printFor = (path, opts, print) => {
-    const node = path.getValue();
-    let indexDoc = path.call(print, "index");
-    if (node.index.type === "mlhs") {
-        indexDoc = join(", ", indexDoc);
-    }
-    return group([
-        "for ",
-        indexDoc,
-        " in ",
-        path.call(print, "collection"),
-        indent([hardline, path.call(print, "stmts")]),
-        hardline,
-        "end"
-    ]);
-};
-exports.printFor = printFor;
-exports.printWhile = printLoop("while");
-exports.printUntil = printLoop("until");

data/dist/ruby/nodes/massign.js

@@ -1,60 +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.printMRHSNewFromArgs = exports.printMRHSAddStar = exports.printMRHS = exports.printMLHSParen = exports.printMLHS = exports.printMAssign = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const { group, indent, join, line, softline } = prettier_1.default;
-const printMAssign = (path, opts, print) => {
-    const node = path.getValue();
-    let valueDoc = path.call(print, "value");
-    if (["mrhs", "mrhs_add_star", "mrhs_new_from_args"].includes(node.value.type)) {
-        valueDoc = group(join([",", line], valueDoc));
-    }
-    const targetDoc = [
-        join([",", line], path.call(print, "target"))
-    ];
-    if (node.target.type === "mlhs" && node.target.comma) {
-        targetDoc.push(",");
-    }
-    return group([group(targetDoc), " =", indent([line, valueDoc])]);
-};
-exports.printMAssign = printMAssign;
-const printMLHS = (path, opts, print) => {
-    return path.map(print, "parts");
-};
-exports.printMLHS = printMLHS;
-const printMLHSParen = (path, opts, print) => {
-    if (["massign", "mlhs_paren"].includes(path.getParentNode().type)) {
-        // If we're nested in brackets as part of the left hand side of an
-        // assignment, i.e., (a, b, c) = 1, 2, 3
-        // ignore the current node and just go straight to the content
-        return path.call(print, "cnts");
-    }
-    const node = path.getValue();
-    const parts = [
-        softline,
-        join([",", line], path.call(print, "cnts"))
-    ];
-    if (node.cnts.comma) {
-        parts.push(",");
-    }
-    return group(["(", indent(parts), [softline, ")"]]);
-};
-exports.printMLHSParen = printMLHSParen;
-const printMRHS = (path, opts, print) => {
-    return path.map(print, "parts");
-};
-exports.printMRHS = printMRHS;
-const printMRHSAddStar = (path, opts, print) => {
-    return [
-        ...path.call(print, "mrhs"),
-        ["*", path.call(print, "star")]
-    ];
-};
-exports.printMRHSAddStar = printMRHSAddStar;
-const printMRHSNewFromArgs = (path, opts, print) => {
-    return path.call(print, "args");
-};
-exports.printMRHSNewFromArgs = printMRHSNewFromArgs;

data/dist/ruby/nodes/methods.js

@@ -1,50 +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.printAccessControl = exports.printDefEndless = exports.printDef = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { group, hardline, indent, line } = prettier_1.default;
-const printDef = (path, opts, print) => {
-    const node = path.getValue();
-    const declaration = ["def "];
-    // In this case, we're printing a method that's defined as a singleton, so
-    // we need to include the target and the operator before the name.
-    if (node.type === "defs") {
-        declaration.push(path.call(print, "target"), path.call(print, "op"));
-    }
-    // In case there are no parens but there are parameters
-    const useParens = node.params.type === "params" && !(0, utils_1.isEmptyParams)(node.params);
-    declaration.push(path.call(print, "name"), useParens ? "(" : "", path.call(print, "params"), useParens ? ")" : "");
-    if ((0, utils_1.isEmptyBodyStmt)(node.bodystmt)) {
-        return group([...declaration, "; end"]);
-    }
-    return group([
-        group(declaration),
-        indent([hardline, path.call(print, "bodystmt")]),
-        hardline,
-        "end"
-    ]);
-};
-exports.printDef = printDef;
-const printDefEndless = (path, opts, print) => {
-    const node = path.getValue();
-    let paramsDoc = "";
-    // If we have any kind of parameters, we're going to print the whole
-    // parentheses. If we don't, then we're just going to skip them entirely.
-    if (node.paren && !(0, utils_1.isEmptyParams)(node.paren.cnts)) {
-        paramsDoc = path.call(print, "paren");
-    }
-    return group([
-        "def ",
-        path.call(print, "name"),
-        paramsDoc,
-        " =",
-        indent(group([line, path.call(print, "stmt")]))
-    ]);
-};
-exports.printDefEndless = printDefEndless;
-const printAccessControl = (path, opts, print) => path.call(print, "value");
-exports.printAccessControl = printAccessControl;

data/dist/ruby/nodes/operators.js

@@ -1,68 +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.printNot = exports.printUnary = exports.printDot3 = exports.printDot2 = exports.printBinary = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { group, indent, line, softline } = prettier_1.default;
-const printBinary = (path, opts, print) => {
-    const node = path.getValue();
-    const space = node.op === "**" ? "" : " ";
-    if (utils_1.noIndent.includes(node.right.type)) {
-        return group([
-            group(path.call(print, "left")),
-            space,
-            node.op,
-            space,
-            group(path.call(print, "right"))
-        ]);
-    }
-    return group([
-        group(path.call(print, "left")),
-        space,
-        group(indent([
-            node.op,
-            space === "" ? softline : line,
-            path.call(print, "right")
-        ]))
-    ]);
-};
-exports.printBinary = printBinary;
-// dot2 nodes are used with ranges (or flip-flops). They can optionally drop
-// their left side for beginless ranges or their right side for endless ranges.
-const printDot2 = (path, opts, print) => {
-    const node = path.getValue();
-    return [
-        node.left ? path.call(print, "left") : "",
-        "..",
-        node.right ? path.call(print, "right") : ""
-    ];
-};
-exports.printDot2 = printDot2;
-// dot3 nodes are used with ranges (or flip-flops). They can optionally drop
-// their left side for beginless ranges or their right side for endless ranges.
-const printDot3 = (path, opts, print) => {
-    const node = path.getValue();
-    return [
-        node.left ? path.call(print, "left") : "",
-        "...",
-        node.right ? path.call(print, "right") : ""
-    ];
-};
-exports.printDot3 = printDot3;
-const printUnary = (path, opts, print) => {
-    const node = path.getValue();
-    return [node.op, path.call(print, "value")];
-};
-exports.printUnary = printUnary;
-const printNot = (path, opts, print) => {
-    const node = path.getValue();
-    const valueDoc = path.call(print, "value");
-    if (node.paren) {
-        return ["not", "(", valueDoc, ")"];
-    }
-    return ["not", " ", valueDoc];
-};
-exports.printNot = printNot;

data/dist/ruby/nodes/params.js

@@ -1,95 +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.printExcessedComma = exports.printRestParam = exports.printKeywordRestParam = exports.printArgsForward = exports.printParams = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const { group, hardline, join, indent, line, lineSuffix, softline } = prettier_1.default;
-function printRestParamSymbol(symbol) {
-    return function printRestParamWithSymbol(path, opts, print) {
-        const node = path.getValue();
-        return node.name ? [symbol, path.call(print, "name")] : symbol;
-    };
-}
-const printParams = (path, opts, print) => {
-    const node = path.getValue();
-    let parts = [];
-    if (node.reqs) {
-        path.each((reqPath) => {
-            // For some very strange reason, if you have a comment attached to a
-            // rest_param, it shows up here in the list of required params.
-            if (reqPath.getValue().type !== "rest_param") {
-                parts.push(print(reqPath));
-            }
-        }, "reqs");
-    }
-    if (node.opts) {
-        parts = parts.concat(path.map((optlPath) => join(" = ", optlPath.map(print)), "opts"));
-    }
-    if (node.rest && node.rest.type !== "excessed_comma") {
-        parts.push(path.call(print, "rest"));
-    }
-    if (node.posts) {
-        parts = parts.concat(path.map(print, "posts"));
-    }
-    if (node.keywords) {
-        parts = parts.concat(path.map((kwargPath) => {
-            const kwarg = kwargPath.getValue();
-            const keyDoc = kwargPath.call(print, 0);
-            if (kwarg[1]) {
-                return group([keyDoc, " ", kwargPath.call(print, 1)]);
-            }
-            return keyDoc;
-        }, "keywords"));
-    }
-    if (node.kwrest) {
-        parts.push(node.kwrest === "nil" ? "**nil" : path.call(print, "kwrest"));
-    }
-    if (node.block) {
-        parts.push(path.call(print, "block"));
-    }
-    const contents = [join([",", line], parts)];
-    // You can put an extra comma at the end of block args between pipes to
-    // change what it does. Below is the difference:
-    //
-    // [[1, 2], [3, 4]].each { |x| p x } # prints [1, 2] then [3, 4]
-    // [[1, 2], [3, 4]].each { |x,| p x } # prints 1 then 3
-    //
-    // In ruby 2.5, the excessed comma is indicated by having a 0 in the rest
-    // param position. In ruby 2.6+ it's indicated by having an "excessed_comma"
-    // node in the rest position. Seems odd, but it's true.
-    if (node.rest === 0 ||
-        (node.rest && node.rest.type === "excessed_comma")) {
-        contents.push(",");
-    }
-    // If the parent node is a paren then we skipped printing the parentheses so
-    // that we could handle them here and get nicer formatting.
-    const parentNode = path.getParentNode();
-    if (["lambda", "paren"].includes(parentNode.type)) {
-        const parts = ["("];
-        // If the parent node is a paren and the paren has comments that are
-        // attached to the left paren, then we need to print those out explicitly
-        // here.
-        if (parentNode.type === "paren" && parentNode.lparen.comments) {
-            const comments = [];
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            parentNode.lparen.comments.forEach((comment, index) => {
-                comment.printed = true;
-                comments.push(lineSuffix(`${index === 0 ? " " : ""}#${comment.value}`));
-            });
-            parts.push(join(hardline, comments));
-        }
-        return group([...parts, indent([softline, ...contents]), softline, ")"]);
-    }
-    return group(contents);
-};
-exports.printParams = printParams;
-const printArgsForward = (path) => path.getValue().value;
-exports.printArgsForward = printArgsForward;
-exports.printKeywordRestParam = printRestParamSymbol("**");
-exports.printRestParam = printRestParamSymbol("*");
-const printExcessedComma = (path, opts, print) => {
-    return path.call(print, "value");
-};
-exports.printExcessedComma = printExcessedComma;

data/dist/ruby/nodes/patterns.js

@@ -1,119 +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.printRAssign = exports.printIn = exports.printHshPtn = exports.printFndPtn = exports.printAryPtn = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const { align, group, hardline, indent, join, line } = prettier_1.default;
-const patterns = ["aryptn", "binary", "fndptn", "hshptn", "rassign"];
-const printPatternArg = (path, opts, print) => {
-    // Pinning is a really special syntax in pattern matching that's not really
-    // all that well supported in ripper. Here we're just going to the original
-    // source to see if the variable is pinned.
-    if (opts.originalText &&
-        opts.originalText[opts.locStart(path.getValue()) - 1] === "^") {
-        return ["^", path.call(print)];
-    }
-    return path.call(print);
-};
-const printAryPtn = (path, opts, print) => {
-    const node = path.getValue();
-    let argDocs = [];
-    if (node.reqs.length > 0) {
-        argDocs = argDocs.concat(path.map((argPath) => printPatternArg(argPath, opts, print), "reqs"));
-    }
-    if (node.rest) {
-        argDocs.push(["*", path.call(print, "rest")]);
-    }
-    if (node.posts.length > 0) {
-        argDocs = argDocs.concat(path.map(print, "posts"));
-    }
-    let argDoc = group(join([",", line], argDocs));
-    // There are a couple of cases where we _must_ use brackets. They include:
-    //
-    // * When the number of arguments inside the array pattern is one 1, then we
-    //   have to include them, otherwise it matches the whole array. Consider the
-    //   difference between `in [elem]` and `in elem`.
-    // * If we have a wrapping constant, then we definitely need the brackets.
-    //   Consider the difference between `in Const[elem]` and `in Const elem`
-    // * If we're nested inside a parent pattern, then we have to have brackets.
-    //   Consider the difference between `in key: first, second` and
-    //   `in key: [first, second]`.
-    if (argDocs.length === 1 ||
-        node.constant ||
-        patterns.includes(path.getParentNode().type)) {
-        argDoc = ["[", argDoc, "]"];
-    }
-    if (node.constant) {
-        return [path.call(print, "constant"), argDoc];
-    }
-    return argDoc;
-};
-exports.printAryPtn = printAryPtn;
-const printFndPtn = (path, opts, print) => {
-    const node = path.getValue();
-    const docs = [
-        "[",
-        group(join([",", line], [
-            ["*", path.call(print, "left")],
-            ...path.map(print, "values"),
-            ["*", path.call(print, "right")]
-        ])),
-        "]"
-    ];
-    if (node.constant) {
-        return [path.call(print, "constant"), docs];
-    }
-    return docs;
-};
-exports.printFndPtn = printFndPtn;
-const printHshPtn = (path, opts, print) => {
-    const node = path.getValue();
-    let args = [];
-    if (node.keywords.length > 0) {
-        const printPair = (pairPath) => {
-            const parts = [pairPath.call(print, 0)];
-            if (pairPath.getValue()[1]) {
-                parts.push(" ", pairPath.call((pairValuePath) => printPatternArg(pairValuePath, opts, print), 1));
-            }
-            return parts;
-        };
-        args = args.concat(path.map(printPair, "keywords"));
-    }
-    if (node.kwrest) {
-        args.push(["**", path.call(print, "kwrest")]);
-    }
-    args = group(join([",", line], args));
-    if (node.constant) {
-        args = ["[", args, "]"];
-    }
-    else if (patterns.includes(path.getParentNode().type)) {
-        args = ["{ ", args, " }"];
-    }
-    if (node.constant) {
-        return [path.call(print, "constant"), args];
-    }
-    return args;
-};
-exports.printHshPtn = printHshPtn;
-const printIn = (path, opts, print) => {
-    const keyword = "in ";
-    const parts = [
-        keyword,
-        align(keyword.length, path.call((valuePath) => printPatternArg(valuePath, opts, print), "pattern")),
-        indent([hardline, path.call(print, "stmts")])
-    ];
-    if (path.getValue().cons) {
-        parts.push(hardline, path.call(print, "cons"));
-    }
-    return group(parts);
-};
-exports.printIn = printIn;
-const printRAssign = (path, opts, print) => group([
-    path.call(print, "value"),
-    " ",
-    path.call(print, "op"),
-    group(indent([line, path.call(print, "pattern")]))
-]);
-exports.printRAssign = printRAssign;

data/dist/ruby/nodes/regexp.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.printRegexpLiteral = void 0;
-const utils_1 = require("../../utils");
-function hasContent(node, pattern) {
-    return node.parts.some((part) => part.type === "tstring_content" && pattern.test(part.value));
-}
-// If the first part of this regex is plain string content, we have a space
-// or an =, and we're contained within a command or command_call node, then we
-// want to use braces because otherwise we could end up with an ambiguous
-// operator, e.g. foo / bar/ or foo /=bar/
-function forwardSlashIsAmbiguous(path) {
-    const node = path.getValue();
-    const firstPart = node.parts[0];
-    return (firstPart &&
-        firstPart.type === "tstring_content" &&
-        [" ", "="].includes(firstPart.value[0]) &&
-        (0, utils_1.hasAncestor)(path, ["command", "command_call"]));
-}
-// This function is responsible for printing out regexp_literal nodes. They can
-// either use the special %r literal syntax or they can use forward slashes. At
-// the end of either of those they can have modifiers like m or x that have
-// special meaning for the regex engine.
-//
-// We favor the use of forward slashes unless the regex contains a forward slash
-// itself. In that case we switch over to using %r with braces.
-const printRegexpLiteral = (path, opts, print) => {
-    const node = path.getValue();
-    const docs = path.map(print, "parts");
-    // We should use braces if using a forward slash would be ambiguous in the
-    // current context or if there's a forward slash in the content of the regexp.
-    const useBraces = forwardSlashIsAmbiguous(path) || hasContent(node, /\//);
-    // If we should be using braces but we have braces in the body of the regexp,
-    // then we're just going to resort to using whatever the original content was.
-    if (useBraces && hasContent(node, /[{}]/)) {
-        return [node.beging, ...docs, node.ending];
-    }
-    return [
-        useBraces ? "%r{" : "/",
-        ...docs,
-        useBraces ? "}" : "/",
-        node.ending.slice(1)
-    ];
-};
-exports.printRegexpLiteral = printRegexpLiteral;

data/dist/ruby/nodes/rescue.js

@@ -1,86 +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.printRetry = exports.printRedo = exports.printRescueMod = exports.printRescueEx = exports.printRescue = exports.printEnsure = exports.printBegin = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const { align, group, hardline, indent, join, line } = prettier_1.default;
-const printBegin = (path, opts, print) => {
-    return [
-        "begin",
-        indent([hardline, path.call(print, "bodystmt")]),
-        hardline,
-        "end"
-    ];
-};
-exports.printBegin = printBegin;
-const printEnsure = (path, opts, print) => {
-    return [
-        path.call(print, "keyword"),
-        indent([hardline, path.call(print, "stmts")])
-    ];
-};
-exports.printEnsure = printEnsure;
-const printRescue = (path, opts, print) => {
-    const node = path.getValue();
-    const parts = ["rescue"];
-    if (node.extn) {
-        parts.push(align("rescue ".length, path.call(print, "extn")));
-    }
-    else {
-        // If you don't specify an error to rescue in a `begin/rescue` block, then
-        // implicitly you're rescuing from `StandardError`. In this case, we're
-        // just going to explicitly add it.
-        parts.push(" StandardError");
-    }
-    const stmtsDoc = path.call(print, "stmts");
-    if (stmtsDoc.length > 0) {
-        parts.push(indent([hardline, stmtsDoc]));
-    }
-    // This is the next clause on the `begin` statement, either another
-    // `rescue`, and `ensure`, or an `else` clause.
-    if (node.cons) {
-        parts.push([hardline, path.call(print, "cons")]);
-    }
-    return group(parts);
-};
-exports.printRescue = printRescue;
-// This is a container node that we're adding into the AST that isn't present in
-// Ripper solely so that we have a nice place to attach inline comments.
-const printRescueEx = (path, opts, print) => {
-    const node = path.getValue();
-    const parts = [];
-    if (node.extns) {
-        // If there's just one exception being rescued, then it's just going to be a
-        // single doc node.
-        let exceptionDoc = path.call(print, "extns");
-        // If there are multiple exceptions being rescued, then we're going to have
-        // multiple doc nodes returned as an array that we need to join together.
-        if (["mrhs", "mrhs_add_star", "mrhs_new_from_args"].includes(node.extns.type)) {
-            exceptionDoc = group(join([",", line], exceptionDoc));
-        }
-        parts.push(" ", exceptionDoc);
-    }
-    if (node.var) {
-        parts.push(" => ", path.call(print, "var"));
-    }
-    return group(parts);
-};
-exports.printRescueEx = printRescueEx;
-const printRescueMod = (path, opts, print) => {
-    return [
-        "begin",
-        indent([hardline, path.call(print, "stmt")]),
-        hardline,
-        "rescue StandardError",
-        indent([hardline, path.call(print, "value")]),
-        hardline,
-        "end"
-    ];
-};
-exports.printRescueMod = printRescueMod;
-const printRedo = (path) => path.getValue().value;
-exports.printRedo = printRedo;
-const printRetry = (path) => path.getValue().value;
-exports.printRetry = printRetry;