prettier 1.5.5 → 2.0.0.pre.rc2

data/src/haml/nodes/tag.js

@@ -1,232 +0,0 @@
-const {
-  align,
-  concat,
-  fill,
-  group,
-  hardline,
-  ifBreak,
-  indent,
-  join,
-  line,
-  softline
-} = require("../../prettier");
-
-function getDynamicAttributes(header, attributes) {
-  const pairs = attributes
-    .slice(1, -2)
-    .split(",")
-    .map((pair) => pair.slice(1).split('" => '));
-
-  const parts = [concat([pairs[0][0], "=", pairs[0][1]])];
-  pairs.slice(1).forEach((pair) => {
-    parts.push(line, concat([pair[0], "=", pair[1]]));
-  });
-
-  return group(concat(["(", align(header + 1, fill(parts)), ")"]));
-}
-
-function getHashValue(value, opts) {
-  if (typeof value !== "string") {
-    return value.toString();
-  }
-
-  // This is a very special syntax created by the parser to let us know that
-  // this should be printed literally instead of as a string.
-  if (value.startsWith("&")) {
-    return value.slice(1);
-  }
-
-  const quote = opts.rubySingleQuote && !value.includes("#{") ? "'" : '"';
-  return `${quote}${value}${quote}`;
-}
-
-function getHashKey(key, opts) {
-  let quoted = key;
-  const joiner = opts.rubyHashLabel ? ":" : " =>";
-
-  if (key.includes(":") || key.includes("-")) {
-    const quote = opts.rubySingleQuote ? "'" : '"';
-    quoted = `${quote}${key}${quote}`;
-  }
-
-  return `${opts.rubyHashLabel ? "" : ":"}${quoted}${joiner}`;
-}
-
-function getKeyValuePair(key, value, opts) {
-  return `${getHashKey(key, opts)} ${getHashValue(value, opts)}`;
-}
-
-function getStaticAttributes(header, attributes, opts) {
-  const keys = Object.keys(attributes).filter(
-    (name) => !["class", "id"].includes(name)
-  );
-
-  const parts = [getKeyValuePair(keys[0], attributes[keys[0]], opts)];
-
-  keys.slice(1).forEach((key) => {
-    parts.push(",", line, getKeyValuePair(key, attributes[key], opts));
-  });
-
-  return group(concat(["{", align(header + 1, fill(parts)), "}"]));
-}
-
-function getAttributesObject(object, opts, level = 0) {
-  if (typeof object !== "object") {
-    return getHashValue(object, opts);
-  }
-
-  const boundary = level === 0 ? softline : line;
-  const parts = Object.keys(object).map((key) =>
-    concat([
-      getHashKey(key, opts),
-      " ",
-      getAttributesObject(object[key], opts, level + 1)
-    ])
-  );
-
-  // If we have support for multi-line attributes laid out like a regular hash,
-  // then we print them that way here.
-  if (opts.supportsMultiline) {
-    return group(
-      concat([
-        "{",
-        indent(group(concat([boundary, join(concat([",", line]), parts)]))),
-        boundary,
-        "}"
-      ])
-    );
-  }
-
-  // Otherwise, if we only have one attribute, then just print it inline
-  // regardless of how long it is.
-  if (parts.length === 0) {
-    return group(concat(["{", parts[0], "}"]));
-  }
-
-  // Otherwise, depending on how long the line is it will split the content into
-  // multi-line attributes that old Haml understands.
-  return group(
-    concat([
-      "{",
-      parts[0],
-      ",",
-      align(
-        opts.headerLength + 1,
-        concat([line, join(concat([",", line]), parts.slice(1))])
-      ),
-      "}"
-    ])
-  );
-}
-
-function getHeader(value, opts, supportsMultiline) {
-  const { attributes } = value;
-  const parts = [];
-
-  if (value.name !== "div") {
-    parts.push(`%${value.name}`);
-  }
-
-  if (attributes.class) {
-    parts.push(`.${attributes.class.replace(/ /g, ".")}`);
-  }
-
-  if (attributes.id) {
-    parts.push(`#${attributes.id}`);
-  }
-
-  if (value.dynamic_attributes.new) {
-    parts.push(
-      getDynamicAttributes(parts.join("").length, value.dynamic_attributes.new)
-    );
-  }
-
-  if (
-    Object.keys(attributes).some((name) => name !== "class" && name !== "id")
-  ) {
-    parts.push(getStaticAttributes(parts.join("").length, attributes, opts));
-  }
-
-  if (value.dynamic_attributes.old) {
-    if (parts.length === 0) {
-      parts.push("%div");
-    }
-
-    if (typeof value.dynamic_attributes.old === "string") {
-      parts.push(value.dynamic_attributes.old);
-    } else {
-      parts.push(
-        getAttributesObject(
-          value.dynamic_attributes.old,
-          Object.assign({}, opts, {
-            supportsMultiline,
-            headerLength: parts.join("").length
-          })
-        )
-      );
-    }
-  }
-
-  if (value.object_ref) {
-    if (parts.length === 0) {
-      parts.push("%div");
-    }
-    parts.push(value.object_ref);
-  }
-
-  if (value.nuke_outer_whitespace) {
-    parts.push(">");
-  }
-
-  if (value.nuke_inner_whitespace) {
-    parts.push("<");
-  }
-
-  if (value.self_closing) {
-    parts.push("/");
-  }
-
-  if (value.value) {
-    const prefix = value.parse ? "= " : ifBreak("", " ");
-
-    return group(
-      concat([
-        group(concat(parts)),
-        indent(concat([softline, prefix, value.value]))
-      ])
-    );
-  }
-
-  // In case none of the other if statements have matched and we're printing a
-  // div, we need to explicitly add it back into the array.
-  if (parts.length === 0 && value.name === "div") {
-    parts.push("%div");
-  }
-
-  return group(concat(parts));
-}
-
-// https://haml.info/docs/yardoc/file.REFERENCE.html#element-name-
-function tag(path, opts, print) {
-  const { children, value } = path.getValue();
-
-  // This is kind of a total hack in that I don't think you're really supposed
-  // to directly use `path.stack`, but it's the easiest way to get the root node
-  // without having to know how many levels deep we are.
-  const { supports_multiline } = path.stack[0];
-
-  const header = getHeader(value, opts, supports_multiline);
-
-  if (children.length === 0) {
-    return header;
-  }
-
-  return group(
-    concat([
-      header,
-      indent(concat([hardline, join(hardline, path.map(print, "children"))]))
-    ])
-  );
-}
-
-module.exports = tag;

