prettier 1.6.1 → 2.0.0.pre.rc1

data/dist/rbs/printer.js

@@ -0,0 +1,517 @@
+"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, makeString, join, line, softline } = prettier_1.default;
+// For some lists of entities in the AST, the parser returns them as an unsorted
+// object (presumably because Ruby hashes have implicit ordering). We do not
+// have that in JavaScript, so here we sort each object by its position in the
+// source string.
+function getSortedKeys(object) {
+    return Object.keys(object).sort((left, right) => object[left].type.location.start_pos -
+        object[right].type.location.start_pos);
+}
+// In some cases, we want to just defer to whatever was in the source.
+function getSource(node, opts) {
+    const { location } = node;
+    return opts.originalText.slice(location.start_pos, location.end_pos);
+}
+const printer = {
+    // 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();
+        let doc = null;
+        if (node.declarations) {
+            // Prints out the root of the tree, which includes zero or more
+            // declarations.
+            return [
+                join([hardline, hardline], path.map(print, "declarations")),
+                hardline
+            ];
+        }
+        /* istanbul ignore else */
+        if (node.declaration) {
+            switch (node.declaration) {
+                // Prints out a type alias, which is a declaration that looks like:
+                // type foo = String
+                case "alias": {
+                    doc = group([
+                        "type ",
+                        node.name,
+                        " =",
+                        indent(group([line, path.call(printType, "type")]))
+                    ]);
+                    break;
+                }
+                // Prints out a class declarations, which looks like:
+                // class Foo end
+                case "class": {
+                    const nodePath = path;
+                    const parts = [
+                        "class ",
+                        printNameAndTypeParams(nodePath, node)
+                    ];
+                    if (node.super_class) {
+                        const superPath = nodePath;
+                        parts.push(" < ", superPath.call(printNameAndArgs, "super_class"));
+                    }
+                    parts.push(indent(printMembers(nodePath)), hardline, "end");
+                    doc = group(parts);
+                    break;
+                }
+                // Prints out a constant or a global declaration, which looks like:
+                // Foo: String
+                // $foo: String
+                case "constant":
+                case "global": {
+                    doc = group([node.name, ": ", path.call(printType, "type")]);
+                    break;
+                }
+                // Prints out an interface declaration, which looks like:
+                // interface _Foo end
+                case "interface": {
+                    const nodePath = path;
+                    doc = group([
+                        "interface ",
+                        printNameAndTypeParams(nodePath, node),
+                        indent(printMembers(nodePath)),
+                        hardline,
+                        "end"
+                    ]);
+                    break;
+                }
+                // Prints out a module declaration, which looks like:
+                // module Foo end
+                case "module": {
+                    const nodePath = path;
+                    const parts = [
+                        "module ",
+                        printNameAndTypeParams(nodePath, node)
+                    ];
+                    if (node.self_types.length > 0) {
+                        parts.push(" : ", join(", ", nodePath.map(printNameAndArgs, "self_types")));
+                    }
+                    parts.push(indent(printMembers(nodePath)), hardline, "end");
+                    doc = group(parts);
+                    break;
+                }
+                /* istanbul ignore next */
+                default:
+                    throw new Error(`unknown declaration: ${node.declaration}`);
+            }
+        }
+        else if (node.member) {
+            switch (node.member) {
+                // Prints out an alias within a declaration, which looks like:
+                // alias foo bar
+                // alias self.foo self.bar
+                case "alias": {
+                    if (node.kind === "singleton") {
+                        doc = ["alias self.", node.new_name, " self.", node.old_name];
+                    }
+                    else {
+                        doc = ["alias ", node.new_name, " ", node.old_name];
+                    }
+                    break;
+                }
+                // Prints out an attr_* meta method, which looks like:
+                // attr_accessor foo
+                // attr_reader self.foo()
+                // attr_writer self.foo(@bar): String
+                case "attr_accessor":
+                case "attr_reader":
+                case "attr_writer": {
+                    const parts = [node.member, " "];
+                    if (node.kind === "singleton") {
+                        parts.push("self.");
+                    }
+                    parts.push(node.name);
+                    if (node.ivar_name === false) {
+                        parts.push("()");
+                    }
+                    else if (node.ivar_name) {
+                        parts.push("(", node.ivar_name, ")");
+                    }
+                    parts.push(": ", path.call(printType, "type"));
+                    doc = group(parts);
+                    break;
+                }
+                // Prints out a class or instance variable member, which looks like:
+                // @foo: String
+                // @@foo: String
+                case "class_variable":
+                case "instance_variable": {
+                    doc = group([node.name, ": ", path.call(printType, "type")]);
+                    break;
+                }
+                // Prints out a class instance variable member, which looks like:
+                // self.@foo: String
+                case "class_instance_variable": {
+                    doc = ["self.", node.name, ": ", path.call(printType, "type")];
+                    break;
+                }
+                // Prints out a mixin, which looks like:
+                // include Foo
+                // prepend Foo
+                // extend Foo
+                case "include":
+                case "extend":
+                case "prepend": {
+                    const nodePath = path;
+                    doc = group([node.member, " ", printNameAndArgs(nodePath)]);
+                    break;
+                }
+                case "public":
+                case "private": {
+                    doc = node.member;
+                    break;
+                }
+                case "method_definition": {
+                    const nodePath = path;
+                    doc = printMethodDefinition(nodePath, node);
+                    break;
+                }
+                /* istanbul ignore next */
+                default:
+                    throw new Error(`unknown member: ${node.member}`);
+            }
+        }
+        else {
+            const ast = JSON.stringify(node, null, 2);
+            throw new Error(`Unsupported node encountered:\n${ast}`);
+        }
+        // An annotation can be attached to most kinds of nodes, and should be
+        // printed using %a{}. Certain nodes can't have annotations at all.
+        if (node.annotations && node.annotations.length > 0) {
+            const annotationsPath = path;
+            doc = [
+                join(hardline, annotationsPath.map((annotationPath) => {
+                    const annotationNode = annotationPath.getValue();
+                    // If there are already braces inside the annotation, then we're
+                    // just going to print out the original string to avoid having to
+                    // escape anything.
+                    if (/[{}]/.test(annotationNode.string)) {
+                        return getSource(annotationNode, opts);
+                    }
+                    return ["%a{", annotationNode.string, "}"];
+                }, "annotations")),
+                hardline,
+                doc
+            ];
+        }
+        // Comments come in as one whole string, so here we split it up into
+        // multiple lines and then prefix it with the pound sign.
+        if (node.comment) {
+            doc = [
+                join(hardline, node.comment.string
+                    .slice(0, -1)
+                    .split("\n")
+                    .map((segment) => `# ${segment}`)),
+                hardline,
+                doc
+            ];
+        }
+        return doc;
+        // Prints out a string in the source, which looks like:
+        // 'foo'
+        function printString(node) {
+            // We're going to go straight to the source here, as if we don't then
+            // we're going to end up with the result of String#inspect, which does
+            // weird things to escape sequences.
+            const value = getSource(node, opts);
+            // Get the quote that was used in the source and the quote that we want to
+            // be using.
+            const originalQuote = value[0];
+            const preferredQuote = opts.rubySingleQuote ? "'" : '"';
+            // Determine if we're allowed to change the quote based on whether or not
+            // there is an escape sequence in the source string.
+            const quote = node.literal.includes("\\")
+                ? originalQuote
+                : preferredQuote;
+            return makeString(value.slice(1, -1), quote, false);
+        }
+        // Certain nodes are names with optional arguments attached, as in Array[A].
+        // We handle all of that printing centralized here.
+        function printNameAndArgs(path) {
+            const node = path.getValue();
+            if (node.args.length === 0) {
+                return node.name;
+            }
+            return group([
+                node.name,
+                "[",
+                join(", ", path.map(printType, "args")),
+                "]"
+            ]);
+        }
+        // This is the big function that prints out any individual type, which can
+        // look like all kinds of things, listed in the case statement below.
+        function printType(path, options) {
+            const node = path.getValue();
+            const forceParens = typeof options === "object" && options.forceParens;
+            switch (node.class) {
+                case "literal":
+                    if (node.literal[0] === '"') {
+                        return printString(node);
+                    }
+                    return node.literal;
+                case "optional": {
+                    const nodePath = path;
+                    return [
+                        nodePath.call((typePath) => printType(typePath, { forceParens: true }), "type"),
+                        "?"
+                    ];
+                }
+                case "tuple": {
+                    // If we don't have any sub types, we explicitly need the space in
+                    // between the brackets to not confuse the parser.
+                    if (node.types.length === 0) {
+                        return "[ ]";
+                    }
+                    const nodePath = path;
+                    return group([
+                        "[",
+                        join(", ", nodePath.map(printType, "types")),
+                        "]"
+                    ]);
+                }
+                case "union": {
+                    const nodePath = path;
+                    const doc = group(join([line, "| "], nodePath.map(printType, "types")));
+                    if (forceParens) {
+                        return ["(", doc, ")"];
+                    }
+                    return doc;
+                }
+                case "intersection": {
+                    const nodePath = path;
+                    const doc = group(join([line, "& "], nodePath.map((typePath) => printType(typePath, { forceParens: true }), "types")));
+                    if (forceParens) {
+                        return ["(", doc, ")"];
+                    }
+                    return doc;
+                }
+                case "class_singleton":
+                    return ["singleton(", node.name, ")"];
+                case "proc":
+                    return [
+                        "^",
+                        printMethodSignature(path)
+                    ];
+                case "record": {
+                    const nodePath = path;
+                    const parts = [];
+                    getSortedKeys(node.fields).forEach((field) => {
+                        const fieldParts = [];
+                        if (node.fields[field].joiner === "rocket") {
+                            fieldParts.push(`${field} => `);
+                        }
+                        else {
+                            fieldParts.push(`${field}: `);
+                        }
+                        fieldParts.push(nodePath.call(printType, "fields", field, "type"));
+                        parts.push(fieldParts);
+                    });
+                    return group([
+                        "{",
+                        indent([line, join([",", line], parts)]),
+                        line,
+                        "}"
+                    ]);
+                }
+                case "class_instance":
+                case "interface": {
+                    const nodePath = path;
+                    return printNameAndArgs(nodePath);
+                }
+                case "alias":
+                case "variable":
+                    return node.name;
+                case "bool":
+                case "bot":
+                case "class":
+                case "instance":
+                case "nil":
+                case "self":
+                case "top":
+                case "untyped":
+                case "void":
+                    return node.class;
+                /* istanbul ignore next */
+                default:
+                    throw new Error(`unknown type: ${node.class}`);
+            }
+        }
+        // Prints out the members of a class, module, or interface.
+        function printMembers(path) {
+            let lastLine = null;
+            const docs = [];
+            path.each((memberPath) => {
+                const memberNode = memberPath.getValue();
+                if (lastLine !== null &&
+                    memberNode.location.start.line - lastLine >= 2) {
+                    docs.push([hardline, hardline]);
+                }
+                else {
+                    docs.push(hardline);
+                }
+                docs.push(print(memberPath));
+                lastLine = memberNode.location.end.line;
+            }, "members");
+            return docs;
+        }
+        // Prints out the name of a class, interface, or module declaration.
+        // Additionally loops through each type parameter if there are any and print
+        // them out joined by commas. Checks for validation and variance.
+        function printNameAndTypeParams(path, node) {
+            if (node.type_params.params.length === 0) {
+                return node.name;
+            }
+            const docs = path.map((paramPath) => {
+                const node = paramPath.getValue();
+                const parts = [];
+                if (node.skip_validation) {
+                    parts.push("unchecked");
+                }
+                if (node.variance === "covariant") {
+                    parts.push("out");
+                }
+                else if (node.variance === "contravariant") {
+                    parts.push("in");
+                }
+                return join(" ", [...parts, node.name]);
+            }, "type_params", "params");
+            return [node.name, "[", join(", ", docs), "]"];
+        }
+        // Returns an array of printed parameters so that the calling function can
+        // join them together in whatever way.
+        function printMethodParams(path) {
+            const node = path.getValue();
+            let parts = [];
+            // required positionals, as in (A)
+            parts = parts.concat(path.map(printMethodParam, "required_positionals"));
+            // optional positionals, as in (?A)
+            parts = parts.concat(path.map((paramPath) => ["?", printMethodParam(paramPath)], "optional_positionals"));
+            // rest positional, as in (*A)
+            if (node.rest_positionals) {
+                const restPositionalsPath = path;
+                parts.push([
+                    "*",
+                    restPositionalsPath.call(printMethodParam, "rest_positionals")
+                ]);
+            }
+            // trailing positionals are required positionals after a rest
+            parts = parts.concat(path.map(printMethodParam, "trailing_positionals"));
+            // required keywords, as in (a: A)
+            getSortedKeys(node.required_keywords).forEach((name) => {
+                parts.push([
+                    name,
+                    ": ",
+                    path.call(printMethodParam, "required_keywords", name)
+                ]);
+            });
+            // optional keywords, as in (?a: A)
+            getSortedKeys(node.optional_keywords).forEach((name) => {
+                parts.push([
+                    "?",
+                    name,
+                    ": ",
+                    path.call(printMethodParam, "optional_keywords", name)
+                ]);
+            });
+            // rest keyword, as in (**A)
+            if (node.rest_keywords) {
+                const restKeywordsPath = path;
+                parts.push([
+                    "**",
+                    restKeywordsPath.call(printMethodParam, "rest_keywords")
+                ]);
+            }
+            return parts;
+            // Prints out a method parameter at a given path. Handles printing out the
+            // name if there is one (and whether or not it's escaped).
+            function printMethodParam(path) {
+                const node = path.getValue();
+                const parts = [path.call(printType, "type")];
+                if (node.name) {
+                    parts.push(" ");
+                    if (node.escaped) {
+                        parts.push("`", node.name, "`");
+                    }
+                    else {
+                        parts.push(node.name);
+                    }
+                }
+                return parts;
+            }
+        }
+        // Prints out a specific method signature, which looks like:
+        // (T t) -> void
+        function printMethodSignature(path) {
+            const node = path.getValue();
+            const parts = [];
+            // We won't have a type_params key if we're printing a block
+            if (node.type_params && node.type_params.length > 0) {
+                parts.push("[", join(", ", node.type_params), "] ");
+            }
+            const params = path.call(printMethodParams, "type");
+            if (params.length > 0) {
+                parts.push("(", indent([softline, join([",", line], params)]), softline, ") ");
+            }
+            if (node.block) {
+                if (!node.block.required) {
+                    parts.push("?");
+                }
+                parts.push("{", indent([line, path.call(printMethodSignature, "block")]), line, "} ");
+            }
+            parts.push("-> ", path.call((typePath) => printType(typePath, { forceParens: true }), "type", "return_type"));
+            return group(parts);
+        }
+        // Prints out a method definition, which looks like:
+        // def t: (T t) -> void
+        function printMethodDefinition(path, node) {
+            let typeDocs = path.map(printMethodSignature, "types");
+            if (node.overload) {
+                typeDocs.push("...");
+            }
+            if (typeDocs.length === 1) {
+                typeDocs = [" ", typeDocs[0]];
+            }
+            else {
+                typeDocs = indent(group([line, join([line, "| "], typeDocs)]));
+            }
+            const parts = ["def "];
+            if (node.kind === "singleton") {
+                parts.push("self.");
+            }
+            else if (node.kind === "singleton_instance") {
+                parts.push("self?.");
+            }
+            const escaped = isMethodNameEscaped();
+            parts.push(escaped ? `\`${node.name}\`` : node.name, ":", typeDocs);
+            return group(parts);
+            // Determine if a method name is escaped in the original source.
+            function isMethodNameEscaped() {
+                const pos = node.location.start_pos + 4;
+                const name = opts.originalText.slice(pos, pos + 2).trimStart();
+                return name[0] === "`" && name[1] !== ":";
+            }
+        }
+    },
+    // 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.comment && node.comment.string.includes("prettier-ignore")) || false);
+    },
+    // This function handles adding the format pragma to a source string. This is
+    // an optional workflow for incremental adoption.
+    insertPragma(text) {
+        return `# @format${text[0] === "#" ? "\n" : "\n\n"}${text}`;
+    }
+};
+exports.default = printer;

