prettier 2.1.0 → 3.0.0

data/dist/ruby/nodes/alias.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.printAlias = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const { addTrailingComment, align, group, hardline, line } = prettier_1.default;
-// The `alias` keyword is used to make a method respond to another name as well
-// as the current one. For example, to get the method `foo` to also respond to
-// `bar`, you would:
-//
-//     alias bar foo
-//
-// Now, in the current context you can call `bar` and it will execute the `foo`
-// method.
-//
-// When you're aliasing two methods, you can either provide bare words (like the
-// example above) or you can provide symbols (note that this includes dynamic
-// symbols like :"foo-#{bar}-baz"). In general, to be consistent with the ruby
-// style guide, we prefer bare words:
-//
-//     https://github.com/rubocop-hq/ruby-style-guide#alias-method-lexically
-//
-// The `alias` node contains two children. The left and right align with the
-// arguments passed to the keyword. So, for the above example the left would be
-// the symbol literal `bar` and the right could be the symbol literal `foo`.
-const printAlias = (path, opts, print) => {
-    const keyword = "alias ";
-    const node = path.getValue();
-    // In general, return the printed doc of the argument at the provided index.
-    // Special handling is given for symbol literals that are not bare words, as
-    // we convert those into bare words by just pulling out the ident node.
-    const printAliasArg = (argPath) => {
-        const argNode = argPath.getValue();
-        if (argNode.type === "symbol_literal") {
-            // If we're going to descend into the symbol literal to grab out the ident
-            // node, then we need to make sure we copy over any comments as well,
-            // otherwise we could accidentally skip printing them.
-            if (argNode.comments) {
-                argNode.comments.forEach((comment) => {
-                    addTrailingComment(argNode.value, comment);
-                });
-            }
-            return argPath.call(print, "value");
-        }
-        return print(argPath);
-    };
-    return group([
-        keyword,
-        path.call(printAliasArg, "left"),
-        group(align(keyword.length, [
-            // If the left child has any comments, then we need to explicitly break
-            // this into two lines
-            node.left.comments ? hardline : line,
-            path.call(printAliasArg, "right")
-        ]))
-    ]);
-};
-exports.printAlias = printAlias;

data/dist/ruby/nodes/aref.js

@@ -1,51 +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.printArefField = exports.printAref = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const { group, indent, join, line, softline } = prettier_1.default;
-// `aref` nodes are when you're pulling a value out of a collection at a
-// specific index. Put another way, it's any time you're calling the method
-// `#[]`.
-//
-// The nodes usually contains two children, details below in the
-// `printArefField` function. In some cases, you don't necessarily have the
-// second child node, because you can call procs with a pretty esoteric syntax.
-// In the following example, you wouldn't have a second child, and `"foo"` would
-// be the first child.
-//
-//     foo[]
-//
-const printAref = (path, opts, print) => {
-    if (!path.getValue().index) {
-        return [path.call(print, "collection"), "[]"];
-    }
-    return (0, exports.printArefField)(path, opts, print);
-};
-exports.printAref = printAref;
-// `aref_field` nodes are for assigning values into collections at specific
-// indices. Put another way, it's any time you're calling the method `#[]=`.
-// The `aref_field` node itself is just the left side of the assignment, and
-// they're always wrapped in `assign` nodes.
-//
-// The nodes always contain two children, the name of the array (usually a
-// `vcall` node and the index (usually an `args_add_block` node). The
-// `args_add_block` is one of a couple nodes that has special handling where its
-// printed form is actually an array to make joining easier.
-//
-// So in the following example, `"foo"` is the array and `["bar"]` is the index.
-//
-//     foo[bar] = baz
-//
-const printArefField = (path, opts, print) => {
-    return group([
-        path.call(print, "collection"),
-        "[",
-        indent([softline, join([",", line], path.call(print, "index"))]),
-        softline,
-        "]"
-    ]);
-};
-exports.printArefField = printArefField;

