prettier 3.2.2 → 4.0.1

data/src/getInfo.js

@@ -1,23 +0,0 @@
-const { existsSync, readFileSync } = require("fs");
-
-// This is how long to wait for the parser to spin up. For the most part, 5
-// seconds is plenty of time. But in some environments, it may be necessary to
-// increase this value.
-const timeoutMs = parseInt(process.env.PRETTIER_RUBY_TIMEOUT_MS || "5000", 10);
-
-const filepath = process.argv[process.argv.length - 1];
-
-const timeout = setTimeout(() => {
-  clearInterval(interval);
-  throw new Error(`Failed to get information from parse server in time. If this
-    happens repeatedly, try increasing the PRETTIER_RUBY_TIMEOUT_MS environment
-    variable beyond 5000.`);
-}, timeoutMs);
-
-const interval = setInterval(() => {
-  if (existsSync(filepath)) {
-    process.stdout.write(readFileSync(filepath).toString("utf8"));
-    clearTimeout(timeout);
-    clearInterval(interval);
-  }
-}, 100);

data/src/netcat.js

@@ -1,13 +0,0 @@
-// A simple fallback when no netcat-compatible adapter is found on the system.
-// On average, this is 2-3x slower than netcat, but still much faster than
-// spawning a new Ruby process.
-
-const { createConnection } = require("net");
-
-const sock = process.argv[process.argv.length - 1];
-const client = createConnection(sock, () => process.stdin.pipe(client));
-
-client.on("data", (data) => process.stdout.write(data));
-client.on("error", (error) => {
-  console.error(error);
-});

data/src/parseSync.js

@@ -1,236 +0,0 @@
-const { spawn, spawnSync } = require("child_process");
-const {
-  existsSync,
-  unlinkSync,
-  mkdtempSync,
-  copyFileSync,
-  mkdirSync,
-  rmdirSync
-} = require("fs");
-const os = require("os");
-const path = require("path");
-const process = require("process");
-
-let parserArgs;
-
-if (process.env.PRETTIER_RUBY_HOST) {
-  const [cmd, ...args] = process.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;
-  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];
-}
-
-// Generate the filepath that should be used to communicate the connection
-// information between this process and the parser server.
-function getInfoFilepath() {
-  return path.join(os.tmpdir(), `prettier-ruby-parser-${process.pid}.info`);
-}
-
-// Return the list of plugins that should be passed to the server process.
-function getPlugins(opts) {
-  const plugins = new Set();
-
-  const rubyPlugins = opts.rubyPlugins.trim();
-  if (rubyPlugins.length > 0) {
-    rubyPlugins.split(",").forEach((plugin) => plugins.add(plugin.trim()));
-  }
-
-  if (opts.singleQuote) {
-    plugins.add("plugin/single_quotes");
-  }
-
-  if (opts.trailingComma !== "none") {
-    plugins.add("plugin/trailing_comma");
-  }
-
-  return Array.from(plugins);
-}
-
-// 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(opts) {
-  const tempDir = mkdtempSync(path.join(os.tmpdir(), "prettier-plugin-ruby-"));
-  const filepath = getInfoFilepath();
-
-  let serverRbPath = path.join(__dirname, "./server.rb");
-  let getInfoJsPath = path.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 = ["server.rb", "getInfo.js", "netcat.js"];
-    serverRbPath = path.join(tempDir, "server.rb");
-    getInfoJsPath = path.join(tempDir, "getInfo.js");
-
-    sourceFiles.forEach((rubyFile) => {
-      const destDir = path.join(tempDir, path.dirname(rubyFile));
-      if (!existsSync(destDir)) {
-        mkdirSync(destDir);
-      }
-      copyFileSync(
-        path.join(__dirname, "..", "src", rubyFile),
-        path.join(tempDir, rubyFile)
-      );
-    });
-
-    cleanupTempFiles = () => {
-      [
-        getInfoJsPath,
-        ...sourceFiles.map((rubyFile) => path.join(tempDir, rubyFile))
-      ].forEach((tmpFilePath) => {
-        if (existsSync(tmpFilePath)) {
-          unlinkSync(tmpFilePath);
-        }
-      });
-
-      sourceFiles.forEach((rubyFile) => {
-        const tempSubdir = path.join(tempDir, path.dirname(rubyFile));
-        if (existsSync(tempSubdir)) {
-          rmdirSync(tempSubdir);
-        }
-      });
-
-      if (existsSync(tempDir)) {
-        rmdirSync(tempDir);
-      }
-    };
-  }
-
-  const server = spawn(
-    "ruby",
-    [serverRbPath, `--plugins=${getPlugins(opts).join(",")}`, filepath],
-    {
-      env: Object.assign({}, process.env, { LANG: getLang() }),
-      detached: true,
-      stdio: "inherit"
-    }
-  );
-
-  server.unref();
-  process.on("exit", () => {
-    if (existsSync(filepath)) {
-      unlinkSync(filepath);
-    }
-
-    if (cleanupTempFiles != null) {
-      cleanupTempFiles();
-    }
-
-    try {
-      if (server.pid) {
-        // Kill the server process if it's still running. If we're on windows
-        // we're going to use the process ID number. If we're not, we're going
-        // to use the negative process ID to indicate the group.
-        const pid = process.platform === "win32" ? server.pid : -server.pid;
-        process.kill(pid);
-      }
-    } catch (e) {
-      if (process.env.PLUGIN_RUBY_CI) {
-        throw new Error(`Failed to kill the parser server: ${e}`);
-      }
-    }
-  });
-
-  const info = 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.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, opts) {
-  if (!parserArgs) {
-    parserArgs = spawnServer(opts);
-  }
-
-  const response = spawnSync(parserArgs.cmd, parserArgs.args, {
-    input: `${parser}|${opts.printWidth}|${opts.tabWidth}|${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;
-}
-
-module.exports = {
-  getLang,
-  getInfoFilepath,
-  parseSync
-};