prettier 1.2.2 → 1.4.0

data/src/haml/parser.js

@@ -0,0 +1,22 @@
+const parseSync = require("../parser/parseSync");
+
+const parse = (text, _parsers, _opts) => {
+  return parseSync("haml", text);
+};
+
+const pragmaPattern = /^\s*-#\s*@(prettier|format)/;
+const hasPragma = (text) => pragmaPattern.test(text);
+
+// These functions are just placeholders until we can actually perform this
+// properly. The functions are necessary otherwise the format with cursor
+// functions break.
+const locStart = (_node) => 0;
+const locEnd = (_node) => 0;
+
+module.exports = {
+  parse,
+  astFormat: "haml",
+  hasPragma,
+  locStart,
+  locEnd
+};

data/src/haml/parser.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+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)
+      Haml::AttributeParser.available? ? parse_value(string) : string
+    end
+
+    private
+
+    def literal(string, level)
+      level == 0 ? string : "&#{string}"
+    end
+
+    def parse_value(string, level = 0)
+      response = Ripper.sexp(string)
+      return literal(string, level) unless response
+
+      case response[1][0][0]
+      when :hash
+        hash = Haml::AttributeParser.parse(string)
+
+        if hash
+          # Explicitly not using Enumerable#to_h here to support Ruby 2.5
+          hash.each_with_object({}) do |(key, value), response|
+            response[key] = parse_value(value, level + 1)
+          end
+        else
+          literal(string, level)
+        end
+      when :string_literal
+        string[1...-1]
+      else
+        literal(string, level)
+      end
+    end
+  end
+
+  ESCAPE = /Haml::Helpers.html_escape\(\((.+)\)\)/.freeze
+
+  # If a node comes in as the plain type but starts with one of the special
+  # characters that haml parses, then we need to escape it with a \ when
+  # printing. So here we make a regexp pattern to check if the node needs to be
+  # escaped.
+  special_chars =
+    Haml::Parser::SPECIAL_CHARACTERS.map { |char| Regexp.escape(char) }
+
+  SPECIAL_START = /\A(?:#{special_chars.join('|')})/
+
+  def as_json
+    case type
+    when :comment, :doctype, :silent_script
+      to_h.tap do |json|
+        json.delete(:parent)
+        json[:children] = children.map(&:as_json)
+      end
+    when :filter, :haml_comment
+      to_h.tap { |json| json.delete(:parent) }
+    when :plain
+      to_h.tap do |json|
+        json.delete(:parent)
+        json[:children] = children.map(&:as_json)
+
+        text = json[:value][:text]
+        json[:value][:text] = "\\#{text}" if text.match?(SPECIAL_START)
+      end
+    when :root
+      to_h.tap { |json| json[:children] = children.map(&:as_json) }
+    when :script
+      to_h.tap do |json|
+        json.delete(:parent)
+        json[:children] = children.map(&:as_json)
+
+        if json[:value][:text].match?(ESCAPE)
+          json[:value][:text].gsub!(ESCAPE) { $1 }
+          json[:value].merge!(escape_html: 'escape_html', interpolate: true)
+        end
+      end
+    when :tag
+      to_h.tap do |json|
+        json.delete(:parent)
+
+        # For some reason this is actually using a symbol to represent a null
+        # object ref instead of nil itself, so just replacing it here for
+        # simplicity in the printer
+        json[:value][:object_ref] = nil if json[:value][:object_ref] == :nil
+
+        # Get a reference to the dynamic attributes hash
+        dynamic_attributes = value[:dynamic_attributes].to_h
+
+        # If we have any in the old style, then we're going to pass it through
+        # the deep attribute parser filter.
+        if dynamic_attributes[:old]
+          dynamic_attributes[:old] =
+            DeepAttributeParser.new.parse(dynamic_attributes[:old])
+        end
+
+        json.merge!(
+          children: children.map(&:as_json),
+          value: value.merge(dynamic_attributes: dynamic_attributes)
+        )
+      end
+    else
+      raise ArgumentError, "Unsupported type: #{type}"
+    end
+  end
+end
+
+module Prettier
+  class HAMLParser
+    def self.parse(source)
+      Haml::Parser.new({}).call(source).as_json
+    rescue StandardError
+      false
+    end
+  end
+end

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