prettier 2.0.0.pre.rc4 → 3.0.0

data/package.json

@@ -1,12 +1,11 @@
 {
   "name": "@prettier/plugin-ruby",
-  "version": "2.0.0-rc4",
+  "version": "3.0.0",
   "description": "prettier plugin for the Ruby programming language",
-  "main": "dist/plugin.js",
+  "main": "src/plugin.js",
   "scripts": {
     "checkFormat": "prettier --check '**/*'",
     "lint": "eslint --cache .",
-    "prepublishOnly": "tsc -p tsconfig.build.json && cp src/parser/getInfo.js dist/parser && cp src/parser/netcat.js dist/parser && cp src/parser/server.rb dist/parser && cp src/haml/parser.rb dist/haml && cp src/rbs/parser.rb dist/rbs && cp src/ruby/parser.rb dist/ruby",
     "test": "jest"
   },
   "repository": {
@@ -23,24 +22,15 @@
     "prettier": ">=2.3.0"
   },
   "devDependencies": {
-    "@types/jest": "^27.0.1",
-    "@types/node": "^16.9.1",
-    "@types/prettier": "^2.3.2",
-    "@typescript-eslint/eslint-plugin": "^4.31.2",
-    "@typescript-eslint/parser": "^4.31.2",
-    "eslint": "^7.22.0",
+    "eslint": "^8.1.0",
     "eslint-config-prettier": "^8.0.0",
     "husky": "^7.0.0",
-    "jest": "^27.0.1",
-    "pretty-quick": "^3.1.0",
-    "ts-jest": "^27.0.5",
-    "ts-node": "^10.2.1",
-    "typescript": "^4.4.3"
+    "jest": "^28.0.1",
+    "pretty-quick": "^3.1.2"
   },
   "eslintConfig": {
     "extends": [
       "eslint:recommended",
-      "plugin:@typescript-eslint/recommended",
       "prettier"
     ],
     "env": {
@@ -48,21 +38,17 @@
       "jest": true,
       "node": true
     },
-    "parser": "@typescript-eslint/parser",
     "rules": {
-      "no-unused-vars": "off",
-      "@typescript-eslint/explicit-module-boundary-types": "off",
-      "@typescript-eslint/no-explicit-any": "off"
+      "no-unused-vars": "off"
     }
   },
   "jest": {
-    "globalSetup": "./test/js/globalSetup.ts",
-    "globalTeardown": "./test/js/globalTeardown.ts",
-    "preset": "ts-jest",
+    "globalSetup": "./test/js/globalSetup.js",
+    "globalTeardown": "./test/js/globalTeardown.js",
     "setupFilesAfterEnv": [
-      "./test/js/setupTests.ts"
+      "./test/js/setupTests.js"
     ],
-    "testRegex": ".test.ts$"
+    "testRegex": ".test.js$"
   },
   "husky": {
     "hooks": {

data/rubocop.yml

@@ -13,26 +13,32 @@ Layout:
 Layout/LineLength:
   Enabled: true
 
-# Disabling all of the following options because they could conflict with a
-# prettier configuration setting.
+Style/MultilineIfModifier:
+  Enabled: false
 
-Style/MultilineIfModifier: # rubyModifier
+# When method chains with multiple blocks are chained together, rubocop will let
+# them pass if they're using braces but not if they're using do and end
+# keywords. Because we will break individual blocks down to using keywords if
+# they are multiline, this conflicts with rubocop.
+Style/MultilineBlockChain:
   Enabled: false
 
-Style/SymbolArray: # rubyArrayLiteral
+Style/SymbolArray:
   Enabled: false
 
-Style/WordArray: # rubyArrayLiteral
+Style/WordArray:
   Enabled: false
 
-Style/TrailingCommaInArguments: # trailingComma
+Style/TrailingCommaInArguments:
   Enabled: false
 
-Style/TrailingCommaInArrayLiteral: # trailingComma
+Style/TrailingCommaInArrayLiteral:
   Enabled: false
 
-Style/TrailingCommaInHashLiteral: # trailingComma
+Style/TrailingCommaInHashLiteral:
   Enabled: false
 
+# lambdas that are constructed with the lambda method call cannot be safely
+# turned into lambda literals without removing a method call.
 Style/Lambda:
   Enabled: false

data/src/getInfo.js

@@ -0,0 +1,23 @@
+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/{dist/parser → src}/netcat.js

@@ -2,7 +2,6 @@
 // On average, this is 2-3x slower than netcat, but still much faster than
 // spawning a new Ruby process.
 
-// eslint-disable-next-line @typescript-eslint/no-var-requires
 const { createConnection } = require("net");
 
 const sock = process.argv[process.argv.length - 1];

data/src/parseSync.js

@@ -0,0 +1,212 @@
+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`);
+}
+
+// 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 = 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, 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) {
+  if (!parserArgs) {
+    parserArgs = spawnServer();
+  }
+
+  const response = 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;
+}
+
+module.exports = {
+  getLang,
+  getInfoFilepath,
+  parseSync
+};

data/src/plugin.js

@@ -0,0 +1,161 @@
+const { parseSync } = require("./parseSync");
+
+/*
+ * 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: [
+    {
+      name: "Ruby",
+      parsers: ["ruby"],
+      extensions: [
+        ".arb",
+        ".axlsx",
+        ".builder",
+        ".eye",
+        ".fcgi",
+        ".gemfile",
+        ".gemspec",
+        ".god",
+        ".jb",
+        ".jbuilder",
+        ".mspec",
+        ".opal",
+        ".pluginspec",
+        ".podspec",
+        ".rabl",
+        ".rake",
+        ".rb",
+        ".rbi",
+        ".rbuild",
+        ".rbw",
+        ".rbx",
+        ".ru",
+        ".ruby",
+        ".thor",
+        ".watchr"
+      ],
+      filenames: [
+        ".irbrc",
+        ".pryrc",
+        ".simplecov",
+        "Appraisals",
+        "Berksfile",
+        "Brewfile",
+        "Buildfile",
+        "Capfile",
+        "Cheffile",
+        "Dangerfile",
+        "Deliverfile",
+        "Fastfile",
+        "Gemfile",
+        "Guardfile",
+        "Jarfile",
+        "Mavenfile",
+        "Podfile",
+        "Puppetfile",
+        "Rakefile",
+        "Snapfile",
+        "Thorfile",
+        "Vagabondfile",
+        "Vagrantfile",
+        "buildfile"
+      ],
+      interpreters: ["jruby", "macruby", "rake", "rbx", "ruby"],
+      linguistLanguageId: 326,
+      vscodeLanguageIds: ["ruby"]
+    },
+    {
+      name: "RBS",
+      parsers: ["rbs"],
+      extensions: [".rbs"]
+    },
+    {
+      name: "HAML",
+      parsers: ["haml"],
+      extensions: [".haml"],
+      vscodeLanguageIds: ["haml"]
+    }
+  ],
+  parsers: {
+    ruby: {
+      parse(text) {
+        return parseSync("ruby", text);
+      },
+      astFormat: "ruby",
+      hasPragma(text) {
+        return /^\s*#[^\S\n]*@(?:prettier|format)\s*?(?:\n|$)/m.test(text);
+      },
+      locStart() {
+        return 0;
+      },
+      locEnd() {
+        return 0;
+      }
+    },
+    rbs: {
+      parse(text) {
+        return parseSync("rbs", text);
+      },
+      astFormat: "rbs",
+      hasPragma(text) {
+        return /^\s*#[^\S\n]*@(prettier|format)\s*(\n|$)/.test(text);
+      },
+      locStart() {
+        return 0;
+      },
+      locEnd() {
+        return 0;
+      }
+    },
+    haml: {
+      parse(text) {
+        return parseSync("haml", text);
+      },
+      astFormat: "haml",
+      hasPragma(text) {
+        return /^\s*-#\s*@(prettier|format)/.test(text);
+      },
+      locStart() {
+        return 0;
+      },
+      locEnd() {
+        return 0;
+      }
+    }
+  },
+  printers: {
+    ruby: {
+      print(path) {
+        return path.getValue();
+      },
+      insertPragma(text) {
+        return `# @format${text.startsWith("#") ? "\n" : "\n\n"}${text}`;
+      }
+    },
+    rbs: {
+      print(path) {
+        return path.getValue();
+      },
+      insertPragma(text) {
+        return `# @format${text.startsWith("#") ? "\n" : "\n\n"}${text}`;
+      }
+    },
+    haml: {
+      print(path) {
+        return path.getValue();
+      },
+      insertPragma(text) {
+        return `-# @format${text.startsWith("-#") ? "\n" : "\n\n"}${text}`;
+      }
+    }
+  },
+  defaultOptions: {
+    printWidth: 80,
+    tabWidth: 2
+  }
+};
+
+module.exports = plugin;