data/src/haml/parser.js

@@ -1,22 +0,0 @@
-const parseSync = require("../parser/parseSync");
-
-const parse = (text, _parsers, opts) => {
-  return parseSync("haml", text, opts);
-};
-
-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/printer.js

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

@@ -1,170 +0,0 @@
-const { spawn, spawnSync, execSync } = require("child_process");
-const { existsSync, mkdtempSync } = require("fs");
-const os = require("os");
-const path = require("path");
-const process = require("process");
-
-let sockfile = process.env.PRETTIER_RUBY_HOST;
-let netcat;
-
-// 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];
-}
-
-// 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 tmpDir = mkdtempSync(path.join(os.tmpdir(), "prettier-ruby"));
-  const tmpFile = path.join(tmpDir, `${process.pid}.sock`);
-
-  const server = spawn("ruby", [path.join(__dirname, "./server.rb"), tmpFile], {
-    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(tmpFile) && new Date() - now < 3000) {
-    execSync("sleep 0.1");
-  }
-
-  return tmpFile;
-}
-
-// 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 a 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 findNetcat(opts) {
-  if (opts.rubyNetcatCommand) {
-    const splits = opts.rubyNetcatCommand.split(" ");
-    return { command: splits[0], args: splits.slice(1) };
-  }
-
-  if (hasCommand("nc")) {
-    return { command: "nc", args: ["-U"] };
-  }
-
-  if (hasCommand("telnet")) {
-    return { command: "telnet", args: ["-u"] };
-  }
-
-  if (hasCommand("ncat")) {
-    return { command: "ncat", args: ["-U"] };
-  }
-
-  if (hasCommand("socat")) {
-    return { command: "socat", args: ["-"] };
-  }
-
-  return { command: "node", args: [require.resolve("./netcat.js")] };
-}
-
-// 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, opts) {
-  if (!sockfile) {
-    sockfile = spawnParseServer();
-  }
-
-  if (!netcat) {
-    netcat = findNetcat(opts);
-  }
-
-  const response = spawnSync(netcat.command, netcat.args.concat(sockfile), {
-    input: `${parser}|${source}`,
-    maxBuffer: 15 * 1024 * 1024
-  });
-
-  const stdout = response.stdout.toString();
-  const stderr = response.stderr.toString();
-  const { status } = response;
-
-  // We need special handling in case the user's version of nc doesn't support
-  // using unix sockets.
-  if (
-    stderr.includes("invalid option -- U") ||
-    stderr.includes("Protocol not supported")
-  ) {
-    throw new Error(`
-      @prettier/plugin-ruby uses netcat to communicate over unix sockets between
-      the node.js process running prettier and an underlying Ruby process used
-      for parsing. Unfortunately the version of netcat that you have installed
-      does not support unix sockets. To solve this either uninstall the version
-      of netcat that you're using and use a different implementation, or change
-      the value of the rubyNetcatCommand option in your prettier configuration.
-    `);
-  }
-
-  // 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 = parseSync;

