prettier 1.3.0 → 1.5.3

data/README.md

@@ -138,7 +138,7 @@ Below are the options (from [`src/plugin.js`](src/plugin.js)) that `@prettier/pl
 | `rubySingleQuote`  | `--ruby-single-quote`  | `true`  | When double quotes are not necessary for interpolation, prefers the use of single quotes for string literals.                        |
 | `rubyToProc`       | `--ruby-to-proc`       | `false` | When possible, convert blocks to the more concise `Symbol#to_proc` syntax.                                                           |
 | `tabWidth`         | `--tab-width`          |   `2`   | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#tab-width)).                                       |
-| `trailingComma`    | `--trailing-comma`     | `"es5"` | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#trailing-comma)). `"es5"` is equivalent to `true`. |
+| `trailingComma`    | `--trailing-comma`     | `false` | Same as in Prettier ([see prettier docs](https://prettier.io/docs/en/options.html#trailing-comma)). `"es5"` is equivalent to `true`. |
 
 Any of these can be added to your existing [prettier configuration
 file](https://prettier.io/docs/en/configuration.html). For example:

data/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "1.3.0",
+  "version": "1.5.3",
   "description": "prettier plugin for the Ruby programming language",
   "main": "src/plugin.js",
   "scripts": {
     "check-format": "prettier --check '**/*'",
     "lint": "eslint --cache .",
-    "test": "PORT=$(bin/port) jest"
+    "test": "jest"
   },
   "repository": {
     "type": "git",
@@ -22,9 +22,9 @@
     "prettier": ">=1.10"
   },
   "devDependencies": {
-    "eslint": "^7.8.1",
-    "eslint-config-prettier": "^7.0.0",
-    "husky": "^4.3.5",
+    "eslint": "^7.21.0",
+    "eslint-config-prettier": "^8.0.0",
+    "husky": "^5.0.9",
     "jest": "^26.0.0",
     "pretty-quick": "^3.1.0"
   },

data/rubocop.yml

@@ -24,3 +24,6 @@ Style/TrailingCommaInArrayLiteral: # trailingComma
 
 Style/TrailingCommaInHashLiteral: # trailingComma
   Enabled: false
+
+Style/Lambda:
+  Enabled: false

data/src/haml/parser.js

@@ -1,18 +1,7 @@
-const { spawnSync } = require("child_process");
-const path = require("path");
-
-const parser = path.join(__dirname, "./parser.rb");
+const parseSync = require("../parser/parseSync");
 
 const parse = (text, _parsers, _opts) => {
-  const child = spawnSync("ruby", [parser], { input: text });
-
-  const error = child.stderr.toString();
-  if (error) {
-    throw new Error(error);
-  }
-
-  const response = child.stdout.toString();
-  return JSON.parse(response);
+  return parseSync("haml", text);
 };
 
 const pragmaPattern = /^\s*-#\s*@(prettier|format)/;

data/src/haml/parser.rb

@@ -1,10 +1,26 @@
 # frozen_string_literal: true
 
-require 'bundler/setup' if ENV['CI']
-require 'haml'
-require 'json'
 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)
@@ -115,27 +131,6 @@ module Prettier
   class HAMLParser
     def self.parse(source)
       Haml::Parser.new({}).call(source).as_json
-    rescue StandardError
-      false
     end
   end
 end
-
-# If this is the main file we're executing, then most likely this is being
-# executed from the haml.js spawn. In that case, read the ruby source from
-# stdin and report back the AST over stdout.
-if $0 == __FILE__
-  response = Prettier::HAMLParser.parse($stdin.read)
-
-  if !response
-    warn(
-      '@prettier/plugin-ruby encountered an error when attempting to parse ' \
-        'the HAML source. This usually means there was a syntax error in the ' \
-        'file in question.'
-    )
-
-    exit 1
-  end
-
-  puts JSON.fast_generate(response)
-end

data/src/parser/getLang.js

@@ -0,0 +1,32 @@
+// 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",
+    darwin: "en_US.UTF-8",
+    freebsd: "C.UTF-8",
+    linux: "C.UTF-8",
+    openbsd: "C.UTF-8",
+    sunos: "C.UTF-8",
+    win32: ".UTF-8"
+  }[platform];
+}
+
+module.exports = getLang;

data/src/parser/getNetcat.js

