prettier 3.2.2 → 4.0.0

data/src/plugin.js

@@ -1,10 +1,190 @@
-const { parseSync } = require("./parseSync");
+import { spawn } from "child_process";
+import fs from "fs";
+import net from "net";
+import os from "os";
+import path from "path";
+import process from "process";
+import url from "url";
 
-/*
- * metadata mostly pulled from linguist and rubocop:
- * https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
- * https://github.com/rubocop/rubocop/blob/master/spec/rubocop/target_finder_spec.rb
- */
+// 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.
+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];
+}
+
+// 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.rubySingleQuote) {
+    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 wait for the file to be
+// created that will contain the connection information.
+export async function spawnServer(opts, killOnExit = true) {
+  const tmpdir = os.tmpdir();
+  const filepath = path.join(tmpdir, `prettier-ruby-parser-${process.pid}.txt`);
+
+  const server = spawn(
+    opts.rubyExecutablePath || "ruby",
+    [
+      url.fileURLToPath(new URL("./server.rb", import.meta.url)),
+      `--plugins=${getPlugins(opts).join(",")}`,
+      filepath
+    ],
+    {
+      env: Object.assign({}, process.env, { LANG: getLang() }),
+      stdio: ["ignore", "ignore", "inherit"],
+      detached: true
+    }
+  );
+
+  server.unref();
+
+  if (killOnExit) {
+    process.on("exit", () => {
+      if (fs.existsSync(filepath)) {
+        fs.unlinkSync(filepath);
+      }
+
+      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 (error) {
+        // If there's an error killing the process, we're going to ignore it.
+      }
+    });
+  }
+
+  return new Promise((resolve, reject) => {
+    const interval = setInterval(() => {
+      if (fs.existsSync(filepath)) {
+        const connectionJSON = fs.readFileSync(filepath).toString("utf-8");
+        resolve({
+          serverPID: server.pid,
+          connectionFilepath: filepath,
+          connectionOptions: JSON.parse(connectionJSON)
+        });
+
+        clearTimeout(timeout);
+        clearInterval(interval);
+      } else if (server.exitCode) {
+        reject(new Error("Failed to start parse server."));
+        clearTimeout(timeout);
+        clearInterval(interval);
+      }
+    }, 100);
+
+    const timeout = setTimeout(
+      () => {
+        const message =
+          "Failed to get connection options from parse server in time. If this happens repeatedly, try increasing the PRETTIER_RUBY_TIMEOUT_MS environment variable beyond 10000.";
+
+        clearInterval(interval);
+        reject(new Error(message));
+      },
+      parseInt(process.env.PRETTIER_RUBY_TIMEOUT_MS || "10000", 10)
+    );
+  });
+}
+
+let connectionOptions;
+if (process.env.PRETTIER_RUBY_HOST) {
+  connectionOptions = JSON.parse(process.env.PRETTIER_RUBY_HOST);
+}
+
+// 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.
+async function parse(parser, source, opts) {
+  if (!connectionOptions) {
+    const spawnedServer = await spawnServer(opts);
+    connectionOptions = spawnedServer.connectionOptions;
+  }
+
+  return new Promise((resolve, reject) => {
+    const socket = new net.Socket();
+
+    socket.on("error", reject);
+    socket.on("data", (data) => {
+      const response = JSON.parse(data.toString("utf-8"));
+
+      if (response.error) {
+        const error = new Error(response.error);
+        if (response.loc) {
+          error.loc = response.loc;
+        }
+
+        reject(error);
+      }
+
+      resolve(response);
+    });
+
+    socket.connect(connectionOptions, () => {
+      socket.end(
+        JSON.stringify({
+          parser,
+          source,
+          maxwidth: opts.printWidth,
+          tabwidth: opts.tabWidth
+        })
+      );
+    });
+  });
+}
+
+// Metadata mostly pulled from linguist and rubocop:
+// https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
+// https://github.com/rubocop/rubocop/blob/master/spec/rubocop/target_finder_spec.rb
 const plugin = {
   languages: [
     {
@@ -81,8 +261,8 @@ const plugin = {
   ],
   parsers: {
     ruby: {
-      parse(text, _parsers, opts) {
-        return parseSync("ruby", text, opts);
+      parse(text, opts) {
+        return parse("ruby", text, opts);
       },
       astFormat: "ruby",
       hasPragma(text) {
@@ -96,8 +276,8 @@ const plugin = {
       }
     },
     rbs: {
-      parse(text, _parsers, opts) {
-        return parseSync("rbs", text, opts);
+      parse(text, opts) {
+        return parse("rbs", text, opts);
       },
       astFormat: "rbs",
       hasPragma(text) {
@@ -111,8 +291,8 @@ const plugin = {
       }
     },
     haml: {
-      parse(text, _parsers, opts) {
-        return parseSync("haml", text, opts);
+      parse(text, opts) {
+        return parse("haml", text, opts);
       },
       astFormat: "haml",
       hasPragma(text) {
@@ -157,8 +337,24 @@ const plugin = {
       type: "string",
       category: "Ruby",
       default: "",
-      description: "The comma-separated list of plugins to require",
+      description: "The comma-separated list of plugins to require.",
       since: "3.1.0"
+    },
+    rubySingleQuote: {
+      type: "boolean",
+      category: "Ruby",
+      default: false,
+      description:
+        "When double quotes are not necessary for interpolation, prefers the use of single quotes for string literals.",
+      since: "1.0.0"
+    },
+    rubyExecutablePath: {
+      type: "string",
+      category: "Ruby",
+      default: "ruby",
+      description:
+        "The path to the Ruby executable to use to run the formatter.",
+      since: "3.3.0"
     }
   },
   defaultOptions: {
@@ -169,4 +365,4 @@ const plugin = {
   }
 };
 
-module.exports = plugin;
+export default plugin;

data/src/server.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
 require "bundler/setup"
-require "socket"
 require "json"
-require "fileutils"
-require "open3"
+require "socket"
 
 require "prettier_print"
 require "syntax_tree"
@@ -16,6 +14,9 @@ ARGV.shift[/^--plugins=(.*)$/, 1]
   .split(",")
   .each { |plugin| require "syntax_tree/#{plugin}" }
 
+# Next, get the file where we should write our connection information.
+connection_filepath = ARGV.shift
+
 # Make sure we trap these signals to be sure we get the quit command coming from
 # the parent node process
 quit = false
@@ -26,47 +27,38 @@ if Signal.list.key?("QUIT") && RUBY_ENGINE != "jruby"
   trap(:QUIT) { quit = true }
 end
 
-# The information variable stores the actual connection information, which will
-# either be an IP address and port or a path to a unix socket file.
-information = ""
-
-# The candidates array is a list of potential programs that could be used to
-# connect to our server. We'll run through them after the server starts to find
-# the best one to use.
-candidates = []
-
-if Gem.win_platform?
-  # If we're on windows, we're going to start up a TCP server. The 0 here means
-  # to bind to some available port.
-  server = TCPServer.new("127.0.0.1", 0)
-  address = server.local_address
-
-  # Ensure that we close the server when this process exits.
-  at_exit { server.close }
-
-  information = "#{address.ip_address} #{address.ip_port}"
-  candidates = %w[nc telnet]
-else
-  # If we're not on windows, then we're going to assume we can use unix socket
-  # files (since they're faster than a TCP server).
-  filepath = "/tmp/prettier-ruby-parser-#{Process.pid}.sock"
-  server = UNIXServer.new(filepath)
-
-  # Ensure that we close the server and delete the socket file when this
-  # process exits.
-  at_exit do
-    server.close
-    File.unlink(filepath)
-  end
+connection_information =
+  if Gem.win_platform?
+    # If we're on windows, we're going to start up a TCP server. The 0 here
+    # means to bind to some available port.
+    server = TCPServer.new(0)
+    address = server.local_address
+
+    # Ensure that we close the server when this process exits.
+    at_exit { server.close }
+
+    # Return the connection information.
+    { address: address.ip_address, port: address.ip_port }
+  else
+    # If we're not on windows, then we're going to assume we can use unix socket
+    # files (since they're faster than a TCP server).
+    filepath = "/tmp/prettier-ruby-parser-#{Process.pid}.sock"
+    server = UNIXServer.new(filepath)
+
+    # Ensure that we close the server and delete the socket file when this
+    # process exits.
+    at_exit do
+      server.close
+      File.unlink(filepath)
+    end
 
-  information = server.local_address.unix_path
-  candidates = ["nc -w 3 -U", "ncat -w 3 -U"]
-end
+    # Return the connection information.
+    { path: server.local_address.unix_path }
+  end
 
 # This is the actual listening thread that will be acting as our server. We have
-# to start it in another thread to begin with so that we can run through our
-# candidate connection programs. Eventually we'll just join into this thread
-# though and it will act as a daemon.
+# to start it in another thread in order to properly trap the signals in this
+# parent thread.
 listener =
   Thread.new do
     loop do
@@ -74,8 +66,8 @@ listener =
 
       # Start up a new thread that will handle each successive connection.
       Thread.new(server.accept_nonblock) do |socket|
-        parser, maxwidth_string, tabwidth_string, source =
-          socket.read.force_encoding("UTF-8").split("|", 4)
+        request = JSON.parse(socket.read.force_encoding("UTF-8"))
+        source = request["source"]
 
         source.each_line do |line|
           case line
@@ -95,14 +87,12 @@ listener =
         # At the moment, we're not going to support odd tabwidths. It's going to
         # have to be a multiple of 2, because of the way that the prettyprint
         # gem functions. So we're going to just use integer division here.
-        scalar = tabwidth_string.to_i / 2
+        scalar = request["tabwidth"].to_i / 2
         genspace = ->(n) { " " * n * scalar }
 
-        maxwidth = maxwidth_string.to_i
+        maxwidth = request["maxwidth"].to_i
         response =
-          case parser
-          when "ping"
-            "pong"
+          case request["parser"]
           when "ruby"
             formatter =
               SyntaxTree::Formatter.new(source, [], maxwidth, "\n", &genspace)
@@ -122,16 +112,19 @@ listener =
             formatter.flush
             formatter.output.join
           when "haml"
-            formatter_class =
+            formatter =
               if defined?(SyntaxTree::Haml::Format::Formatter)
-                SyntaxTree::Haml::Format::Formatter
+                SyntaxTree::Haml::Format::Formatter.new(
+                  source,
+                  +"",
+                  maxwidth,
+                  "\n",
+                  &genspace
+                )
               else
-                PrettierPrint
+                PrettierPrint.new(+"", maxwidth, "\n", &genspace)
               end
 
-            formatter =
-              formatter_class.new(source, +"", maxwidth, "\n", &genspace)
-
             SyntaxTree::Haml.parse(source).format(formatter)
             formatter.flush
             formatter.output
@@ -149,8 +142,8 @@ listener =
         begin
           socket.write(JSON.fast_generate(error: error.message))
         rescue Errno::EPIPE
-          # Do nothing, the pipe has been closed by the parent process so we don't
-          # actually care about writing to it anymore.
+          # Do nothing, the pipe has been closed by the parent process so we
+          # don't actually care about writing to it anymore.
         end
       ensure
         socket.close
@@ -165,35 +158,5 @@ listener =
     end
   end
 
-# Map each candidate connection method to a thread that will check if it works.
-candidates.map! do |candidate|
-  Thread.new do
-    Thread.current.report_on_exception = false
-
-    # We do not care about stderr here, so throw it away
-    stdout, _stderr, status =
-      Open3.capture3("#{candidate} #{information}", stdin_data: "ping")
-
-    candidate if JSON.parse(stdout) == "pong" && status.exitstatus == 0
-  rescue StandardError
-    # We don't actually care if this fails, because we'll just skip that
-    # connection option.
-  end
-end
-
-# Find the first one prefix that successfully returned the correct value.
-prefix =
-  candidates.detect do |candidate|
-    value = candidate.value
-    break value if value
-  end
-
-# Default to running the netcat.js script that we ship with the plugin. It's a
-# good fallback as it will always work, but it is slower than the other options.
-prefix ||= "node #{File.expand_path("netcat.js", __dir__)}"
-
-# Write out our connection information to the file given as the first argument
-# to this script.
-File.write(ARGV[0], "#{prefix} #{information}")
-
+File.write(connection_filepath, JSON.fast_generate(connection_information))
 listener.join

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: prettier
 version: !ruby/object:Gem::Version
-  version: 3.2.2
+  version: 4.0.0
 platform: ruby
 authors:
 - Kevin Newton
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-09-20 00:00:00.000000000 Z
+date: 2023-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: syntax_tree
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.7.1
+        version: 4.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.7.1
+        version: 4.0.1
 - !ruby/object:Gem::Dependency
   name: syntax_tree-haml
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 2.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: 2.0.0
 - !ruby/object:Gem::Dependency
   name: syntax_tree-rbs
   requirement: !ruby/object:Gem::Requirement
@@ -103,35 +103,67 @@ extra_rdoc_files: []
 files:
 - CHANGELOG.md
 - CODE_OF_CONDUCT.md
-- CONTRIBUTING.md
 - LICENSE
 - README.md
 - exe/rbprettier
 - lib/prettier.rb
 - lib/prettier/rake/task.rb
-- node_modules/prettier/bin-prettier.js
-- node_modules/prettier/cli.js
+- node_modules/prettier/LICENSE
+- node_modules/prettier/README.md
+- node_modules/prettier/bin/prettier.cjs
+- node_modules/prettier/doc.d.ts
 - node_modules/prettier/doc.js
-- node_modules/prettier/index.js
+- node_modules/prettier/doc.mjs
+- node_modules/prettier/index.cjs
+- node_modules/prettier/index.d.ts
+- node_modules/prettier/index.mjs
+- node_modules/prettier/internal/cli.mjs
+- node_modules/prettier/internal/internal.mjs
 - node_modules/prettier/package.json
-- node_modules/prettier/parser-angular.js
-- node_modules/prettier/parser-babel.js
-- node_modules/prettier/parser-espree.js
-- node_modules/prettier/parser-flow.js
-- node_modules/prettier/parser-glimmer.js
-- node_modules/prettier/parser-graphql.js
-- node_modules/prettier/parser-html.js
-- node_modules/prettier/parser-markdown.js
-- node_modules/prettier/parser-meriyah.js
-- node_modules/prettier/parser-postcss.js
-- node_modules/prettier/parser-typescript.js
-- node_modules/prettier/parser-yaml.js
-- node_modules/prettier/third-party.js
+- node_modules/prettier/plugins/acorn.d.ts
+- node_modules/prettier/plugins/acorn.js
+- node_modules/prettier/plugins/acorn.mjs
+- node_modules/prettier/plugins/angular.d.ts
+- node_modules/prettier/plugins/angular.js
+- node_modules/prettier/plugins/angular.mjs
+- node_modules/prettier/plugins/babel.d.ts
+- node_modules/prettier/plugins/babel.js
+- node_modules/prettier/plugins/babel.mjs
+- node_modules/prettier/plugins/estree.d.ts
+- node_modules/prettier/plugins/estree.js
+- node_modules/prettier/plugins/estree.mjs
+- node_modules/prettier/plugins/flow.d.ts
+- node_modules/prettier/plugins/flow.js
+- node_modules/prettier/plugins/flow.mjs
+- node_modules/prettier/plugins/glimmer.d.ts
+- node_modules/prettier/plugins/glimmer.js
+- node_modules/prettier/plugins/glimmer.mjs
+- node_modules/prettier/plugins/graphql.d.ts
+- node_modules/prettier/plugins/graphql.js
+- node_modules/prettier/plugins/graphql.mjs
+- node_modules/prettier/plugins/html.d.ts
+- node_modules/prettier/plugins/html.js
+- node_modules/prettier/plugins/html.mjs
+- node_modules/prettier/plugins/markdown.d.ts
+- node_modules/prettier/plugins/markdown.js
+- node_modules/prettier/plugins/markdown.mjs
+- node_modules/prettier/plugins/meriyah.d.ts
+- node_modules/prettier/plugins/meriyah.js
+- node_modules/prettier/plugins/meriyah.mjs
+- node_modules/prettier/plugins/postcss.d.ts
+- node_modules/prettier/plugins/postcss.js
+- node_modules/prettier/plugins/postcss.mjs
+- node_modules/prettier/plugins/typescript.d.ts
+- node_modules/prettier/plugins/typescript.js
+- node_modules/prettier/plugins/typescript.mjs
+- node_modules/prettier/plugins/yaml.d.ts
+- node_modules/prettier/plugins/yaml.js
+- node_modules/prettier/plugins/yaml.mjs
+- node_modules/prettier/standalone.d.ts
+- node_modules/prettier/standalone.js
+- node_modules/prettier/standalone.mjs
 - package.json
 - rubocop.yml
-- src/getInfo.js
-- src/netcat.js
-- src/parseSync.js
 - src/plugin.js
 - src/server.rb
 homepage: https://github.com/prettier/plugin-ruby#readme
@@ -146,14 +178,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.7.3
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.21
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: prettier plugin for the Ruby programming language