prettier 2.1.0 → 3.0.0

data/dist/ruby/nodes/calls.js

@@ -1,263 +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.printCallContainer = exports.printMethodAddBlock = exports.printMethodAddArg = exports.printCall = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const toProc_1 = __importDefault(require("../toProc"));
-const { group, hardline, ifBreak, indent, join, softline } = prettier_1.default;
-const chained = ["call", "method_add_arg", "method_add_block"];
-function hasLeadingComments(node) {
-    var _a;
-    return (_a = node.comments) === null || _a === void 0 ? void 0 : _a.some(({ leading }) => leading);
-}
-const printCall = (path, opts, print) => {
-    const node = path.getValue();
-    const receiverDoc = path.call(print, "receiver");
-    const operatorDoc = (0, utils_1.makeCall)(path, opts, print);
-    // You can call lambdas with a special syntax that looks like func.(*args).
-    // In this case, "call" is returned for the 3rd child node. We don't alter
-    // call syntax so if `call` is implicit, we don't print it out.
-    const messageDoc = node.message === "call" ? "" : path.call(print, "message");
-    // Create some arrays that are going to represent each side of our call.
-    let leftSideDoc = [receiverDoc];
-    let rightSideDoc = [operatorDoc, messageDoc];
-    // If there are leading comments on the right side of the call, then it means
-    // we have a structure where there's a receiver and an operator together, then
-    // a comment, then the message, as in:
-    //
-    //     foo.
-    //       # comment
-    //       baz
-    //
-    // In the case we need to group the receiver and the operator together or
-    // we'll end up with a syntax error.
-    const operatorIsTrailing = node.message !== "call" && hasLeadingComments(node.message);
-    if (operatorIsTrailing) {
-        leftSideDoc = [receiverDoc, operatorDoc];
-        rightSideDoc = [messageDoc];
-    }
-    // For certain left sides of the call nodes, we want to attach directly to
-    // the } or end.
-    if (utils_1.noIndent.includes(node.receiver.type)) {
-        return [leftSideDoc, rightSideDoc];
-    }
-    if (node.receiver.type === "call" &&
-        node.receiver.message !== "call" &&
-        node.receiver.message.value === "where" &&
-        messageDoc === "not") {
-        // This is very specialized behavior wherein we group .where.not calls
-        // together because it looks better. For more information, see
-        // https://github.com/prettier/plugin-ruby/issues/862.
-    }
-    else {
-        // Otherwise, we're going to put a line node into the right side doc.
-        rightSideDoc.unshift(node.receiver.comments ? hardline : softline);
-    }
-    // Get a reference to the parent node so we can check if we're inside a chain
-    const parentNode = path.getParentNode();
-    // If our parent node is a chained node then we're not going to group the
-    // right side of the expression, as we want to have a nice multi-line layout.
-    if (chained.includes(parentNode.type) && !node.comments) {
-        parentNode.chain = (node.chain || 0) + 1;
-        parentNode.callChain = (node.callChain || 0) + 1;
-        parentNode.firstReceiverType = node.firstReceiverType || node.receiver.type;
-        // Here we're going to determine what doc nodes to send up to the parent
-        // node to represent when we're in the multi-line form.
-        let breakDocLHS;
-        if (node.breakDoc && operatorIsTrailing) {
-            // Here we already have a child node that has passed up its
-            // representation. In this case node.breakDoc represents the receiver
-            // without any lines inserted. With regard to this node, it means it's
-            // everything up until the operator. So we're just going to append the
-            // operator.
-            breakDocLHS = node.breakDoc.concat(operatorDoc);
-        }
-        else if (node.breakDoc) {
-            // Here we don't need a trailing operator, so we're just going to use the
-            // existing node.breakDoc. The operator will be a part of the rightSideDoc
-            // variable.
-            breakDocLHS = node.breakDoc;
-        }
-        else {
-            // Here we're at the bottom of the chain, so there's no representation yet
-            // for the receiver. So we're just going to pass up the left side.
-            breakDocLHS = leftSideDoc;
-        }
-        parentNode.breakDoc = breakDocLHS.concat(rightSideDoc);
-    }
-    // If we're at the top of a chain, then we're going to print out a nice
-    // multi-line layout if this doesn't break into multiple lines.
-    if (!chained.includes(parentNode.type) &&
-        (node.chain || 0) >= 3 &&
-        node.breakDoc) {
-        return ifBreak(group(indent(node.breakDoc.concat(rightSideDoc))), [
-            leftSideDoc,
-            group(rightSideDoc)
-        ]);
-    }
-    return group([leftSideDoc, group(indent(rightSideDoc))]);
-};
-exports.printCall = printCall;
-const printMethodAddArg = (path, opts, print) => {
-    const node = path.getValue();
-    const methodDoc = path.call(print, "call");
-    const argsDoc = path.call(print, "args");
-    // You can end up here if you have a method with a ? ending, presumably
-    // because the parser knows that it cannot be a local variable. You can also
-    // end up here if you are explicitly using an empty set of parentheses.
-    if (argsDoc.length === 0) {
-        // If you're using an explicit set of parentheses on something that looks
-        // like a constant, then we need to match that in order to maintain valid
-        // Ruby. For example, you could do something like Foo(), on which we would
-        // need to keep the parentheses to make it look like a method call.
-        if (node.call.type === "fcall" && node.call.value.type === "const") {
-            return [methodDoc, "()"];
-        }
-        // If you're using an explicit set parentheses with the special call syntax,
-        // then we need to explicitly print out an extra set of parentheses. For
-        // example, if you call something like Foo.new.() (implicitly calling the
-        // #call method on a new instance of the Foo class), then we have to print
-        // out those parentheses, otherwise we'll end up with Foo.new.
-        if (node.call.type === "call" && node.call.message === "call") {
-            return [methodDoc, "()"];
-        }
-        return methodDoc;
-    }
-    // This case will ONLY be hit if we can successfully turn the block into a
-    // to_proc call. In that case, we just explicitly add the parens around it.
-    if (node.args.type === "args" && argsDoc.length > 0) {
-        return [methodDoc, "(", ...argsDoc, ")"];
-    }
-    // Get a reference to the parent node so we can check if we're inside a chain
-    const parentNode = path.getParentNode();
-    // If our parent node is a chained node then we're not going to group the
-    // right side of the expression, as we want to have a nice multi-line layout.
-    if (chained.includes(parentNode.type) && !node.comments) {
-        parentNode.chain = (node.chain || 0) + 1;
-        parentNode.breakDoc = (node.breakDoc || [methodDoc]).concat(argsDoc);
-        parentNode.firstReceiverType = node.firstReceiverType;
-    }
-    // This is the threshold at which we will start to try to make a nicely
-    // indented call chain. For the most part, it's always 3.
-    let threshold = 3;
-    // Here, we have very specialized behavior where if we're within a sig block,
-    // then we're going to assume we're creating a Sorbet type signature. In that
-    // case, we really want the threshold to be lowered to 2 so that we create
-    // method chains off of any two method calls within the block. For more
-    // details, see
-    // https://github.com/prettier/plugin-ruby/issues/863.
-    let sigBlock = path.getParentNode(2);
-    if (sigBlock) {
-        // If we're at a do_block, then we want to go one more level up. This is
-        // because do_blocks have bodystmt nodes instead of just stmt nodes.
-        if (sigBlock.type === "do_block") {
-            sigBlock = path.getParentNode(3);
-        }
-        if (sigBlock.type === "method_add_block") {
-            // Pulling this out into a separate variable so we can get back some of
-            // our type safety.
-            const sigBlockNode = sigBlock;
-            if (sigBlockNode.block &&
-                sigBlockNode.call.type === "method_add_arg" &&
-                sigBlockNode.call.call.type === "fcall" &&
-                sigBlockNode.call.call.value.value === "sig") {
-                threshold = 2;
-            }
-        }
-    }
-    // If we're at the top of a chain, then we're going to print out a nice
-    // multi-line layout if this doesn't break into multiple lines.
-    if (!chained.includes(parentNode.type) &&
-        (node.chain || 0) >= threshold &&
-        node.breakDoc) {
-        // This is pretty specialized behavior. Basically if we're at the top of a
-        // chain but we've only had method calls without arguments and now we have
-        // arguments, then we're effectively trying to call a method with arguments
-        // that is nested under a bunch of stuff. So we group together to first part
-        // to make it so just the arguments break. This looks like, for example:
-        //
-        //     config.action_dispatch.rescue_responses.merge!(
-        //       'ActiveRecord::ConnectionTimeoutError' => :service_unavailable,
-        //       'ActiveRecord::QueryCanceled' => :service_unavailable
-        //     )
-        //
-        if (node.callChain === node.chain) {
-            return [group(indent(node.breakDoc)), group(argsDoc)];
-        }
-        return ifBreak(group(indent(node.breakDoc.concat(argsDoc))), [
-            methodDoc,
-            argsDoc
-        ]);
-    }
-    // If there are already parentheses, then we can just use the doc that's
-    // already printed.
-    if (node.args.type == "arg_paren") {
-        return group([methodDoc, argsDoc]);
-    }
-    return [methodDoc, " ", join(", ", argsDoc), " "];
-};
-exports.printMethodAddArg = printMethodAddArg;
-const printMethodAddBlock = (path, opts, print) => {
-    const node = path.getValue();
-    const callDoc = path.call(print, "call");
-    const blockDoc = path.call(print, "block");
-    // Don't bother trying to do any kind of fancy toProc transform if the option
-    // is disabled.
-    if (opts.rubyToProc) {
-        const proc = (0, toProc_1.default)(path, node.block);
-        if (proc && node.call.type === "call") {
-            return group([
-                path.call(print, "call"),
-                "(",
-                indent([softline, proc]),
-                [softline, ")"]
-            ]);
-        }
-        if (proc) {
-            return path.call(print, "call");
-        }
-    }
-    // Get a reference to the parent node so we can check if we're inside a chain
-    const parentNode = path.getParentNode();
-    // If our parent node is a chained node then we're not going to group the
-    // right side of the expression, as we want to have a nice multi-line layout.
-    if (chained.includes(parentNode.type)) {
-        parentNode.chain = (node.chain || 0) + 1;
-        parentNode.breakDoc = (node.breakDoc || [callDoc]).concat(blockDoc);
-        parentNode.firstReceiverType = node.firstReceiverType;
-    }
-    // If we're at the top of a chain, then we're going to print out a nice
-    // multi-line layout if this doesn't break into multiple lines.
-    if (!chained.includes(parentNode.type) &&
-        (node.chain || 0) >= 3 &&
-        node.breakDoc) {
-        // This is pretty specialized behavior. Basically if we're at the top of a
-        // chain but we've only had method calls without arguments and now we have
-        // a method call with a block, then we're effectively trying to call a
-        // method with arguments that is nested under a bunch of stuff. So we group
-        // together to first part to make it so just the block breaks. This looks
-        // like, for example:
-        //
-        //     Rails.application.routes.draw do
-        //       root 'articles#index'
-        //       resources :articles
-        //     end
-        //
-        if (node.callChain === node.chain) {
-            return [group(indent(node.breakDoc)), group(blockDoc)];
-        }
-        return ifBreak(group(indent(node.breakDoc.concat(blockDoc))), [
-            callDoc,
-            blockDoc
-        ]);
-    }
-    return [callDoc, blockDoc];
-};
-exports.printMethodAddBlock = printMethodAddBlock;
-const printCallContainer = (path, opts, print) => {
-    return path.call(print, "value");
-};
-exports.printCallContainer = printCallContainer;

