prettier 1.6.1 → 2.0.0.pre.rc1

data/dist/ruby/nodes/loops.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printUntilModifer = exports.printUntil = exports.printWhileModifier = exports.printWhile = exports.printFor = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const utils_1 = require("../../utils");
+const { align, breakParent, group, hardline, ifBreak, indent, join, softline } = prettier_1.default;
+function printLoop(keyword, modifier) {
+    return function printLoopWithOptions(path, { rubyModifier }, print) {
+        const [, stmts] = path.getValue().body;
+        // If the only statement inside this while loop is a void statement, then we
+        // can shorten to just displaying the predicate and then a semicolon.
+        if ((0, utils_1.isEmptyStmts)(stmts)) {
+            return group([
+                group([keyword, " ", path.call(print, "body", 0)]),
+                hardline,
+                "end"
+            ]);
+        }
+        const inlineLoop = (0, utils_1.inlineEnsureParens)(path, [
+            path.call(print, "body", 1),
+            ` ${keyword} `,
+            path.call(print, "body", 0)
+        ]);
+        // If we're in the modifier form and we're modifying a `begin`, then this is
+        // a special case where we need to explicitly use the modifier form because
+        // otherwise the semantic meaning changes. This looks like:
+        //
+        //     begin
+        //       foo
+        //     end while bar
+        //
+        // The above is effectively a `do...while` loop (which we don't have in
+        // ruby).
+        if (modifier && path.getValue().body[1].type === "begin") {
+            return inlineLoop;
+        }
+        const blockLoop = [
+            [`${keyword} `, align(keyword.length + 1, path.call(print, "body", 0))],
+            indent([softline, path.call(print, "body", 1)]),
+            softline,
+            "end"
+        ];
+        // If we're disallowing inline loops or if the predicate of the loop
+        // contains an assignment (in which case we can't know for certain that that
+        // assignment doesn't impact the statements inside the loop) then we can't
+        // use the modifier form and we must use the block form.
+        if (!rubyModifier || (0, utils_1.containsAssignment)(path.getValue().body[0])) {
+            return [breakParent, blockLoop];
+        }
+        return group(ifBreak(blockLoop, inlineLoop));
+    };
+}
+const printFor = (path, opts, print) => {
+    const [varDoc, rangeDoc, stmtsDoc] = path.map(print, "body");
+    const varsDoc = path.getValue().body[0].type === "mlhs" ? join(", ", varDoc) : varDoc;
+    return group([
+        "for ",
+        varsDoc,
+        " in ",
+        rangeDoc,
+        indent([hardline, stmtsDoc]),
+        hardline,
+        "end"
+    ]);
+};
+exports.printFor = printFor;
+exports.printWhile = printLoop("while", false);
+exports.printWhileModifier = printLoop("while", true);
+exports.printUntil = printLoop("until", false);
+exports.printUntilModifer = printLoop("until", true);

data/dist/ruby/nodes/massign.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printMRHSNewFromArgs = exports.printMRHSAddStar = exports.printMRHS = exports.printMLHSParen = exports.printMLHSAddStar = exports.printMLHSAddPost = exports.printMLHS = exports.printMAssign = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const { group, indent, join, line, softline } = prettier_1.default;
+const printMAssign = (path, opts, print) => {
+    let right = path.call(print, "body", 1);
+    if (["mrhs_add_star", "mrhs_new_from_args"].includes(path.getValue().body[1].type)) {
+        right = group(join([",", line], right));
+    }
+    const parts = [join([",", line], path.call(print, "body", 0))];
+    if (path.getValue().body[0].comma) {
+        parts.push(",");
+    }
+    return group([group(parts), " =", indent([line, right])]);
+};
+exports.printMAssign = printMAssign;
+const printMLHS = (path, opts, print) => {
+    return path.map(print, "body");
+};
+exports.printMLHS = printMLHS;
+const printMLHSAddPost = (path, opts, print) => {
+    return [
+        ...path.call(print, "body", 0),
+        ...path.call(print, "body", 1)
+    ];
+};
+exports.printMLHSAddPost = printMLHSAddPost;
+const printMLHSAddStar = (path, opts, print) => {
+    const parts = ["*"];
+    if (path.getValue().body[1]) {
+        parts.push(path.call(print, "body", 1));
+    }
+    return [...path.call(print, "body", 0), parts];
+};
+exports.printMLHSAddStar = printMLHSAddStar;
+const printMLHSParen = (path, opts, print) => {
+    if (["massign", "mlhs_paren"].includes(path.getParentNode().type)) {
+        // If we're nested in brackets as part of the left hand side of an
+        // assignment, i.e., (a, b, c) = 1, 2, 3
+        // ignore the current node and just go straight to the content
+        return path.call(print, "body", 0);
+    }
+    const parts = [
+        softline,
+        join([",", line], path.call(print, "body", 0))
+    ];
+    if (path.getValue().body[0].comma) {
+        parts.push(",");
+    }
+    return group(["(", indent(parts), [softline, ")"]]);
+};
+exports.printMLHSParen = printMLHSParen;
+const printMRHS = (path, opts, print) => {
+    return path.map(print, "body");
+};
+exports.printMRHS = printMRHS;
+const printMRHSAddStar = (path, opts, print) => {
+    const [leftDoc, rightDoc] = path.map(print, "body");
+    return [...leftDoc, ["*", rightDoc]];
+};
+exports.printMRHSAddStar = printMRHSAddStar;
+const printMRHSNewFromArgs = (path, opts, print) => {
+    const parts = path.call(print, "body", 0);
+    if (path.getValue().body[1]) {
+        parts.push(path.call(print, "body", 1));
+    }
+    return parts;
+};
+exports.printMRHSNewFromArgs = printMRHSNewFromArgs;