data/dist/ruby/nodes/args.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.printArgStar = exports.printBlockArg = exports.printArgsAddBlock = exports.printArgs = exports.printArgParen = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const toProc_1 = __importDefault(require("../toProc"));
-const { group, ifBreak, indent, join, line, softline } = prettier_1.default;
-const noTrailingComma = ["command", "command_call"];
-function getArgs(node) {
-    switch (node.type) {
-        case "args":
-            return node.parts;
-        case "args_add_block": {
-            const args = getArgs(node.args);
-            return node.block ? [...args, node.block] : args;
-        }
-    }
-}
-function getArgParenTrailingComma(node) {
-    // If we have a block, then we don't want to add a trailing comma.
-    if (node.type === "args_add_block" && node.block) {
-        return "";
-    }
-    // If we only have one argument and that first argument necessitates that we
-    // skip putting a comma (because it would interfere with parsing the argument)
-    // then we don't want to add a trailing comma.
-    const args = getArgs(node);
-    if (args.length === 1 && noTrailingComma.includes(args[0].type)) {
-        return "";
-    }
-    return ifBreak(",", "");
-}
-const printArgParen = (path, opts, print) => {
-    const argsNode = path.getValue().args;
-    if (argsNode === null) {
-        return "";
-    }
-    // Here we can skip the entire rest of the method by just checking if it's
-    // an args_forward node, as we're guaranteed that there are no other arg
-    // nodes.
-    if (argsNode.type === "args_forward") {
-        return group([
-            "(",
-            indent([softline, path.call(print, "args")]),
-            softline,
-            ")"
-        ]);
-    }
-    // Now here we return a doc that represents the whole grouped expression,
-    // including the surrouding parentheses.
-    return group([
-        "(",
-        indent([
-            softline,
-            join([",", line], path.call(print, "args")),
-            (0, utils_1.getTrailingComma)(opts) ? getArgParenTrailingComma(argsNode) : ""
-        ]),
-        softline,
-        ")"
-    ]);
-};
-exports.printArgParen = printArgParen;
-const printArgs = (path, { rubyToProc }, print) => {
-    const args = path.map(print, "parts");
-    // Don't bother trying to do any kind of fancy toProc transform if the
-    // option is disabled.
-    if (rubyToProc) {
-        let blockNode = null;
-        // Look up the chain to see if these arguments are contained within a
-        // method_add_block node, and if they are that that node has a block
-        // associated with it. If it does, we're going to attempt to transform it
-        // into the to_proc shorthand and add it to the list of arguments.
-        [1, 2, 3].find((parent) => {
-            const parentNode = path.getParentNode(parent);
-            blockNode =
-                parentNode &&
-                    parentNode.type === "method_add_block" &&
-                    parentNode.block;
-            return blockNode;
-        });
-        const proc = blockNode && (0, toProc_1.default)(path, blockNode);
-        // If we have a successful to_proc transformation, but we're part of an
-        // aref node, that means it's something to the effect of
-        //
-        //     foo[:bar].each(&:to_s)
-        //
-        // In this case we need to just return regular arguments, otherwise we
-        // would end up putting &:to_s inside the brackets accidentally.
-        if (proc && path.getParentNode(1).type !== "aref") {
-            args.push(proc);
-        }
-    }
-    return args;
-};
-exports.printArgs = printArgs;
-const printArgsAddBlock = (path, opts, print) => {
-    const node = path.getValue();
-    const parts = path.call(print, "args");
-    if (node.block) {
-        let blockDoc = path.call(print, "block");
-        if (!(node.block.comments || []).some(({ leading }) => leading)) {
-            // If we don't have any leading comments, we can just prepend the
-            // operator.
-            blockDoc = ["&", blockDoc];
-        }
-        else {
-            // If we have a method call like:
-            //
-            //     foo(
-            //       # comment
-            //       &block
-            //     )
-            //
-            // then we need to make sure we don't accidentally prepend the operator
-            // before the comment.
-            //
-            // In prettier >= 2.3.0, the comments are printed as an array before the
-            // content. I don't love this kind of reflection, but it's the simplest
-            // way at the moment to get this right.
-            blockDoc = blockDoc[0].concat(["&", blockDoc[1]], blockDoc.slice(2));
-        }
-        parts.push(blockDoc);
-    }
-    return parts;
-};
-exports.printArgsAddBlock = printArgsAddBlock;
-const printBlockArg = (path, opts, print) => {
-    return ["&", path.call(print, "name")];
-};
-exports.printBlockArg = printBlockArg;
-const printArgStar = (path, opts, print) => {
-    const node = path.getValue();
-    return node.value ? ["*", path.call(print, "value")] : "*";
-};
-exports.printArgStar = printArgStar;

data/dist/ruby/nodes/arrays.js