data/dist/ruby/nodes/case.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.printWhen = exports.printCase = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const { align, fill, group, hardline, indent, line } = prettier_1.default;
-const printCase = (path, opts, print) => {
-    const parts = ["case"];
-    // You don't need to explicitly have something to test against in a case
-    // statement (without it it effectively becomes an if/elsif chain).
-    if (path.getValue().value) {
-        parts.push(" ", path.call(print, "value"));
-    }
-    return [...parts, hardline, path.call(print, "cons"), hardline, "end"];
-};
-exports.printCase = printCase;
-const printWhen = (path, opts, print) => {
-    const node = path.getValue();
-    // The `fill` builder command expects an array of docs alternating with
-    // line breaks. This is so it can loop through and determine where to break.
-    const preds = fill(path.call(print, "args").reduce((accum, pred, index) => {
-        if (index === 0) {
-            return [pred];
-        }
-        // Pull off the last element and make it concat with a comma so that
-        // we can maintain alternating lines and docs.
-        return [
-            ...accum.slice(0, -1),
-            [accum[accum.length - 1], ","],
-            line,
-            pred
-        ];
-    }, []));
-    const stmts = path.call(print, "stmts");
-    const parts = [["when ", align("when ".length, preds)]];
-    // It's possible in a when to just have empty void statements, in which case
-    // we would skip adding the body.
-    if (!stmts.every((part) => !part)) {
-        parts.push(indent([hardline, stmts]));
-    }
-    // This is the next clause on the case statement, either another `when` or
-    // an `else` clause.
-    if (node.cons) {
-        parts.push(hardline, path.call(print, "cons"));
-    }
-    return group(parts);
-};
-exports.printWhen = printWhen;

