prettier 1.6.1 → 2.0.0.pre.rc1

data/dist/ruby/printer.js

@@ -0,0 +1,125 @@
+"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 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 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. The types on this are a little
+    // abysmal, but we're going to leave it as is to get this out.
+    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 "paren":
+                return [node.lparen, node.body[0]];
+            default: {
+                if (Array.isArray(node.body)) {
+                    return node.body.filter((child) => child && typeof child === "object");
+                }
+                return [];
+            }
+        }
+    },
+    // 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) {
+            return printer(path, opts, print);
+        }
+        if (node.type[0] === "@") {
+            return node.body;
+        }
+        throw new Error(`Unsupported node encountered: ${node.type}`);
+    },
+    // 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

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+function isCall(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) {
+    const [variables, blockContents] = node.body;
+    // Ensure that there are variables being passed to this block.
+    const params = variables && variables.body[0];
+    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)) {
+        return null;
+    }
+    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)) {
+            return null;
+        }
+        statements = blockStatements;
+    }
+    else {
+        // We’re in a brace block
+        statements = blockContents;
+    }
+    // Ensure the block contains only one statement
+    if (statements.body.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) {
+        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") {
+        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;
+    if (path.getValue().type === "method_add_block") {
+        assocNode = path.getParentNode();
+    }
+    else {
+        assocNode = path.getParentNode(2);
+    }
+    if (assocNode && assocNode.type === "assoc_new") {
+        const [key] = assocNode.body;
+        if (key.type === "@label" && ["if:", "unless:"].includes(key.body)) {
+            return null;
+        }
+        if (key.type === "symbol_literal" &&
+            ["if", "unless"].includes(key.body[0].body)) {
+            return null;
+        }
+    }
+    return `&:${method.body}`;
+}
+exports.default = toProc;

data/dist/types/haml.js

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

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

data/dist/types/rbs.js

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

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

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

data/dist/types.js

@@ -0,0 +1,30 @@
+"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]; } });
+}) : (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

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// 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;
+    }
+    const anyNode = node;
+    return Array.isArray(anyNode.body) && anyNode.body.some(containsAssignment);
+}
+exports.default = containsAssignment;

data/dist/utils/getTrailingComma.js

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

@@ -0,0 +1,15 @@
+"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/{src → dist}/utils/inlineEnsureParens.js

@@ -1,13 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
 const needsParens = [
-  "args",
-  "assign",
-  "assoc_new",
-  "binary",
-  "call",
-  "massign",
-  "opassign"
+    "args",
+    "assign",
+    "assoc_new",
+    "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:
@@ -39,12 +40,10 @@ const needsParens = [
 //
 // This approach maintains the nice conciseness of the inline version, while
 // keeping the correct semantic meaning.
-const inlineEnsureParens = (path, parts) => {
-  if (needsParens.includes(path.getParentNode().type)) {
-    return ["("].concat(parts, ")");
-  }
-
-  return parts;
-};
-
-module.exports = inlineEnsureParens;
+function inlineEnsureParens(path, parts) {
+    if (needsParens.includes(path.getParentNode().type)) {
+        return ["(", ...parts, ")"];
+    }
+    return parts;
+}
+exports.default = inlineEnsureParens;

data/dist/utils/isEmptyBodyStmt.js

@@ -0,0 +1,10 @@
+"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.body[0]) && !node.body.slice(1).some(Boolean);
+}
+exports.default = isEmptyBodyStmt;

data/dist/utils/isEmptyStmts.js

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

data/dist/utils/literal.js

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

data/dist/utils/literallineWithoutBreakParent.js

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

data/dist/utils/makeCall.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const makeCall = (path, opts, print) => {
+    const operation = path.getValue().body[1];
+    // 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;
+    }
+    return operation === "::" ? "." : path.call(print, "body", 1);
+};
+exports.default = makeCall;

data/dist/utils/noIndent.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const noIndent = [
+    "array",
+    "hash",
+    "heredoc",
+    "if",
+    "unless",
+    "xstring_literal"
+];
+exports.default = noIndent;

data/dist/utils/printEmptyCollection.js