data/dist/ruby/nodes/methods.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printAccessControl = exports.printSingleLineMethod = exports.printDef = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const utils_1 = require("../../utils");
+const { group, hardline, indent, line } = prettier_1.default;
+const printDef = (path, opts, print) => {
+    const node = path.getValue();
+    const declaration = ["def "];
+    let paramsNode;
+    let bodystmtNode;
+    let nameDoc;
+    let paramsDoc;
+    let bodystmtDoc;
+    if (node.type === "def") {
+        paramsNode = node.body[1];
+        bodystmtNode = node.body[2];
+        nameDoc = path.call(print, "body", 0);
+        paramsDoc = path.call(print, "body", 1);
+        bodystmtDoc = path.call(print, "body", 2);
+    }
+    else {
+        // In this case, we're printing a method that's defined as a singleton, so
+        // we need to include the target and the operator
+        declaration.push(path.call(print, "body", 0), path.call(print, "body", 1));
+        paramsNode = node.body[3];
+        bodystmtNode = node.body[4];
+        nameDoc = path.call(print, "body", 2);
+        paramsDoc = path.call(print, "body", 3);
+        bodystmtDoc = path.call(print, "body", 4);
+    }
+    // In case there are no parens but there are arguments
+    const parens = paramsNode.type === "params" && paramsNode.body.some((type) => type);
+    declaration.push(nameDoc, parens ? "(" : "", paramsDoc, parens ? ")" : "");
+    if ((0, utils_1.isEmptyBodyStmt)(bodystmtNode)) {
+        return group([...declaration, "; end"]);
+    }
+    return group([
+        group(declaration),
+        indent([hardline, bodystmtDoc]),
+        hardline,
+        "end"
+    ]);
+};
+exports.printDef = printDef;
+const printSingleLineMethod = (path, opts, print) => {
+    const parensNode = path.getValue().body[1];
+    let paramsDoc = "";
+    if (parensNode) {
+        const paramsNode = parensNode.body[0];
+        if (paramsNode.body.some((type) => type)) {
+            paramsDoc = path.call(print, "body", 1);
+        }
+    }
+    return group([
+        "def ",
+        path.call(print, "body", 0),
+        paramsDoc,
+        " =",
+        indent(group([line, path.call(print, "body", 2)]))
+    ]);
+};
+exports.printSingleLineMethod = printSingleLineMethod;
+const printAccessControl = (path, opts, print) => {
+    return path.call(print, "body", 0);
+};
+exports.printAccessControl = printAccessControl;

data/dist/ruby/nodes/operators.js

