prettier 2.1.0 → 3.1.1

data/dist/ruby/printer.js

@@ -1,67 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const prettier_1 = __importDefault(require("../prettier"));
-const utils_1 = require("../utils");
-const embed_1 = __importDefault(require("./embed"));
-const nodes_1 = __importDefault(require("./nodes"));
-const { trim } = prettier_1.default;
-const noComments = ["args", "args_add_block", "mlhs", "mlhs_paren"];
-const printer = {
-    // Certain nodes are used more for organizational purposed than for actually
-    // displaying content, so we tell prettier that we don't want comments
-    // attached to them.
-    canAttachComment(node) {
-        return !noComments.includes(node.type);
-    },
-    embed: embed_1.default,
-    // This function tells prettier how to recurse down our AST so that it can
-    // find where it needs to attach the comments.
-    getCommentChildNodes(node) {
-        return (0, utils_1.getChildNodes)(node);
-    },
-    // This is an escape-hatch to ignore nodes in the tree. If you have a comment
-    // that includes this pattern, then the entire node will be ignored and just
-    // the original source will be printed out.
-    hasPrettierIgnore(path) {
-        const node = path.getValue();
-        return ((node.comments &&
-            node.comments.some((comment) => comment.value.includes("prettier-ignore"))) ||
-            false);
-    },
-    // To be honest I'm not 100% sure this function is actually necessary, but it
-    // *feels* like a block comment equivalent in JavaScript so I'm going to leave
-    // it in place for now.
-    isBlockComment(comment) {
-        return comment.type === "embdoc";
-    },
-    // This function handles adding the format pragma to a source string. This is
-    // an optional workflow for incremental adoption.
-    insertPragma(text) {
-        const boundary = text.startsWith("#") ? "\n" : "\n\n";
-        return `# @format${boundary}${text}`;
-    },
-    // This is the generic node print function, used to convert any node in the
-    // AST into its equivalent Doc representation.
-    print(path, opts, print) {
-        const node = path.getValue();
-        const printer = nodes_1.default[node.type];
-        if (!printer) {
-            throw new Error(`Unsupported node type: ${node.type}`);
-        }
-        return printer(path, opts, print);
-    },
-    // This is the generic print function for any comment in the AST. It handles
-    // both regular comments that begin with a # and embdoc comments, which are
-    // surrounded by =begin..=end.
-    printComment(path) {
-        const comment = path.getValue();
-        if (comment.type === "comment") {
-            return `#${comment.value}`;
-        }
-        return [trim, comment.value];
-    }
-};
-exports.default = printer;

data/dist/ruby/toProc.js

@@ -1,91 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function isPeriod(node) {
-    // Older versions of Ruby didn't have a @period ripper event, so we need to
-    // explicitly cast to any here.
-    if (node === "::" || node === ".") {
-        return true;
-    }
-    return node.type === "period";
-}
-// If you have a simple block that only calls a method on the single required
-// parameter that is passed to it, then you can replace that block with the
-// simpler `Symbol#to_proc`. Meaning, it would go from:
-//
-//     [1, 2, 3].map { |i| i.to_s }
-//
-// to:
-//
-//     [1, 2, 3].map(&:to_s)
-//
-// This works with `do` blocks as well.
-function toProc(path, node) {
-    // Ensure that there are variables being passed to this block.
-    const params = node.block_var && node.block_var.params;
-    if (!params) {
-        return null;
-    }
-    // Ensure there is one and only one parameter, and that it is required.
-    if (params.reqs.length !== 1 ||
-        params.opts.length !== 0 ||
-        params.rest ||
-        params.posts.length !== 0 ||
-        params.keywords.length !== 0 ||
-        params.kwrest ||
-        params.block) {
-        return null;
-    }
-    // Get the list of statements from the block
-    let statements;
-    if (node.type === "do_block") {
-        // If you have any other clauses on the bodystmt, then we can't transform.
-        if (node.bodystmt.rsc || node.bodystmt.els || node.bodystmt.ens) {
-            return null;
-        }
-        statements = node.bodystmt.stmts.body;
-    }
-    else {
-        statements = node.stmts.body;
-    }
-    // Ensure the block contains only one statement
-    if (statements.length !== 1) {
-        return null;
-    }
-    // Ensure that statement is a call and that it has no comments attached
-    const [call] = statements;
-    if (call.type !== "call" || call.comments) {
-        return null;
-    }
-    // Ensure the call is a method of the block argument
-    if (call.receiver.type !== "var_ref" ||
-        call.receiver.value.value !== params.reqs[0].value ||
-        !isPeriod(call.op) ||
-        call.message === "call" ||
-        call.message.type !== "ident") {
-        return null;
-    }
-    // Ensure that we're not inside of a hash that is being passed to a key that
-    // corresponds to `:if` or `:unless` to avoid problems with callbacks with
-    // Rails. For more context, see:
-    // https://github.com/prettier/plugin-ruby/issues/449
-    let parentNode = null;
-    if (path.getValue().type === "method_add_block") {
-        parentNode = path.getParentNode();
-    }
-    else {
-        parentNode = path.getParentNode(2);
-    }
-    if (parentNode && parentNode.type === "assoc") {
-        const assocNode = parentNode;
-        const key = assocNode.key;
-        if (key.type === "label" && ["if:", "unless:"].includes(key.value)) {
-            return null;
-        }
-        if (key.type === "symbol_literal" &&
-            ["if", "unless"].includes(key.value.value)) {
-            return null;
-        }
-    }
-    return `&:${call.message.value}`;
-}
-exports.default = toProc;