@@ -1,122 +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.printArray = exports.printWords = exports.printSymbols = exports.printQwords = exports.printQsymbols = exports.printWord = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { group, ifBreak, indent, join, line, softline } = prettier_1.default;
-// Checks that every argument within this args node is a string_literal node
-// that has no spaces or interpolations. This means we're dealing with an array
-// that looks something like:
-//
-//     ['a', 'b', 'c']
-//
-function isStringArray(args) {
-    return (args.parts.length > 1 &&
-        args.parts.every((arg) => {
-            // We want to verify that every node inside of this array is a string
-            // literal. We also want to make sure none of them have comments attached.
-            if (arg.type !== "string_literal" || arg.comments) {
-                return false;
-            }
-            // If the string has multiple parts (meaning plain string content but also
-            // interpolated content) then we know it's not a simple string.
-            if (arg.parts.length !== 1) {
-                return false;
-            }
-            const part = arg.parts[0];
-            // If the only part of this string is not @tstring_content then it's
-            // interpolated, so again we can return false.
-            if (part.type !== "tstring_content") {
-                return false;
-            }
-            // Finally, verify that the string doesn't contain a space, an escape
-            // character, or brackets so that we know it can be put into a string
-            // literal array.
-            return !/[\s\\[\]]/.test(part.value);
-        }));
-}
-// Checks that every argument within this args node is a symbol_literal node (as
-// opposed to a dyna_symbol) so it has no interpolation. This means we're
-// dealing with an array that looks something like:
-//
-//     [:a, :b, :c]
-//
-function isSymbolArray(args) {
-    return (args.parts.length > 1 &&
-        args.parts.every((arg) => arg.type === "symbol_literal" && !arg.comments));
-}
-// Prints out a word that is a part of a special array literal that accepts
-// interpolation. The body is an array of either plain strings or interpolated
-// expressions.
-const printWord = (path, opts, print) => {
-    return path.map(print, "parts");
-};
-exports.printWord = printWord;
-// Prints out a special array literal. Accepts the parts of the array literal as
-// an argument, where the first element of the parts array is a string that
-// contains the special start.
-function printArrayLiteralParts(start, parts) {
-    return group([
-        start,
-        "[",
-        indent([softline, join(line, parts)]),
-        softline,
-        "]"
-    ]);
-}
-function printArrayLiteral(start) {
-    return function printArrayLiteralWithStart(path, opts, print) {
-        return printArrayLiteralParts(start, path.map(print, "elems"));
-    };
-}
-exports.printQsymbols = printArrayLiteral("%i");
-exports.printQwords = printArrayLiteral("%w");
-exports.printSymbols = printArrayLiteral("%I");
-exports.printWords = printArrayLiteral("%W");
-// An array node is any literal array in Ruby. This includes all of the special
-// array literals as well as regular arrays. If it is a special array literal
-// then it will have one child that represents the special array, otherwise it
-// will have one child that contains all of the elements of the array.
-const printArray = (path, opts, print) => {
-    const array = path.getValue();
-    const contents = array.cnts;
-    // If there is no inner arguments node, then we're dealing with an empty
-    // array, so we can go ahead and return.
-    if (contents === null) {
-        return (0, utils_1.printEmptyCollection)(path, opts, "[", "]");
-    }
-    if (opts.rubyArrayLiteral) {
-        // If we have an array that contains only simple string literals with no
-        // spaces or interpolation, then we're going to print a %w array.
-        if (isStringArray(contents)) {
-            const printString = (stringPath) => stringPath.call(print, "parts", 0);
-            const nodePath = path;
-            const parts = nodePath.map(printString, "cnts", "parts");
-            return printArrayLiteralParts("%w", parts);
-        }
-        // If we have an array that contains only simple symbol literals with no
-        // interpolation, then we're going to print a %i array.
-        if (isSymbolArray(contents)) {
-            const printSymbol = (symbolPath) => symbolPath.call(print, "value");
-            const nodePath = path;
-            const parts = nodePath.map(printSymbol, "cnts", "parts");
-            return printArrayLiteralParts("%i", parts);
-        }
-    }
-    // Here we have a normal array of any type of object with no special literal
-    // types or anything.
-    return group([
-        "[",
-        indent([
-            softline,
-            join([",", line], path.call(print, "cnts")),
-            (0, utils_1.getTrailingComma)(opts) ? ifBreak(",", "") : ""
-        ]),
-        softline,
-        "]"
-    ]);
-};
-exports.printArray = printArray;

data/dist/ruby/nodes/assign.js