@@ -0,0 +1,50 @@
+const { spawnSync } = require("child_process");
+const os = require("os");
+
+// Checks to see if an executable is available.
+function hasCommand(name) {
+  let result;
+
+  if (os.type() === "Windows_NT") {
+    result = spawnSync("where", [name]);
+  } else {
+    result = spawnSync("command", ["-v", name]);
+  }
+
+  return result.status === 0;
+}
+
+// Finds an netcat-like adapter to use for sending data to a socket. We order
+// these by likelihood of being found so we can avoid some shell-outs.
+function getCommandAndArg() {
+  if (hasCommand("nc")) {
+    return ["nc", "-U"];
+  }
+
+  if (hasCommand("telnet")) {
+    return ["telnet", "-u"];
+  }
+
+  if (hasCommand("ncat")) {
+    return ["ncat", "-U"];
+  }
+
+  if (hasCommand("socat")) {
+    return ["socat", "-"];
+  }
+
+  return ["node", require.resolve("./netcat.js")];
+}
+
+let command;
+let arg;
+
+function getNetcat() {
+  if (!command) {
+    [command, arg] = getCommandAndArg();
+  }
+
+  return { command, arg };
+}
+
+module.exports = getNetcat;

data/src/parser/netcat.js

@@ -0,0 +1,15 @@
+// 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/parser/parseSync.js

@@ -0,0 +1,28 @@
+const requestParse = require("./requestParse");
+
+// 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) {
+  const { stdout, stderr, status } = requestParse(parser, source);
+
+  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 = parseSync;

data/src/parser/requestParse.js

@@ -0,0 +1,74 @@
+const { spawn, spawnSync, execSync } = require("child_process");
+const path = require("path");
+const { existsSync, mkdtempSync } = require("fs");
+const process = require("process");
+const os = require("os");
+
+const getNetcat = require("./getNetcat");
+const getLang = require("./getLang");
+
+let sockfile = process.env.PRETTIER_RUBY_HOST;
+
+// Spawn the parser.rb subprocess. We do this since booting Ruby is slow, and we
+// can re-use the parser process multiple times since it is statelesss.
+function spawnParseServer() {
+  const server = spawn(
+    "ruby",
+    [path.join(__dirname, "./server.rb"), sockfile],
+    {
+      env: Object.assign({}, process.env, { LANG: getLang() }),
+      detached: true,
+      stdio: "inherit"
+    }
+  );
+
+  process.on("exit", () => {
+    try {
+      process.kill(-server.pid);
+    } catch (e) {
+      // ignore
+    }
+  });
+
+  server.unref();
+  const now = new Date();
+
+  // Wait for server to go live.
+  while (!existsSync(sockfile) && new Date() - now < 3000) {
+    execSync("sleep 0.1");
+  }
+}
+
+// Ensures that a parser server is currently running by checking against the
+// sockfile variable. If it is not, create a temporary directory to house the
+// sockfile and spawn the ruby process.
+function ensureParseServer() {
+  if (sockfile) {
+    return;
+  }
+
+  const tmpDir = mkdtempSync(path.join(os.tmpdir(), "prettier-ruby"));
+  sockfile = path.join(tmpDir, `${process.pid}.sock`);
+
+  spawnParseServer();
+}
+
+// Sends a request to the parse server to parse the given content.
+function requestParse(parser, source) {
+  ensureParseServer();
+
+  const { command, arg } = getNetcat();
+  const { stdout, stderr, status } = spawnSync(command, [arg, sockfile], {
+    input: `${parser}|${source}`,
+    maxBuffer: 15 * 1024 * 1024
+  });
+
+  return {
+    command,
+    stdout: stdout.toString(),
+    stderr: stderr.toString(),
+    status
+  };
+}
+
+module.exports = requestParse;