@@ -0,0 +1,70 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printUnary = exports.printDot3 = exports.printDot2 = exports.printBinary = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const utils_1 = require("../../utils");
+const { group, indent, line, softline } = prettier_1.default;
+const printBinary = (path, opts, print) => {
+    const [, operator, rightNode] = path.getValue().body;
+    const space = operator === "**" ? "" : " ";
+    if (utils_1.noIndent.includes(rightNode.type)) {
+        return group([
+            group(path.call(print, "body", 0)),
+            space,
+            operator,
+            space,
+            group(path.call(print, "body", 2))
+        ]);
+    }
+    return group([
+        group(path.call(print, "body", 0)),
+        space,
+        group(indent([
+            operator,
+            space === "" ? softline : line,
+            path.call(print, "body", 2)
+        ]))
+    ]);
+};
+exports.printBinary = printBinary;
+// dot2 nodes are used with ranges (or flip-flops). They can optionally drop
+// their left side for beginless ranges or their right side for endless ranges.
+const printDot2 = (path, opts, print) => {
+    const [leftNode, rightNode] = path.getValue().body;
+    return [
+        leftNode ? path.call(print, "body", 0) : "",
+        "..",
+        rightNode ? path.call(print, "body", 1) : ""
+    ];
+};
+exports.printDot2 = printDot2;
+// dot3 nodes are used with ranges (or flip-flops). They can optionally drop
+// their left side for beginless ranges or their right side for endless ranges.
+const printDot3 = (path, opts, print) => {
+    const [leftNode, rightNode] = path.getValue().body;
+    return [
+        leftNode ? path.call(print, "body", 0) : "",
+        "...",
+        rightNode ? path.call(print, "body", 1) : ""
+    ];
+};
+exports.printDot3 = printDot3;
+const printUnary = (path, opts, print) => {
+    const node = path.getValue();
+    const contentsDoc = path.call(print, "body", 0);
+    if (node.oper === "not") {
+        // Here we defer to the original source, as it's kind of difficult to
+        // determine if we can actually remove the parentheses being used.
+        if (node.paren) {
+            return ["not", "(", contentsDoc, ")"];
+        }
+        else {
+            return ["not", " ", contentsDoc];
+        }
+    }
+    return [node.oper, contentsDoc];
+};
+exports.printUnary = printUnary;

data/dist/ruby/nodes/params.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printRestParam = exports.printKeywordRestParam = exports.printArgsForward = exports.printParams = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const utils_1 = require("../../utils");
+const { group, hardline, join, indent, line, lineSuffix, softline } = prettier_1.default;
+function printRestParamSymbol(symbol) {
+    return function printRestParamWithSymbol(path, opts, print) {
+        return path.getValue().body[0]
+            ? [symbol, path.call(print, "body", 0)]
+            : symbol;
+    };
+}
+const printParams = (path, opts, print) => {
+    const [reqs, optls, rest, post, kwargs, kwargRest, block] = path.getValue().body;
+    let parts = [];
+    if (reqs) {
+        path.each((reqPath) => {
+            // For some very strange reason, if you have a comment attached to a
+            // rest_param, it shows up here in the list of required params.
+            if (reqPath.getValue().type !== "rest_param") {
+                parts.push(print(reqPath));
+            }
+        }, "body", 0);
+    }
+    if (optls) {
+        parts = parts.concat(path.map((optlPath) => join(" = ", optlPath.map(print)), "body", 1));
+    }
+    if (rest && rest.type !== "excessed_comma") {
+        parts.push(path.call(print, "body", 2));
+    }
+    if (post) {
+        parts = parts.concat(path.map(print, "body", 3));
+    }
+    if (kwargs) {
+        parts = parts.concat(path.map((kwargPath) => {
+            if (!kwargPath.getValue()[1]) {
+                return kwargPath.call(print, 0);
+            }
+            return group(join(" ", kwargPath.map(print)));
+        }, "body", 4));
+    }
+    if (kwargRest) {
+        parts.push(kwargRest === "nil" ? "**nil" : path.call(print, "body", 5));
+    }
+    if (block) {
+        parts.push(path.call(print, "body", 6));
+    }
+    const contents = [join([",", line], parts)];
+    // You can put an extra comma at the end of block args between pipes to
+    // change what it does. Below is the difference:
+    //
+    // [[1, 2], [3, 4]].each { |x| p x } # prints [1, 2] then [3, 4]
+    // [[1, 2], [3, 4]].each { |x,| p x } # prints 1 then 3
+    //
+    // In ruby 2.5, the excessed comma is indicated by having a 0 in the rest
+    // param position. In ruby 2.6+ it's indicated by having an "excessed_comma"
+    // node in the rest position. Seems odd, but it's true.
+    if (rest === 0 || (rest && rest.type === "excessed_comma")) {
+        contents.push(",");
+    }
+    // If the parent node is a paren then we skipped printing the parentheses so
+    // that we could handle them here and get nicer formatting.
+    const parentNode = path.getParentNode();
+    if (["lambda", "paren"].includes(parentNode.type)) {
+        const parts = ["("];
+        // If the parent node is a paren and the paren has comments that are
+        // attached to the left paren, then we need to print those out explicitly
+        // here.
+        if (parentNode.type === "paren" && parentNode.lparen.comments) {
+            const comments = [];
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            parentNode.lparen.comments.forEach((comment, index) => {
+                comment.printed = true;
+                comments.push(lineSuffix(`${index === 0 ? " " : ""}#${comment.value}`));
+            });
+            parts.push(join(hardline, comments));
+        }
+        return group([...parts, indent([softline, ...contents]), softline, ")"]);
+    }
+    return group(contents);
+};
+exports.printParams = printParams;
+exports.printArgsForward = (0, utils_1.literal)("...");
+exports.printKeywordRestParam = printRestParamSymbol("**");
+exports.printRestParam = printRestParamSymbol("*");

