prettier 1.6.1 → 2.0.0.pre.rc1

data/dist/ruby/nodes/return.js

@@ -0,0 +1,75 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printReturn0 = exports.printReturn = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const utils_1 = require("../../utils");
+const { group, ifBreak, indent, line, join, softline } = prettier_1.default;
+// You can't skip the parentheses if you have comments or certain operators with
+// lower precedence than the return keyword.
+function canSkipParens(args) {
+    const stmts = args.body[0].body[0];
+    // return(
+    //   # a
+    //   b
+    // )
+    if (stmts.comments) {
+        return false;
+    }
+    const stmt = stmts.body[0];
+    // return (a or b)
+    if (stmt.type === "binary" && ["and", "or"].includes(stmt.body[1])) {
+        return false;
+    }
+    // return (not a)
+    if (stmt.type === "unary" && stmt.oper === "not") {
+        return false;
+    }
+    return true;
+}
+const printReturn = (path, opts, print) => {
+    let args = path.getValue().body[0].body[0];
+    let steps = ["body", 0, "body", 0];
+    if (args.body.length === 1) {
+        // If the body of the return contains parens, then just skip directly to the
+        // content of the parens so that we can skip printing parens if we don't
+        // want them.
+        if (args.body[0] && args.body[0].type === "paren" && canSkipParens(args)) {
+            args = args.body[0].body[0];
+            steps = steps.concat("body", 0, "body", 0);
+        }
+        // If we're returning an array literal that isn't a special array, single
+        // element array, or an empty array, then we want to grab the arguments so
+        // that we can print them out as if they were normal return arguments.
+        if (args.body[0] &&
+            args.body[0].type === "array" &&
+            args.body[0].body[0] &&
+            args.body[0].body[0].body.length > 1 &&
+            ["args", "args_add_star"].includes(args.body[0].body[0].type)) {
+            steps = steps.concat("body", 0, "body", 0);
+        }
+    }
+    // Now that we've established which actual node is the arguments to return,
+    // we grab it out of the path by diving down the steps that we've set up.
+    const parts = path.call(print, ...steps);
+    const useBrackets = Array.isArray(parts) && parts.length > 1;
+    // If we got the value straight out of the parens, then `parts` would only
+    // be a singular doc as opposed to an array.
+    const value = Array.isArray(parts) ? join([",", line], parts) : parts;
+    // We only get here if we have comments somewhere that would prevent us from
+    // skipping the parentheses.
+    if (args.body.length === 1 && args.body[0].type === "paren") {
+        return ["return", value];
+    }
+    return group([
+        "return",
+        ifBreak(useBrackets ? " [" : "(", " "),
+        indent([softline, value]),
+        softline,
+        ifBreak(useBrackets ? "]" : ")", "")
+    ]);
+};
+exports.printReturn = printReturn;
+exports.printReturn0 = (0, utils_1.literal)("return");