data/dist/ruby/nodes/class.js

@@ -1,54 +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.printSClass = exports.printModule = exports.printClass = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { group, hardline, indent } = prettier_1.default;
-const printClass = (path, opts, print) => {
-    const node = path.getValue();
-    const parts = ["class ", path.call(print, "constant")];
-    if (node.superclass) {
-        parts.push(" < ", path.call(print, "superclass"));
-    }
-    const declaration = group(parts);
-    if ((0, utils_1.isEmptyBodyStmt)(node.bodystmt)) {
-        return group([declaration, hardline, "end"]);
-    }
-    return group([
-        declaration,
-        indent([hardline, path.call(print, "bodystmt")]),
-        [hardline, "end"]
-    ]);
-};
-exports.printClass = printClass;
-const printModule = (path, opts, print) => {
-    const node = path.getValue();
-    const declaration = group(["module ", path.call(print, "constant")]);
-    if ((0, utils_1.isEmptyBodyStmt)(node.bodystmt)) {
-        return group([declaration, hardline, "end"]);
-    }
-    return group([
-        declaration,
-        indent([hardline, path.call(print, "bodystmt")]),
-        hardline,
-        "end"
-    ]);
-};
-exports.printModule = printModule;
-const printSClass = (path, opts, print) => {
-    const node = path.getValue();
-    const declaration = ["class << ", path.call(print, "target")];
-    if ((0, utils_1.isEmptyBodyStmt)(node.bodystmt)) {
-        return group([declaration, hardline, "end"]);
-    }
-    return group([
-        declaration,
-        indent([hardline, path.call(print, "bodystmt")]),
-        hardline,
-        "end"
-    ]);
-};
-exports.printSClass = printSClass;