data/dist/ruby/nodes/patterns.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printRAssign = exports.printIn = exports.printHshPtn = exports.printFndPtn = exports.printAryPtn = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const { align, group, hardline, indent, join, line } = prettier_1.default;
+const patterns = ["aryptn", "binary", "fndptn", "hshptn", "rassign"];
+const printPatternArg = (path, opts, print) => {
+    // Pinning is a really special syntax in pattern matching that's not really
+    // all that well supported in ripper. Here we're just going to the original
+    // source to see if the variable is pinned.
+    if (opts.originalText &&
+        opts.originalText[opts.locStart(path.getValue()) - 1] === "^") {
+        return ["^", path.call(print)];
+    }
+    return path.call(print);
+};
+const printAryPtn = (path, opts, print) => {
+    const [constant, preargs, splatarg, postargs] = path.getValue().body;
+    let args = [];
+    if (preargs) {
+        args = args.concat(path.map((argPath) => printPatternArg(argPath, opts, print), "body", 1));
+    }
+    if (splatarg) {
+        args.push(["*", path.call(print, "body", 2)]);
+    }
+    if (postargs) {
+        args = args.concat(path.map(print, "body", 3));
+    }
+    args = group(join([",", line], args));
+    if (constant || patterns.includes(path.getParentNode().type)) {
+        args = ["[", args, "]"];
+    }
+    if (constant) {
+        return [path.call(print, "body", 0), args];
+    }
+    return args;
+};
+exports.printAryPtn = printAryPtn;
+const printFndPtn = (path, opts, print) => {
+    const [constant] = path.getValue().body;
+    const docs = [
+        "[",
+        group(join([",", line], [
+            ["*", path.call(print, "body", 1)],
+            ...path.map(print, "body", 2),
+            ["*", path.call(print, "body", 3)]
+        ])),
+        "]"
+    ];
+    if (constant) {
+        return [path.call(print, "body", 0), docs];
+    }
+    return docs;
+};
+exports.printFndPtn = printFndPtn;
+const printHshPtn = (path, opts, print) => {
+    const [constant, keyValuePairs, keyValueRest] = path.getValue().body;
+    let args = [];
+    if (keyValuePairs.length > 0) {
+        const printPair = (pairPath) => {
+            const parts = [pairPath.call(print, 0)];
+            if (pairPath.getValue()[1]) {
+                parts.push(" ", pairPath.call((pairValuePath) => printPatternArg(pairValuePath, opts, print), 1));
+            }
+            return parts;
+        };
+        args = args.concat(path.map(printPair, "body", 1));
+    }
+    if (keyValueRest) {
+        args.push(["**", path.call(print, "body", 2)]);
+    }
+    args = group(join([",", line], args));
+    if (constant) {
+        args = ["[", args, "]"];
+    }
+    else if (patterns.includes(path.getParentNode().type)) {
+        args = ["{ ", args, " }"];
+    }
+    if (constant) {
+        return [path.call(print, "body", 0), args];
+    }
+    return args;
+};
+exports.printHshPtn = printHshPtn;
+const printIn = (path, opts, print) => {
+    const parts = [
+        "in ",
+        align("in ".length, path.call((valuePath) => printPatternArg(valuePath, opts, print), "body", 0)),
+        indent([hardline, path.call(print, "body", 1)])
+    ];
+    if (path.getValue().body[2]) {
+        parts.push(hardline, path.call(print, "body", 2));
+    }
+    return group(parts);
+};
+exports.printIn = printIn;
+const printRAssign = (path, opts, print) => {
+    const { keyword } = path.getValue();
+    const [leftDoc, rightDoc] = path.map(print, "body");
+    return group([
+        leftDoc,
+        keyword ? " in" : " =>",
+        group(indent([line, rightDoc]))
+    ]);
+};
+exports.printRAssign = printRAssign;

