prettier 2.0.0 → 2.1.0

data/dist/ruby/nodes/strings.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (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 location_1 = require("../location");
 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
@@ -12,13 +13,13 @@ const { group, hardline, indent, literalline, removeLines, softline, join } = pr
 // 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("\\")));
+    return node.parts.some((part) => part.type === "tstring_content" &&
+        (part.value.includes("#{") || part.value.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("'"));
+    return node.parts.every((part) => part.type === "tstring_content" && !part.value.includes("'"));
 }
 const quotePattern = new RegExp("\\\\([\\s\\S])|(['\"])", "g");
 function normalizeQuotes(content, enclosingQuote) {
@@ -55,12 +56,12 @@ function getClosingQuote(quote) {
 // 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 { value } = path.getValue();
+    if (value.length !== 2) {
+        return value;
     }
     const quote = opts.rubySingleQuote ? "'" : '"';
-    return [quote, body.slice(1), quote];
+    return [quote, value.slice(1), quote];
 };
 exports.printChar = printChar;
 const printPercentSDynaSymbol = (path, opts, print) => {
@@ -70,15 +71,15 @@ const printPercentSDynaSymbol = (path, opts, print) => {
     parts.push(node.quote);
     path.each((childPath) => {
         const childNode = childPath.getValue();
-        if (childNode.type !== "@tstring_content") {
+        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")));
+            parts.push(join(literalline, childNode.value.split("\n")));
         }
-    }, "body");
+    }, "parts");
     // Push on the closing character, which is the opposite of the third
     // character from the opening.
     parts.push(quotePairs[node.quote[2]]);
@@ -97,11 +98,11 @@ function shouldPrintPercentSDynaSymbol(node) {
     // 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('"')));
+    return node.parts.some((child) => child.type === "tstring_content" &&
+        (child.value.includes("\n") ||
+            child.value.includes(closing) ||
+            child.value.includes("'") ||
+            child.value.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
@@ -133,44 +134,45 @@ const printDynaSymbol = (path, opts, print) => {
     parts.push(quote);
     path.each((childPath) => {
         const child = childPath.getValue();
-        if (child.type !== "@tstring_content") {
+        if (child.type !== "tstring_content") {
             parts.push(print(childPath));
         }
         else {
-            parts.push(join(literalline, normalizeQuotes(child.body, quote).split("\n")));
+            parts.push(join(literalline, normalizeQuotes(child.value, quote).split("\n")));
         }
-    }, "body");
+    }, "parts");
     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) {
+    if (parentNode.type !== "assoc" || parentNode.key !== 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])]);
+    return group([
+        path.call(print, "left"),
+        " \\",
+        indent([hardline, path.call(print, "right")])
+    ]);
 };
 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), "}"];
-};
+const printStringDVar = (path, opts, print) => ["#{", path.call(print, "var"), "}"];
 exports.printStringDVar = printStringDVar;
 const printStringEmbExpr = (path, opts, print) => {
     const node = path.getValue();
-    const parts = path.call(print, "body", 0);
+    const doc = path.call(print, "stmts");
     // 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), "}"];
+    if ((0, location_1.getStartLine)(node.loc) === (0, location_1.getEndLine)(node.loc)) {
+        return ["#{", removeLines(doc), "}"];
     }
-    return group(["#{", indent([softline, parts]), [softline, "}"]]);
+    return group(["#{", indent([softline, doc]), [softline, "}"]]);
 };
 exports.printStringEmbExpr = printStringEmbExpr;
 // Prints out a literal string. This function does its best to respect the
@@ -181,7 +183,7 @@ 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) {
+    if (node.parts.length === 0) {
         return rubySingleQuote ? "''" : '""';
     }
     // Determine the quote that should enclose the new string
@@ -195,24 +197,24 @@ const printStringLiteral = (path, { rubySingleQuote }, print) => {
     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") {
+        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 join(literalline, normalizeQuotes(part.value, quote).split("\n"));
+    }, "parts");
     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)];
