prettier 1.2.3 → 1.5.0

data/src/haml/printer.js

@@ -0,0 +1,28 @@
+const embed = require("./embed");
+const nodes = {
+  comment: require("./nodes/comment"),
+  doctype: require("./nodes/doctype"),
+  filter: require("./nodes/filter"),
+  haml_comment: require("./nodes/hamlComment"),
+  plain: require("./nodes/plain"),
+  root: require("./nodes/root"),
+  script: require("./nodes/script"),
+  silent_script: require("./nodes/silentScript"),
+  tag: require("./nodes/tag")
+};
+
+const genericPrint = (path, opts, print) => {
+  const { type } = path.getValue();
+
+  /* istanbul ignore next */
+  if (!(type in nodes)) {
+    throw new Error(`Unsupported node encountered: ${type}`);
+  }
+
+  return nodes[type](path, opts, print);
+};
+
+module.exports = {
+  embed,
+  print: genericPrint
+};

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,33 @@
+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 response = requestParse(parser, source);
+
+  if (
+    response.stdout.length === 0 ||
+    (response.status !== null && response.status !== 0)
+  ) {
+    console.error("Could not parse response from server");
+    console.error(response);
+
+    throw new Error(response.stderr || "An unknown error occurred");
+  }
+
+  const parsed = JSON.parse(response.stdout);
+
+  if (parsed.error) {
+    throw new Error(
+      `@prettier/plugin-ruby encountered an error when attempting to parse \
+the ruby source. This usually means there was a syntax error in the \
+file in question. You can verify by running \`ruby -i [path/to/file]\`.`
+    );
+  }
+
+  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,61 @@
+# frozen_string_literal: true
+
+require 'bundler/setup' if ENV['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 }
+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
+  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

@@ -1,5 +1,11 @@
-const printer = require("./ruby/printer");
-const parser = require("./ruby/parser");
+const rubyPrinter = require("./ruby/printer");
+const rubyParser = require("./ruby/parser");
+
+const rbsPrinter = require("./rbs/printer");
+const rbsParser = require("./rbs/parser");
+
+const hamlPrinter = require("./haml/printer");
+const hamlParser = require("./haml/parser");
 
 /*
  * metadata mostly pulled from linguist and rubocop:
@@ -30,6 +36,7 @@ module.exports = {
         ".rabl",
         ".rake",
         ".rb",
+        ".rbi",
         ".rbuild",
         ".rbw",
         ".rbx",
@@ -67,13 +74,28 @@ module.exports = {
       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: parser
+    ruby: rubyParser,
+    rbs: rbsParser,
+    haml: hamlParser
   },
   printers: {
-    ruby: printer
+    ruby: rubyPrinter,
+    rbs: rbsPrinter,
+    haml: hamlPrinter
   },
   options: {
     rubyArrayLiteral: {

data/src/prettier.js

@@ -1,6 +1,7 @@
 // If `RBPRETTIER` is set, then this is being run from the `Prettier::run` ruby
 // method. In that case, we need to pull `prettier` from the node_modules
 // directly, as it's been shipped with the gem.
+/* istanbul ignore next */
 const source = process.env.RBPRETTIER ? "../node_modules/prettier" : "prettier";
 
 const prettier = require(source);

data/src/rbs/parser.js

@@ -0,0 +1,39 @@
+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) {
+  return parseSync("rbs", text);
+}
+
+const pragmaPattern = /#\s*@(prettier|format)/;
+
+// This function handles checking whether or not the source string has the
+// pragma for prettier. This is an optional workflow for incremental adoption.
+function hasPragma(text) {
+  return pragmaPattern.test(text);
+}
+
+// This function is critical for comments and cursor support, and is responsible
+// for returning the index of the character within the source string that is the
+// beginning of the given node.
+function locStart(node) {
+  return (node.location || node.type.location).start_pos;
+}
+
+// This function is critical for comments and cursor support, and is responsible
+// for returning the index of the character within the source string that is the
+// ending of the given node.
+function locEnd(node) {
+  return (node.location || node.type.location).end_pos;
+}
+
+module.exports = {
+  parse,
+  astFormat: "rbs",
+  hasPragma,
+  locStart,
+  locEnd
+};

data/src/rbs/parser.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+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_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)
+    { type: type, name: name, escaped: escaped }.to_json(*a)
+  end
+end
+
+# Monkey-patch this so that we get the name field in the serialized JSON, as
+# well as information about whether or not we need to escape it.
+class RBS::AST::Members::MethodDefinition
+  def to_json(*a)
+    {
+      member: :method_definition,
+      name: name,
+      kind: kind,
+      types: types,
+      annotations: annotations,
+      location: location,
+      comment: comment,
+      overload: overload
+    }.to_json(*a)
+  end
+end
+
+# Monkey-patch this so that we get the information we need about how to join the
+# key-value pairs of the record.
+class RBS::Types::Record
+  def to_json(*a)
+    fields_extra = {}
+
+    # Explicitly not using Enumerable#to_h here to support Ruby 2.5
+    fields.each do |key, type|
+      if key.is_a?(Symbol) && key.match?(/\A[A-Za-z_][A-Za-z_]*\z/) &&
+           !key.match?(RBS::Parser::KEYWORDS_RE)
+        fields_extra[key] = { type: type, joiner: :label }
+      else
+        fields_extra[key.inspect] = { type: type, joiner: :rocket }
+      end
+    end
+
+    { class: :record, fields: fields_extra, location: location }.to_json(*a)
+  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