data/dist/types/haml.js

@@ -1,4 +0,0 @@
-"use strict";
-// This file contains all of the types that represent objects being returned
-// from the HAML parser.
-Object.defineProperty(exports, "__esModule", { value: true });

data/dist/types/plugin.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-;

data/dist/types/rbs.js

@@ -1,4 +0,0 @@
-"use strict";
-// This file contains all of the types that represent objects being returned
-// from the RBS parser.
-Object.defineProperty(exports, "__esModule", { value: true });

data/dist/types/ruby.js

@@ -1,4 +0,0 @@
-"use strict";
-// This file contains all of the types that represent objects being returned
-// from our ripper-based parser.
-Object.defineProperty(exports, "__esModule", { value: true });

data/dist/types/utils.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

data/dist/types.js

@@ -1,34 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Ruby = exports.RBS = exports.Plugin = exports.HAML = void 0;
-exports.HAML = __importStar(require("./types/haml"));
-exports.Plugin = __importStar(require("./types/plugin"));
-exports.RBS = __importStar(require("./types/rbs"));
-exports.Ruby = __importStar(require("./types/ruby"));
-__exportStar(require("./types/utils"), exports);

data/dist/utils/containsAssignment.js

@@ -1,18 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const getChildNodes_1 = __importDefault(require("./getChildNodes"));
-// If the node is a type of assignment or if the node is a paren and nested
-// inside that paren is a node that is a type of assignment.
-function containsAssignment(node) {
-    if (!node) {
-        return false;
-    }
-    if (["assign", "massign", "opassign"].includes(node.type)) {
-        return true;
-    }
-    return (0, getChildNodes_1.default)(node).some(containsAssignment);
-}
-exports.default = containsAssignment;

data/dist/utils/getChildNodes.js