+    return [":", path.call(print, "value")];
 };
 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"), "`"];
+    return ["`", ...path.map(print, "parts"), "`"];
 };
 exports.printXStringLiteral = printXStringLiteral;

data/dist/ruby/nodes/super.js

@@ -5,26 +5,22 @@ var __importDefault = (this && this.__importDefault) || function (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];
+    const { args } = path.getValue();
     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
+        // we assume they are attempting to override a parent method and pass no
         // arguments up.
-        if (args.body[0] === null) {
-            return "super()";
-        }
-        return ["super", path.call(print, "body", 0)];
+        return args.args === null ? "super()" : ["super", path.call(print, "args")];
     }
     const keyword = "super ";
-    const argsDocs = path.call(print, "body", 0);
     return group([
         keyword,
-        align(keyword.length, group(join([",", line], argsDocs)))
+        align(keyword.length, group(join([",", line], path.call(print, "args"))))
     ]);
 };
 exports.printSuper = printSuper;
 // Version of super without any parens or args.
-exports.printZSuper = (0, utils_1.literal)("super");
+const printZSuper = (path) => path.getValue().value;
+exports.printZSuper = printZSuper;

data/dist/ruby/nodes/undef.js

@@ -6,21 +6,26 @@ 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 symsDocs = path.map((symbolPath) => {
+        const symbolNode = symbolPath.getValue();
+        // If we're not printing a symbol literal then it's a dyna symbol, so
+        // we're just going to print that node on its own.
+        if (symbolNode.type !== "symbol_literal") {
+            return print(symbolPath);
+        }
+        // We need to make sure we copy over any comments before we do the
+        // printing so they get printed as well.
+        if (symbolNode.comments) {
+            symbolNode.comments.forEach((comment) => {
+                addTrailingComment(symbolNode.value, comment);
+            });
+        }
+        // If we're printing a symbol literal, then we want to descend into it and
+        // just print the underlying contents so that it prints as a bare word.
+        return symbolPath.call(print, "value");
+    }, "syms");
     const keyword = "undef ";
-    const argNodes = path.map((symbolPath) => printUndefSymbol(symbolPath, opts, print), "body");
-    return group([keyword, align(keyword.length, join([",", line], argNodes))]);
+    return group([keyword, align(keyword.length, join([",", line], symsDocs))]);
 };
 exports.printUndef = printUndef;

data/dist/ruby/nodes.js

@@ -31,11 +31,13 @@ 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 printToken = (path) => path.getValue().value;
+const printVoidStmt = () => "";
 const nodes = {
-    "@__end__": statements_1.printEndContent,
-    "@CHAR": strings_1.printChar,
-    "@comment": statements_1.printComment,
-    "@int": ints_1.printInt,
+    BEGIN: hooks_1.printBEGIN,
+    CHAR: strings_1.printChar,
+    END: hooks_1.printEND,
+    __end__: statements_1.printEndContent,
     access_ctrl: methods_1.printAccessControl,
     alias: alias_1.printAlias,
     aref: aref_1.printAref,
@@ -43,20 +45,21 @@ const nodes = {
     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,
+    arg_star: args_1.printArgStar,
     array: arrays_1.printArray,
     aryptn: patterns_1.printAryPtn,
     assign: assign_1.printAssign,
-    assoc_new: hashes_1.printAssocNew,
+    assoc: hashes_1.printAssoc,
     assoc_splat: hashes_1.printAssocSplat,
     assoclist_from_args: hashes_1.printHashContents,
+    backref: printToken,
+    backtick: printToken,
     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,
+    blockarg: args_1.printBlockArg,
     bodystmt: statements_1.printBodyStmt,
     brace_block: blocks_1.printBraceBlock,
     break: flow_1.printBreak,
@@ -65,51 +68,70 @@ const nodes = {
     class: class_1.printClass,
     command: commands_1.printCommand,
     command_call: commands_1.printCommandCall,
+    comment: statements_1.printComment,
+    const: printToken,
     const_path_field: constants_1.printConstPath,
     const_path_ref: constants_1.printConstPath,
     const_ref: constants_1.printConstRef,
+    cvar: printToken,
     def: methods_1.printDef,
-    defs: methods_1.printDef,
-    defsl: methods_1.printSingleLineMethod,
+    def_endless: methods_1.printDefEndless,
     defined: constants_1.printDefined,
+    defs: methods_1.printDef,
     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,
+    embdoc: statements_1.printComment,
     ensure: rescue_1.printEnsure,
+    excessed_comma: params_1.printExcessedComma,
     fcall: calls_1.printCallContainer,
-    fndptn: patterns_1.printFndPtn,
     field: constants_1.printField,
+    float: printToken,
+    fndptn: patterns_1.printFndPtn,
     for: loops_1.printFor,
+    gvar: printToken,
     hash: hashes_1.printHash,
     heredoc: heredocs_1.printHeredoc,
+    heredoc_beg: printToken,
     hshptn: patterns_1.printHshPtn,
+    ident: printToken,
     if: conditionals_1.printIf,
-    ifop: conditionals_1.printTernary,
     if_mod: conditionals_1.printIfModifier,
+    ifop: conditionals_1.printTernary,
+    imaginary: printToken,
     in: patterns_1.printIn,
+    int: ints_1.printInt,
+    ivar: printToken,
+    kw: printToken,
     kwrest_param: params_1.printKeywordRestParam,
+    label: printToken,
     lambda: lambdas_1.printLambda,
+    lbrace: printToken,
+    lparen: printToken,
     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,
+    module: class_1.printModule,
     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,
+    not: operators_1.printNot,
+    op: printToken,
     opassign: assign_1.printOpAssign,
     params: params_1.printParams,
     paren: statements_1.printParen,
+    period: printToken,
     program: statements_1.printProgram,
+    qsymbols: arrays_1.printQsymbols,
+    qwords: arrays_1.printQwords,
     rassign: patterns_1.printRAssign,
+    rational: printToken,
     redo: rescue_1.printRedo,
     regexp_literal: regexp_1.printRegexpLiteral,
     rescue: rescue_1.printRescue,
@@ -117,35 +139,39 @@ const nodes = {
     rescue_mod: rescue_1.printRescueMod,
     rest_param: params_1.printRestParam,
     retry: rescue_1.printRetry,
-    return: return_1.printReturn,
     return0: return_1.printReturn0,
+    return: return_1.printReturn,
     sclass: class_1.printSClass,
-    stmts: statements_1.printStmts,
+    statements: statements_1.printStatements,
     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,
+    symbols: arrays_1.printSymbols,
     top_const_field: constants_1.printTopConst,
     top_const_ref: constants_1.printTopConst,
+    tstring_content: printToken,
     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,
+    until_mod: loops_1.printUntil,
     var_alias: alias_1.printAlias,
     var_field: assign_1.printVarField,
     var_ref: assign_1.printVarRef,
     vcall: calls_1.printCallContainer,
+    void_stmt: printVoidStmt,
     when: case_1.printWhen,
     while: loops_1.printWhile,
-    while_mod: loops_1.printWhileModifier,
+    while_mod: loops_1.printWhile,
     word: arrays_1.printWord,
+    words: arrays_1.printWords,
     xstring_literal: strings_1.printXStringLiteral,
-    yield: flow_1.printYield,
     yield0: flow_1.printYield0,
+    yield: flow_1.printYield,
     zsuper: super_1.printZSuper
 };
 exports.default = nodes;

data/dist/ruby/parser.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const parseSync_1 = __importDefault(require("../parser/parseSync"));
+const location_1 = require("./location");
 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
@@ -22,13 +23,13 @@ const parser = {
     // 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;
+        return (0, location_1.getStartChar)(node.loc);
     },
     // 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;
+        return (0, location_1.getEndChar)(node.loc);
     }
 };
 exports.default = parser;