data/dist/ruby/nodes/regexp.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printRegexpLiteral = void 0;
+const utils_1 = require("../../utils");
+function hasContent(node, pattern) {
+    return node.body.some((child) => child.type === "@tstring_content" && pattern.test(child.body));
+}
+// If the first part of this regex is plain string content, we have a space
+// or an =, and we're contained within a command or command_call node, then we
+// want to use braces because otherwise we could end up with an ambiguous
+// operator, e.g. foo / bar/ or foo /=bar/
+function forwardSlashIsAmbiguous(path) {
+    const node = path.getValue();
+    const firstChildNode = node.body[0];
+    return (firstChildNode &&
+        firstChildNode.type === "@tstring_content" &&
+        [" ", "="].includes(firstChildNode.body[0]) &&
+        (0, utils_1.hasAncestor)(path, ["command", "command_call"]));
+}
+// This function is responsible for printing out regexp_literal nodes. They can
+// either use the special %r literal syntax or they can use forward slashes. At
+// the end of either of those they can have modifiers like m or x that have
+// special meaning for the regex engine.
+//
+// We favor the use of forward slashes unless the regex contains a forward slash
+// itself. In that case we switch over to using %r with braces.
+const printRegexpLiteral = (path, opts, print) => {
+    const node = path.getValue();
+    const docs = path.map(print, "body");
+    // We should use braces if using a forward slash would be ambiguous in the
+    // current context or if there's a forward slash in the content of the regexp.
+    const useBraces = forwardSlashIsAmbiguous(path) || hasContent(node, /\//);
+    // If we should be using braces but we have braces in the body of the regexp,
+    // then we're just going to resort to using whatever the original content was.
+    if (useBraces && hasContent(node, /[{}]/)) {
+        return [node.beging, ...docs, node.ending];
+    }
+    return [
+        useBraces ? "%r{" : "/",
+        ...docs,
+        useBraces ? "}" : "/",
+        node.ending.slice(1)
+    ];
+};
+exports.printRegexpLiteral = printRegexpLiteral;

data/dist/ruby/nodes/rescue.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printRetry = exports.printRedo = exports.printRescueMod = exports.printRescueEx = exports.printRescue = exports.printEnsure = exports.printBegin = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const utils_1 = require("../../utils");
+const { align, group, hardline, indent, join, line } = prettier_1.default;
+const printBegin = (path, opts, print) => {
+    return [
+        "begin",
+        indent([hardline, path.map(print, "body")]),
+        hardline,
+        "end"
+    ];
+};
+exports.printBegin = printBegin;
+const printEnsure = (path, opts, print) => {
+    return [
+        path.call(print, "body", 0),
+        indent([hardline, path.call(print, "body", 1)])
+    ];
+};
+exports.printEnsure = printEnsure;
+const printRescue = (path, opts, print) => {
+    const parts = ["rescue"];
+    if (path.getValue().body[0]) {
+        parts.push(align("rescue ".length, path.call(print, "body", 0)));
+    }
+    else {
+        // If you don't specify an error to rescue in a `begin/rescue` block, then
+        // implicitly you're rescuing from `StandardError`. In this case, we're
+        // just going to explicitly add it.
+        parts.push(" StandardError");
+    }
+    const bodystmt = path.call(print, "body", 1);
+    if (bodystmt.length > 0) {
+        parts.push(indent([hardline, bodystmt]));
+    }
+    // This is the next clause on the `begin` statement, either another
+    // `rescue`, and `ensure`, or an `else` clause.
+    if (path.getValue().body[2]) {
+        parts.push([hardline, path.call(print, "body", 2)]);
+    }
+    return group(parts);
+};
+exports.printRescue = printRescue;
+// This is a container node that we're adding into the AST that isn't present in
+// Ripper solely so that we have a nice place to attach inline comments.
+const printRescueEx = (path, opts, print) => {
+    const [exception, variable] = path.getValue().body;
+    const parts = [];
+    if (exception) {
+        let exceptionDoc = path.call(print, "body", 0);
+        if (Array.isArray(exceptionDoc)) {
+            const joiner = [",", line];
+            exceptionDoc = group(join(joiner, exceptionDoc));
+        }
+        parts.push(" ", exceptionDoc);
+    }
+    if (variable) {
+        parts.push(" => ", path.call(print, "body", 1));
+    }
+    return group(parts);
+};
+exports.printRescueEx = printRescueEx;
+const printRescueMod = (path, opts, print) => {
+    const [statementDoc, valueDoc] = path.map(print, "body");
+    return [
+        "begin",
+        indent([hardline, statementDoc]),
+        hardline,
+        "rescue StandardError",
+        indent([hardline, valueDoc]),
+        hardline,
+        "end"
+    ];
+};
+exports.printRescueMod = printRescueMod;
+exports.printRedo = (0, utils_1.literal)("redo");
+exports.printRetry = (0, utils_1.literal)("retry");