prettier 2.0.0 → 2.1.0

data/dist/ruby/printer.js

@@ -4,18 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (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",
-    "args_add_star",
-    "mlhs",
-    "mlhs_add_post",
-    "mlhs_add_star",
-    "mlhs_paren"
-];
+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
@@ -25,61 +18,9 @@ const printer = {
     },
     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. The types on this are a little
-    // abysmal, but we're going to leave it as is to get this out.
+    // find where it needs to attach the comments.
     getCommentChildNodes(node) {
-        switch (node.type) {
-            case "heredoc":
-                return [node.beging];
-            case "aryptn":
-                return [node.body[0]]
-                    .concat(node.body[1])
-                    .concat(node.body[2])
-                    .concat(node.body[3]);
-            case "hshptn": {
-                const pairs = node.body[1];
-                const values = pairs.reduce((left, right) => left.concat(right), []);
-                return [node.body[0]].concat(values).concat(node.body[2]);
-            }
-            case "params": {
-                const [reqs, optls, rest, post, kwargs, kwargRest, block] = node.body;
-                let parts = reqs || [];
-                (optls || []).forEach((optl) => {
-                    parts = parts.concat(optl);
-                });
-                if (rest) {
-                    parts.push(rest);
-                }
-                parts = parts.concat(post || []);
-                (kwargs || []).forEach((kwarg) => {
-                    if (kwarg[1]) {
-                        parts = parts.concat(kwarg);
-                    }
-                    else {
-                        parts.push(kwarg[0]);
-                    }
-                });
-                if (kwargRest && kwargRest !== "nil") {
-                    parts.push(kwargRest);
-                }
-                if (block) {
-                    parts.push(block);
-                }
-                return parts;
-            }
-            case "brace_block":
-                return [node.body[0], node.body[1], node.beging];
-            case "do_block":
-                return [node.body[0], node.body[1], node.beging];
-            case "paren":
-                return [node.lparen, node.body[0]];
-            default: {
-                if (Array.isArray(node.body)) {
-                    return node.body.filter((child) => child && typeof child === "object");
-                }
-                return [];
-            }
-        }
+        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
@@ -94,7 +35,7 @@ const printer = {
     // *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";
+        return comment.type === "embdoc";
     },
     // This function handles adding the format pragma to a source string. This is
     // an optional workflow for incremental adoption.
@@ -107,20 +48,17 @@ const printer = {
     print(path, opts, print) {
         const node = path.getValue();
         const printer = nodes_1.default[node.type];
-        if (printer) {
-            return printer(path, opts, print);
-        }
-        if (node.type[0] === "@") {
-            return node.body;
+        if (!printer) {
+            throw new Error(`Unsupported node type: ${node.type}`);
         }
-        throw new Error(`Unsupported node encountered: ${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") {
+        if (comment.type === "comment") {
             return `#${comment.value}`;
         }
         return [trim, comment.value];

data/dist/ruby/toProc.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-function isCall(node) {
+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";
+    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
@@ -20,74 +20,72 @@ function isCall(node) {
 //
 // This works with `do` blocks as well.
 function toProc(path, node) {
-    const [variables, blockContents] = node.body;
     // Ensure that there are variables being passed to this block.
-    const params = variables && variables.body[0];
+    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.
-    const reqParams = params.body[0];
-    const otherParams = params.body.slice(1);
-    if (!Array.isArray(reqParams) ||
-        reqParams.length !== 1 ||
-        otherParams.some(Boolean)) {
+    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 (blockContents.type === "bodystmt") {
-        // We’re in a `do` block
-        const blockStatements = blockContents.body[0];
-        const rescueElseEnsure = blockContents.body.slice(1);
-        // You can’t use the to_proc shortcut if you’re rescuing
-        if (rescueElseEnsure.some(Boolean)) {
+    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 = blockStatements;
+        statements = node.bodystmt.stmts.body;
     }
     else {
-        // We’re in a brace block
-        statements = blockContents;
+        statements = node.stmts.body;
     }
     // Ensure the block contains only one statement
-    if (statements.body.length !== 1) {
+    if (statements.length !== 1) {
         return null;
     }
     // Ensure that statement is a call and that it has no comments attached
-    const [statement] = statements.body;
-    if (statement.type !== "call" || statement.comments) {
+    const [call] = statements;
+    if (call.type !== "call" || call.comments) {
         return null;
     }
     // Ensure the call is a method of the block argument
-    const [varRef, call, method] = statement.body;
-    if (varRef.type !== "var_ref" ||
-        varRef.body[0].body !== reqParams[0].body ||
-        !isCall(call) ||
-        method === "call" ||
-        method.type !== "@ident") {
+    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 assocNode = null;
+    let parentNode = null;
     if (path.getValue().type === "method_add_block") {
-        assocNode = path.getParentNode();
+        parentNode = path.getParentNode();
     }
     else {
-        assocNode = path.getParentNode(2);
+        parentNode = path.getParentNode(2);
     }
-    if (assocNode && assocNode.type === "assoc_new") {
-        const [key] = assocNode.body;
-        if (key.type === "@label" && ["if:", "unless:"].includes(key.body)) {
+    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.body[0].body)) {
+            ["if", "unless"].includes(key.value.value)) {
             return null;
         }
     }
-    return `&:${method.body}`;
+    return `&:${call.message.value}`;
 }
 exports.default = toProc;

data/dist/types.js

@@ -1,7 +1,11 @@
 "use strict";
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
-    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[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];

data/dist/utils/containsAssignment.js

@@ -1,5 +1,9 @@
 "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) {
@@ -9,7 +13,6 @@ function containsAssignment(node) {
     if (["assign", "massign", "opassign"].includes(node.type)) {
         return true;
     }
-    const anyNode = node;
-    return Array.isArray(anyNode.body) && anyNode.body.some(containsAssignment);
+    return (0, getChildNodes_1.default)(node).some(containsAssignment);
 }
 exports.default = containsAssignment;

data/dist/utils/getChildNodes.js

@@ -0,0 +1,305 @@
+"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/inlineEnsureParens.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const needsParens = [
     "args",
     "assign",
-    "assoc_new",
+    "assoc",
     "binary",
     "call",
     "massign",

data/dist/utils/isEmptyBodyStmt.js

@@ -5,6 +5,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const isEmptyStmts_1 = __importDefault(require("./isEmptyStmts"));
 function isEmptyBodyStmt(node) {
-    return (0, isEmptyStmts_1.default)(node.body[0]) && !node.body.slice(1).some(Boolean);
+    return (0, isEmptyStmts_1.default)(node.stmts) && !node.rsc && !node.ens && !node.els;
 }
 exports.default = isEmptyBodyStmt;

data/dist/utils/isEmptyParams.js

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

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

data/dist/utils/makeCall.js

@@ -1,13 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const makeCall = (path, opts, print) => {
-    const operation = path.getValue().body[1];
+    const node = path.getValue();
+    const operator = node.op;
     // Ignoring the next block for coverage information because it's only relevant
     // in Ruby 2.5 and below.
     /* istanbul ignore next */
-    if ([".", "&."].includes(operation)) {
-        return operation;
+    if ([".", "&."].includes(operator)) {
+        return operator;
     }
-    return operation === "::" ? "." : path.call(print, "body", 1);
+    return operator === "::" ? "." : path.call(print, "op");
 };
 exports.default = makeCall;

data/dist/utils/printEmptyCollection.js

@@ -4,10 +4,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const prettier_1 = __importDefault(require("../prettier"));
+const location_1 = require("../ruby/location");
 const { group, hardline, indent, join, line } = prettier_1.default;
 function containedWithin(node) {
     return function containedWithinNode(comment) {
-        return comment.sc >= node.sc && comment.ec <= node.ec;
+        return ((0, location_1.getStartChar)(comment.loc) >= (0, location_1.getStartChar)(node.loc) &&
+            (0, location_1.getEndChar)(comment.loc) <= (0, location_1.getEndChar)(node.loc));
     };
 }
 // Empty collections are array or hash literals that do not contain any

data/dist/utils/skipAssignIndent.js

@@ -6,10 +6,14 @@ const skippable = [
     "hash",
     "heredoc",
     "lambda",
-    "regexp_literal"
+    "qsymbols",
+    "qwords",
+    "regexp_literal",
+    "symbols",
+    "words"
 ];
 function skipAssignIndent(node) {
     return (skippable.includes(node.type) ||
-        (node.type === "call" && skipAssignIndent(node.body[0])));
+        (node.type === "call" && skipAssignIndent(node.receiver)));
 }
 exports.default = skipAssignIndent;