prettier 2.1.0 → 3.0.0

data/dist/haml/parser.rb

@@ -1,149 +0,0 @@
-# frozen_string_literal: true
-
-require 'ripper'
-
-begin
-  require 'haml'
-rescue LoadError
-  # If we can't load the haml gem, then we're going to provide a shim parser
-  # that will warn and bail out.
-  class Prettier::HAMLParser
-    def self.parse(text)
-      warn(
-        'The `haml` gem could not be loaded. Please ensure you have it ' \
-          'installed and that it is available in the gem path.'
-      )
-
-      false
-    end
-  end
-
-  return
-end
-
-class Haml::Parser::ParseNode
-  class DeepAttributeParser
-    def parse(string)
-      Haml::AttributeParser.available? ? parse_value(string) : string
-    end
-
-    private
-
-    def literal(string, level)
-      level == 0 ? string : "&#{string}"
-    end
-
-    def parse_value(string, level = 0)
-      response = Ripper.sexp(string)
-      return literal(string, level) unless response
-
-      case response[1][0][0]
-      when :hash
-        hash = Haml::AttributeParser.parse(string)
-
-        if hash
-          # Explicitly not using Enumerable#to_h here to support Ruby 2.5
-          hash.each_with_object({}) do |(key, value), response|
-            # For attributes that starts with @, wrap the attribute in quotes
-            # For other attributes, remove the quotes
-            # AlpineJS uses @-attributes
-            # {'type': 'submit'} => {type: 'submit'}
-            # {'@click': 'open'} => {'@click': 'open'}
-            key = "\'#{key}\'" if key.start_with?('@')
-            response[key] = parse_value(value, level + 1)
-          end
-        else
-          literal(string, level)
-        end
-      when :string_literal
-        string[1...-1]
-      else
-        literal(string, level)
-      end
-    end
-  end
-
-  ESCAPE = /Haml::Helpers.html_escape\(\((.+)\)\)/.freeze
-
-  # If a node comes in as the plain type but starts with one of the special
-  # characters that haml parses, then we need to escape it with a \ when
-  # printing. So here we make a regexp pattern to check if the node needs to be
-  # escaped.
-  special_chars =
-    Haml::Parser::SPECIAL_CHARACTERS.map { |char| Regexp.escape(char) }
-
-  SPECIAL_START = /\A(?:#{special_chars.join('|')})/
-
-  def as_json
-    case type
-    when :comment, :doctype, :silent_script
-      to_h.tap do |json|
-        json.delete(:parent)
-        json[:children] = children.map(&:as_json)
-      end
-    when :filter, :haml_comment
-      to_h.tap { |json| json.delete(:parent) }
-    when :plain
-      to_h.tap do |json|
-        json.delete(:parent)
-        json[:children] = children.map(&:as_json)
-
-        text = json[:value][:text]
-        json[:value][:text] = "\\#{text}" if text.match?(SPECIAL_START)
-      end
-    when :root
-      to_h.tap do |json|
-        json[:children] = children.map(&:as_json)
-
-        # We need this information in the printer to know how to lay out
-        # multi-line attributes.
-        json[:supports_multiline] =
-          Gem::Version.new(Haml::VERSION) >= Gem::Version.new('5.2')
-      end
-    when :script
-      to_h.tap do |json|
-        json.delete(:parent)
-        json[:children] = children.map(&:as_json)
-
-        if json[:value][:text].match?(ESCAPE)
-          json[:value][:text].gsub!(ESCAPE) { $1 }
-          json[:value].merge!(escape_html: 'escape_html', interpolate: true)
-        end
-      end
-    when :tag
-      to_h.tap do |json|
-        json.delete(:parent)
-
-        # For some reason this is actually using a symbol to represent a null
-        # object ref instead of nil itself, so just replacing it here for
-        # simplicity in the printer
-        json[:value][:object_ref] = nil if json[:value][:object_ref] == :nil
-
-        # Get a reference to the dynamic attributes hash
-        dynamic_attributes = value[:dynamic_attributes].to_h
-
-        # If we have any in the old style, then we're going to pass it through
-        # the deep attribute parser filter.
-        if dynamic_attributes[:old]
-          dynamic_attributes[:old] =
-            DeepAttributeParser.new.parse(dynamic_attributes[:old])
-        end
-
-        json.merge!(
-          children: children.map(&:as_json),
-          value: value.merge(dynamic_attributes: dynamic_attributes)
-        )
-      end
-    else
-      raise ArgumentError, "Unsupported type: #{type}"
-    end
-  end
-end
-
-module Prettier
-  class HAMLParser
-    def self.parse(source)
-      Haml::Parser.new({}).call(source).as_json
-    end
-  end
-end

data/dist/haml/printer.js

@@ -1,336 +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 embed_1 = __importDefault(require("./embed"));
-const { align, fill, group, hardline, ifBreak, indent, join, line, makeString, softline } = prettier_1.default;
-const docTypes = {
-    basic: "Basic",
-    frameset: "Frameset",
-    mobile: "Mobile",
-    rdfa: "RDFa",
-    strict: "Strict",
-    xml: "XML"
-};
-const docVersions = ["1.1", "5"];
-// Prints out a hash key according to the configured prettier options.
-function printHashKey(key, opts) {
-    let quoted = key;
-    const joiner = opts.rubyHashLabel ? ":" : " =>";
-    if (key.includes(":") || key.includes("-")) {
-        const quote = opts.rubySingleQuote ? "'" : '"';
-        quoted = `${quote}${key}${quote}`;
-    }
-    return `${opts.rubyHashLabel ? "" : ":"}${quoted}${joiner}`;
-}
-// Prints out the value inside of a hash key-value pair according to the
-// configured prettier options.
-function printHashValue(value, opts) {
-    if (typeof value !== "string") {
-        return value.toString();
-    }
-    // This is a very special syntax created by the parser to let us know that
-    // this should be printed literally instead of as a string.
-    if (value.startsWith("&")) {
-        return value.slice(1);
-    }
-    const quote = opts.rubySingleQuote && !value.includes("#{") && !value.includes("'")
-        ? "'"
-        : '"';
-    return makeString(value, quote);
-}
-// This will print an attributes object to a Doc node. It handles nesting on
-// multiple levels and will print out according to whether or not the version of
-// HAML being used supports multi-line attributes.
-function printAttributes(object, opts, level = 0) {
-    if (typeof object !== "object") {
-        return printHashValue(object, opts);
-    }
-    const boundary = level === 0 ? softline : line;
-    const parts = Object.keys(object).map((key) => [
-        printHashKey(key, opts),
-        " ",
-        printAttributes(object[key], opts, level + 1)
-    ]);
-    // If we have support for multi-line attributes laid out like a regular hash,
-    // then we print them that way here.
-    if (opts.supportsMultiline) {
-        return group([
-            "{",
-            indent(group([boundary, join([",", line], parts)])),
-            boundary,
-            "}"
-        ]);
-    }
-    // Otherwise, if we only have one attribute, then just print it inline
-    // regardless of how long it is.
-    if (parts.length === 0) {
-        return group(["{", parts[0], "}"]);
-    }
-    // Otherwise, depending on how long the line is it will split the content into
-    // multi-line attributes that old Haml understands.
-    return group([
-        "{",
-        parts[0],
-        ",",
-        align(opts.headerLength + 1, [line, join([",", line], parts.slice(1))]),
-        "}"
-    ]);
-}
-// A utility function used in a silent script that is meant to determine if a
-// child node is a continuation of a parent node (as in a when clause within a
-// case statement or an else clause within an if).
-function isContinuation(parentNode, childNode) {
-    if (childNode.type !== "silent_script") {
-        return false;
-    }
-    const parent = parentNode.value.keyword;
-    const child = childNode.value.keyword;
-    return ((parent === "case" && ["when", "else"].includes(child)) ||
-        (["if", "unless"].includes(parent) && ["elsif", "else"].includes(child)));
-}
-const printer = {
-    embed: embed_1.default,
-    // This is our printer's main print function that will switch on the type of
-    // node and print it out by returning a Doc tree.
-    print(path, opts, print) {
-        const node = path.getValue();
-        switch (node.type) {
-            // https://haml.info/docs/yardoc/file.REFERENCE.html#html-comments-
-            case "comment": {
-                const { value } = node;
-                const parts = ["/"];
-                if (value.revealed) {
-                    parts.push("!");
-                }
-                if (value.conditional) {
-                    parts.push(value.conditional);
-                }
-                else if (value.text) {
-                    parts.push(" ", value.text);
-                }
-                return printWithChildren(node, group(parts));
-            }
-            // https://haml.info/docs/yardoc/file.REFERENCE.html#doctype-
-            case "doctype": {
-                const { value } = node;
-                const parts = ["!!!"];
-                if (value.type in docTypes) {
-                    parts.push(docTypes[value.type]);
-                }
-                else if (value.version && docVersions.includes(value.version)) {
-                    parts.push(value.version);
-                }
-                else {
-                    parts.push(value.type);
-                }
-                if (value.encoding) {
-                    parts.push(value.encoding);
-                }
-                return group(join(" ", parts));
-            }
-            // https://haml.info/docs/yardoc/file.REFERENCE.html#filters
-            case "filter":
-                return group([
-                    ":",
-                    node.value.name,
-                    indent([hardline, join(hardline, node.value.text.trim().split("\n"))])
-                ]);
-            // https://haml.info/docs/yardoc/file.REFERENCE.html#haml-comments--
-            case "haml_comment": {
-                const { value } = node;
-                const parts = ["-#"];
-                if (value.text) {
-                    if (opts.originalText.split("\n")[node.line - 1].trim() === "-#") {
-                        const lines = value.text.trim().split("\n");
-                        parts.push(indent([hardline, join(hardline, lines)]));
-                    }
-                    else {
-                        parts.push(" ", value.text.trim());
-                    }
-                }
-                return parts;
-            }
-            // https://haml.info/docs/yardoc/file.REFERENCE.html#plain-text
-            case "plain":
-                return node.value.text;
-            // The root node in the AST that we build in the parser.
-            case "root": {
-                const nodePath = path;
-                return [join(hardline, nodePath.map(print, "children")), hardline];
-            }
-            // https://haml.info/docs/yardoc/file.REFERENCE.html#inserting_ruby
-            case "script": {
-                const { value } = node;
-                const parts = [];
-                if (value.escape_html) {
-                    parts.unshift("&");
-                }
-                if (value.preserve) {
-                    parts.push("~");
-                }
-                else if (!value.interpolate) {
-                    parts.push("=");
-                }
-                if (value.escape_html && !value.preserve && value.interpolate) {
-                    parts.push(" ", value.text.trim().slice(1, -1));
-                }
-                else {
-                    parts.push(" ", value.text.trim());
-                }
-                return printWithChildren(node, group(parts));
-            }
-            // https://haml.info/docs/yardoc/file.REFERENCE.html#running-ruby--
-            case "silent_script": {
-                const parts = [`- ${node.value.text.trim()}`];
-                if (node.children.length > 0) {
-                    const nodePath = path;
-                    parts.push(nodePath.map((childPath) => {
-                        const child = childPath.getValue();
-                        const concated = [hardline, print(childPath)];
-                        return isContinuation(node, child) ? concated : indent(concated);
-                    }, "children"));
-                }
-                return group(parts);
-            }
-            // https://haml.info/docs/yardoc/file.REFERENCE.html#element-name-
-            case "tag": {
-                const { value } = node;
-                const { attributes, dynamic_attributes } = value;
-                const parts = [];
-                // If we have a tag that isn't a div, then we need to print out that
-                // name of that tag first. If it is a div, first we'll check if there
-                // are any other things that would force us to print out the div
-                // explicitly, and otherwise we'll leave it off.
-                if (value.name !== "div") {
-                    parts.push(`%${value.name}`);
-                }
-                // If we have a class attribute, then we're going to print that here
-                // using the special class syntax.
-                if (attributes.class) {
-                    parts.push(`.${attributes.class.replace(/ /g, ".")}`);
-                }
-                // If we have an id attribute, then we're going to print that here using
-                // the special id syntax.
-                if (attributes.id) {
-                    parts.push(`#${attributes.id}`);
-                }
-                // If we're using dynamic attributes on this tag, then they come in as a
-                // string that looks like the output of Hash#inspect from Ruby. So here
-                // we're going to split it all up and print it out nicely.
-                if (dynamic_attributes.new) {
-                    const docs = [];
-                    dynamic_attributes.new
-                        .slice(1, -2)
-                        .split(",")
-                        .forEach((pair, index) => {
-                        if (index !== 0) {
-                            docs.push(line);
-                        }
-                        docs.push(join("=", pair.slice(1).split('" => ')));
-                    });
-                    parts.push(group(["(", align(parts.join("").length + 1, fill(docs)), ")"]));
-                }
-                // If there are any static attributes that are not class or id (because
-                // we already took care of those), then we're going to print them out
-                // here.
-                const staticAttributes = Object.keys(attributes).filter((name) => !["class", "id"].includes(name));
-                if (staticAttributes.length > 0) {
-                    const docs = staticAttributes.reduce((accum, key) => {
-                        const doc = `${printHashKey(key, opts)} ${printHashValue(attributes[key], opts)}`;
-                        return accum.length === 0 ? [doc] : [...accum, ",", line, doc];
-                    }, []);
-                    parts.push(group(["{", align(parts.join("").length + 1, fill(docs)), "}"]));
-                }
-                // If there are dynamic attributes that don't use the newer syntax, then
-                // we're going to print them out here.
-                if (dynamic_attributes.old) {
-                    if (parts.length === 0) {
-                        parts.push("%div");
-                    }
-                    if (typeof dynamic_attributes.old === "string") {
-                        parts.push(dynamic_attributes.old);
-                    }
-                    else {
-                        // This is kind of a total hack in that I don't think you're
-                        // really supposed to directly use `path.stack`, but it's the
-                        // easiest way to get the root node without having to know how
-                        // many levels deep we are.
-                        const root = path.stack[0];
-                        parts.push(printAttributes(dynamic_attributes.old, {
-                            ...opts,
-                            supportsMultiline: root.supports_multiline,
-                            headerLength: parts.join("").length
-                        }));
-                    }
-                }
-                // https://haml.info/docs/yardoc/file.REFERENCE.html#object-reference-
-                if (value.object_ref) {
-                    if (parts.length === 0) {
-                        parts.push("%div");
-                    }
-                    parts.push(value.object_ref);
-                }
-                // https://haml.info/docs/yardoc/file.REFERENCE.html#whitespace-removal--and-
-                if (value.nuke_outer_whitespace) {
-                    parts.push(">");
-                }
-                if (value.nuke_inner_whitespace) {
-                    parts.push("<");
-                }
-                // https://haml.info/docs/yardoc/file.REFERENCE.html#empty-void-tags-
-                if (value.self_closing) {
-                    parts.push("/");
-                }
-                if (value.value) {
-                    let contents;
-                    if (value.parse && value.value.match(/#[{$@]/)) {
-                        // There's a weird case here where if the value includes
-                        // interpolation and it's marked as { parse: true }, then we don't
-                        // actually want the = prefix, and we want to remove extra escaping.
-                        contents = [
-                            ifBreak("", " "),
-                            value.value.slice(1, -1).replace(/\\"/g, '"')
-                        ];
-                    }
-                    else if (value.parse) {
-                        contents = ["= ", value.value];
-                    }
-                    else {
-                        contents = [ifBreak("", " "), value.value];
-                    }
-                    return printWithChildren(node, group([group(parts), indent([softline, ...contents])]));
-                }
-                // In case none of the other if statements have matched and we're
-                // printing a div, we need to explicitly add it back into the array.
-                if (parts.length === 0 && value.name === "div") {
-                    parts.push("%div");
-                }
-                return printWithChildren(node, group(parts));
-            }
-            default:
-                throw new Error(`Unsupported node encountered: ${node.type}`);
-        }
-        // It's common to a couple of nodes to attach nested child nodes on the
-        // children property. This utility prints them out grouped together with
-        // their parent node docs.
-        function printWithChildren(node, docs) {
-            if (node.children.length === 0) {
-                return docs;
-            }
-            const nodePath = path;
-            return group([
-                docs,
-                indent([hardline, join(hardline, nodePath.map(print, "children"))])
-            ]);
-        }
-    },
-    // This function handles adding the format pragma to a source string. This is
-    // an optional workflow for incremental adoption.
-    insertPragma(text) {
-        return `-# @format${text.startsWith("-#") ? "\n" : "\n\n"}${text}`;
-    }
-};
-exports.default = printer;

data/dist/parser/parseSync.js

@@ -1,179 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getInfoFilepath = exports.getLang = void 0;
-const child_process_1 = require("child_process");
-const fs_1 = require("fs");
-const os_1 = __importDefault(require("os"));
-const path_1 = __importDefault(require("path"));
-const process_1 = __importDefault(require("process"));
-let parserArgs;
-if (process_1.default.env.PRETTIER_RUBY_HOST) {
-    const [cmd, ...args] = process_1.default.env.PRETTIER_RUBY_HOST.split(" ");
-    parserArgs = { cmd, args };
-}
-// In order to properly parse ruby code, we need to tell the ruby process to
-// parse using UTF-8. Unfortunately, the way that you accomplish this looks
-// differently depending on your platform.
-/* istanbul ignore next */
-function getLang() {
-    const { env, platform } = process_1.default;
-    const envValue = env.LC_ALL || env.LC_CTYPE || env.LANG;
-    // If an env var is set for the locale that already includes UTF-8 in the
-    // name, then assume we can go with that.
-    if (envValue && envValue.includes("UTF-8")) {
-        return envValue;
-    }
-    // Otherwise, we're going to guess which encoding to use based on the system.
-    // This is probably not the best approach in the world, as you could be on
-    // linux and not have C.UTF-8, but in that case you're probably passing an env
-    // var for it. This object below represents all of the possible values of
-    // process.platform per:
-    // https://nodejs.org/api/process.html#process_process_platform
-    return {
-        aix: "C.UTF-8",
-        android: "C.UTF-8",
-        cygwin: "C.UTF-8",
-        darwin: "en_US.UTF-8",
-        freebsd: "C.UTF-8",
-        haiku: "C.UTF-8",
-        linux: "C.UTF-8",
-        netbsd: "C.UTF-8",
-        openbsd: "C.UTF-8",
-        sunos: "C.UTF-8",
-        win32: ".UTF-8"
-    }[platform];
-}
-exports.getLang = getLang;
-// Generate the filepath that should be used to communicate the connection
-// information between this process and the parser server.
-function getInfoFilepath() {
-    return path_1.default.join(os_1.default.tmpdir(), `prettier-ruby-parser-${process_1.default.pid}.info`);
-}
-exports.getInfoFilepath = getInfoFilepath;
-// Create a file that will act as a communication mechanism, spawn a parser
-// server with that filepath as an argument, then spawn another process that
-// will read that information in order to enable us to connect to it in the
-// spawnSync function.
-function spawnServer() {
-    const tempDir = (0, fs_1.mkdtempSync)(path_1.default.join(os_1.default.tmpdir(), "prettier-plugin-ruby-"));
-    const filepath = getInfoFilepath();
-    let serverRbPath = path_1.default.join(__dirname, "./server.rb");
-    let getInfoJsPath = path_1.default.join(__dirname, "./getInfo.js");
-    let cleanupTempFiles;
-    if (runningInPnPZip()) {
-        // If we're running in a Yarn PnP environment inside a ZIP file, it's not possible to run
-        // the Ruby server or the getInfo.js script directly.  Instead, we need to copy them and all
-        // the files they depend on to a temporary directory.
-        const sourceFiles = [
-            "parser/server.rb",
-            "parser/getInfo.js",
-            "parser/netcat.js",
-            "ruby/parser.rb",
-            "rbs/parser.rb",
-            "haml/parser.rb"
-        ];
-        serverRbPath = path_1.default.join(tempDir, "parser", "server.rb");
-        getInfoJsPath = path_1.default.join(tempDir, "parser", "getInfo.js");
-        sourceFiles.forEach((rubyFile) => {
-            const destDir = path_1.default.join(tempDir, path_1.default.dirname(rubyFile));
-            if (!(0, fs_1.existsSync)(destDir)) {
-                (0, fs_1.mkdirSync)(destDir);
-            }
-            (0, fs_1.copyFileSync)(path_1.default.join(__dirname, "..", rubyFile), path_1.default.join(tempDir, rubyFile));
-        });
-        cleanupTempFiles = () => {
-            [
-                getInfoJsPath,
-                ...sourceFiles.map((rubyFile) => path_1.default.join(tempDir, rubyFile))
-            ].forEach((tmpFilePath) => {
-                if ((0, fs_1.existsSync)(tmpFilePath)) {
-                    (0, fs_1.unlinkSync)(tmpFilePath);
-                }
-            });
-            sourceFiles.forEach((rubyFile) => {
-                const tempSubdir = path_1.default.join(tempDir, path_1.default.dirname(rubyFile));
-                if ((0, fs_1.existsSync)(tempSubdir)) {
-                    (0, fs_1.rmdirSync)(tempSubdir);
-                }
-            });
-            if ((0, fs_1.existsSync)(tempDir)) {
-                (0, fs_1.rmdirSync)(tempDir);
-            }
-        };
-    }
-    const server = (0, child_process_1.spawn)("ruby", [serverRbPath, filepath], {
-        env: Object.assign({}, process_1.default.env, { LANG: getLang() }),
-        detached: true,
-        stdio: "inherit"
-    });
-    server.unref();
-    process_1.default.on("exit", () => {
-        if ((0, fs_1.existsSync)(filepath)) {
-            (0, fs_1.unlinkSync)(filepath);
-        }
-        if (cleanupTempFiles != null) {
-            cleanupTempFiles();
-        }
-        try {
-            if (server.pid) {
-                process_1.default.kill(-server.pid);
-            }
-        }
-        catch (e) {
-            if (process_1.default.env.PLUGIN_RUBY_CI) {
-                throw new Error(`Failed to kill the parser server: ${e}`);
-            }
-        }
-    });
-    const info = (0, child_process_1.spawnSync)("node", [getInfoJsPath, filepath]);
-    if (info.status !== 0) {
-        throw new Error(`
-      We failed to spawn our parser server. Please report this error on GitHub
-      at https://github.com/prettier/plugin-ruby. The error message was:
-
-        ${info.stderr.toString()}.
-    `);
-    }
-    const [cmd, ...args] = info.stdout.toString().split(" ");
-    return { cmd, args };
-}
-// If we're in a yarn Plug'n'Play environment, then the relative paths being
-// used by the parser server and the various scripts used to communicate
-// therein are not going to work with its virtual file system.
-function runningInPnPZip() {
-    return process_1.default.versions.pnp && __dirname.includes(".zip");
-}
-// Formats and sends a request to the parser server. We use netcat (or something
-// like it) here since Prettier requires the results of `parse` to be
-// synchronous and Node.js does not offer a mechanism for synchronous socket
-// requests.
-function parseSync(parser, source) {
-    if (!parserArgs) {
-        parserArgs = spawnServer();
-    }
-    const response = (0, child_process_1.spawnSync)(parserArgs.cmd, parserArgs.args, {
-        input: `${parser}|${source}`,
-        maxBuffer: 15 * 1024 * 1024
-    });
-    const stdout = response.stdout.toString();
-    const stderr = response.stderr.toString();
-    const { status } = response;
-    // If we didn't receive anything over stdout or we have a bad exit status,
-    // then throw whatever we can.
-    if (stdout.length === 0 || (status !== null && status !== 0)) {
-        throw new Error(stderr || "An unknown error occurred");
-    }
-    const parsed = JSON.parse(stdout);
-    if (parsed.error) {
-        const error = new Error(parsed.error);
-        if (parsed.loc) {
-            error.loc = parsed.loc;
-        }
-        throw error;
-    }
-    return parsed;
-}
-exports.default = parseSync;