data/dist/ruby/nodes/commands.js

@@ -1,138 +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.printCommandCall = exports.printCommand = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { align, group, ifBreak, indent, join, line, softline } = prettier_1.default;
-function throwBadDoc(doc) {
-    throw new Error(`Unknown doc ${doc}`);
-}
-function reduceDocLength(sum, doc) {
-    // If we've hit a line, then we're going to start the counting back at 0 since
-    // it will be starting from the beginning of a line.
-    if (typeof doc === "object" && !Array.isArray(doc) && doc.type === "line") {
-        return 0;
-    }
-    return sum + docBreakLength(doc);
-}
-// Loop through the already created doc nodes and determine the overall length
-// so that we can properly align the command arguments.
-function docBreakLength(doc) {
-    if (Array.isArray(doc)) {
-        return doc.reduce(reduceDocLength, 0);
-    }
-    if (typeof doc === "string") {
-        return doc.length;
-    }
-    switch (doc.type) {
-        case "concat":
-        case "fill":
-            return doc.parts.reduce(reduceDocLength, 0);
-        case "align":
-        case "group":
-        case "indent":
-        case "line-suffix":
-            return docBreakLength(doc.contents);
-        case "if-break":
-            return docBreakLength(doc.breakContents);
-        case "line":
-            return 0;
-        case "break-parent":
-        case "cursor":
-        case "indent-if-break":
-        case "label":
-        case "line-suffix-boundary":
-        case "trim":
-            return 0;
-        default:
-            throwBadDoc(doc);
-    }
-}
-function hasDef(node) {
-    return (node.args.type === "args_add_block" &&
-        node.args.args.type === "args" &&
-        node.args.args.parts[0] &&
-        ["def", "defs"].includes(node.args.args.parts[0].type));
-}
-// Very special handling case for rspec matchers. In general with rspec matchers
-// you expect to see something like:
-//
-//     expect(foo).to receive(:bar).with(
-//       'one',
-//       'two',
-//       'three',
-//       'four',
-//       'five'
-//     )
-//
-// In this case the arguments are aligned to the left side as opposed to being
-// aligned with the `receive` call.
-function skipArgsAlign(node) {
-    return ["to", "not_to", "to_not"].includes(node.message.value);
-}
-// If there is a ternary argument to a command and it's going to get broken
-// into multiple lines, then we're going to have to use parentheses around the
-// command in order to make sure operator precedence doesn't get messed up.
-function hasTernaryArg(node) {
-    var _a;
-    switch (node.type) {
-        case "args":
-            return node.parts.some((child) => child.type === "ifop");
-        case "args_add_block":
-            return hasTernaryArg(node.args) || ((_a = node.block) === null || _a === void 0 ? void 0 : _a.type) === "ifop";
-    }
-}
-const printCommand = (path, opts, print) => {
-    const node = path.getValue();
-    const command = path.call(print, "message");
-    const joinedArgs = join([",", line], path.call(print, "args"));
-    const hasTernary = hasTernaryArg(node.args);
-    let breakArgs;
-    if (hasTernary) {
-        breakArgs = indent([softline, joinedArgs]);
-    }
-    else if (hasDef(node)) {
-        breakArgs = joinedArgs;
-    }
-    else {
-        breakArgs = align(docBreakLength(command) + 1, joinedArgs);
-    }
-    return group(ifBreak([
-        command,
-        hasTernary ? "(" : " ",
-        breakArgs,
-        hasTernary ? [softline, ")"] : ""
-    ], [command, " ", joinedArgs]));
-};
-exports.printCommand = printCommand;
-const printCommandCall = (path, opts, print) => {
-    const node = path.getValue();
-    const parts = [
-        path.call(print, "receiver"),
-        (0, utils_1.makeCall)(path, opts, print),
-        path.call(print, "message")
-    ];
-    if (!node.args) {
-        return parts;
-    }
-    const argDocs = join([",", line], path.call(print, "args"));
-    let breakDoc;
-    if (hasTernaryArg(node.args)) {
-        breakDoc = parts.concat("(", indent([softline, argDocs]), softline, ")");
-        parts.push(" ");
-    }
-    else if (skipArgsAlign(node)) {
-        parts.push(" ");
-        breakDoc = parts.concat(argDocs);
-    }
-    else {
-        parts.push(" ");
-        breakDoc = parts.concat(align(docBreakLength(parts), argDocs));
-    }
-    const joinedDoc = parts.concat(argDocs);
-    return group(ifBreak(breakDoc, joinedDoc));
-};
-exports.printCommandCall = printCommandCall;