@@ -1,37 +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.printVarRef = exports.printVarField = exports.printOpAssign = exports.printAssign = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { group, indent, join, line } = prettier_1.default;
-const printAssign = (...args) => {
-    return printOpAssignOrAssign("=", ...args);
-};
-exports.printAssign = printAssign;
-const printOpAssign = (path, opts, print) => {
-    const opDoc = path.call(print, "op");
-    return printOpAssignOrAssign(opDoc, path, opts, print);
-};
-exports.printOpAssign = printOpAssign;
-function printOpAssignOrAssign(opDoc, path, opts, print) {
-    const valueNode = path.getValue().value;
-    const targetDoc = path.call(print, "target");
-    const valueDoc = path.call(print, "value");
-    let rightSideDoc = valueDoc;
-    // If the right side of this assignment is a multiple assignment, then we need
-    // to join it together with commas.
-    if (["mrhs", "mrhs_add_star", "mrhs_new_from_args"].includes(valueNode.type)) {
-        rightSideDoc = group(join([",", line], valueDoc));
-    }
-    if ((0, utils_1.skipAssignIndent)(valueNode)) {
-        return group([targetDoc, " ", opDoc, " ", rightSideDoc]);
-    }
-    return group([targetDoc, " ", opDoc, indent([line, rightSideDoc])]);
-}
-const printVarField = (path, opts, print) => (path.getValue().value ? path.call(print, "value") : "");
-exports.printVarField = printVarField;
-const printVarRef = (path, opts, print) => path.call(print, "value");
-exports.printVarRef = printVarRef;

data/dist/ruby/nodes/blocks.js

@@ -1,90 +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.printDoBlock = exports.printBraceBlock = exports.printBlockVar = void 0;
-const prettier_1 = __importDefault(require("../../prettier"));
-const utils_1 = require("../../utils");
-const { breakParent, group, ifBreak, indent, join, removeLines, softline } = prettier_1.default;
-const printBlockVar = (path, opts, print) => {
-    const parts = ["|", removeLines(path.call(print, "params"))];
-    // The second part of this node is a list of optional block-local variables
-    if (path.getValue().locals.length > 0) {
-        parts.push("; ", join(", ", path.map(print, "locals")));
-    }
-    parts.push("| ");
-    return parts;
-};
-exports.printBlockVar = printBlockVar;
-// You have to go through the main print function if you could potentially have
-// comments attached. So we're doing this weird reflection on the printed docs
-// to retroactively change the printed keyword depending on if we're using
-// braces or not. Ideally we wouldn't do this, we would instead do this
-// reflection in the child printer, but this keeps the logic to just this file
-// and contains it, so keeping it here for now.
-function printBlockBegin(path, print, useBraces) {
-    let docs = print(path);
-    const doc = useBraces && !path.getValue().comments ? "{" : "do";
-    if (Array.isArray(docs)) {
-        docs[1] = doc;
-    }
-    else {
-        docs = doc;
-    }
-    return docs;
-}
-function printBlock(braces) {
-    return function printBlockWithBraces(path, opts, print) {
-        const node = path.getValue();
-        const stmts = node.type === "brace_block" ? node.stmts.body : node.bodystmt.stmts.body;
-        let doBlockBody = "";
-        if (stmts.length !== 1 ||
-            stmts[0].type !== "void_stmt" ||
-            stmts[0].comments) {
-            doBlockBody = indent([
-                softline,
-                path.call(print, node.type === "brace_block" ? "stmts" : "bodystmt")
-            ]);
-        }
-        // If this block is nested underneath a command or command_call node, then
-        // we can't use `do...end` because that will get associated with the parent
-        // node as opposed to the current node (because of the difference in
-        // operator precedence). Instead, we still use a multi-line format but
-        // switch to using braces instead.
-        const useBraces = braces && (0, utils_1.hasAncestor)(path, ["command", "command_call"]);
-        const doBlock = [
-            " ",
-            path.call((beginPath) => printBlockBegin(beginPath, print, useBraces), node.type === "brace_block" ? "lbrace" : "keyword"),
-            node.block_var ? [" ", path.call(print, "block_var")] : "",
-            doBlockBody,
-            [softline, useBraces ? "}" : "end"]
-        ];
-        // We can hit this next pattern if within the block the only statement is a
-        // comment.
-        if (stmts.length === 1 &&
-            stmts[0].type === "void_stmt" &&
-            stmts[0].comments) {
-            return [breakParent, doBlock];
-        }
-        const blockReceiver = path.getParentNode().call;
-        // If the parent node is a command node, then there are no parentheses
-        // around the arguments to that command, so we need to break the block
-        if (["command", "command_call"].includes(blockReceiver.type)) {
-            return [breakParent, doBlock];
-        }
-        const hasBody = stmts.some(({ type }) => type !== "void_stmt");
-        const braceBlock = [
-            " ",
-            path.call((beginPath) => printBlockBegin(beginPath, print, true), node.type === "brace_block" ? "lbrace" : "keyword"),
-            hasBody || node.block_var ? " " : "",
-            node.block_var ? path.call(print, "block_var") : "",
-            path.call(print, node.type === "brace_block" ? "stmts" : "bodystmt"),
-            hasBody ? " " : "",
-            "}"
-        ];
-        return group(ifBreak(doBlock, braceBlock));
-    };
-}
-exports.printBraceBlock = printBlock(true);
-exports.printDoBlock = printBlock(false);