@@ -1,305 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function throwBadNode(node) {
-    throw new Error(`Unknown node ${node.type}`);
-}
-function getChildNodes(node) {
-    switch (node.type) {
-        case "CHAR":
-        case "__end__":
-        case "backref":
-        case "backtick":
-        case "const":
-        case "cvar":
-        case "float":
-        case "gvar":
-        case "heredoc_beg":
-        case "ident":
-        case "imaginary":
-        case "int":
-        case "ivar":
-        case "kw":
-        case "label":
-        case "lbrace":
-        case "lparen":
-        case "op":
-        case "period":
-        case "rational":
-        case "tstring_content":
-            return [];
-        case "BEGIN":
-            return [node.lbrace, node.stmts];
-        case "END":
-            return [node.lbrace, node.stmts];
-        case "access_ctrl":
-            return [node.value];
-        case "alias":
-            return [node.left, node.right];
-        case "aref":
-            return [node.collection, node.index];
-        case "aref_field":
-            return [node.collection, node.index];
-        case "arg_paren":
-            return [node.args];
-        case "args":
-            return node.parts;
-        case "args_add_block":
-            return [node.args, node.block];
-        case "args_forward":
-            return [];
-        case "arg_star":
-            return [node.value];
-        case "array":
-            return [node.cnts];
-        case "aryptn":
-            return [node.constant, ...node.reqs, node.rest, ...node.posts];
-        case "assign":
-            return [node.target, node.value];
-        case "assoc":
-            return [node.key, node.value];
-        case "assoc_splat":
-            return [node.value];
-        case "assoclist_from_args":
-            return node.assocs;
-        case "bare_assoc_hash":
-            return node.assocs;
-        case "begin":
-            return [node.bodystmt];
-        case "binary":
-            return [node.left, node.right];
-        case "block_var":
-            return [node.params, ...node.locals];
-        case "blockarg":
-            return [node.name];
-        case "bodystmt":
-            return [node.stmts, node.rsc, node.els, node.ens];
-        case "brace_block":
-            return [node.lbrace, node.block_var, node.stmts];
-        case "break":
-            return [node.args];
-        case "call": {
-            const childNodes = [node.receiver];
-            if (node.op !== "::") {
-                childNodes.push(node.op);
-            }
-            if (node.message !== "call") {
-                childNodes.push(node.message);
-            }
-            return childNodes;
-        }
-        case "case":
-            return [node.value, node.cons];
-        case "class":
-            return [node.constant, node.superclass, node.bodystmt];
-        case "command":
-            return [node.message, node.args];
-        case "command_call":
-            return [node.receiver, node.message, node.args];
-        case "const_path_field":
-            return [node.parent, node.constant];
-        case "const_path_ref":
-            return [node.parent, node.constant];
-        case "const_ref":
-            return [node.constant];
-        case "def":
-            return [node.name, node.params, node.bodystmt];
-        case "def_endless":
-            return [node.name, node.paren, node.stmt];
-        case "defined":
-            return [node.value];
-        case "defs":
-            return [node.target, node.op, node.name, node.params, node.bodystmt];
-        case "do_block":
-            return [node.keyword, node.block_var, node.bodystmt];
-        case "dot2":
-            return [node.left, node.right];
-        case "dot3":
-            return [node.left, node.right];
-        case "dyna_symbol":
-            return node.parts;
-        case "else":
-            return [node.stmts];
-        case "elsif":
-            return [node.pred, node.stmts, node.cons];
-        case "ensure":
-            return [node.keyword, node.stmts];
-        case "excessed_comma":
-            return [];
-        case "fcall":
-            return [node.value];
-        case "field": {
-            const childNodes = [node.parent];
-            if (node.op !== "::") {
-                childNodes.push(node.op);
-            }
-            childNodes.push(node.name);
-            return childNodes;
-        }
-        case "fndptn":
-            return [node.constant, node.left, ...node.values, node.right];
-        case "for":
-            return [node.index, node.collection, node.stmts];
-        case "hash":
-            return [node.cnts];
-        case "heredoc":
-            return [node.beging, ...node.parts];
-        case "hshptn": {
-            const childNodes = [node.constant];
-            node.keywords.forEach(([key, value]) => {
-                childNodes.push(key, value);
-            });
-            childNodes.push(node.kwrest);
-            return childNodes;
-        }
-        case "if":
-            return [node.pred, node.stmts, node.cons];
-        case "ifop":
-            return [node.pred, node.tthy, node.flsy];
-        case "if_mod":
-            return [node.stmt, node.pred];
-        case "in":
-            return [node.pattern, node.stmts, node.cons];
-        case "kwrest_param":
-            return [node.name];
-        case "lambda":
-            return [node.params, node.stmts];
-        case "massign":
-            return [node.target, node.value];
-        case "method_add_arg":
-            return [node.call, node.args];
-        case "method_add_block":
-            return [node.call, node.block];
-        case "mlhs":
-            return node.parts;
-        case "mlhs_paren":
-            return [node.cnts];
-        case "module":
-            return [node.constant, node.bodystmt];
-        case "mrhs":
-            return node.parts;
-        case "mrhs_add_star":
-            return [node.mrhs, node.star];
-        case "mrhs_new_from_args":
-            return [node.args];
-        case "next":
-            return [node.args];
-        case "not":
-            return [node.value];
-        case "opassign":
-            return [node.target, node.op, node.value];
-        case "params": {
-            let childNodes = [...node.reqs];
-            node.opts.forEach(([key, value]) => {
-                childNodes.push(key, value);
-            });
-            childNodes.push(node.rest);
-            childNodes = childNodes.concat(node.posts);
-            node.keywords.forEach(([key, value]) => {
-                childNodes.push(key);
-                if (value) {
-                    childNodes.push(value);
-                }
-            });
-            if (node.kwrest && node.kwrest !== "nil") {
-                childNodes.push(node.kwrest);
-            }
-            if (node.block) {
-                childNodes.push(node.block);
-            }
-            return childNodes;
-        }
-        case "paren":
-            return [node.lparen, node.cnts];
-        case "program":
-            return [node.stmts];
-        case "qsymbols":
-            return [];
-        case "qwords":
-            return [];
-        case "rassign":
-            return [node.value, node.op, node.pattern];
-        case "redo":
-            return [];
-        case "regexp_literal":
-            return node.parts;
-        case "rescue":
-            return [node.extn, node.stmts, node.cons];
-        case "rescue_ex":
-            return [node.extns, node.var];
-        case "rescue_mod":
-            return [node.stmt, node.value];
-        case "rest_param":
-            return [node.name];
-        case "retry":
-            return [];
-        case "return":
-            return [node.args];
-        case "return0":
-            return [];
-        case "sclass":
-            return [node.target, node.bodystmt];
-        case "statements":
-            return node.body;
-        case "string_concat":
-            return [node.left, node.right];
-        case "string_dvar":
-            return [node.var];
-        case "string_embexpr":
-            return [node.stmts];
-        case "string_literal":
-            return node.parts;
-        case "super":
-            return [node.args];
-        case "symbol_literal":
-            return [node.value];
-        case "symbols":
-            return [];
-        case "top_const_field":
-            return [node.constant];
-        case "top_const_ref":
-            return [node.constant];
-        case "unary":
-            return [node.value];
-        case "undef":
-            return node.syms;
-        case "unless":
-            return [node.pred, node.stmts, node.cons];
-        case "unless_mod":
-            return [node.stmt, node.pred];
-        case "until":
-            return [node.pred, node.stmts];
-        case "until_mod":
-            return [node.stmt, node.pred];
-        case "var_alias":
-            return [node.left, node.right];
-        case "var_field":
-            return [node.value];
-        case "var_ref":
-            return [node.value];
-        case "vcall":
-            return [node.value];
-        case "void_stmt":
-            return [];
-        case "when":
-            return [node.args, node.stmts, node.cons];
-        case "while":
-            return [node.pred, node.stmts];
-        case "while_mod":
-            return [node.stmt, node.pred];
-        case "word":
-            return node.parts;
-        case "words":
-            return [];
-        case "xstring_literal":
-            return node.parts;
-        case "yield":
-            return [node.args];
-        case "yield0":
-            return [];
-        case "zsuper":
-            return [];
-        default:
-            throwBadNode(node);
-    }
-}
-exports.default = getChildNodes;