data/dist/ruby/embed.js

@@ -0,0 +1,110 @@
+"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 utils_1 = require("../utils");
+const { group, indent, dedent, lineSuffix, mapDoc, markAsRoot, stripTrailingHardline } = prettier_1.default;
+const parsers = {
+    css: "css",
+    javascript: "babel",
+    js: "babel",
+    less: "less",
+    markdown: "markdown",
+    ruby: "ruby",
+    scss: "scss"
+};
+// This function is in here because it handles embedded parser values. I don't
+// have a test that exercises it because I'm not sure for which parser it is
+// necessary, but since it's in prettier core I'm keeping it here.
+/* istanbul ignore next */
+function replaceNewlines(doc) {
+    return mapDoc(doc, (currentDoc) => typeof currentDoc === "string" && currentDoc.includes("\n")
+        ? currentDoc
+            .split(/(\n)/g)
+            .map((v, i) => (i % 2 === 0 ? v : utils_1.literallineWithoutBreakParent))
+        : currentDoc);
+}
+// Returns a number that represents the minimum amount of leading whitespace
+// that is present on every line in the given string. So for example if you have
+// the following heredoc:
+//
+//     <<~HERE
+//       my
+//       content
+//       here
+//     HERE
+//
+// then the return value of this function would be 2. If you indented every line
+// of the inner content 2 more spaces then this function would return 4.
+function getCommonLeadingWhitespace(content) {
+    const pattern = /^\s+/;
+    return content
+        .split("\n")
+        .slice(0, -1)
+        .filter((line) => line.trim().length > 0)
+        .reduce((minimum, line) => {
+        const matched = pattern.exec(line);
+        const length = matched ? matched[0].length : 0;
+        return minimum === null ? length : Math.min(minimum, length);
+    }, content.length);
+}
+// Returns a new string with the common whitespace stripped out. Effectively it
+// emulates what a squiggly heredoc does in Ruby.
+function stripCommonLeadingWhitespace(content) {
+    const lines = content.split("\n");
+    const minimum = getCommonLeadingWhitespace(content);
+    return lines.map((line) => line.slice(minimum)).join("\n");
+}
+const embed = (path, print, textToDoc) => {
+    const node = path.getValue();
+    // Currently we only support embedded formatting on heredoc nodes
+    if (node.type !== "heredoc") {
+        return null;
+    }
+    // First, ensure that we don't have any interpolation
+    const { beging, body, ending } = node;
+    const isSquiggly = beging.body[2] === "~";
+    if (body.some((part) => part.type !== "@tstring_content")) {
+        return null;
+    }
+    // Next, find the parser associated with this heredoc (if there is one). For
+    // example, if you use <<~CSS, we'd hook it up to the css parser.
+    const parser = parsers[beging.body.slice(3).toLowerCase()];
+    if (!parser) {
+        return null;
+    }
+    // Get the content as if it were a source string.
+    let content = body.map((part) => part.body).join("");
+    // If we're using a squiggly heredoc, then we're going to manually strip off
+    // the leading whitespace of each line up to the minimum leading whitespace so
+    // that the embedded parser can handle that for us.
+    if (isSquiggly) {
+        content = stripCommonLeadingWhitespace(content);
+    }
+    // Pass that content into the embedded parser. Get back the doc node.
+    const formatted = [
+        utils_1.literallineWithoutBreakParent,
+        replaceNewlines(stripTrailingHardline(textToDoc(content, { parser })))
+    ];
+    // If we're using a squiggly heredoc, then we can properly handle indentation
+    // ourselves.
+    if (isSquiggly) {
+        return [
+            path.call(print, "beging"),
+            lineSuffix(dedent([
+                indent(markAsRoot(formatted)),
+                { type: "line", hard: true },
+                ending.trim()
+            ]))
+        ];
+    }
+    // Otherwise, we need to just assume it's formatted correctly and return the
+    // content as it is.
+    return markAsRoot([
+        path.call(print, "beging"),
+        lineSuffix(group([formatted, utils_1.literallineWithoutBreakParent, ending.trim()]))
+    ]);
+};
+exports.default = embed;