@@ -0,0 +1,44 @@
+"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 { group, hardline, indent, join, line } = prettier_1.default;
+function containedWithin(node) {
+    return function containedWithinNode(comment) {
+        return comment.sc >= node.sc && comment.ec <= node.ec;
+    };
+}
+// Empty collections are array or hash literals that do not contain any
+// contents. They can, however, have comments inside the body. You can solve
+// this by having a child node inside the array that gets the comments attached
+// to it, but that requires modifying the parser. Instead, we can just manually
+// print out the non-leading comments here.
+function printEmptyCollection(path, opts, startToken, endToken) {
+    const node = path.getValue();
+    const containedWithinNode = containedWithin(node);
+    // If there are no comments or only leading comments, then we can just print
+    // out the start and end token and be done, as there are no comments inside
+    // the body of this node.
+    if (!node.comments || !node.comments.some(containedWithinNode)) {
+        return `${startToken}${endToken}`;
+    }
+    const comments = [];
+    const nodePath = path;
+    // For each comment, go through its path and print it out manually.
+    nodePath.each((commentPath) => {
+        const comment = commentPath.getValue();
+        if (containedWithinNode(comment)) {
+            comment.printed = true;
+            comments.push(opts.printer.printComment(commentPath, opts));
+        }
+    }, "comments");
+    return group([
+        startToken,
+        indent([hardline, join(hardline, comments)]),
+        line,
+        endToken
+    ]);
+}
+exports.default = printEmptyCollection;

data/dist/utils/skipAssignIndent.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const skippable = [
+    "array",
+    "dyna_symbol",
+    "hash",
+    "heredoc",
+    "lambda",
+    "regexp_literal"
+];
+function skipAssignIndent(node) {
+    return (skippable.includes(node.type) ||
+        (node.type === "call" && skipAssignIndent(node.body[0])));
+}
+exports.default = skipAssignIndent;

data/dist/utils.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skipAssignIndent = exports.printEmptyCollection = exports.noIndent = exports.makeCall = exports.literallineWithoutBreakParent = exports.literal = exports.inlineEnsureParens = exports.hasAncestor = exports.isEmptyStmts = exports.isEmptyBodyStmt = exports.getTrailingComma = exports.containsAssignment = void 0;
+var containsAssignment_1 = require("./utils/containsAssignment");
+Object.defineProperty(exports, "containsAssignment", { enumerable: true, get: function () { return __importDefault(containsAssignment_1).default; } });
+var getTrailingComma_1 = require("./utils/getTrailingComma");
+Object.defineProperty(exports, "getTrailingComma", { enumerable: true, get: function () { return __importDefault(getTrailingComma_1).default; } });
+var isEmptyBodyStmt_1 = require("./utils/isEmptyBodyStmt");
+Object.defineProperty(exports, "isEmptyBodyStmt", { enumerable: true, get: function () { return __importDefault(isEmptyBodyStmt_1).default; } });
+var isEmptyStmts_1 = require("./utils/isEmptyStmts");
+Object.defineProperty(exports, "isEmptyStmts", { enumerable: true, get: function () { return __importDefault(isEmptyStmts_1).default; } });
+var hasAncestor_1 = require("./utils/hasAncestor");
+Object.defineProperty(exports, "hasAncestor", { enumerable: true, get: function () { return __importDefault(hasAncestor_1).default; } });
+var inlineEnsureParens_1 = require("./utils/inlineEnsureParens");
+Object.defineProperty(exports, "inlineEnsureParens", { enumerable: true, get: function () { return __importDefault(inlineEnsureParens_1).default; } });
+var literal_1 = require("./utils/literal");
+Object.defineProperty(exports, "literal", { enumerable: true, get: function () { return __importDefault(literal_1).default; } });
+var literallineWithoutBreakParent_1 = require("./utils/literallineWithoutBreakParent");
+Object.defineProperty(exports, "literallineWithoutBreakParent", { enumerable: true, get: function () { return __importDefault(literallineWithoutBreakParent_1).default; } });
+var makeCall_1 = require("./utils/makeCall");
+Object.defineProperty(exports, "makeCall", { enumerable: true, get: function () { return __importDefault(makeCall_1).default; } });
+var noIndent_1 = require("./utils/noIndent");
+Object.defineProperty(exports, "noIndent", { enumerable: true, get: function () { return __importDefault(noIndent_1).default; } });
+var printEmptyCollection_1 = require("./utils/printEmptyCollection");
+Object.defineProperty(exports, "printEmptyCollection", { enumerable: true, get: function () { return __importDefault(printEmptyCollection_1).default; } });
+var skipAssignIndent_1 = require("./utils/skipAssignIndent");
+Object.defineProperty(exports, "skipAssignIndent", { enumerable: true, get: function () { return __importDefault(skipAssignIndent_1).default; } });