data/{dist/parser → src}/server.rb

@@ -1,25 +1,28 @@
 # frozen_string_literal: true
 
-require 'bundler/setup' if ENV['PLUGIN_RUBY_CI']
-require 'socket'
-require 'json'
-require 'fileutils'
-require 'open3'
+require "bundler/setup"
+require "socket"
+require "json"
+require "fileutils"
+require "open3"
 
-require_relative '../ruby/parser'
-require_relative '../rbs/parser'
-require_relative '../haml/parser'
+require "syntax_tree"
+require "syntax_tree/haml"
+require "syntax_tree/rbs"
 
 # Make sure we trap these signals to be sure we get the quit command coming from
 # the parent node process
 quit = false
 trap(:INT) { quit = true }
 trap(:TERM) { quit = true }
-trap(:QUIT) { quit = true } if Signal.list.key?('QUIT')
+
+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 = ''
+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
@@ -29,7 +32,7 @@ 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)
+  server = TCPServer.new("127.0.0.1", 0)
   address = server.local_address
 
   # Ensure that we close the server when this process exits.
@@ -51,7 +54,7 @@ else
   end
 
   information = server.local_address.unix_path
-  candidates = ['nc -w 3 -U', 'ncat -w 3 -U']
+  candidates = ["nc -w 3 -U", "ncat -w 3 -U"]
 end
 
 # This is the actual listening thread that will be acting as our server. We have