data/dist/ruby/nodes/statements.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printStmts = exports.printProgram = exports.printComment = exports.printEndContent = exports.printParen = exports.printBodyStmt = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const utils_1 = require("../../utils");
+const { breakParent, dedent, group, hardline, indent, join, line, literalline, softline, trim } = prettier_1.default;
+const printBodyStmt = (path, opts, print) => {
+    const [stmts, rescue, elseClause, ensure] = path.getValue().body;
+    const parts = [];
+    if (!(0, utils_1.isEmptyStmts)(stmts)) {
+        parts.push(path.call(print, "body", 0));
+    }
+    if (rescue) {
+        parts.push(dedent([hardline, path.call(print, "body", 1)]));
+    }
+    if (elseClause) {
+        // Before Ruby 2.6, this piece of bodystmt was an explicit "else" node
+        /* istanbul ignore next */
+        const stmts = elseClause.type === "else"
+            ? path.call(print, "body", 2, "body", 0)
+            : path.call(print, "body", 2);
+        parts.push([dedent([hardline, "else"]), hardline, stmts]);
+    }
+    if (ensure) {
+        parts.push(dedent([hardline, path.call(print, "body", 3)]));
+    }
+    return group(parts);
+};
+exports.printBodyStmt = printBodyStmt;
+const argNodeTypes = ["args", "args_add_star", "args_add_block"];
+const printParen = (path, opts, print) => {
+    const contentNode = path.getValue().body[0];
+    if (!contentNode) {
+        return [path.call(print, "lparen"), ")"];
+    }
+    let contentDoc = path.call(print, "body", 0);
+    // If the content is params, we're going to let it handle its own parentheses
+    // so that it breaks nicely.
+    if (contentNode.type === "params") {
+        return contentDoc;
+    }
+    // If we have an arg type node as the contents, then it's going to return an
+    // array, so we need to explicitly join that content here.
+    if (argNodeTypes.includes(contentNode.type)) {
+        contentDoc = join([",", line], contentDoc);
+    }
+    return group([
+        path.call(print, "lparen"),
+        indent([softline, contentDoc]),
+        softline,
+        ")"
+    ]);
+};
+exports.printParen = printParen;
+const printEndContent = (path) => {
+    const { body } = path.getValue();
+    return [trim, "__END__", literalline, body];
+};
+exports.printEndContent = printEndContent;
+const printComment = (path, opts) => {
+    return opts.printer.printComment(path, opts);
+};
+exports.printComment = printComment;
+const printProgram = (path, opts, print) => {
+    return [join(hardline, path.map(print, "body")), hardline];
+};
+exports.printProgram = printProgram;
+const printStmts = (path, opts, print) => {
+    const stmts = path.getValue().body;
+    // This is a special case where we have only comments inside a statement
+    // list. In this case we want to avoid doing any kind of line number
+    // tracking and just print out the comments.
+    if (stmts.length === 1 &&
+        stmts[0].type === "void_stmt" &&
+        stmts[0].comments) {
+        const nodePath = path;
+        const comments = nodePath.map((commentPath) => {
+            commentPath.getValue().printed = true;
+            return opts.printer.printComment(commentPath, opts);
+        }, "body", 0, "comments");
+        return [breakParent, join(hardline, comments)];
+    }
+    const parts = [];
+    let lineNo = null;
+    stmts.forEach((stmt, index) => {
+        if (stmt.type === "void_stmt") {
+            return;
+        }
+        const printed = path.call(print, "body", index);
+        if (lineNo === null) {
+            parts.push(printed);
+        }
+        else if (stmt.sl - lineNo > 1 ||
+            [stmt.type, stmts[index - 1].type].includes("access_ctrl")) {
+            parts.push(hardline, hardline, printed);
+        }
+        else if (stmt.sl !== lineNo ||
+            path.getParentNode().type !== "string_embexpr") {
+            parts.push(hardline, printed);
+        }
+        else {
+            parts.push("; ", printed);
+        }
+        lineNo = stmt.el;
+    });
+    return parts;
+};
+exports.printStmts = printStmts;

data/dist/ruby/nodes/strings.js