data/src/parser/server.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'bundler/setup' if ENV['PLUGIN_RUBY_CI']
+require 'socket'
+require 'json'
+
+require_relative '../ruby/parser'
+require_relative '../rbs/parser'
+require_relative '../haml/parser'
+
+# Set the program name so that it's easy to find if we need it
+$PROGRAM_NAME = 'prettier-ruby-parser'
+
+# Make sure we trap these signals to be sure we get the quit command coming from
+# the parent node process
+quit = false
+trap(:QUIT) { quit = true } if RUBY_PLATFORM != 'java'
+trap(:INT) { quit = true }
+trap(:TERM) { quit = true }
+
+sockfile = ARGV.first || "/tmp/#{$PROGRAM_NAME}.sock"
+server = UNIXServer.new(sockfile)
+
+at_exit do
+  server.close
+  File.unlink(sockfile)
+end
+
+loop do
+  break if quit
+
+  # Start up a new thread that will handle each successive connection.
+  Thread.new(server.accept_nonblock) do |socket|
+    parser, source = socket.read.force_encoding('UTF-8').split('|', 2)
+
+    response =
+      case parser
+      when 'ruby'
+        Prettier::Parser.parse(source)
+      when 'rbs'
+        Prettier::RBSParser.parse(source)
+      when 'haml'
+        Prettier::HAMLParser.parse(source)
+      end
+
+    if response
+      socket.write(JSON.fast_generate(response))
+    else
+      socket.write('{ "error": true }')
+    end
+  rescue Prettier::Parser::ParserError => error
+    loc = { start: { line: error.lineno, column: error.column } }
+    socket.write(JSON.fast_generate(error: error.message, loc: loc))
+  rescue StandardError => error
+    socket.write(JSON.fast_generate(error: error.message))
+  ensure
+    socket.close
+  end
+rescue IO::WaitReadable, Errno::EINTR
+  # Wait for select(2) to give us a connection that has content for 1 second.
+  # Otherwise timeout and continue on (so that we hit our "break if quit"
+  # pretty often).
+  IO.select([server], nil, nil, 1)
+
+  retry unless quit
+end

data/src/plugin.js

@@ -36,6 +36,7 @@ module.exports = {
         ".rabl",
         ".rake",
         ".rb",
+        ".rbi",
         ".rbuild",
         ".rbw",
         ".rbx",

data/src/rbs/parser.js

@@ -1,23 +1,11 @@
-const { spawnSync } = require("child_process");
-const path = require("path");
+const parseSync = require("../parser/parseSync");
 
 // This function is responsible for taking an input string of text and returning
 // to prettier a JavaScript object that is the equivalent AST that represents
 // the code stored in that string. We accomplish this by spawning a new Ruby
 // process of parser.rb and reading JSON off STDOUT.
 function parse(text, _parsers, _opts) {
-  const child = spawnSync("ruby", [path.join(__dirname, "./parser.rb")], {
-    input: text,
-    maxBuffer: 15 * 1024 * 1024 // 15MB
-  });
-
-  const error = child.stderr.toString();
-  if (error) {
-    throw new Error(error);
-  }
-
-  const response = child.stdout.toString();
-  return JSON.parse(response);
+  return parseSync("rbs", text);
 }
 
 const pragmaPattern = /#\s*@(prettier|format)/;

data/src/rbs/parser.rb

@@ -1,21 +1,43 @@
 #!/usr/bin/env ruby
 
-require 'bundler/setup' if ENV['CI']
-require 'json'
-require 'rbs'
+begin
+  require 'rbs'
+rescue LoadError
+  # If we can't load the rbs gem, then we're going to provide a shim parser that
+  # will warn and bail out.
+  class Prettier::RBSParser
+    def self.parse(text)
+      warn(
+        'The `rbs` 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
 
 # Monkey-patch this so that we can get the character positions.
 class RBS::Location
   def to_json(*args)
     {
-      start: { line: start_line, column: start_column },
-      end: { line: end_line, column: end_column },
+      start: {
+        line: start_line,
+        column: start_column
+      },
+      end: {
+        line: end_line,
+        column: end_column
+      },
       start_pos: start_pos,
       end_pos: end_pos
     }.to_json(*args)
   end
 end
 
+# Monkey-patch this so that we get whether or not it needs to be escaped.
 class RBS::Types::Function::Param
   def to_json(*a)
     escaped = name && /\A#{RBS::Parser::KEYWORDS_RE}\z/.match?(name)
@@ -60,32 +82,11 @@ class RBS::Types::Record
   end
 end
 
+# The main parser interface.
 module Prettier
   class RBSParser
     def self.parse(text)
       { declarations: RBS::Parser.parse_signature(text) }
-    rescue StandardError
-      false
     end
   end
 end
-
-# If this is the main file we're executing, then most likely this is being
-# executed from the parser.js spawn. In that case, read the rbs source from
-# stdin and report back the AST over stdout.
-
-if $0 == __FILE__
-  response = Prettier::RBSParser.parse($stdin.read)
-
-  if !response
-    warn(
-      '@prettier/plugin-ruby encountered an error when attempting to parse ' \
-        'the RBS source. This usually means there was a syntax error in the ' \
-        'file in question.'
-    )
-
-    exit 1
-  end
-
-  puts JSON.fast_generate(response)
-end