@@ -65,26 +68,41 @@ listener =
 
       # 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)
+        parser, source = socket.read.force_encoding("UTF-8").split("|", 2)
+
+        source.each_line do |line|
+          case line
+          when /^\s*#.+?coding/
+            # If we've found an encoding comment, then we're going to take that
+            # into account and reclassify the encoding for the source.
+            encoding = Ripper.new(line).tap(&:parse).encoding
+            source = source.force_encoding(encoding)
+            break
+          when /^\s*#/
+            # continue
+          else
+            break
+          end
+        end
 
         response =
           case parser
-          when 'ping'
-            'pong'
-          when 'ruby'
-            Prettier::Parser.parse(source)
-          when 'rbs'
-            Prettier::RBSParser.parse(source)
-          when 'haml'
-            Prettier::HAMLParser.parse(source)
+          when "ping"
+            "pong"
+          when "ruby"
+            SyntaxTree.format(source)
+          when "rbs"
+            SyntaxTree::RBS.format(source)
+          when "haml"
+            SyntaxTree::Haml.format(source)
           end
 
         if response
-          socket.write(JSON.fast_generate(response))
+          socket.write(JSON.fast_generate(response.force_encoding("UTF-8")))
         else
-          socket.write('{ "error": true }')
+          socket.write("{ \"error\": true }")
         end
-      rescue Prettier::Parser::ParserError => error
+      rescue SyntaxTree::Parser::ParseError => error
         loc = { start: { line: error.lineno, column: error.column } }
         socket.write(JSON.fast_generate(error: error.message, loc: loc))
       rescue StandardError => error
@@ -114,9 +132,9 @@ candidates.map! do |candidate|
 
     # We do not care about stderr here, so throw it away
     stdout, _stderr, status =
-      Open3.capture3("#{candidate} #{information}", stdin_data: 'ping')
+      Open3.capture3("#{candidate} #{information}", stdin_data: "ping")
 
-    candidate if JSON.parse(stdout) == 'pong' && status.exitstatus == 0
+    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.
@@ -132,7 +150,7 @@ prefix =
 
 # 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__)}"
+prefix ||= "node #{File.expand_path("netcat.js", __dir__)}"
 
 # Write out our connection information to the file given as the first argument
 # to this script.