data/src/parser/server.rb

@@ -1,66 +0,0 @@
-# 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

@@ -1,148 +0,0 @@
-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:
- * https://github.com/github/linguist/blob/master/lib/linguist/languages.yml
- * https://github.com/rubocop-hq/rubocop/blob/master/spec/rubocop/target_finder_spec.rb
- */
-
-module.exports = {
-  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: rubyParser,
-    rbs: rbsParser,
-    haml: hamlParser
-  },
-  printers: {
-    ruby: rubyPrinter,
-    rbs: rbsPrinter,
-    haml: hamlPrinter
-  },
-  options: {
-    rubyArrayLiteral: {
-      type: "boolean",
-      category: "Ruby",
-      default: true,
-      description:
-        "When possible, favor the use of string and symbol array literals."
-    },
-    rubyHashLabel: {
-      type: "boolean",
-      category: "Ruby",
-      default: true,
-      description:
-        "When possible, uses the shortened hash key syntax, as opposed to hash rockets."
-    },
-    rubyModifier: {
-      type: "boolean",
-      category: "Ruby",
-      default: true,
-      description:
-        "When it fits on one line, allows if, unless, while, and until statements to use the modifier form."
-    },
-    rubyNetcatCommand: {
-      type: "string",
-      category: "Ruby",
-      description:
-        'The prefix of the command to execute to communicate between the node.js process and the Ruby process. (For example, "nc -U" or "telnet -u") Normally you should not set this option.'
-    },
-    rubySingleQuote: {
-      type: "boolean",
-      category: "Ruby",
-      default: true,
-      description:
-        "When double quotes are not necessary for interpolation, prefers the use of single quotes for string literals."
-    },
-    rubyToProc: {
-      type: "boolean",
-      category: "Ruby",
-      default: false,
-      description:
-        "When possible, convert blocks to the more concise Symbol#to_proc syntax."
-    }
-  },
-  defaultOptions: {
-    printWidth: 80,
-    tabWidth: 2,
-    trailingComma: "none"
-  }
-};

data/src/prettier.js

@@ -1,16 +0,0 @@
-// 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);
-
-// Just combine all the things into one big object so that we can import
-// whatever we need from prettier without having to dive too deeply.
-module.exports = Object.assign(
-  {},
-  prettier.doc.builders,
-  prettier.doc.utils,
-  prettier.util
-);