data/dist/utils/getTrailingComma.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function getTrailingComma(opts) {
-    return ["all", "es5"].includes(opts.trailingComma);
-}
-exports.default = getTrailingComma;

data/dist/utils/hasAncestor.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function hasAncestor(path, types) {
-    let parent = 0;
-    let parentNode = path.getParentNode();
-    while (parentNode) {
-        if (types.includes(parentNode.type)) {
-            return true;
-        }
-        parent += 1;
-        parentNode = path.getParentNode(parent);
-    }
-    return false;
-}
-exports.default = hasAncestor;

data/dist/utils/inlineEnsureParens.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const needsParens = [
-    "args",
-    "assign",
-    "assoc",
-    "binary",
-    "call",
-    "massign",
-    "opassign"
-];
-// If you have a modifier statement (for instance an inline if statement or an
-// inline while loop) there are times when you need to wrap the entire statement
-// in parentheses. This occurs when you have something like:
-//
-//     foo[:foo] =
-//       if bar?
-//         baz
-//       end
-//
-// Normally we would shorten this to an inline version, which would result in:
-//
-//     foo[:foo] = baz if bar?
-//
-// but this actually has different semantic meaning. The first example will
-// result in a nil being inserted into the hash for the :foo key, whereas the
-// second example will result in an empty hash because the if statement applies
-// to the entire assignment.
-//
-// We can fix this in a couple of ways. We can use the then keyword, as in:
-//
-//     foo[:foo] = if bar? then baz end
-//
-// but I haven't actually seen this anywhere. We can also just leave it as is
-// with the multi-line version, but for a short predicate and short value it
-// looks pretty silly. The last option and the one I've selected here is to add
-// parentheses on both sides of the expression, as in:
-//
-//     foo[:foo] = (baz if bar?)
-//
-// This approach maintains the nice conciseness of the inline version, while
-// keeping the correct semantic meaning.
-function inlineEnsureParens(path, parts) {
-    if (needsParens.includes(path.getParentNode().type)) {
-        return ["(", ...parts, ")"];
-    }
-    return parts;
-}
-exports.default = inlineEnsureParens;

data/dist/utils/isEmptyBodyStmt.js

@@ -1,10 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const isEmptyStmts_1 = __importDefault(require("./isEmptyStmts"));
-function isEmptyBodyStmt(node) {
-    return (0, isEmptyStmts_1.default)(node.stmts) && !node.rsc && !node.ens && !node.els;
-}
-exports.default = isEmptyBodyStmt;

data/dist/utils/isEmptyParams.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function isEmptyParams(node) {
-    return (node.reqs.length === 0 &&
-        node.opts.length === 0 &&
-        !node.rest &&
-        node.posts.length === 0 &&
-        node.keywords.length === 0 &&
-        !node.kwrest &&
-        !node.block);
-}
-exports.default = isEmptyParams;

data/dist/utils/isEmptyStmts.js

@@ -1,10 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function isEmptyStmts(node) {
-    return (node &&
-        node.type === "statements" &&
-        node.body.length === 1 &&
-        node.body[0].type === "void_stmt" &&
-        !node.body[0].comments);
-}
-exports.default = isEmptyStmts;

data/dist/utils/literal.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-function literal(value) {
-    return function printLiteral() {
-        return value;
-    };
-}
-exports.default = literal;

data/dist/utils/literallineWithoutBreakParent.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const literallineWithoutBreakParent = {
-    type: "line",
-    hard: true,
-    literal: true
-};
-exports.default = literallineWithoutBreakParent;