data/dist/ruby/nodes/alias.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printAlias = void 0;
+const prettier_1 = __importDefault(require("../../prettier"));
+const { addTrailingComment, align, group, hardline, line } = prettier_1.default;
+// The `alias` keyword is used to make a method respond to another name as well
+// as the current one. For example, to get the method `foo` to also respond to
+// `bar`, you would:
+//
+//     alias bar foo
+//
+// Now, in the current context you can call `bar` and it will execute the `foo`
+// method.
+//
+// When you're aliasing two methods, you can either provide bare words (like the
+// example above) or you can provide symbols (note that this includes dynamic
+// symbols like :"foo-#{bar}-baz"). In general, to be consistent with the ruby
+// style guide, we prefer bare words:
+//
+//     https://github.com/rubocop-hq/ruby-style-guide#alias-method-lexically
+//
+// The `alias` node contains two children. The left and right align with the
+// arguments passed to the keyword. So, for the above example the left would be
+// the symbol literal `bar` and the right could be the symbol literal `foo`.
+const printAlias = (path, opts, print) => {
+    const keyword = "alias ";
+    // In general, return the printed doc of the argument at the provided index.
+    // Special handling is given for symbol literals that are not bare words, as
+    // we convert those into bare words by just pulling out the ident node.
+    const printAliasArg = (argPath) => {
+        const argNode = argPath.getValue();
+        if (argNode.type === "symbol_literal") {
+            // If 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 (argNode.comments) {
+                argNode.comments.forEach((comment) => {
+                    addTrailingComment(argNode.body[0], comment);
+                });
+            }
+            return argPath.call(print, "body", 0);
+        }
+        return print(argPath);
+    };
+    return group([
+        keyword,
+        path.call(printAliasArg, "body", 0),
+        group(align(keyword.length, [
+            // If the left child has any comments, then we need to explicitly break
+            // this into two lines
+            path.getValue().body[0].comments ? hardline : line,
+            path.call(printAliasArg, "body", 1)
+        ]))
+    ]);
+};
+exports.printAlias = printAlias;