prettier 2.1.0 → 3.1.1

data/dist/rbs/printer.js

@@ -1,525 +0,0 @@
-"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 = value.match(new RegExp(`\\\\[^${originalQuote}]`))
-                ? 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.length === 0) {
-                return node.name;
-            }
-            const docs = path.map((paramPath) => {
-                const node = paramPath.getValue();
-                const parts = [];
-                if (node.unchecked) {
-                    parts.push("unchecked");
-                }
-                if (node.variance === "covariant") {
-                    parts.push("out");
-                }
-                else if (node.variance === "contravariant") {
-                    parts.push("in");
-                }
-                if (node.upper_bound) {
-                    const path = paramPath;
-                    const upperBound = path.call(printType, "upper_bound");
-                    return join(" ", [...parts, node.name, "<", upperBound]);
-                }
-                else {
-                    return join(" ", [...parts, node.name]);
-                }
-            }, "type_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) {
-                const typeParamNames = node.type_params.map((tp) => tp.name);
-                parts.push("[", join(", ", typeParamNames), "] ");
-            }
-            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

@@ -1,115 +0,0 @@
-"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");
-}
-// A type assertion so that TypeScript knows we're working with an array of
-// exclusively plain string content.
-function isTStringContentArray(body) {
-    return body.every((part) => part.type === "tstring_content");
-}
-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, parts, ending } = node;
-    const isSquiggly = beging.value[2] === "~";
-    if (!isTStringContentArray(parts)) {
-        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.value.slice(3).toLowerCase()];
-    if (!parser) {
-        return null;
-    }
-    // Get the content as if it were a source string.
-    let content = parts.map((part) => part.value).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/location.js

@@ -1,19 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getEndChar = exports.getEndLine = exports.getStartChar = exports.getStartLine = void 0;
-function getStartLine(location) {
-    return location[0];
-}
-exports.getStartLine = getStartLine;
-function getStartChar(location) {
-    return location[1];
-}
-exports.getStartChar = getStartChar;
-function getEndLine(location) {
-    return location[2];
-}
-exports.getEndLine = getEndLine;
-function getEndChar(location) {
-    return location[3];
-}
-exports.getEndChar = getEndChar;