@@ -0,0 +1,218 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printXStringLiteral = exports.printSymbolLiteral = exports.printStringLiteral = exports.printStringEmbExpr = exports.printStringDVar = exports.printStringConcat = exports.printDynaSymbol = exports.printChar = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const { group, hardline, indent, literalline, removeLines, softline, join } = prettier_1.default;
+// If there is some part of this string that matches an escape sequence or that
+// contains the interpolation pattern ("#{"), then we are locked into whichever
+// quote the user chose. (If they chose single quotes, then double quoting
+// would activate the escape sequence, and if they chose double quotes, then
+// single quotes would deactivate it.)
+function isQuoteLocked(node) {
+    return node.body.some((part) => part.type === "@tstring_content" &&
+        (part.body.includes("#{") || part.body.includes("\\")));
+}
+// A string is considered to be able to use single quotes if it contains only
+// plain string content and that content does not contain a single quote.
+function isSingleQuotable(node) {
+    return node.body.every((part) => part.type === "@tstring_content" && !part.body.includes("'"));
+}
+const quotePattern = new RegExp("\\\\([\\s\\S])|(['\"])", "g");
+function normalizeQuotes(content, enclosingQuote) {
+    // Escape and unescape single and double quotes as needed to be able to
+    // enclose `content` with `enclosingQuote`.
+    return content.replace(quotePattern, (match, escaped, quote) => {
+        if (quote === enclosingQuote) {
+            return `\\${quote}`;
+        }
+        if (quote) {
+            return quote;
+        }
+        return `\\${escaped}`;
+    });
+}
+const quotePairs = {
+    "(": ")",
+    "[": "]",
+    "{": "}",
+    "<": ">"
+};
+function getClosingQuote(quote) {
+    if (!quote.startsWith("%")) {
+        return quote;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    const boundary = /%[Qq]?(.)/.exec(quote)[1];
+    if (boundary in quotePairs) {
+        return quotePairs[boundary];
+    }
+    return boundary;
+}
+// Prints a @CHAR node. @CHAR nodes are special character strings that usually
+// are strings of length 1. If they're any longer than we'll try to apply the
+// correct quotes.
+const printChar = (path, opts) => {
+    const { body } = path.getValue();
+    if (body.length !== 2) {
+        return body;
+    }
+    const quote = opts.rubySingleQuote ? "'" : '"';
+    return [quote, body.slice(1), quote];
+};
+exports.printChar = printChar;
+const printPercentSDynaSymbol = (path, opts, print) => {
+    const node = path.getValue();
+    const parts = [];
+    // Push on the quote, which includes the opening character.
+    parts.push(node.quote);
+    path.each((childPath) => {
+        const childNode = childPath.getValue();
+        if (childNode.type !== "@tstring_content") {
+            // Here we are printing an embedded variable or expression.
+            parts.push(print(childPath));
+        }
+        else {
+            // Here we are printing plain string content.
+            parts.push(join(literalline, childNode.body.split("\n")));
+        }
+    }, "body");
+    // Push on the closing character, which is the opposite of the third
+    // character from the opening.
+    parts.push(quotePairs[node.quote[2]]);
+    return parts;
+};
+// We don't actually want to print %s symbols, as they're much more rarely seen
+// in the wild. But we're going to be forced into it if it's a multi-line symbol
+// or if the quoting would get super complicated.
+function shouldPrintPercentSDynaSymbol(node) {
+    // We shouldn't print a %s dyna symbol if it was not already that way in the
+    // original source.
+    if (node.quote[0] !== "%") {
+        return false;
+    }
+    // Here we're going to check if there is a closing character, a new line, or a
+    // quote in the content of the dyna symbol. If there is, then quoting could
+    // get weird, so just bail out and stick to the original bounds in the source.
+    const closing = quotePairs[node.quote[2]];
+    return node.body.some((child) => child.type === "@tstring_content" &&
+        (child.body.includes("\n") ||
+            child.body.includes(closing) ||
+            child.body.includes("'") ||
+            child.body.includes('"')));
+}
+// Prints a dynamic symbol. Assumes there's a quote property attached to the
+// node that will tell us which quote to use when printing. We're just going to
+// use whatever quote was provided.
+//
+// In the case of a plain dyna symbol, node.quote will be either :" or :'
+// For %s dyna symbols, node.quote will be %s[, %s(, %s{, or %s<
+const printDynaSymbol = (path, opts, print) => {
+    const node = path.getValue();
+    if (shouldPrintPercentSDynaSymbol(node)) {
+        return printPercentSDynaSymbol(path, opts, print);
+    }
+    const parts = [];
+    let quote;
+    if (isQuoteLocked(node)) {
+        if (node.quote.startsWith("%")) {
+            quote = opts.rubySingleQuote ? "'" : '"';
+        }
+        else if (node.quote.startsWith(":")) {
+            quote = node.quote.slice(1);
+        }
+        else {
+            quote = node.quote;
+        }
+    }
+    else {
+        quote = opts.rubySingleQuote && isSingleQuotable(node) ? "'" : '"';
+    }
+    parts.push(quote);
+    path.each((childPath) => {
+        const child = childPath.getValue();
+        if (child.type !== "@tstring_content") {
+            parts.push(print(childPath));
+        }
+        else {
+            parts.push(join(literalline, normalizeQuotes(child.body, quote).split("\n")));
+        }
+    }, "body");
+    parts.push(quote);
+    // If we're inside of an assoc_new node as the key, then it will handle
+    // printing the : on its own since it could change sides.
+    const parentNode = path.getParentNode();
+    if (parentNode.type !== "assoc_new" || parentNode.body[0] !== node) {
+        parts.unshift(":");
+    }
+    return parts;
+};
+exports.printDynaSymbol = printDynaSymbol;
+const printStringConcat = (path, opts, print) => {
+    const [leftDoc, rightDoc] = path.map(print, "body");
+    return group([leftDoc, " \\", indent([hardline, rightDoc])]);
+};
+exports.printStringConcat = printStringConcat;
+// Prints out an interpolated variable in the string by converting it into an
+// embedded expression.
+const printStringDVar = (path, opts, print) => {
+    return ["#{", path.call(print, "body", 0), "}"];
+};
+exports.printStringDVar = printStringDVar;
+const printStringEmbExpr = (path, opts, print) => {
+    const node = path.getValue();
+    const parts = path.call(print, "body", 0);
+    // If the contents of this embedded expression were originally on the same
+    // line in the source, then we're going to leave them in place and assume
+    // that's the way the developer wanted this expression represented.
+    if (node.sl === node.el) {
+        return ["#{", removeLines(parts), "}"];
+    }
+    return group(["#{", indent([softline, parts]), [softline, "}"]]);
+};
+exports.printStringEmbExpr = printStringEmbExpr;
+// Prints out a literal string. This function does its best to respect the
+// wishes of the user with regards to single versus double quotes, but if the
+// string contains any escape expressions then it will just keep the original
+// quotes.
+const printStringLiteral = (path, { rubySingleQuote }, print) => {
+    const node = path.getValue();
+    // If the string is empty, it will not have any parts, so just print out the
+    // quotes corresponding to the config
+    if (node.body.length === 0) {
+        return rubySingleQuote ? "''" : '""';
+    }
+    // Determine the quote that should enclose the new string
+    let quote;
+    if (isQuoteLocked(node)) {
+        quote = node.quote;
+    }
+    else {
+        quote = rubySingleQuote && isSingleQuotable(node) ? "'" : '"';
+    }
+    const parts = path.map((partPath) => {
+        const part = partPath.getValue();
+        // In this case, the part of the string is an embedded expression
+        if (part.type !== "@tstring_content") {
+            return print(partPath);
+        }
+        // In this case, the part of the string is just regular string content
+        return join(literalline, normalizeQuotes(part.body, quote).split("\n"));
+    }, "body");
+    return [quote, ...parts, getClosingQuote(quote)];
+};
+exports.printStringLiteral = printStringLiteral;
+// Prints out a symbol literal. Its child will always be the ident that
+// represents the string content of the symbol.
+const printSymbolLiteral = (path, opts, print) => {
+    return [":", path.call(print, "body", 0)];
+};
+exports.printSymbolLiteral = printSymbolLiteral;
+// Prints out an xstring literal. Its child is an array of string parts,
+// including plain string content and interpolated content.
+const printXStringLiteral = (path, opts, print) => {
+    return ["`", ...path.map(print, "body"), "`"];
+};
+exports.printXStringLiteral = printXStringLiteral;

data/dist/ruby/nodes/super.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.printZSuper = exports.printSuper = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const utils_1 = require("../../utils");
+const { align, group, join, line } = prettier_1.default;
+const printSuper = (path, opts, print) => {
+    const args = path.getValue().body[0];
+    if (args.type === "arg_paren") {
+        // In case there are explicitly no arguments but they are using parens,
+        // we assume they are attempting to override the initializer and pass no
+        // arguments up.
+        if (args.body[0] === null) {
+            return "super()";
+        }
+        return ["super", path.call(print, "body", 0)];
+    }
+    const keyword = "super ";
+    const argsDocs = path.call(print, "body", 0);
+    return group([
+        keyword,
+        align(keyword.length, group(join([",", line], argsDocs)))
+    ]);
+};
+exports.printSuper = printSuper;
+// Version of super without any parens or args.
+exports.printZSuper = (0, utils_1.literal)("super");

data/dist/ruby/nodes/undef.js

@@ -0,0 +1,26 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printUndef = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const { addTrailingComment, align, group, join, line } = prettier_1.default;
+const printUndefSymbol = (path, opts, print) => {
+    const node = path.getValue();
+    // Since we're going to descend into the symbol literal to grab out the ident
+    // node, then we need to make sure we copy over any comments as well,
+    // otherwise we could accidentally skip printing them.
+    if (node.comments) {
+        node.comments.forEach((comment) => {
+            addTrailingComment(node.body[0], comment);
+        });
+    }
+    return path.call(print, "body", 0);
+};
+const printUndef = (path, opts, print) => {
+    const keyword = "undef ";
+    const argNodes = path.map((symbolPath) => printUndefSymbol(symbolPath, opts, print), "body");
+    return group([keyword, align(keyword.length, join([",", line], argNodes))]);
+};
+exports.printUndef = printUndef;

data/dist/ruby/nodes.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const alias_1 = require("./nodes/alias");
+const aref_1 = require("./nodes/aref");
+const args_1 = require("./nodes/args");
+const arrays_1 = require("./nodes/arrays");
+const assign_1 = require("./nodes/assign");
+const blocks_1 = require("./nodes/blocks");
+const calls_1 = require("./nodes/calls");
+const case_1 = require("./nodes/case");
+const class_1 = require("./nodes/class");
+const commands_1 = require("./nodes/commands");
+const conditionals_1 = require("./nodes/conditionals");
+const constants_1 = require("./nodes/constants");
+const flow_1 = require("./nodes/flow");
+const hashes_1 = require("./nodes/hashes");
+const heredocs_1 = require("./nodes/heredocs");
+const hooks_1 = require("./nodes/hooks");
+const ints_1 = require("./nodes/ints");
+const lambdas_1 = require("./nodes/lambdas");
+const loops_1 = require("./nodes/loops");
+const massign_1 = require("./nodes/massign");
+const methods_1 = require("./nodes/methods");
+const operators_1 = require("./nodes/operators");
+const params_1 = require("./nodes/params");
+const patterns_1 = require("./nodes/patterns");
+const regexp_1 = require("./nodes/regexp");
+const rescue_1 = require("./nodes/rescue");
+const return_1 = require("./nodes/return");
+const statements_1 = require("./nodes/statements");
+const strings_1 = require("./nodes/strings");
+const super_1 = require("./nodes/super");
+const undef_1 = require("./nodes/undef");
+const nodes = {
+    "@__end__": statements_1.printEndContent,
+    "@CHAR": strings_1.printChar,
+    "@comment": statements_1.printComment,
+    "@int": ints_1.printInt,
+    access_ctrl: methods_1.printAccessControl,
+    alias: alias_1.printAlias,
+    aref: aref_1.printAref,
+    aref_field: aref_1.printArefField,
+    arg_paren: args_1.printArgParen,
+    args: args_1.printArgs,
+    args_add_block: args_1.printArgsAddBlock,
+    args_add_star: args_1.printArgsAddStar,
+    args_forward: params_1.printArgsForward,
+    array: arrays_1.printArray,
+    aryptn: patterns_1.printAryPtn,
+    assign: assign_1.printAssign,
+    assoc_new: hashes_1.printAssocNew,
+    assoc_splat: hashes_1.printAssocSplat,
+    assoclist_from_args: hashes_1.printHashContents,
+    bare_assoc_hash: hashes_1.printHashContents,
+    BEGIN: hooks_1.printBEGIN,
+    begin: rescue_1.printBegin,
+    binary: operators_1.printBinary,
+    blockarg: args_1.printBlockArg,
+    block_var: blocks_1.printBlockVar,
+    bodystmt: statements_1.printBodyStmt,
+    brace_block: blocks_1.printBraceBlock,
+    break: flow_1.printBreak,
+    call: calls_1.printCall,
+    case: case_1.printCase,
+    class: class_1.printClass,
+    command: commands_1.printCommand,
+    command_call: commands_1.printCommandCall,
+    const_path_field: constants_1.printConstPath,
+    const_path_ref: constants_1.printConstPath,
+    const_ref: constants_1.printConstRef,
+    def: methods_1.printDef,
+    defs: methods_1.printDef,
+    defsl: methods_1.printSingleLineMethod,
+    defined: constants_1.printDefined,
+    do_block: blocks_1.printDoBlock,
+    dot2: operators_1.printDot2,
+    dot3: operators_1.printDot3,
+    dyna_symbol: strings_1.printDynaSymbol,
+    else: conditionals_1.printElse,
+    elsif: conditionals_1.printElsif,
+    END: hooks_1.printEND,
+    ensure: rescue_1.printEnsure,
+    fcall: calls_1.printCallContainer,
+    fndptn: patterns_1.printFndPtn,
+    field: constants_1.printField,
+    for: loops_1.printFor,
+    hash: hashes_1.printHash,
+    heredoc: heredocs_1.printHeredoc,
+    hshptn: patterns_1.printHshPtn,
+    if: conditionals_1.printIf,
+    ifop: conditionals_1.printTernary,
+    if_mod: conditionals_1.printIfModifier,
+    in: patterns_1.printIn,
+    kwrest_param: params_1.printKeywordRestParam,
+    lambda: lambdas_1.printLambda,
+    massign: massign_1.printMAssign,
+    method_add_arg: calls_1.printMethodAddArg,
+    method_add_block: calls_1.printMethodAddBlock,
+    mlhs: massign_1.printMLHS,
+    mlhs_add_post: massign_1.printMLHSAddPost,
+    mlhs_add_star: massign_1.printMLHSAddStar,
+    mlhs_paren: massign_1.printMLHSParen,
+    mrhs: massign_1.printMRHS,
+    mrhs_add_star: massign_1.printMRHSAddStar,
+    mrhs_new_from_args: massign_1.printMRHSNewFromArgs,
+    module: class_1.printModule,
+    next: flow_1.printNext,
+    opassign: assign_1.printOpAssign,
+    params: params_1.printParams,
+    paren: statements_1.printParen,
+    program: statements_1.printProgram,
+    rassign: patterns_1.printRAssign,
+    redo: rescue_1.printRedo,
+    regexp_literal: regexp_1.printRegexpLiteral,
+    rescue: rescue_1.printRescue,
+    rescue_ex: rescue_1.printRescueEx,
+    rescue_mod: rescue_1.printRescueMod,
+    rest_param: params_1.printRestParam,
+    retry: rescue_1.printRetry,
+    return: return_1.printReturn,
+    return0: return_1.printReturn0,
+    sclass: class_1.printSClass,
+    stmts: statements_1.printStmts,
+    string_concat: strings_1.printStringConcat,
+    string_dvar: strings_1.printStringDVar,
+    string_embexpr: strings_1.printStringEmbExpr,
+    string_literal: strings_1.printStringLiteral,
+    super: super_1.printSuper,
+    symbol_literal: strings_1.printSymbolLiteral,
+    top_const_field: constants_1.printTopConst,
+    top_const_ref: constants_1.printTopConst,
+    unary: operators_1.printUnary,
+    undef: undef_1.printUndef,
+    unless: conditionals_1.printUnless,
+    unless_mod: conditionals_1.printUnlessModifier,
+    until: loops_1.printUntil,
+    until_mod: loops_1.printUntilModifer,
+    var_alias: alias_1.printAlias,
+    var_field: assign_1.printVarField,
+    var_ref: assign_1.printVarRef,
+    vcall: calls_1.printCallContainer,
+    when: case_1.printWhen,
+    while: loops_1.printWhile,
+    while_mod: loops_1.printWhileModifier,
+    word: arrays_1.printWord,
+    xstring_literal: strings_1.printXStringLiteral,
+    yield: flow_1.printYield,
+    yield0: flow_1.printYield0,
+    zsuper: super_1.printZSuper
+};
+exports.default = nodes;

data/dist/ruby/parser.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const parseSync_1 = __importDefault(require("../parser/parseSync"));
+const parser = {
+    // This function is responsible for taking an input string of text and
+    // returning to prettier a JavaScript object that is the equivalent AST that
+    // represents the code stored in that string. We accomplish this by spawning a
+    // new Ruby process of parser.rb and reading JSON off STDOUT.
+    parse(text) {
+        return (0, parseSync_1.default)("ruby", text);
+    },
+    astFormat: "ruby",
+    // This function handles checking whether or not the source string has the
+    // pragma for prettier. This is an optional workflow for incremental adoption.
+    hasPragma(text) {
+        return /^\s*#[^\S\n]*@(?:prettier|format)\s*?(?:\n|$)/m.test(text);
+    },
+    // This function is critical for comments and cursor support, and is
+    // responsible for returning the index of the character within the source
+    // string that is the beginning of the given node.
+    locStart(node) {
+        return node.sc;
+    },
+    // This function is critical for comments and cursor support, and is
+    // responsible for returning the index of the character within the source
+    // string that is the ending of the given node.
+    locEnd(node) {
+        return node.ec;
+    }
+};
+exports.default = parser;